djsundog
/
circuitpython
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

Merge branch 'master' into nrf52840_usbboot

This commit is contained in:
hathach 2018-07-10 02:02:52 +07:00
parent 7715d19efe 64b9ee9c74
commit 0e819599e7
29 changed files with 357 additions and 706 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

1
.gitignore vendored
View File

@ -58,3 +58,4 @@ TAGS
################# #################
*.orig *.orig
*.DS_Store

8
lib/utils/pyexec.c Normal file → Executable file
View File

@ -33,6 +33,7 @@
#include "py/runtime.h" #include "py/runtime.h"
#include "py/repl.h" #include "py/repl.h"
#include "py/gc.h" #include "py/gc.h"
#include "py/gc_long_lived.h"
#include "py/frozenmod.h" #include "py/frozenmod.h"
#include "py/mphal.h" #include "py/mphal.h"
#if defined(USE_DEVICE_MODE) #if defined(USE_DEVICE_MODE)
@ -97,6 +98,13 @@ STATIC int parse_compile_execute(const void *source, mp_parse_input_kind_t input
#endif #endif
} }
// If the code was loaded from a file its likely to be running for a while so we'll long
// live it and collect any garbage before running.
if (input_kind == MP_PARSE_FILE_INPUT) {
module_fun = make_obj_long_lived(module_fun, 6);
gc_collect();
}
// execute code // execute code
mp_hal_set_interrupt_char(CHAR_CTRL_C); // allow ctrl-C to interrupt us mp_hal_set_interrupt_char(CHAR_CTRL_C); // allow ctrl-C to interrupt us
start = mp_hal_ticks_ms(); start = mp_hal_ticks_ms();

10
main.c Normal file → Executable file
View File

@ -44,6 +44,7 @@
#include "lib/utils/pyexec.h" #include "lib/utils/pyexec.h"
#include "mpconfigboard.h" #include "mpconfigboard.h"
#include "supervisor/cpu.h"
#include "supervisor/port.h" #include "supervisor/port.h"
#include "supervisor/filesystem.h" #include "supervisor/filesystem.h"
// TODO(tannewt): Figure out how to choose language at compile time. // TODO(tannewt): Figure out how to choose language at compile time.
@ -381,16 +382,17 @@ int __attribute__((used)) main(void) {
} }
void gc_collect(void) { void gc_collect(void) {
// WARNING: This gc_collect implementation doesn't try to get root
// pointers from CPU registers, and thus may function incorrectly.
void *dummy;
gc_collect_start(); gc_collect_start();
mp_uint_t regs[10];
mp_uint_t sp = cpu_get_regs_and_sp(regs);
// This collects root pointers from the VFS mount table. Some of them may // This collects root pointers from the VFS mount table. Some of them may
// have lost their references in the VM even though they are mounted. // have lost their references in the VM even though they are mounted.
gc_collect_root((void**)&MP_STATE_VM(vfs_mount_table), sizeof(mp_vfs_mount_t) / sizeof(mp_uint_t)); gc_collect_root((void**)&MP_STATE_VM(vfs_mount_table), sizeof(mp_vfs_mount_t) / sizeof(mp_uint_t));
// This naively collects all object references from an approximate stack // This naively collects all object references from an approximate stack
// range. // range.
gc_collect_root(&dummy, ((mp_uint_t)&_estack - (mp_uint_t)&dummy) / sizeof(mp_uint_t)); gc_collect_root((void**)sp, ((uint32_t)&_estack - sp) / sizeof(uint32_t));
gc_collect_end(); gc_collect_end();
} }

3
ports/atmel-samd/Makefile Normal file → Executable file
View File

@ -412,6 +412,8 @@ endif
SRC_SHARED_MODULE_EXPANDED = $(addprefix shared-bindings/, $(SRC_SHARED_MODULE)) \ SRC_SHARED_MODULE_EXPANDED = $(addprefix shared-bindings/, $(SRC_SHARED_MODULE)) \
$(addprefix shared-module/, $(SRC_SHARED_MODULE)) $(addprefix shared-module/, $(SRC_SHARED_MODULE))
SRC_S = supervisor/$(CHIP_FAMILY)_cpu.s
OBJ = $(PY_O) $(SUPERVISOR_O) $(addprefix $(BUILD)/, $(SRC_C:.c=.o)) OBJ = $(PY_O) $(SUPERVISOR_O) $(addprefix $(BUILD)/, $(SRC_C:.c=.o))
OBJ += $(addprefix $(BUILD)/, $(SRC_ASF:.c=.o)) OBJ += $(addprefix $(BUILD)/, $(SRC_ASF:.c=.o))
OBJ += $(addprefix $(BUILD)/, $(SRC_COMMON_HAL_EXPANDED:.c=.o)) OBJ += $(addprefix $(BUILD)/, $(SRC_COMMON_HAL_EXPANDED:.c=.o))
@ -419,6 +421,7 @@ OBJ += $(addprefix $(BUILD)/, $(SRC_SHARED_MODULE_EXPANDED:.c=.o))
ifeq ($(INTERNAL_LIBM),1) ifeq ($(INTERNAL_LIBM),1)
OBJ += $(addprefix $(BUILD)/, $(SRC_LIBM:.c=.o)) OBJ += $(addprefix $(BUILD)/, $(SRC_LIBM:.c=.o))
endif endif
OBJ += $(addprefix $(BUILD)/, $(SRC_S:.s=.o))
SRC_QSTR += $(SRC_C) $(SRC_SUPERVISOR) $(SRC_COMMON_HAL_EXPANDED) $(SRC_SHARED_MODULE_EXPANDED) $(STM_SRC_C) SRC_QSTR += $(SRC_C) $(SRC_SUPERVISOR) $(SRC_COMMON_HAL_EXPANDED) $(SRC_SHARED_MODULE_EXPANDED) $(STM_SRC_C)

35
ports/atmel-samd/supervisor/samd21_cpu.s Executable file
View File

@ -0,0 +1,35 @@
.syntax unified
.cpu cortex-m0
.thumb
.text
.align 2
@ uint cpu_get_regs_and_sp(r0=uint regs[10])
.global cpu_get_regs_and_sp
.thumb
.thumb_func
.type cpu_get_regs_and_sp, %function
cpu_get_regs_and_sp:
@ store registers into given array
str r4, [r0, #0]
str r5, [r0, #4]
str r6, [r0, #8]
str r7, [r0, #12]
push {r1}
mov r1, r8
str r1, [r0, #16]
mov r1, r9
str r1, [r0, #20]
mov r1, r10
str r1, [r0, #24]
mov r1, r11
str r1, [r0, #28]
mov r1, r12
str r1, [r0, #32]
mov r1, r13
str r1, [r0, #36]
pop {r1}
@ return the sp
mov r0, sp
bx lr

27
ports/atmel-samd/supervisor/samd51_cpu.s Executable file
View File

@ -0,0 +1,27 @@
.syntax unified
.cpu cortex-m4
.thumb
.text
.align 2
@ uint cpu_get_regs_and_sp(r0=uint regs[10])
.global cpu_get_regs_and_sp
.thumb
.thumb_func
.type cpu_get_regs_and_sp, %function
cpu_get_regs_and_sp:
@ store registers into given array
str r4, [r0], #4
str r5, [r0], #4
str r6, [r0], #4
str r7, [r0], #4
str r8, [r0], #4
str r9, [r0], #4
str r10, [r0], #4
str r11, [r0], #4
str r12, [r0], #4
str r13, [r0], #4
@ return the sp
mov r0, sp
bx lr

15
ports/nrf/Makefile Normal file → Executable file
View File

@ -10,11 +10,9 @@ else
endif endif
endif endif
# If SoftDevice is selected, try to use that one.
# Default to SD132 (exact version can be set with SOFTDEV_VERSION)
SD_LOWER = $(shell echo $(SD) | tr '[:upper:]' '[:lower:]') SD_LOWER = $(shell echo $(SD) | tr '[:upper:]' '[:lower:]')
# If the build directory with SD # Build directory with SD
BUILD = $(if $(SD),build-$(BOARD)-$(SD_LOWER),build-$(BOARD)) BUILD = $(if $(SD),build-$(BOARD)-$(SD_LOWER),build-$(BOARD))
include ../../py/mkenv.mk include ../../py/mkenv.mk
@ -94,19 +92,18 @@ LIBS += -L $(dir $(LIBC_FILE_NAME)) -lc
LIBS += -L $(dir $(LIBGCC_FILE_NAME)) -lgcc LIBS += -L $(dir $(LIBGCC_FILE_NAME)) -lgcc
SRC_HAL = $(addprefix hal/,\ SRC_HAL = $(addprefix hal/,\
hal_uart.c \
hal_rng.c \ hal_rng.c \
) )
SRC_NRFX = $(addprefix nrfx/,\ SRC_NRFX = $(addprefix nrfx/,\
drivers/src/nrfx_power.c \
drivers/src/nrfx_spim.c \ drivers/src/nrfx_spim.c \
drivers/src/nrfx_twim.c \ drivers/src/nrfx_twim.c \
drivers/src/nrfx_power.c \ drivers/src/nrfx_uart.c \
) )
SRC_C += \ SRC_C += \
mphalport.c \ mphalport.c \
help.c \
fatfs_port.c \ fatfs_port.c \
fifo.c \ fifo.c \
tick.c \ tick.c \
@ -126,12 +123,11 @@ SRC_C += \
lib/utils/context_manager_helpers.c \ lib/utils/context_manager_helpers.c \
lib/utils/interrupt_char.c \ lib/utils/interrupt_char.c \
lib/utils/pyexec.c \ lib/utils/pyexec.c \
lib/utils/stdout_helpers.c \
lib/libc/string0.c \ lib/libc/string0.c \
lib/mp-readline/readline.c \ lib/mp-readline/readline.c \
internal_flash.c \ internal_flash.c \
# lib/utils/stdout_helpers.c
ifeq ($(MCU_SUB_VARIANT),nrf52840) ifeq ($(MCU_SUB_VARIANT),nrf52840)
SRC_C += \ SRC_C += \
@ -233,6 +229,8 @@ SRC_SHARED_BINDINGS = \
SRC_SHARED_MODULE_EXPANDED = $(addprefix shared-bindings/, $(SRC_SHARED_BINDINGS)) \ SRC_SHARED_MODULE_EXPANDED = $(addprefix shared-bindings/, $(SRC_SHARED_BINDINGS)) \
$(addprefix shared-module/, $(SRC_SHARED_MODULE)) $(addprefix shared-module/, $(SRC_SHARED_MODULE))
SRC_S = supervisor/cpu.s
FROZEN_MPY_PY_FILES := $(shell find -L $(FROZEN_MPY_DIR) -type f -name '*.py') FROZEN_MPY_PY_FILES := $(shell find -L $(FROZEN_MPY_DIR) -type f -name '*.py')
FROZEN_MPY_MPY_FILES := $(addprefix $(BUILD)/,$(FROZEN_MPY_PY_FILES:.py=.mpy)) FROZEN_MPY_MPY_FILES := $(addprefix $(BUILD)/,$(FROZEN_MPY_PY_FILES:.py=.mpy))
@ -243,6 +241,7 @@ OBJ += $(addprefix $(BUILD)/, $(SRC_NRFX:.c=.o))
OBJ += $(addprefix $(BUILD)/, $(DRIVERS_SRC_C:.c=.o)) OBJ += $(addprefix $(BUILD)/, $(DRIVERS_SRC_C:.c=.o))
OBJ += $(addprefix $(BUILD)/, $(SRC_COMMON_HAL_EXPANDED:.c=.o)) OBJ += $(addprefix $(BUILD)/, $(SRC_COMMON_HAL_EXPANDED:.c=.o))
OBJ += $(addprefix $(BUILD)/, $(SRC_SHARED_MODULE_EXPANDED:.c=.o)) OBJ += $(addprefix $(BUILD)/, $(SRC_SHARED_MODULE_EXPANDED:.c=.o))
OBJ += $(addprefix $(BUILD)/, $(SRC_S:.s=.o))
$(BUILD)/$(FATFS_DIR)/ff.o: COPT += -Os $(BUILD)/$(FATFS_DIR)/ff.o: COPT += -Os
$(filter $(PY_BUILD)/../extmod/vfs_fat_%.o, $(PY_O)): COPT += -Os $(filter $(PY_BUILD)/../extmod/vfs_fat_%.o, $(PY_O)): COPT += -Os

47
ports/nrf/boards/feather52832/mpconfigboard.h
View File

@ -25,47 +25,12 @@
*/ */
#define MICROPY_HW_BOARD_NAME "Bluefruit nRF52 Feather" #define MICROPY_HW_BOARD_NAME "Bluefruit nRF52 Feather"
#define MICROPY_HW_MCU_NAME "NRF52832" #define MICROPY_HW_MCU_NAME "nRF52832"
#define MICROPY_PY_SYS_PLATFORM "nrf52" #define MICROPY_PY_SYS_PLATFORM "nRF52"
#define MICROPY_HW_HAS_LED (1) #define MICROPY_HW_UART_RX NRF_GPIO_PIN_MAP(0, 8)
#define MICROPY_HW_HAS_SWITCH (0) #define MICROPY_HW_UART_TX NRF_GPIO_PIN_MAP(0, 6)
#define MICROPY_HW_HAS_FLASH (0) #define MICROPY_HW_UART_HWFC (0)
#define MICROPY_HW_HAS_SDCARD (0)
#define MICROPY_HW_HAS_MMA7660 (0)
#define MICROPY_HW_HAS_LIS3DSH (0)
#define MICROPY_HW_HAS_LCD (0)
#define MICROPY_HW_ENABLE_RNG (0)
#define MICROPY_HW_ENABLE_RTC (0)
#define MICROPY_HW_ENABLE_TIMER (0)
#define MICROPY_HW_ENABLE_SERVO (0)
#define MICROPY_HW_ENABLE_DAC (0)
#define MICROPY_HW_ENABLE_CAN (0)
#define MICROPY_HW_LED_COUNT (2) #define PORT_HEAP_SIZE (32 * 1024)
#define MICROPY_HW_LED_PULLUP (0)
#define MICROPY_HW_LED1 (17) // LED1
#define MICROPY_HW_LED2 (19) // LED2
// UART config
#define MICROPY_HW_UART1_RX (pin_P0_08)
#define MICROPY_HW_UART1_TX (pin_P0_06)
#define MICROPY_HW_UART1_HWFC (0)
// SPI0 config
#define MICROPY_HW_SPI0_NAME "SPI0"
#define MICROPY_HW_SPI0_SCK (pin_P0_12) // (Arduino D13)
#define MICROPY_HW_SPI0_MOSI (pin_P0_13) // (Arduino D11)
#define MICROPY_HW_SPI0_MISO (pin_P0_14) // (Arduino D12)
#define MICROPY_HW_PWM0_NAME "PWM0"
#define MICROPY_HW_PWM1_NAME "PWM1"
#define MICROPY_HW_PWM2_NAME "PWM2"
#define HELP_TEXT_BOARD_LED "1,2"
#define PORT_HEAP_SIZE (32*1024)
#define CIRCUITPY_AUTORELOAD_DELAY_MS 500 #define CIRCUITPY_AUTORELOAD_DELAY_MS 500

51
ports/nrf/boards/feather52840/mpconfigboard.h
View File

@ -27,51 +27,12 @@
#define FEATHER52840 #define FEATHER52840
#define MICROPY_HW_BOARD_NAME "Feather52840" #define MICROPY_HW_BOARD_NAME "Feather52840"
#define MICROPY_HW_MCU_NAME "NRF52840" #define MICROPY_HW_MCU_NAME "nRF52840"
#define MICROPY_PY_SYS_PLATFORM "nrf52840" #define MICROPY_PY_SYS_PLATFORM "Feather52840"
#define MICROPY_HW_HAS_LED (1) #define MICROPY_HW_UART_RX NRF_GPIO_PIN_MAP(0, 8)
#define MICROPY_HW_HAS_SWITCH (0) #define MICROPY_HW_UART_TX NRF_GPIO_PIN_MAP(0, 6)
#define MICROPY_HW_HAS_FLASH (0) #define MICROPY_HW_UART_HWFC (0)
#define MICROPY_HW_HAS_SDCARD (0)
#define MICROPY_HW_HAS_MMA7660 (0)
#define MICROPY_HW_HAS_LIS3DSH (0)
#define MICROPY_HW_HAS_LCD (0)
#define MICROPY_HW_ENABLE_RNG (0)
#define MICROPY_HW_ENABLE_RTC (0)
#define MICROPY_HW_ENABLE_TIMER (0)
#define MICROPY_HW_ENABLE_SERVO (0)
#define MICROPY_HW_ENABLE_DAC (0)
#define MICROPY_HW_ENABLE_CAN (0)
#define MICROPY_HW_LED_COUNT (2) #define PORT_HEAP_SIZE (128 * 1024)
#define MICROPY_HW_LED_PULLUP (1)
#define MICROPY_HW_LED1 (pin_P1_02) // LED1
#define MICROPY_HW_LED2 (pin_P1_10) // LED2
// UART config
#define MICROPY_HW_UART1_RX (pin_P1_00)
#define MICROPY_HW_UART1_TX (pin_P0_24)
#define MICROPY_HW_UART1_CTS (NULL)
#define MICROPY_HW_UART1_RTS (NULL)
#define MICROPY_HW_UART1_HWFC (0)
// SPI0 config
#define MICROPY_HW_SPI0_NAME "SPI0"
#define MICROPY_HW_SPI0_SCK (pin_P0_20)
#define MICROPY_HW_SPI0_MOSI (pin_P0_23)
#define MICROPY_HW_SPI0_MISO (pin_P0_22)
#define MICROPY_HW_PWM0_NAME "PWM0"
#define MICROPY_HW_PWM1_NAME "PWM1"
#define MICROPY_HW_PWM2_NAME "PWM2"
#if 0
#define MICROPY_HW_PWM3_NAME "PWM3"
#endif
#define HELP_TEXT_BOARD_LED "1,2,3,4"
#define PORT_HEAP_SIZE (128*1024)
#define CIRCUITPY_AUTORELOAD_DELAY_MS 500 #define CIRCUITPY_AUTORELOAD_DELAY_MS 500

51
ports/nrf/boards/pca10040/mpconfigboard.h
View File

@ -24,52 +24,13 @@
* THE SOFTWARE. * THE SOFTWARE.
*/ */
#define PCA10040
#define MICROPY_HW_BOARD_NAME "PCA10040" #define MICROPY_HW_BOARD_NAME "PCA10040"
#define MICROPY_HW_MCU_NAME "NRF52832" #define MICROPY_HW_MCU_NAME "nRF52832"
#define MICROPY_PY_SYS_PLATFORM "nrf52-DK" #define MICROPY_PY_SYS_PLATFORM "nRF52-DK"
#define MICROPY_HW_HAS_LED (1) #define MICROPY_HW_UART_RX NRF_GPIO_PIN_MAP(0, 8)
#define MICROPY_HW_HAS_SWITCH (0) #define MICROPY_HW_UART_TX NRF_GPIO_PIN_MAP(0, 6)
#define MICROPY_HW_HAS_FLASH (0) #define MICROPY_HW_UART_HWFC (0)
#define MICROPY_HW_HAS_SDCARD (0)
#define MICROPY_HW_HAS_MMA7660 (0)
#define MICROPY_HW_HAS_LIS3DSH (0)
#define MICROPY_HW_HAS_LCD (0)
#define MICROPY_HW_ENABLE_RNG (0)
#define MICROPY_HW_ENABLE_RTC (0)
#define MICROPY_HW_ENABLE_TIMER (0)
#define MICROPY_HW_ENABLE_SERVO (0)
#define MICROPY_HW_ENABLE_DAC (0)
#define MICROPY_HW_ENABLE_CAN (0)
#define MICROPY_HW_LED_COUNT (4) #define PORT_HEAP_SIZE (32 * 1024)
#define MICROPY_HW_LED_PULLUP (1)
#define MICROPY_HW_LED1 (17) // LED1
#define MICROPY_HW_LED2 (18) // LED2
#define MICROPY_HW_LED3 (19) // LED3
#define MICROPY_HW_LED4 (20) // LED4
// UART config
#define MICROPY_HW_UART1_RX (pin_P0_08)
#define MICROPY_HW_UART1_TX (pin_P0_06)
#define MICROPY_HW_UART1_CTS (pin_P0_07)
#define MICROPY_HW_UART1_RTS (pin_P0_05)
#define MICROPY_HW_UART1_HWFC (1)
// SPI0 config
#define MICROPY_HW_SPI0_NAME "SPI0"
#define MICROPY_HW_SPI0_SCK (pin_P0_25) // (Arduino D13)
#define MICROPY_HW_SPI0_MOSI (pin_P0_23) // (Arduino D11)
#define MICROPY_HW_SPI0_MISO (pin_P0_24) // (Arduino D12)
#define MICROPY_HW_PWM0_NAME "PWM0"
#define MICROPY_HW_PWM1_NAME "PWM1"
#define MICROPY_HW_PWM2_NAME "PWM2"
#define HELP_TEXT_BOARD_LED "1,2,3,4"
#define PORT_HEAP_SIZE (32*1024)
#define CIRCUITPY_AUTORELOAD_DELAY_MS 500 #define CIRCUITPY_AUTORELOAD_DELAY_MS 500

55
ports/nrf/boards/pca10056/mpconfigboard.h
View File

@ -24,58 +24,15 @@
* THE SOFTWARE. * THE SOFTWARE.
*/ */
#define PCA10056
#define MICROPY_HW_BOARD_NAME "PCA10056" #define MICROPY_HW_BOARD_NAME "PCA10056"
#define MICROPY_HW_MCU_NAME "NRF52840" #define MICROPY_HW_MCU_NAME "nRF52840"
#define MICROPY_PY_SYS_PLATFORM "nrf52840-DK" #define MICROPY_PY_SYS_PLATFORM "nRF52840-DK"
#define MICROPY_HW_HAS_LED (1) #define MICROPY_HW_UART_RX NRF_GPIO_PIN_MAP(0, 8)
#define MICROPY_HW_HAS_SWITCH (0) #define MICROPY_HW_UART_TX NRF_GPIO_PIN_MAP(0, 6)
#define MICROPY_HW_HAS_FLASH (0) #define MICROPY_HW_UART_HWFC (0)
#define MICROPY_HW_HAS_SDCARD (0)
#define MICROPY_HW_HAS_MMA7660 (0)
#define MICROPY_HW_HAS_LIS3DSH (0)
#define MICROPY_HW_HAS_LCD (0)
#define MICROPY_HW_ENABLE_RNG (0)
#define MICROPY_HW_ENABLE_RTC (0)
#define MICROPY_HW_ENABLE_TIMER (0)
#define MICROPY_HW_ENABLE_SERVO (0)
#define MICROPY_HW_ENABLE_DAC (0)
#define MICROPY_HW_ENABLE_CAN (0)
#define MICROPY_HW_LED_COUNT (4) #define PORT_HEAP_SIZE (128 * 1024)
#define MICROPY_HW_LED_PULLUP (1)
#define MICROPY_HW_LED1 (13) // LED1
#define MICROPY_HW_LED2 (14) // LED2
#define MICROPY_HW_LED3 (15) // LED3
#define MICROPY_HW_LED4 (16) // LED4
// UART config
#define MICROPY_HW_UART1_RX (pin_P0_08)
#define MICROPY_HW_UART1_TX (pin_P0_06)
#define MICROPY_HW_UART1_CTS (pin_P0_07)
#define MICROPY_HW_UART1_RTS (pin_P0_05)
#define MICROPY_HW_UART1_HWFC (1)
// SPI0 config
#define MICROPY_HW_SPI0_NAME "SPI0"
#define MICROPY_HW_SPI0_SCK (pin_P1_15)
#define MICROPY_HW_SPI0_MOSI (pin_P1_13)
#define MICROPY_HW_SPI0_MISO (pin_P1_14)
#define MICROPY_HW_PWM0_NAME "PWM0"
#define MICROPY_HW_PWM1_NAME "PWM1"
#define MICROPY_HW_PWM2_NAME "PWM2"
#if 0
#define MICROPY_HW_PWM3_NAME "PWM3"
#endif
#define HELP_TEXT_BOARD_LED "1,2,3,4"
#define PORT_HEAP_SIZE (128*1024)
#define CIRCUITPY_AUTORELOAD_DELAY_MS 500 #define CIRCUITPY_AUTORELOAD_DELAY_MS 500

31
ports/nrf/common-hal/busio/I2C.c
View File

@ -34,6 +34,7 @@
#include "nrf_gpio.h" #include "nrf_gpio.h"
#define INST_NO 0 #define INST_NO 0
#define MAX_XFER_SIZE ((1U << NRFX_CONCAT_3(TWIM, INST_NO, _EASYDMA_MAXCNT_SIZE)) - 1)
static uint8_t twi_error_to_mp(const nrfx_err_t err) { static uint8_t twi_error_to_mp(const nrfx_err_t err) {
switch (err) { switch (err) {
@ -152,8 +153,21 @@ uint8_t common_hal_busio_i2c_write(busio_i2c_obj_t *self, uint16_t addr, const u
if(len == 0) if(len == 0)
return common_hal_busio_i2c_probe(self, addr) ? 0 : MP_ENODEV; return common_hal_busio_i2c_probe(self, addr) ? 0 : MP_ENODEV;
const uint32_t parts = len / MAX_XFER_SIZE;
const uint32_t remainder = len % MAX_XFER_SIZE;
nrfx_err_t err = NRFX_SUCCESS;
nrfx_twim_enable(&self->twim); nrfx_twim_enable(&self->twim);
const nrfx_err_t err = nrfx_twim_tx(&self->twim, addr, data, len, !stopBit);
for (uint32_t i = 0; i < parts; ++i) {
err = nrfx_twim_tx(&self->twim, addr, data + i * MAX_XFER_SIZE, MAX_XFER_SIZE, !stopBit);
if (err != NRFX_SUCCESS)
break;
}
if ((remainder > 0) && (err == NRFX_SUCCESS))
err = nrfx_twim_tx(&self->twim, addr, data + parts * MAX_XFER_SIZE, remainder, !stopBit);
nrfx_twim_disable(&self->twim); nrfx_twim_disable(&self->twim);
return twi_error_to_mp(err); return twi_error_to_mp(err);
@ -163,8 +177,21 @@ uint8_t common_hal_busio_i2c_read(busio_i2c_obj_t *self, uint16_t addr, uint8_t
if(len == 0) if(len == 0)
return 0; return 0;
const uint32_t parts = len / MAX_XFER_SIZE;
const uint32_t remainder = len % MAX_XFER_SIZE;
nrfx_err_t err = NRFX_SUCCESS;
nrfx_twim_enable(&self->twim); nrfx_twim_enable(&self->twim);
const nrfx_err_t err = nrfx_twim_rx(&self->twim, addr, data, len);
for (uint32_t i = 0; i < parts; ++i) {
err = nrfx_twim_rx(&self->twim, addr, data + i * MAX_XFER_SIZE, MAX_XFER_SIZE);
if (err != NRFX_SUCCESS)
break;
}
if ((remainder > 0) && (err == NRFX_SUCCESS))
err = nrfx_twim_rx(&self->twim, addr, data + parts * MAX_XFER_SIZE, remainder);
nrfx_twim_disable(&self->twim); nrfx_twim_disable(&self->twim);
return twi_error_to_mp(err); return twi_error_to_mp(err);

58
ports/nrf/common-hal/busio/SPI.c
View File

@ -33,6 +33,8 @@
#define INST_NO 2 #define INST_NO 2
#endif #endif
#define MAX_XFER_SIZE ((1U << NRFX_CONCAT_3(SPIM, INST_NO, _EASYDMA_MAXCNT_SIZE)) - 1)
// Convert frequency to clock-speed-dependent value // Convert frequency to clock-speed-dependent value
static nrf_spim_frequency_t baudrate_to_spim_frequency(const uint32_t baudrate) { static nrf_spim_frequency_t baudrate_to_spim_frequency(const uint32_t baudrate) {
if (baudrate <= 125000) if (baudrate <= 125000)
@ -152,30 +154,68 @@ bool common_hal_busio_spi_write(busio_spi_obj_t *self, const uint8_t *data, size
if (len == 0) if (len == 0)
return true; return true;
const nrfx_spim_xfer_desc_t xfer = NRFX_SPIM_XFER_TX(data, len); const uint32_t parts = len / MAX_XFER_SIZE;
const nrfx_err_t err = nrfx_spim_xfer(&self->spim, &xfer, 0); const uint32_t remainder = len % MAX_XFER_SIZE;
return (err == NRFX_SUCCESS); for (uint32_t i = 0; i < parts; ++i) {
const nrfx_spim_xfer_desc_t xfer = NRFX_SPIM_XFER_TX(data + i * MAX_XFER_SIZE, MAX_XFER_SIZE);
if (nrfx_spim_xfer(&self->spim, &xfer, 0) != NRFX_SUCCESS)
return false;
}
if (remainder > 0) {
const nrfx_spim_xfer_desc_t xfer = NRFX_SPIM_XFER_TX(data + parts * MAX_XFER_SIZE, remainder);
if (nrfx_spim_xfer(&self->spim, &xfer, 0) != NRFX_SUCCESS)
return false;
}
return true;
} }
bool common_hal_busio_spi_read(busio_spi_obj_t *self, uint8_t *data, size_t len, uint8_t write_value) { bool common_hal_busio_spi_read(busio_spi_obj_t *self, uint8_t *data, size_t len, uint8_t write_value) {
if (len == 0) if (len == 0)
return true; return true;
const nrfx_spim_xfer_desc_t xfer = NRFX_SPIM_XFER_RX(data, len); const uint32_t parts = len / MAX_XFER_SIZE;
const nrfx_err_t err = nrfx_spim_xfer(&self->spim, &xfer, 0); const uint32_t remainder = len % MAX_XFER_SIZE;
return (err == NRFX_SUCCESS); for (uint32_t i = 0; i < parts; ++i) {
const nrfx_spim_xfer_desc_t xfer = NRFX_SPIM_XFER_RX(data + i * MAX_XFER_SIZE, MAX_XFER_SIZE);
if (nrfx_spim_xfer(&self->spim, &xfer, 0) != NRFX_SUCCESS)
return false;
}
if (remainder > 0) {
const nrfx_spim_xfer_desc_t xfer = NRFX_SPIM_XFER_RX(data + parts * MAX_XFER_SIZE, remainder);
if (nrfx_spim_xfer(&self->spim, &xfer, 0) != NRFX_SUCCESS)
return false;
}
return true;
} }
bool common_hal_busio_spi_transfer(busio_spi_obj_t *self, uint8_t *data_out, uint8_t *data_in, size_t len) { bool common_hal_busio_spi_transfer(busio_spi_obj_t *self, uint8_t *data_out, uint8_t *data_in, size_t len) {
if (len == 0) if (len == 0)
return true; return true;
const nrfx_spim_xfer_desc_t xfer = NRFX_SPIM_SINGLE_XFER(data_out, len, data_in, len); const uint32_t parts = len / MAX_XFER_SIZE;
const nrfx_err_t err = nrfx_spim_xfer(&self->spim, &xfer, 0); const uint32_t remainder = len % MAX_XFER_SIZE;
return (err == NRFX_SUCCESS); for (uint32_t i = 0; i < parts; ++i) {
const nrfx_spim_xfer_desc_t xfer = NRFX_SPIM_SINGLE_XFER(data_out + i * MAX_XFER_SIZE, MAX_XFER_SIZE,
data_in + i * MAX_XFER_SIZE, MAX_XFER_SIZE);
if (nrfx_spim_xfer(&self->spim, &xfer, 0) != NRFX_SUCCESS)
return false;
}
if (remainder > 0) {
const nrfx_spim_xfer_desc_t xfer = NRFX_SPIM_SINGLE_XFER(data_out + parts * MAX_XFER_SIZE, remainder,
data_in + parts * MAX_XFER_SIZE, remainder);
if (nrfx_spim_xfer(&self->spim, &xfer, 0) != NRFX_SUCCESS)
return false;
}
return true;
} }
uint32_t common_hal_busio_spi_get_frequency(busio_spi_obj_t* self) { uint32_t common_hal_busio_spi_get_frequency(busio_spi_obj_t* self) {

185
ports/nrf/hal/hal_uart.c
View File

@ -1,185 +0,0 @@
/*
* This file is part of the MicroPython project, http://micropython.org/
*
* The MIT License (MIT)
*
* Copyright (c) 2016 Glenn Ruben Bakke
*
* 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 <stdint.h>
#include <stdio.h>
#include "nrf.h"
#include "mphalport.h"
#include "hal_uart.h"
#include "fifo.h"
#include "lib/utils/interrupt_char.h"
#ifdef HAL_UART_MODULE_ENABLED
FIFO_DEF(_ff_uart, 128, uint8_t, true, UARTE0_UART0_IRQn);
uint32_t hal_uart_baudrate_lookup[] = {
UART_BAUDRATE_BAUDRATE_Baud1200, ///< 1200 baud.
UART_BAUDRATE_BAUDRATE_Baud2400, ///< 2400 baud.
UART_BAUDRATE_BAUDRATE_Baud4800, ///< 4800 baud.
UART_BAUDRATE_BAUDRATE_Baud9600, ///< 9600 baud.
UART_BAUDRATE_BAUDRATE_Baud14400, ///< 14400 baud.
UART_BAUDRATE_BAUDRATE_Baud19200, ///< 19200 baud.
UART_BAUDRATE_BAUDRATE_Baud28800, ///< 28800 baud.
UART_BAUDRATE_BAUDRATE_Baud38400, ///< 38400 baud.
UART_BAUDRATE_BAUDRATE_Baud57600, ///< 57600 baud.
UART_BAUDRATE_BAUDRATE_Baud76800, ///< 76800 baud.
UART_BAUDRATE_BAUDRATE_Baud115200, ///< 115200 baud.
UART_BAUDRATE_BAUDRATE_Baud230400, ///< 230400 baud.
UART_BAUDRATE_BAUDRATE_Baud250000, ///< 250000 baud.
UART_BAUDRATE_BAUDRATE_Baud460800, ///< 460800 baud.
UART_BAUDRATE_BAUDRATE_Baud921600, ///< 921600 baud.
UART_BAUDRATE_BAUDRATE_Baud1M, ///< 1000000 baud.
};
hal_uart_error_t hal_uart_char_write(NRF_UART_Type * p_instance, uint8_t ch) {
p_instance->ERRORSRC = 0;
p_instance->TXD = (uint8_t)ch;
while (p_instance->EVENTS_TXDRDY != 1) {
// Blocking wait.
}
// Clear the TX flag.
p_instance->EVENTS_TXDRDY = 0;
return p_instance->ERRORSRC;
}
hal_uart_error_t hal_uart_char_read(NRF_UART_Type * p_instance, uint8_t * ch) {
while ( !fifo_read(_ff_uart, ch) ) {
// wait for fifo data
}
return HAL_UART_ERROR_NONE;
}
hal_uart_error_t hal_uart_buffer_write(NRF_UART_Type * p_instance, uint8_t * p_buffer, uint32_t num_of_bytes, uart_complete_cb cb) {
int i = 0;
hal_uart_error_t err = 0;
uint8_t ch = p_buffer[i++];
while (i < num_of_bytes) {
err = hal_uart_char_write(p_instance, ch);
if (err) {
return err;
}
ch = p_buffer[i++];
}
cb();
return err;
}
hal_uart_error_t hal_uart_buffer_read(NRF_UART_Type * p_instance, uint8_t * p_buffer, uint32_t num_of_bytes, uart_complete_cb cb) {
int i = 0;
hal_uart_error_t err = 0;
while (i < num_of_bytes) {
hal_uart_error_t err = hal_uart_char_read(p_instance, &p_buffer[i]);
if (err) {
return err;
}
i++;
}
cb();
return err;
}
int hal_uart_available(NRF_UART_Type * p_instance)
{
return fifo_count(_ff_uart);
}
void hal_uart_init(NRF_UART_Type * p_instance, hal_uart_init_t const * p_uart_init) {
hal_gpio_cfg_pin(p_uart_init->tx_pin->port, p_uart_init->tx_pin->pin, HAL_GPIO_MODE_OUTPUT, HAL_GPIO_PULL_DISABLED);
hal_gpio_cfg_pin(p_uart_init->rx_pin->port, p_uart_init->rx_pin->pin, HAL_GPIO_MODE_INPUT, HAL_GPIO_PULL_DISABLED);
hal_gpio_pin_clear(p_uart_init->tx_pin->port, p_uart_init->tx_pin->pin);
p_instance->PSELTXD = p_uart_init->tx_pin->pin;
p_instance->PSELRXD = p_uart_init->rx_pin->pin;
#if NRF52840_XXAA
p_instance->PSELTXD |= (p_uart_init->tx_pin->port << UARTE_PSEL_TXD_PORT_Pos);
p_instance->PSELRXD |= (p_uart_init->rx_pin->port << UARTE_PSEL_RXD_PORT_Pos);
#endif
if (p_uart_init->flow_control) {
hal_gpio_cfg_pin(p_uart_init->rts_pin->port, p_uart_init->rts_pin->pin, HAL_GPIO_MODE_OUTPUT, HAL_GPIO_PULL_DISABLED);
hal_gpio_cfg_pin(p_uart_init->cts_pin->port, p_uart_init->cts_pin->pin, HAL_GPIO_MODE_INPUT, HAL_GPIO_PULL_DISABLED);
p_instance->PSELCTS = p_uart_init->cts_pin->pin;
p_instance->PSELRTS = p_uart_init->rts_pin->pin;
#if NRF52840_XXAA
p_instance->PSELCTS |= (p_uart_init->cts_pin->port << UARTE_PSEL_CTS_PORT_Pos);
p_instance->PSELRTS |= (p_uart_init->rts_pin->port << UARTE_PSEL_RTS_PORT_Pos);
#endif
p_instance->CONFIG = (UART_CONFIG_HWFC_Enabled << UART_CONFIG_HWFC_Pos);
}
p_instance->BAUDRATE = (hal_uart_baudrate_lookup[p_uart_init->baud_rate]);
p_instance->ENABLE = (UART_ENABLE_ENABLE_Enabled << UART_ENABLE_ENABLE_Pos);
p_instance->EVENTS_TXDRDY = 0;
p_instance->EVENTS_RXDRDY = 0;
p_instance->TASKS_STARTTX = 1;
p_instance->TASKS_STARTRX = 1;
// Adafruit IRQ + fifo
fifo_clear(_ff_uart);
p_instance->INTENSET = UART_INTENSET_RXDRDY_Msk;
NVIC_ClearPendingIRQ(p_uart_init->irq_num);
NVIC_SetPriority(p_uart_init->irq_num, p_uart_init->irq_priority);
NVIC_EnableIRQ(p_uart_init->irq_num);
}
bool hal_uart_inited(NRF_UART_Type * p_instance)
{
return !(p_instance->PSELTXD & (1 << 31)) && !(p_instance->PSELRXD & (1 << 31));
}
void UARTE0_UART0_IRQHandler(void)
{
NRF_UART_Type * p_instance = NRF_UART0;
if (p_instance->EVENTS_RXDRDY)
{
uint8_t ch = (uint8_t) p_instance->RXD;
// Keyboard interrupt
if (mp_interrupt_char != -1 && ch == mp_interrupt_char)
{
mp_keyboard_interrupt();
}else
{
fifo_write(_ff_uart, &ch);
}
p_instance->EVENTS_RXDRDY = 0x0UL;
}
}
#endif // HAL_UART_MODULE_ENABLED

114
ports/nrf/hal/hal_uart.h
View File

@ -1,114 +0,0 @@
/*
* This file is part of the MicroPython project, http://micropython.org/
*
* The MIT License (MIT)
*
* Copyright (c) 2016 Glenn Ruben Bakke
*
* 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.
*/
#ifndef HAL_UART_H__
#define HAL_UART_H__
#include <stdint.h>
#include <stdbool.h>
#include "nrf.h"
#define UART_HWCONTROL_NONE ((uint32_t)UARTE_CONFIG_HWFC_Disabled << UARTE_CONFIG_HWFC_Pos)
#define UART_HWCONTROL_RTS_CTS ((uint32_t)(UARTE_CONFIG_HWFC_Enabled << UARTE_CONFIG_HWFC_Pos)
#define IS_UART_HARDWARE_FLOW_CONTROL(CONTROL)\
(((CONTROL) == UART_HWCONTROL_NONE) || \
((CONTROL) == UART_HWCONTROL_RTS_CTS))
#ifdef HAL_UART_MODULE_ENABLED
#define UART_BASE_POINTERS (const uint32_t[]){NRF_UART0_BASE}
#define UART_IRQ_VALUES (const uint32_t[]){UARTE0_UART0_IRQn}
#else // HAL_UARTE_MODULE_ENABLED
#ifdef NRF52832_XXAA
#define UART_BASE_POINTERS (const uint32_t[]){NRF_UARTE0_BASE}
#define UART_IRQ_VALUES (const uint32_t[]){UARTE0_UART0_IRQn}
#elif NRF52840_XXAA
#define UART_BASE_POINTERS (const uint32_t[]){NRF_UARTE0_BASE, \
NRF_UARTE1_BASE}
#define UART_IRQ_VALUES (const uint32_t[]){UARTE0_UART0_IRQn, \
UARTE1_IRQn}
#endif // HAL_UARTE_MODULE_ENABLED
#endif
#define UART_BASE(x) ((NRF_UART_Type *)UART_BASE_POINTERS[x])
#define UART_IRQ_NUM(x) (UART_IRQ_VALUES[x])
typedef enum
{
HAL_UART_ERROR_NONE = 0x00, /*!< No error */
HAL_UART_ERROR_ORE = 0x01, /*!< Overrun error. A start bit is received while the previous data still lies in RXD. (Previous data is lost.) */
HAL_UART_ERROR_PE = 0x02, /*!< Parity error. A character with bad parity is received, if HW parity check is enabled. */
HAL_UART_ERROR_FE = 0x04, /*!< Frame error. A valid stop bit is not detected on the serial data input after all bits in a character have been received. */
HAL_UART_ERROR_BE = 0x08, /*!< Break error. The serial data input is '0' for longer than the length of a data frame. (The data frame length is 10 bits without parity bit, and 11 bits with parity bit.). */
} hal_uart_error_t;
typedef enum {
HAL_UART_BAUD_1K2 = 0, /**< 1200 baud */
HAL_UART_BAUD_2K4, /**< 2400 baud */
HAL_UART_BAUD_4K8, /**< 4800 baud */
HAL_UART_BAUD_9K6, /**< 9600 baud */
HAL_UART_BAUD_14K4, /**< 14.4 kbaud */
HAL_UART_BAUD_19K2, /**< 19.2 kbaud */
HAL_UART_BAUD_28K8, /**< 28.8 kbaud */
HAL_UART_BAUD_38K4, /**< 38.4 kbaud */
HAL_UART_BAUD_57K6, /**< 57.6 kbaud */
HAL_UART_BAUD_76K8, /**< 76.8 kbaud */
HAL_UART_BAUD_115K2, /**< 115.2 kbaud */
HAL_UART_BAUD_230K4, /**< 230.4 kbaud */
HAL_UART_BAUD_250K0, /**< 250.0 kbaud */
HAL_UART_BAUD_500K0, /**< 500.0 kbaud */
HAL_UART_BAUD_1M0 /**< 1 mbaud */
} hal_uart_baudrate_t;
typedef struct {
uint8_t id; /* UART instance id */
const pin_obj_t * rx_pin; /* RX pin. */
const pin_obj_t * tx_pin; /* TX pin. */
const pin_obj_t * rts_pin; /* RTS pin, only used if flow control is enabled. */
const pin_obj_t * cts_pin; /* CTS pin, only used if flow control is enabled. */
bool flow_control; /* Flow control setting, if flow control is used, the system will use low power UART mode, based on CTS signal. */
bool use_parity; /* Even parity if TRUE, no parity if FALSE. */
uint32_t baud_rate; /* Baud rate configuration. */
uint32_t irq_priority; /* UARTE IRQ priority. */
uint32_t irq_num;
} hal_uart_init_t;
typedef struct
{
NRF_UART_Type * p_instance; /* UART registers base address */
hal_uart_init_t init; /* UART communication parameters */
} UART_HandleTypeDef;
typedef void (*uart_complete_cb)(void);
void hal_uart_init(NRF_UART_Type * p_instance, hal_uart_init_t const * p_uart_init);
bool hal_uart_inited(NRF_UART_Type * p_instance);
hal_uart_error_t hal_uart_char_write(NRF_UART_Type * p_instance, uint8_t ch);
hal_uart_error_t hal_uart_char_read(NRF_UART_Type * p_instance, uint8_t * ch);
int hal_uart_available(NRF_UART_Type * p_instance);
#endif // HAL_UART_H__

10
ports/nrf/mpconfigport.h
View File

@ -93,8 +93,8 @@
#define MICROPY_PY_BUILTINS_EXECFILE (0) #define MICROPY_PY_BUILTINS_EXECFILE (0)
#define MICROPY_PY_BUILTINS_COMPILE (1) #define MICROPY_PY_BUILTINS_COMPILE (1)
#define MICROPY_PY_BUILTINS_HELP (1) #define MICROPY_PY_BUILTINS_HELP (1)
#define MICROPY_PY_BUILTINS_HELP_TEXT nrf5_help_text
#define MICROPY_PY_BUILTINS_HELP_MODULES (1) #define MICROPY_PY_BUILTINS_HELP_MODULES (1)
#define MICROPY_PY_BUILTINS_HELP_TEXT circuitpython_help_text
#define MICROPY_PY_BUILTINS_INPUT (1) #define MICROPY_PY_BUILTINS_INPUT (1)
#define MICROPY_MODULE_BUILTIN_INIT (1) #define MICROPY_MODULE_BUILTIN_INIT (1)
#define MICROPY_PY_ALL_SPECIAL_METHODS (0) #define MICROPY_PY_ALL_SPECIAL_METHODS (0)
@ -126,14 +126,6 @@
#define MICROPY_KBD_EXCEPTION (1) #define MICROPY_KBD_EXCEPTION (1)
#ifndef MICROPY_HW_LED_COUNT
#define MICROPY_HW_LED_COUNT (0)
#endif
#ifndef MICROPY_HW_LED_PULLUP
#define MICROPY_HW_LED_PULLUP (0)
#endif
#ifndef MICROPY_PY_HW_RNG #ifndef MICROPY_PY_HW_RNG
#define MICROPY_PY_HW_RNG (1) #define MICROPY_PY_HW_RNG (1)
#endif #endif

89
ports/nrf/mphalport.c
View File

@ -4,6 +4,7 @@
* The MIT License (MIT) * The MIT License (MIT)
* *
* Copyright (c) 2015 Glenn Ruben Bakke * Copyright (c) 2015 Glenn Ruben Bakke
* Copyright (c) 2018 Artur Pacholec
* *
* Permission is hereby granted, free of charge, to any person obtaining a copy * Permission is hereby granted, free of charge, to any person obtaining a copy
* of this software and associated documentation files (the "Software"), to deal * of this software and associated documentation files (the "Software"), to deal
@ -27,73 +28,36 @@
#include <errno.h> #include <errno.h>
#include <string.h> #include <string.h>
#include "mphalport.h"
#include "py/mpstate.h" #include "py/mpstate.h"
#include "py/mphal.h"
#include "py/mperrno.h"
#include "tick.h"
#if !defined( NRF52840_XXAA) || ( defined(CFG_HWUART_FOR_SERIAL) && CFG_HWUART_FOR_SERIAL == 1 )
#include "hal_uart.h"
#define UART_INSTANCE UART_BASE(0)
#if (MICROPY_PY_BLE_NUS == 0) #if (MICROPY_PY_BLE_NUS == 0)
#if !defined( NRF52840_XXAA) || ( defined(CFG_HWUART_FOR_SERIAL) && CFG_HWUART_FOR_SERIAL == 1 )
int mp_hal_stdin_rx_chr(void) { int mp_hal_stdin_rx_chr(void) {
for (;;) { uint8_t data = 0;
#ifdef MICROPY_VM_HOOK_LOOP
MICROPY_VM_HOOK_LOOP
#endif
// if (reload_requested) {
// return CHAR_CTRL_D;
// }
if ( hal_uart_available(UART_INSTANCE) ) { while (!nrfx_uart_rx_ready(&serial_instance));
uint8_t ch;
hal_uart_char_read(UART_INSTANCE, &ch);
return (int) ch;
}
}
return 0; const nrfx_err_t err = nrfx_uart_rx(&serial_instance, &data, sizeof(data));
if (err == NRFX_SUCCESS)
NRFX_ASSERT(err);
return data;
} }
bool mp_hal_stdin_any(void) { bool mp_hal_stdin_any(void) {
return hal_uart_available(UART_INSTANCE); return nrfx_uart_rx_ready(&serial_instance);
} }
void mp_hal_stdout_tx_strn(const char *str, mp_uint_t len) { void mp_hal_stdout_tx_strn(const char *str, mp_uint_t len) {
if (len == 0)
return;
// #ifdef MICROPY_HW_LED_TX const nrfx_err_t err = nrfx_uart_tx(&serial_instance, (uint8_t*)str, len);
// gpio_toggle_pin_level(MICROPY_HW_LED_TX); if (err == NRFX_SUCCESS)
// #endif NRFX_ASSERT(err);
//
// #ifdef CIRCUITPY_BOOT_OUTPUT_FILE
// if (boot_output_file != NULL) {
// UINT bytes_written = 0;
// f_write(boot_output_file, str, len, &bytes_written);
// }
// #endif
if ( hal_uart_inited(UART_INSTANCE) ) {
while(len--) {
hal_uart_char_write(UART_INSTANCE, *str++);
}
}
}
void mp_hal_stdout_tx_strn_cooked(const char *str, mp_uint_t len) {
while(len--){
if (*str == '\n') {
hal_uart_char_write(UART_INSTANCE, '\r');
}
hal_uart_char_write(UART_INSTANCE, *str++);
}
}
#endif
void mp_hal_stdout_tx_str(const char *str) {
mp_hal_stdout_tx_strn(str, strlen(str));
} }
#else #else
@ -140,22 +104,14 @@ void mp_hal_stdout_tx_strn(const char *str, mp_uint_t len) {
tud_cdc_write(str, len); tud_cdc_write(str, len);
} }
// TODO use stdout_helper.c #endif // USB
void mp_hal_stdout_tx_strn_cooked(const char *str, size_t len) {
while (len--) {
if (*str == '\n') {
mp_hal_stdout_tx_strn("\r", 1);
}
mp_hal_stdout_tx_strn(str++, 1);
}
}
void mp_hal_stdout_tx_str(const char *str) { #endif // NUS
mp_hal_stdout_tx_strn(str, strlen(str));
}
#endif
/*------------------------------------------------------------------*/
/* delay
*------------------------------------------------------------------*/
void mp_hal_delay_ms(mp_uint_t delay) { void mp_hal_delay_ms(mp_uint_t delay) {
uint64_t start_tick = ticks_ms; uint64_t start_tick = ticks_ms;
uint64_t duration = 0; uint64_t duration = 0;
@ -249,4 +205,3 @@ void mp_hal_delay_us(mp_uint_t us)
} }

51
ports/nrf/mphalport.h
View File

@ -27,53 +27,28 @@
#ifndef __NRF52_HAL #ifndef __NRF52_HAL
#define __NRF52_HAL #define __NRF52_HAL
#include "py/mpconfig.h" #include <stdbool.h>
#include NRF5_HAL_H #include <stdint.h>
#include "pin.h"
#include "hal_gpio.h" #include "hal_gpio.h"
#include "lib/utils/interrupt_char.h"
#include "nrf.h"
#include NRF5_HAL_H
#include "nrfx_uart.h"
#include "pin.h"
#include "py/mpconfig.h"
#include "lib/oofatfs/ff.h" extern nrfx_uart_t serial_instance;
typedef enum extern volatile uint64_t ticks_ms;
{
HAL_OK = 0x00,
HAL_ERROR = 0x01,
HAL_BUSY = 0x02,
HAL_TIMEOUT = 0x03
} HAL_StatusTypeDef;
extern FIL* boot_output_file; static inline mp_uint_t mp_hal_ticks_ms(void) {
return ticks_ms;
static inline uint32_t hal_tick_fake(void) {
return 0;
} }
#define mp_hal_ticks_ms hal_tick_fake // TODO: implement. Right now, return 0 always
extern const unsigned char mp_hal_status_to_errno_table[4];
NORETURN void mp_hal_raise(HAL_StatusTypeDef status);
void mp_hal_set_interrupt_char(int c); // -1 to disable
int mp_hal_stdin_rx_chr(void); int mp_hal_stdin_rx_chr(void);
void mp_hal_stdout_tx_str(const char *str); void mp_hal_stdout_tx_str(const char *str);
bool mp_hal_stdin_any(void); bool mp_hal_stdin_any(void);
#define mp_hal_pin_obj_t const pin_obj_t*
#define mp_hal_get_pin_obj(o) pin_find(o)
#define mp_hal_pin_high(p) hal_gpio_pin_high(p)
#define mp_hal_pin_low(p) hal_gpio_pin_low(p)
#define mp_hal_pin_read(p) hal_gpio_pin_read(p)
#define mp_hal_pin_write(p, v) do { if (v) { mp_hal_pin_high(p); } else { mp_hal_pin_low(p); } } while (0)
#define mp_hal_pin_od_low(p) mp_hal_pin_low(p)
#define mp_hal_pin_od_high(p) mp_hal_pin_high(p)
#define mp_hal_pin_open_drain(p) hal_gpio_cfg_pin(p->port, p->pin, HAL_GPIO_MODE_INPUT, HAL_GPIO_PULL_DISABLED)
// TODO: empty implementation for now. Used by machine_spi.c:69
#define mp_hal_delay_us_fast(p)
#define mp_hal_ticks_us() (0)
#define mp_hal_ticks_cpu() (0)
#endif #endif

14
ports/nrf/nrfx_config.h
View File

@ -1,6 +1,10 @@
#ifndef NRFX_CONFIG_H__ #ifndef NRFX_CONFIG_H__
#define NRFX_CONFIG_H__ #define NRFX_CONFIG_H__
// Power
#define NRFX_POWER_ENABLED 1
#define NRFX_POWER_CONFIG_IRQ_PRIORITY 7
// SPI // SPI
#define NRFX_SPIM_ENABLED 1 #define NRFX_SPIM_ENABLED 1
@ -21,7 +25,13 @@
#define NRFX_TWIM_DEFAULT_CONFIG_FREQUENCY NRF_TWIM_FREQ_400K #define NRFX_TWIM_DEFAULT_CONFIG_FREQUENCY NRF_TWIM_FREQ_400K
#define NRFX_TWIM_DEFAULT_CONFIG_HOLD_BUS_UNINIT 0 #define NRFX_TWIM_DEFAULT_CONFIG_HOLD_BUS_UNINIT 0
#define NRFX_POWER_ENABLED 1 // UART
#define NRFX_POWER_CONFIG_IRQ_PRIORITY 7 #define NRFX_UART_ENABLED 1
#define NRFX_UART0_ENABLED 1
#define NRFX_UART_DEFAULT_CONFIG_IRQ_PRIORITY 7
#define NRFX_UART_DEFAULT_CONFIG_HWFC NRF_UART_HWFC_DISABLED
#define NRFX_UART_DEFAULT_CONFIG_PARITY NRF_UART_PARITY_EXCLUDED
#define NRFX_UART_DEFAULT_CONFIG_BAUDRATE NRF_UART_BAUDRATE_115200
#endif #endif

27
ports/nrf/supervisor/cpu.s Executable file
View File

@ -0,0 +1,27 @@
.syntax unified
.cpu cortex-m4
.thumb
.text
.align 2
@ uint cpu_get_regs_and_sp(r0=uint regs[10])
.global cpu_get_regs_and_sp
.thumb
.thumb_func
.type cpu_get_regs_and_sp, %function
cpu_get_regs_and_sp:
@ store registers into given array
str r4, [r0], #4
str r5, [r0], #4
str r6, [r0], #4
str r7, [r0], #4
str r8, [r0], #4
str r9, [r0], #4
str r10, [r0], #4
str r11, [r0], #4
str r12, [r0], #4
str r13, [r0], #4
@ return the sp
mov r0, sp
bx lr

54
ports/nrf/supervisor/serial.c
View File

@ -24,52 +24,47 @@
* THE SOFTWARE. * THE SOFTWARE.
*/ */
#include "supervisor/serial.h"
#include "py/obj.h"
#include "py/runtime.h"
#include "mphalport.h" #include "mphalport.h"
#include "pins.h"
#include "hal_uart.h"
#if (MICROPY_PY_BLE_NUS) #if MICROPY_PY_BLE_NUS
#include "ble_uart.h" #include "ble_uart.h"
#else
#include "nrf_gpio.h"
#include "pin.h"
#endif #endif
#if !defined( NRF52840_XXAA) || ( defined(CFG_HWUART_FOR_SERIAL) && CFG_HWUART_FOR_SERIAL == 1 ) #if !defined( NRF52840_XXAA) || ( defined(CFG_HWUART_FOR_SERIAL) && CFG_HWUART_FOR_SERIAL == 1 )
void serial_init(void) { #define INST_NO 0
nrfx_uart_t serial_instance = NRFX_UART_INSTANCE(INST_NO);
void serial_init(void) {
#if MICROPY_PY_BLE_NUS #if MICROPY_PY_BLE_NUS
ble_uart_init0(); ble_uart_init0();
while (!ble_uart_enabled()) { while (!ble_uart_enabled()) {
; ;
} }
#else #else
hal_uart_init_t param = nrfx_uart_config_t config = NRFX_UART_DEFAULT_CONFIG;
{ config.pseltxd = MICROPY_HW_UART_TX;
.id = 0, config.pselrxd = MICROPY_HW_UART_RX;
.rx_pin = &MICROPY_HW_UART1_RX, config.hwfc = MICROPY_HW_UART_HWFC ? NRF_UART_HWFC_ENABLED : NRF_UART_HWFC_DISABLED;
.tx_pin = &MICROPY_HW_UART1_TX, #ifdef MICROPY_HW_UART_CTS
#if MICROPY_HW_UART1_HWFC config.pselcts = MICROPY_HW_UART_CTS;
.rts_pin = &MICROPY_HW_UART1_RTS, #endif
.cts_pin = &MICROPY_HW_UART1_CTS, #ifdef MICROPY_HW_UART_RTS
#else config.pselrts = MICROPY_HW_UART_RTS;
.rts_pin = NULL,
.cts_pin = NULL,
#endif #endif
.flow_control = MICROPY_HW_UART1_HWFC ? true : false,
.use_parity = false,
.baud_rate = HAL_UART_BAUD_115K2,
.irq_priority = 6,
.irq_num = UARTE0_UART0_IRQn
};
hal_uart_init( UART_BASE(0), &param); const nrfx_err_t err = nrfx_uart_init(&serial_instance, &config, NULL);
if (err == NRFX_SUCCESS)
NRFX_ASSERT(err);
nrfx_uart_rx_enable(&serial_instance);
#endif #endif
} }
bool serial_connected(void) { bool serial_connected(void) {
return true; return true;
} }
@ -82,8 +77,8 @@ bool serial_bytes_available(void) {
return mp_hal_stdin_any(); return mp_hal_stdin_any();
} }
void serial_write(const char* text) { void serial_write(const char *text) {
mp_hal_stdout_tx_str(text); mp_hal_stdout_tx_str(text);
} }
#else #else
@ -112,4 +107,3 @@ void serial_write(const char* text) {
} }
#endif #endif

5
py/builtinimport.c Normal file → Executable file
View File

@ -31,6 +31,7 @@
#include "py/compile.h" #include "py/compile.h"
#include "py/gc_long_lived.h" #include "py/gc_long_lived.h"
#include "py/gc.h"
#include "py/objmodule.h" #include "py/objmodule.h"
#include "py/persistentcode.h" #include "py/persistentcode.h"
#include "py/runtime.h" #include "py/runtime.h"
@ -468,6 +469,10 @@ mp_obj_t mp_builtin___import__(size_t n_args, const mp_obj_t *args) {
// (the module that was just loaded) is not a package. This will be caught // (the module that was just loaded) is not a package. This will be caught
// on the next iteration because the file will not exist. // on the next iteration because the file will not exist.
} }
// Loading a module thrashes the heap significantly so we explicitly clean up
// afterwards.
gc_collect();
} }
if (outer_module_obj != MP_OBJ_NULL) { if (outer_module_obj != MP_OBJ_NULL) {
qstr s = qstr_from_strn(mod_str + last, i - last); qstr s = qstr_from_strn(mod_str + last, i - last);

0
py/gc.c Normal file → Executable file
View File

2
py/gc_long_lived.c Normal file → Executable file
View File

@ -121,7 +121,7 @@ mp_obj_t make_obj_long_lived(mp_obj_t obj, uint8_t max_depth){
} else if (MP_OBJ_IS_TYPE(obj, &mp_type_property)) { } else if (MP_OBJ_IS_TYPE(obj, &mp_type_property)) {
mp_obj_property_t *prop = MP_OBJ_TO_PTR(obj); mp_obj_property_t *prop = MP_OBJ_TO_PTR(obj);
return MP_OBJ_FROM_PTR(make_property_long_lived(prop, max_depth)); return MP_OBJ_FROM_PTR(make_property_long_lived(prop, max_depth));
} else if (MP_OBJ_IS_TYPE(obj, &mp_type_str)) { } else if (MP_OBJ_IS_TYPE(obj, &mp_type_str) || MP_OBJ_IS_TYPE(obj, &mp_type_bytes)) {
mp_obj_str_t *str = MP_OBJ_TO_PTR(obj); mp_obj_str_t *str = MP_OBJ_TO_PTR(obj);
return MP_OBJ_FROM_PTR(make_str_long_lived(str)); return MP_OBJ_FROM_PTR(make_str_long_lived(str));
} else if (MP_OBJ_IS_TYPE(obj, &mp_type_type)) { } else if (MP_OBJ_IS_TYPE(obj, &mp_type_type)) {

6
py/mpconfig.h Normal file → Executable file
View File

@ -130,6 +130,12 @@
#define MICROPY_ALLOC_QSTR_CHUNK_INIT (128) #define MICROPY_ALLOC_QSTR_CHUNK_INIT (128)
#endif #endif
// Max number of entries in newly allocated QSTR pools. Smaller numbers may make QSTR lookups
// slightly slower but reduce the waste of unused spots.
#ifndef MICROPY_QSTR_POOL_MAX_ENTRIES
#define MICROPY_QSTR_POOL_MAX_ENTRIES (64)
#endif
// Initial amount for lexer indentation level // Initial amount for lexer indentation level
#ifndef MICROPY_ALLOC_LEXER_INDENT_INIT #ifndef MICROPY_ALLOC_LEXER_INDENT_INIT
#define MICROPY_ALLOC_LEXER_INDENT_INIT (10) #define MICROPY_ALLOC_LEXER_INDENT_INIT (10)

10
py/qstr.c Normal file → Executable file
View File

@ -144,14 +144,18 @@ STATIC qstr qstr_add(const byte *q_ptr) {
// make sure we have room in the pool for a new qstr // make sure we have room in the pool for a new qstr
if (MP_STATE_VM(last_pool)->len >= MP_STATE_VM(last_pool)->alloc) { if (MP_STATE_VM(last_pool)->len >= MP_STATE_VM(last_pool)->alloc) {
qstr_pool_t *pool = m_new_ll_obj_var_maybe(qstr_pool_t, const char*, MP_STATE_VM(last_pool)->alloc * 2); uint32_t new_pool_length = MP_STATE_VM(last_pool)->alloc * 2;
if (new_pool_length > MICROPY_QSTR_POOL_MAX_ENTRIES) {
new_pool_length = MICROPY_QSTR_POOL_MAX_ENTRIES;
}
qstr_pool_t *pool = m_new_ll_obj_var_maybe(qstr_pool_t, const char*, new_pool_length);
if (pool == NULL) { if (pool == NULL) {
QSTR_EXIT(); QSTR_EXIT();
m_malloc_fail(MP_STATE_VM(last_pool)->alloc * 2); m_malloc_fail(new_pool_length);
} }
pool->prev = MP_STATE_VM(last_pool); pool->prev = MP_STATE_VM(last_pool);
pool->total_prev_len = MP_STATE_VM(last_pool)->total_prev_len + MP_STATE_VM(last_pool)->len; pool->total_prev_len = MP_STATE_VM(last_pool)->total_prev_len + MP_STATE_VM(last_pool)->len;
pool->alloc = MP_STATE_VM(last_pool)->alloc * 2; pool->alloc = new_pool_length;
pool->len = 0; pool->len = 0;
MP_STATE_VM(last_pool) = pool; MP_STATE_VM(last_pool) = pool;
DEBUG_printf("QSTR: allocate new pool of size %d\n", MP_STATE_VM(last_pool)->alloc); DEBUG_printf("QSTR: allocate new pool of size %d\n", MP_STATE_VM(last_pool)->alloc);

34
ports/nrf/help.c → supervisor/cpu.h Normal file → Executable file
View File

@ -3,8 +3,7 @@
* *
* The MIT License (MIT) * The MIT License (MIT)
* *
* Copyright (c) 2013, 2014 Damien P. George * Copyright (c) 2017 Scott Shawcroft for Adafruit Industries
* Copyright (c) 2016 Glenn Ruben Bakke
* *
* Permission is hereby granted, free of charge, to any person obtaining a copy * Permission is hereby granted, free of charge, to any person obtaining a copy
* of this software and associated documentation files (the "Software"), to deal * of this software and associated documentation files (the "Software"), to deal
@ -25,30 +24,11 @@
* THE SOFTWARE. * THE SOFTWARE.
*/ */
#include "py/builtin.h" #ifndef MICROPY_INCLUDED_SUPERVISOR_CPU_H
#define MICROPY_INCLUDED_SUPERVISOR_CPU_H
#if BLUETOOTH_SD // Adds up to 10 pointers from the CPUs registers to regs. This is used to make sure no actively
#include "help_sd.h" // used heap memory is freed. Its usually implemented in assembly.
#endif mp_uint_t cpu_get_regs_and_sp(mp_uint_t *regs);
const char nrf5_help_text[] = #endif // MICROPY_INCLUDED_SUPERVISOR_CPU_H
"Welcome to MicroPython!\n"
"\n"
"For online help please visit http://micropython.org/help/.\n"
"\n"
"Quick overview of commands for the board:\n"
#if MICROPY_HW_HAS_LED
" pyb.LED(n) -- create an LED object for LED n (n=" HELP_TEXT_BOARD_LED ")\n"
"\n"
#endif
#if BLUETOOTH_SD
HELP_TEXT_SD
#endif
"Control commands:\n"
" CTRL-A -- on a blank line, enter raw REPL mode\n"
" CTRL-B -- on a blank line, enter normal REPL mode\n"
" CTRL-D -- on a blank line, do a soft reset of the board\n"
" CTRL-E -- on a blank line, enter paste mode\n"
"\n"
"For further help on a specific object, type help(obj)\n"
;

68
tools/analyze_heap_dump.py Normal file → Executable file
View File

@ -135,8 +135,11 @@ def do_all_the_things(ram_filename, bin_filename, map_filename, print_block_cont
ram_start = symbols["_srelocate"][0] ram_start = symbols["_srelocate"][0]
ram_end = symbols["_estack"][0] ram_end = symbols["_estack"][0]
ram_length = ram_end - ram_start ram_length = ram_end - ram_start
# print(ram_length, "ram length")
# print(len(ram_dump) // ram_length, "snapshots")
if analyze_snapshots == "all": if analyze_snapshots == "all":
snapshots = range(len(ram_dump) // ram_length - 1, -1, -1) snapshots = range(len(ram_dump) // ram_length - 1, -1, -1)
#snapshots = range(4576, -1, -1)
elif analyze_snapshots == "last": elif analyze_snapshots == "last":
snapshots = range(len(ram_dump) // ram_length - 1, len(ram_dump) // ram_length - 2, -1) snapshots = range(len(ram_dump) // ram_length - 1, len(ram_dump) // ram_length - 2, -1)
for snapshot_num in snapshots: for snapshot_num in snapshots:
@ -167,16 +170,16 @@ def do_all_the_things(ram_filename, bin_filename, map_filename, print_block_cont
mp_state_ctx = symbols["mp_state_ctx"][0] mp_state_ctx = symbols["mp_state_ctx"][0]
manual_symbol_map["mp_state_ctx+20"] = "mp_state_ctx.vm.last_pool" manual_symbol_map["mp_state_ctx+20"] = "mp_state_ctx.vm.last_pool"
last_pool = load_pointer(mp_state_ctx + 20) # (gdb) p &mp_state_ctx.vm.last_pool last_pool = load_pointer(mp_state_ctx + 20) # (gdb) p &mp_state_ctx.vm.last_pool
manual_symbol_map["mp_state_ctx+88"] = "mp_state_ctx.vm.dict_main.map.table" manual_symbol_map["mp_state_ctx+104"] = "mp_state_ctx.vm.dict_main.map.table"
dict_main_table = load_pointer(mp_state_ctx + 88) # (gdb) p &mp_state_ctx.vm.dict_main.map.table dict_main_table = load_pointer(mp_state_ctx + 104) # (gdb) p &mp_state_ctx.vm.dict_main.map.table
manual_symbol_map["mp_state_ctx+68"] = "mp_state_ctx.vm.mp_loaded_modules_dict.map.table" manual_symbol_map["mp_state_ctx+84"] = "mp_state_ctx.vm.mp_loaded_modules_dict.map.table"
imports_table = load_pointer(mp_state_ctx + 68) # (gdb) p &mp_state_ctx.vm.mp_loaded_modules_dict.map.table imports_table = load_pointer(mp_state_ctx + 84) # (gdb) p &mp_state_ctx.vm.mp_loaded_modules_dict.map.table
manual_symbol_map["mp_state_ctx+104"] = "mp_state_ctx.vm.mp_sys_path_obj.items" manual_symbol_map["mp_state_ctx+120"] = "mp_state_ctx.vm.mp_sys_path_obj.items"
manual_symbol_map["mp_state_ctx+120"] = "mp_state_ctx.vm.mp_sys_argv_obj.items" manual_symbol_map["mp_state_ctx+136"] = "mp_state_ctx.vm.mp_sys_argv_obj.items"
for i in range(READLINE_HIST_SIZE): for i in range(READLINE_HIST_SIZE):
manual_symbol_map["mp_state_ctx+{}".format(128 + i * 4)] = "mp_state_ctx.vm.readline_hist[{}]".format(i) manual_symbol_map["mp_state_ctx+{}".format(144 + i * 4)] = "mp_state_ctx.vm.readline_hist[{}]".format(i)
tuple_type = symbols["mp_type_tuple"][0] tuple_type = symbols["mp_type_tuple"][0]
type_type = symbols["mp_type_type"][0] type_type = symbols["mp_type_type"][0]
@ -214,8 +217,8 @@ def do_all_the_things(ram_filename, bin_filename, map_filename, print_block_cont
pool_start = heap_start + total_byte_len - pool_length - pool_shift pool_start = heap_start + total_byte_len - pool_length - pool_shift
pool = heap[-pool_length-pool_shift:] pool = heap[-pool_length-pool_shift:]
total_height = 65 * 18 total_height = 128 * 18
total_width = (pool_length // (64 * 16)) * 90 total_width = (pool_length // (128 * 16)) * 85
map_element_blocks = [dict_main_table, imports_table] map_element_blocks = [dict_main_table, imports_table]
string_blocks = [] string_blocks = []
@ -255,10 +258,11 @@ def do_all_the_things(ram_filename, bin_filename, map_filename, print_block_cont
block_data[address] = data block_data[address] = data
for k in range(len(data) // 4): for k in range(len(data) // 4):
word = struct.unpack_from("<I", data, offset=(k * 4))[0] word = struct.unpack_from("<I", data, offset=(k * 4))[0]
if word < 0x00040000 and k == 0 or address in qstr_pools: if word < len(rom) and k == 0 or address in qstr_pools:
potential_type = word potential_type = word
bgcolor = "gray" bgcolor = "gray"
if address in qstr_pools: if address in qstr_pools:
#print(address, len(data))
bgcolor = "tomato" bgcolor = "tomato"
elif potential_type in function_types: elif potential_type in function_types:
bgcolor = "green" bgcolor = "green"
@ -292,11 +296,11 @@ def do_all_the_things(ram_filename, bin_filename, map_filename, print_block_cont
if potential_type == dynamic_type: if potential_type == dynamic_type:
if k == 0: if k == 0:
node.attr["fillcolor"] = "plum" node.attr["fillcolor"] = "plum"
if k == 3 and 0x20000000 < word < 0x20040000: if k == 3 and ram_start < word < ram_end:
map_element_blocks.append(word) map_element_blocks.append(word)
if potential_type in function_types: if potential_type in function_types:
if k == 2 and 0x20000000 < word < 0x20040000: if k == 2 and ram_start < word < ram_end:
bytecode_blocks.append(word) bytecode_blocks.append(word)
@ -338,7 +342,12 @@ def do_all_the_things(ram_filename, bin_filename, map_filename, print_block_cont
pool_ptr = last_pool pool_ptr = last_pool
if not is_qstr(qstr_index): if not is_qstr(qstr_index):
return "object" return "object"
pool = block_data[pool_ptr]
prev, total_prev_len, alloc, length = struct.unpack_from("<IIII", pool)
qstr_index >>= 3 qstr_index >>= 3
if qstr_index > total_prev_len + alloc:
return "invalid"
while pool_ptr != 0: while pool_ptr != 0:
if pool_ptr > ram_start: if pool_ptr > ram_start:
if pool_ptr in block_data: if pool_ptr in block_data:
@ -492,7 +501,10 @@ def do_all_the_things(ram_filename, bin_filename, map_filename, print_block_cont
offset = len(data) offset = len(data)
continue continue
offset += 2 + qstr_len + 1 offset += 2 + qstr_len + 1
qstrs_in_chunk += " " + data[offset - qstr_len - 1: offset - 1].decode("utf-8") try:
qstrs_in_chunk += " " + data[offset - qstr_len - 1: offset - 1].decode("utf-8")
except UnicodeDecodeError:
qstrs_in_chunk += " " + "░"*qstr_len
printable_qstrs = "" printable_qstrs = ""
for i in range(len(qstrs_in_chunk)): for i in range(len(qstrs_in_chunk)):
c = qstrs_in_chunk[i] c = qstrs_in_chunk[i]
@ -515,20 +527,28 @@ def do_all_the_things(ram_filename, bin_filename, map_filename, print_block_cont
# First render the graph of objects on the heap. # First render the graph of objects on the heap.
if draw_heap_ownership: if draw_heap_ownership:
ownership_graph.layout(prog="dot") ownership_graph.layout(prog="dot")
fn = os.path.join(output_directory, "heap_ownership{:04d}.png".format(snapshot_num)) fn = os.path.join(output_directory, "heap_ownership{:04d}.svg".format(snapshot_num))
print(fn) print(fn)
ownership_graph.draw(fn) ownership_graph.draw(fn)
# Clear edge positioning from ownership graph layout.
if draw_heap_ownership:
for edge in ownership_graph.iteredges():
del edge.attr["pos"]
else:
for edge in ownership_graph.edges():
ownership_graph.delete_edge(edge)
# Second, render the heap layout in memory order. # Second, render the heap layout in memory order.
for node in ownership_graph: for node in ownership_graph.nodes():
try: try:
address = int(node.name) address = int(node.name)
except ValueError: except ValueError:
ownership_graph.remove_node(node) ownership_graph.remove_node(node.name)
continue continue
block = (address - pool_start) // 16 block = (address - pool_start) // 16
x = block // 64 x = block // 128
y = 64 - block % 64 y = 128 - block % 128
try: try:
height = float(node.attr["height"]) height = float(node.attr["height"])
except: except:
@ -538,11 +558,6 @@ def do_all_the_things(ram_filename, bin_filename, map_filename, print_block_cont
# print(hex(address), block, len(block_data[address]), x, y, height) # print(hex(address), block, len(block_data[address]), x, y, height)
node.attr["pos"] = "{},{}".format(x * 80, (y - (height - 0.25) * 2) * 18) # in inches node.attr["pos"] = "{},{}".format(x * 80, (y - (height - 0.25) * 2) * 18) # in inches
# Clear edge positioning from ownership graph layout.
if draw_heap_ownership:
for edge in ownership_graph.iteredges():
del edge.attr["pos"]
# Reformat block nodes so they are the correct size and do not have keys in them. # Reformat block nodes so they are the correct size and do not have keys in them.
for block in sorted(map_element_blocks): for block in sorted(map_element_blocks):
try: try:
@ -565,9 +580,9 @@ def do_all_the_things(ram_filename, bin_filename, map_filename, print_block_cont
else: else:
#print(" {}, {}".format(format(key), format(value))) #print(" {}, {}".format(format(key), format(value)))
cells.append((key, "")) cells.append((key, ""))
if value in block_data: # if value in block_data:
edge = ownership_graph.get_edge(block, value) # edge = ownership_graph.get_edge(block, value)
edge.attr["tailport"] = str(key) # edge.attr["tailport"] = str(key)
rows = "" rows = ""
for i in range(len(cells) // 2): for i in range(len(cells) // 2):
rows += "<tr><td port=\"{}\" height=\"18\" width=\"40\">{}</td><td port=\"{}\" height=\"18\" width=\"40\">{}</td></tr>".format( rows += "<tr><td port=\"{}\" height=\"18\" width=\"40\">{}</td><td port=\"{}\" height=\"18\" width=\"40\">{}</td></tr>".format(
@ -586,6 +601,7 @@ def do_all_the_things(ram_filename, bin_filename, map_filename, print_block_cont
if draw_heap_layout: if draw_heap_layout:
fn = os.path.join(output_directory, "heap_layout{:04d}.png".format(snapshot_num)) fn = os.path.join(output_directory, "heap_layout{:04d}.png".format(snapshot_num))
print(fn) print(fn)
#ownership_graph.write(fn+".dot")
ownership_graph.draw(fn) ownership_graph.draw(fn)
if __name__ == "__main__": if __name__ == "__main__":

2
tools/output_gc_until_repl.txt
View File

@ -19,7 +19,7 @@ append binary memory ram.bin &_srelocate &_estack
continue continue
end end
break main.c:164 break main.c:179
continue continue