From 850f2b9c494d176928fad40459111ec652f65ad8 Mon Sep 17 00:00:00 2001 From: Albort Xue Date: Tue, 20 Aug 2019 20:35:34 +0800 Subject: [PATCH] ports/nxp: -Add nxp MIMXRT1064 port. -Enable sdcard lcd lpi2c pinmux led --- .gitmodules | 3 + lib/nxplib | 1 + ports/nxp/Makefile | 259 + .../nxp/board/evkmimxrt1064/FreeRTOSConfig.h | 123 + .../board/evkmimxrt1064/FreeRTOSConfigBoard.h | 61 + ports/nxp/board/evkmimxrt1064/app.h | 25 + ports/nxp/board/evkmimxrt1064/board.c | 451 + ports/nxp/board/evkmimxrt1064/board.h | 277 + ports/nxp/board/evkmimxrt1064/clock_config.c | 493 + ports/nxp/board/evkmimxrt1064/clock_config.h | 122 + ports/nxp/board/evkmimxrt1064/common.h | 75 + .../evkmimxrt1064_flexspi_nor_config.c | 49 + .../evkmimxrt1064_flexspi_nor_config.h | 268 + .../evkmimxrt1064_sdram_ini_dcd.c | 320 + .../evkmimxrt1064_sdram_ini_dcd.h | 32 + ports/nxp/board/evkmimxrt1064/fsl_clock.c | 1228 + ports/nxp/board/evkmimxrt1064/fsl_clock.h | 1567 + ports/nxp/board/evkmimxrt1064/fsl_iomuxc.h | 1405 + ports/nxp/board/evkmimxrt1064/hardware_init.c | 36 + .../board/evkmimxrt1064/littlevgl_support.c | 305 + .../board/evkmimxrt1064/littlevgl_support.h | 41 + ports/nxp/board/evkmimxrt1064/lv_conf.h | 408 + .../evkmimxrt1064/lv_mp_mem_custom_include.h | 31 + ports/nxp/board/evkmimxrt1064/mpconfigboard.h | 7 + .../nxp/board/evkmimxrt1064/mpconfigboard.mk | 37 + ports/nxp/board/evkmimxrt1064/pin_mux.c | 1064 + ports/nxp/board/evkmimxrt1064/pin_mux.h | 81 + ports/nxp/board/evkmimxrt1064/port-pad.c | 75 + ports/nxp/board/evkmimxrt1064/port-pad.h | 28 + ports/nxp/ffconf.h | 65 + ports/nxp/gccollect.c | 50 + ports/nxp/gccollect.h | 38 + ports/nxp/led.c | 155 + ports/nxp/led.h | 39 + ports/nxp/main.c | 419 + ports/nxp/modSDL.c | 141 + ports/nxp/modlvgl.c | 24200 ++++++++++++++++ ports/nxp/modpyb.c | 76 + ports/nxp/moduos.c | 77 + ports/nxp/mpconfigport.h | 200 + ports/nxp/mphalport.c | 10 + ports/nxp/mphalport.h | 48 + ports/nxp/pin.c | 301 + ports/nxp/pin.h | 57 + ports/nxp/pybi2c.c | 385 + ports/nxp/pybi2c.h | 45 + ports/nxp/pybpinmux.c | 164 + ports/nxp/pybpinmux.h | 51 + ports/nxp/qstrdefsport.h | 1 + ports/nxp/sdcard.c | 224 + ports/nxp/sdcard.h | 50 + ports/nxp/uart_core.c | 60 + 52 files changed, 35728 insertions(+) create mode 160000 lib/nxplib create mode 100644 ports/nxp/Makefile create mode 100644 ports/nxp/board/evkmimxrt1064/FreeRTOSConfig.h create mode 100644 ports/nxp/board/evkmimxrt1064/FreeRTOSConfigBoard.h create mode 100644 ports/nxp/board/evkmimxrt1064/app.h create mode 100644 ports/nxp/board/evkmimxrt1064/board.c create mode 100644 ports/nxp/board/evkmimxrt1064/board.h create mode 100644 ports/nxp/board/evkmimxrt1064/clock_config.c create mode 100644 ports/nxp/board/evkmimxrt1064/clock_config.h create mode 100644 ports/nxp/board/evkmimxrt1064/common.h create mode 100644 ports/nxp/board/evkmimxrt1064/evkmimxrt1064_flexspi_nor_config.c create mode 100644 ports/nxp/board/evkmimxrt1064/evkmimxrt1064_flexspi_nor_config.h create mode 100644 ports/nxp/board/evkmimxrt1064/evkmimxrt1064_sdram_ini_dcd.c create mode 100644 ports/nxp/board/evkmimxrt1064/evkmimxrt1064_sdram_ini_dcd.h create mode 100644 ports/nxp/board/evkmimxrt1064/fsl_clock.c create mode 100644 ports/nxp/board/evkmimxrt1064/fsl_clock.h create mode 100644 ports/nxp/board/evkmimxrt1064/fsl_iomuxc.h create mode 100644 ports/nxp/board/evkmimxrt1064/hardware_init.c create mode 100644 ports/nxp/board/evkmimxrt1064/littlevgl_support.c create mode 100644 ports/nxp/board/evkmimxrt1064/littlevgl_support.h create mode 100644 ports/nxp/board/evkmimxrt1064/lv_conf.h create mode 100644 ports/nxp/board/evkmimxrt1064/lv_mp_mem_custom_include.h create mode 100644 ports/nxp/board/evkmimxrt1064/mpconfigboard.h create mode 100644 ports/nxp/board/evkmimxrt1064/mpconfigboard.mk create mode 100644 ports/nxp/board/evkmimxrt1064/pin_mux.c create mode 100644 ports/nxp/board/evkmimxrt1064/pin_mux.h create mode 100644 ports/nxp/board/evkmimxrt1064/port-pad.c create mode 100644 ports/nxp/board/evkmimxrt1064/port-pad.h create mode 100644 ports/nxp/ffconf.h create mode 100644 ports/nxp/gccollect.c create mode 100644 ports/nxp/gccollect.h create mode 100644 ports/nxp/led.c create mode 100644 ports/nxp/led.h create mode 100644 ports/nxp/main.c create mode 100644 ports/nxp/modSDL.c create mode 100644 ports/nxp/modlvgl.c create mode 100644 ports/nxp/modpyb.c create mode 100644 ports/nxp/moduos.c create mode 100644 ports/nxp/mpconfigport.h create mode 100644 ports/nxp/mphalport.c create mode 100644 ports/nxp/mphalport.h create mode 100644 ports/nxp/pin.c create mode 100644 ports/nxp/pin.h create mode 100644 ports/nxp/pybi2c.c create mode 100644 ports/nxp/pybi2c.h create mode 100644 ports/nxp/pybpinmux.c create mode 100644 ports/nxp/pybpinmux.h create mode 100644 ports/nxp/qstrdefsport.h create mode 100644 ports/nxp/sdcard.c create mode 100644 ports/nxp/sdcard.h create mode 100644 ports/nxp/uart_core.c diff --git a/.gitmodules b/.gitmodules index 544815b3a346..d972502669ca 100644 --- a/.gitmodules +++ b/.gitmodules @@ -27,3 +27,6 @@ [submodule "lib/tinyusb"] path = lib/tinyusb url = https://github.com/hathach/tinyusb +[submodule "lib/nxplib"] + path = lib/nxplib + url = https://github.com/yanyao12138/nxplib.git diff --git a/lib/nxplib b/lib/nxplib new file mode 160000 index 000000000000..ffac813a7248 --- /dev/null +++ b/lib/nxplib @@ -0,0 +1 @@ +Subproject commit ffac813a7248420cfd9a7fbcae9492aca2729279 diff --git a/ports/nxp/Makefile b/ports/nxp/Makefile new file mode 100644 index 000000000000..88fd633b8e19 --- /dev/null +++ b/ports/nxp/Makefile @@ -0,0 +1,259 @@ +BOARD ?= evkmimxrt1064 + +BUILD ?= build-$(BOARD) + +Toolchain ?= gcc + +Series ?= imx + +Device ?= MIMXRT1064 + +include board/$(BOARD)/mpconfigboard.mk + +#FreeRTos variable +FreeRTOS_DIR = lib/nxplib/rtos + +#NXP lib variable +NXP_DRIVER_DIR = lib/nxplib/drivers/$(Series) +NXP_MIDDLEWARE_DIR = lib/nxplib/middleware +NXP_DEVICE_DIR = lib/nxplib/devices/$(Device) +NXP_COMPONENTS_DIR = lib/nxplib/components + +NXP_UTILITIES_DIR = $(NXP_DEVICE_DIR)/utilities +NXP_TOOLCHAIN_DIR = $(NXP_DEVICE_DIR)/$(Toolchain) +NXP_XIP_DIR = $(NXP_DEVICE_DIR)/xip + +LVGL_SRC = +ifeq ($(LITTLEVGL_ENABLE), 1) +#littlevGL +LVGL_BINDING_DIR = $(TOP)/lib/lv_binding_micropython +LVGL_DIR += $(TOP)/$(NXP_MIDDLEWARE_DIR)/littlevgl +LVGL_INC += -I$(LVGL_DIR) +ALL_LVGL_SRC = $(shell find $(LVGL_DIR) -type f) $(TOP)/$(BOARD_DIR)/lv_conf.h +LVGL_MPY = ./modlvgl.c +LVGL_SRC_INC = $(shell find $(LVGL_DIR) -type f -name "*.h") +LVGL_SRC = $(subst $(TOP)/,,$(shell find $(LVGL_DIR) -type f -name "*.c") $(LVGL_MPY)) modSDL.c +endif + +# qstr definitions (must come before including py.mk) +include ../../py/mkenv.mk +QSTR_DEFS = qstrdefsport.h +QSTR_GLOBAL_DEPENDENCIES += $(LVGL_MPY) + +# include py core make definitions +include $(TOP)/py/py.mk + +CROSS_COMPILE = arm-none-eabi- + +INC += -I. +INC += -I$(TOP) +INC += -I$(BUILD) +INC += -I$(TOP)/$(NXP_DRIVER_DIR) +INC += -I$(TOP)/lib/libm_dbl +INC += -I$(TOP)/lib/cmsis/inc +INC += -I$(TOP)/py +INC += -I$(TOP)/lib +INC += -I$(TOP)/$(FreeRTOS_DIR)/amazon-freertos/lib/include +INC += -I$(TOP)/$(FreeRTOS_DIR)/amazon-freertos/lib/include/private +INC += -I$(TOP)/$(FreeRTOS_DIR)/amazon-freertos/lib/FreeRTOS/portable/GCC/ARM_CM4F +INC += -I$(TOP)/$(NXP_DEVICE_DIR) +INC += -I$(TOP)/$(NXP_MIDDLEWARE_DIR)/sdmmc/inc +INC += -I$(TOP)/$(NXP_MIDDLEWARE_DIR)/sdmmc/port +INC += -I$(TOP)/$(NXP_COMPONENTS_DIR)/list +INC += -I$(TOP)/$(NXP_COMPONENTS_DIR)/serial_manager +INC += -I$(TOP)/$(NXP_COMPONENTS_DIR)/uart +INC += -I$(TOP)/$(NXP_COMPONENTS_DIR)/ft5406_rt +INC += -I$(TOP)/$(NXP_COMPONENTS_DIR)/i2c +INC += -I$(TOP)/$(NXP_COMPONENTS_DIR) +INC += -I$(TOP)/$(NXP_XIP_DIR) +INC += -I$(TOP)/$(NXP_UTILITIES_DIR) +INC += -I$(TOP)/$(NXP_UTILITIES_DIR)/debug_console +INC += -I$(TOP)/$(NXP_UTILITIES_DIR)/str +INC += -I$(TOP)/extmod +INC += -I$(TOP)/lib/oofatfs +INC += -I$(TOP)/$(BOARD_DIR) + +ifeq ($(LITTLEVGL_ENABLE), 1) +INC += -I$(LVGL_DIR) +endif + +LD_DIR = $(TOP)/$(NXP_TOOLCHAIN_DIR) + +FATFS_DIR=lib/oofatfs + +STARTUP_FILE = $(NXP_TOOLCHAIN_DIR)/startup_$(Device).o + +CFLAGS = $(INC) $(CFLAGS_CORE) $(CFLAGS_BOARD) -Wall -Werror -std=gnu99 \ + -fno-tree-scev-cprop -Wpointer-arith -fdata-sections -ffunction-sections \ + -DLV_CONF_INCLUDE_SIMPLE=1 \ + -DFSL_RTOS_FREE_RTOS \ + -D__STARTUP_CLEAR_BSS \ + -D__STARTUP_INITIALIZE_NONCACHEDATA \ + -DFFCONF_H=\"ports/nxp/ffconf.h\" \ + --specs=nosys.specs \ + --specs=nano.specs \ + -D__START=main \ + + +# ignore unused function +CFLAGS += -Wno-unused-function + +LDFLAGS = --defsym=__heap_size__=0x8000 -T $(LD_DIR)/$(LINK_FILE) -Map=$(@:.elf=.map) --cref --gc-sections + +# Tune for Debugging or Optimization +ifeq ($(DEBUG), 1) +CFLAGS += -O0 -ggdb +else +CFLAGS += -Os -DNDEBUG +CFLAGS += -fdata-sections -ffunction-sections +endif + +LIBS = $(shell $(CC) $(CFLAGS) -print-libgcc-file-name) + +# Options for mpy-cross +MPY_CROSS_FLAGS += -march=armv7m + +SRC_LIB = $(addprefix lib/,\ + oofatfs/ff.c \ + oofatfs/ffunicode.c \ + ) + +SRC_FreeRTOS = $(addprefix $(FreeRTOS_DIR)/, \ + amazon-freertos/lib/FreeRTOS/event_groups.c \ + amazon-freertos/lib/FreeRTOS/list.c \ + amazon-freertos/lib/FreeRTOS/queue.c \ + amazon-freertos/lib/FreeRTOS/stream_buffer.c \ + amazon-freertos/lib/FreeRTOS/tasks.c \ + amazon-freertos/lib/FreeRTOS/timers.c \ + amazon-freertos/lib/FreeRTOS/portable/MemMang/heap_4.c \ + amazon-freertos/lib/FreeRTOS/portable/GCC/ARM_CM4F/port.c \ +) + +SRC_LIBM = $(addprefix lib/libm/,\ + math.c \ + acoshf.c \ + asinfacosf.c \ + asinhf.c \ + atan2f.c \ + atanf.c \ + atanhf.c \ + ef_rem_pio2.c \ + erf_lgamma.c \ + ef_sqrt.c \ + fmodf.c \ + kf_cos.c \ + kf_rem_pio2.c \ + kf_sin.c \ + kf_tan.c \ + log1pf.c \ + nearbyintf.c \ + sf_cos.c \ + sf_erf.c \ + sf_frexp.c \ + sf_ldexp.c \ + sf_modf.c \ + sf_sin.c \ + sf_tan.c \ + wf_lgamma.c \ + wf_tgamma.c \ +) + +EXTMOD_SRC_C = $(addprefix extmod/, \ + modubinascii.c \ + modujson.c \ + modure.c \ +) + +SRC_FSL_DRIVERS = $(addprefix $(NXP_DRIVER_DIR)/, \ + fsl_common.c \ + fsl_gpio.c \ + fsl_lpuart.c \ + fsl_usdhc.c \ + fsl_cache.c \ + fsl_lpi2c.c \ + fsl_gpt.c \ + $(BOARD_FSL_DRIVERS) \ +) + +SRC_NXP_MIDDLEWARE = $(addprefix $(NXP_MIDDLEWARE_DIR)/, \ + sdmmc/port/usdhc/freertos/fsl_sdmmc_host.c \ + sdmmc/port/usdhc/freertos/fsl_sdmmc_event.c \ + sdmmc/src/fsl_mmc.c \ + sdmmc/src/fsl_sd.c \ + sdmmc/src/fsl_sdio.c \ + sdmmc/src/fsl_sdmmc_common.c \ +) + +SRC_C = \ + $(SRC_FSL_DRIVERS) \ + $(SRC_BOARD) \ + $(NXP_COMPONENTS_DIR)/lists/generic_list.c \ + $(NXP_COMPONENTS_DIR)/serial_manager/serial_manager.c \ + $(NXP_COMPONENTS_DIR)/serial_manager/serial_port_uart.c \ + $(NXP_COMPONENTS_DIR)/uart/lpuart_adapter.c \ + $(NXP_COMPONENTS_DIR)/i2c/lpi2c_adapter.c \ + $(NXP_COMPONENTS_DIR)/ft5406_rt/fsl_ft5406_rt.c \ + $(NXP_XIP_DIR)/fsl_flexspi_nor_boot.c \ + $(NXP_UTILITIES_DIR)/fsl_assert.c \ + $(NXP_UTILITIES_DIR)/debug_console/fsl_debug_console.c \ + $(NXP_UTILITIES_DIR)/str/fsl_str.c \ + $(SRC_FreeRTOS) \ + $(SRC_NXP_MIDDLEWARE) \ + $(EXTMOD_SRC_C) \ + $(LVGL_SRC) \ + $(SRC_SPECIFIC) \ + main.c \ + gccollect.c \ + uart_core.c \ + pin.c \ + led.c \ + sdcard.c \ + mphalport.c \ + pybi2c.c \ + pybpinmux.c \ + lib/utils/printf.c \ + lib/utils/pyexec.c \ + lib/libc/string0.c \ + lib/mp-readline/readline.c \ + lib/timeutils/timeutils.c \ + moduos.c \ + modpyb.c \ + extmod/vfs.c \ + extmod/vfs_fat.c \ + extmod/vfs_fat_file.c \ + extmod/vfs_posix.c \ + extmod/vfs_reader.c \ + extmod/vfs_fat_diskio.c + +SRC_O = \ + $(STARTUP_FILE) \ + $(NXP_DEVICE_DIR)/system_$(Device).o \ + lib/utils/gchelper_m3.o \ + + +OBJ += $(addprefix $(BUILD)/, $(SRC_O)) +OBJ += $(PY_CORE_O) $(addprefix $(BUILD)/, $(SRC_C:.c=.o)) +OBJ += $(addprefix $(BUILD)/, $(SRC_LIBM:.c=.o)) +OBJ += $(addprefix $(BUILD)/, $(SRC_LIB:.c=.o)) +OBJ += $(addprefix $(BUILD)/, $(SRC_LVGL_C:.c=.o)) + +$(BUILD)/$(FATFS_DIR)/ff.o: COPT += -Os +$(filter $(PY_BUILD)/../extmod/vfs_fat_%.o, $(PY_O)): COPT += -Os + + + +# List of source for qstr extraction +SRC_QSTR += $(LVGL_SRC) +SRC_QSTR += $(SRC_C) + +all: $(BUILD)/firmware.bin + +$(BUILD)/firmware.elf: $(OBJ) + $(ECHO) "LINK $@" + $(Q)$(LD) $(LDFLAGS) -o $@ $^ $(LIBS) + $(Q)$(SIZE) $@ + +$(BUILD)/firmware.bin: $(BUILD)/firmware.elf + $(Q)$(OBJCOPY) -O binary $^ $(BUILD)/firmware.bin + +include $(TOP)/py/mkrules.mk diff --git a/ports/nxp/board/evkmimxrt1064/FreeRTOSConfig.h b/ports/nxp/board/evkmimxrt1064/FreeRTOSConfig.h new file mode 100644 index 000000000000..495fe6753a60 --- /dev/null +++ b/ports/nxp/board/evkmimxrt1064/FreeRTOSConfig.h @@ -0,0 +1,123 @@ +/* + * FreeRTOS Kernel V10.2.0 + * Copyright (C) 2019 Amazon.com, Inc. or its affiliates. All Rights Reserved. + * + * 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. + * + * http://www.FreeRTOS.org + * http://aws.amazon.com/freertos + * + * 1 tab == 4 spaces! + */ + +#ifndef FREERTOS_CONFIG_H +#define FREERTOS_CONFIG_H + +/*----------------------------------------------------------- + * Application specific definitions. + * + * These definitions should be adjusted for your particular hardware and + * application requirements. + * + * THESE PARAMETERS ARE DESCRIBED WITHIN THE 'CONFIGURATION' SECTION OF THE + * FreeRTOS API DOCUMENTATION AVAILABLE ON THE FreeRTOS.org WEB SITE. + * + * See http://www.freertos.org/a00110.html. + *----------------------------------------------------------*/ + +#define configUSE_PREEMPTION 1 +#define configUSE_TICKLESS_IDLE 0 +#define configCPU_CLOCK_HZ (SystemCoreClock) +#define configTICK_RATE_HZ ((TickType_t)1000) +#define configMAX_PRIORITIES 18 +#define configMINIMAL_STACK_SIZE ((unsigned short)90) +#define configMAX_TASK_NAME_LEN 10 +#define configUSE_16_BIT_TICKS 0 +#define configIDLE_SHOULD_YIELD 1 +#define configUSE_TASK_NOTIFICATIONS 1 +#define configUSE_MUTEXES 1 +#define configUSE_RECURSIVE_MUTEXES 1 +#define configUSE_COUNTING_SEMAPHORES 1 +#define configUSE_ALTERNATIVE_API 0 /* Deprecated! */ +#define configQUEUE_REGISTRY_SIZE 8 +#define configUSE_QUEUE_SETS 0 +#define configUSE_TIME_SLICING 0 +#define configUSE_NEWLIB_REENTRANT 0 +#define configENABLE_BACKWARD_COMPATIBILITY 1 +#define configNUM_THREAD_LOCAL_STORAGE_POINTERS 5 +#define configUSE_APPLICATION_TASK_TAG 0 + +/* Used memory allocation (heap_x.c) */ +#define configFRTOS_MEMORY_SCHEME 3 +/* Tasks.c additions (e.g. Thread Aware Debug capability) */ +#define configINCLUDE_FREERTOS_TASK_C_ADDITIONS_H 1 + +/* Memory allocation related definitions. */ +#define configSUPPORT_STATIC_ALLOCATION 0 +#define configSUPPORT_DYNAMIC_ALLOCATION 1 +#define configTOTAL_HEAP_SIZE 46*1024 +#define configAPPLICATION_ALLOCATED_HEAP 0 + +/* Hook function related definitions. */ +#define configUSE_IDLE_HOOK 0 +#define configUSE_TICK_HOOK 0 +#define configCHECK_FOR_STACK_OVERFLOW 1 +#define configUSE_MALLOC_FAILED_HOOK 1 +#define configUSE_DAEMON_TASK_STARTUP_HOOK 0 + +/* Run time and task stats gathering related definitions. */ +#define configGENERATE_RUN_TIME_STATS 0 +#define configUSE_TRACE_FACILITY 1 +#define configUSE_STATS_FORMATTING_FUNCTIONS 1 + +/* Co-routine related definitions. */ +#define configUSE_CO_ROUTINES 0 +#define configMAX_CO_ROUTINE_PRIORITIES 2 + +/* Software timer related definitions. */ +#define configUSE_TIMERS 1 +#define configTIMER_TASK_PRIORITY 17 +#define configTIMER_QUEUE_LENGTH 10 +#define configTIMER_TASK_STACK_DEPTH (configMINIMAL_STACK_SIZE * 2) + +/* Define to trap errors during development. */ +#define configASSERT(x) if((x) == 0) {taskDISABLE_INTERRUPTS(); for (;;);} + +/* Optional functions - most linkers will remove unused functions anyway. */ +#define INCLUDE_vTaskPrioritySet 1 +#define INCLUDE_uxTaskPriorityGet 1 +#define INCLUDE_vTaskDelete 1 +#define INCLUDE_vTaskSuspend 1 +#define INCLUDE_xResumeFromISR 1 +#define INCLUDE_vTaskDelayUntil 1 +#define INCLUDE_vTaskDelay 1 +#define INCLUDE_xTaskGetSchedulerState 1 +#define INCLUDE_xTaskGetCurrentTaskHandle 1 +#define INCLUDE_uxTaskGetStackHighWaterMark 0 +#define INCLUDE_xTaskGetIdleTaskHandle 0 +#define INCLUDE_eTaskGetState 0 +#define INCLUDE_xEventGroupSetBitFromISR 1 +#define INCLUDE_xTimerPendFunctionCall 1 +#define INCLUDE_xTaskAbortDelay 0 +#define INCLUDE_xTaskGetHandle 0 +#define INCLUDE_xTaskResumeFromISR 1 + +/****************** Macro definitions ***************/ +#include "FreeRTOSConfigBoard.h" + +#endif /* FREERTOS_CONFIG_H */ diff --git a/ports/nxp/board/evkmimxrt1064/FreeRTOSConfigBoard.h b/ports/nxp/board/evkmimxrt1064/FreeRTOSConfigBoard.h new file mode 100644 index 000000000000..d04c07fa5545 --- /dev/null +++ b/ports/nxp/board/evkmimxrt1064/FreeRTOSConfigBoard.h @@ -0,0 +1,61 @@ +/* + * FreeRTOS Kernel V10.0.1 + * Copyright (C) 2017 Amazon.com, Inc. or its affiliates. All Rights Reserved. + * + * 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. + * + * http://aws.amazon.com/freertos + * http://www.FreeRTOS.org + */ + + +#ifndef FREERTOS_CONFIG_BOARD_H +#define FREERTOS_CONFIG_BOARD_H +/*${macro:start}*/ +/* Interrupt nesting behaviour configuration. Cortex-M specific. */ +#ifdef __NVIC_PRIO_BITS +/* __BVIC_PRIO_BITS will be specified when CMSIS is being used. */ +#define configPRIO_BITS __NVIC_PRIO_BITS +#else +#define configPRIO_BITS 4 /* 15 priority levels */ +#endif + +/* The lowest interrupt priority that can be used in a call to a "set priority" +function. */ +#define configLIBRARY_LOWEST_INTERRUPT_PRIORITY ((1U << (configPRIO_BITS)) - 1) + +/* The highest interrupt priority that can be used by any interrupt service +routine that makes calls to interrupt safe FreeRTOS API functions. DO NOT CALL +INTERRUPT SAFE FREERTOS API FUNCTIONS FROM ANY INTERRUPT THAT HAS A HIGHER +PRIORITY THAN THIS! (higher priorities are lower numeric values. */ +#define configLIBRARY_MAX_SYSCALL_INTERRUPT_PRIORITY 2 + +/* Interrupt priorities used by the kernel port layer itself. These are generic +to all Cortex-M ports, and do not rely on any particular library functions. */ +#define configKERNEL_INTERRUPT_PRIORITY (configLIBRARY_LOWEST_INTERRUPT_PRIORITY << (8 - configPRIO_BITS)) +/* !!!! configMAX_SYSCALL_INTERRUPT_PRIORITY must not be set to zero !!!! +See http://www.FreeRTOS.org/RTOS-Cortex-M3-M4.html. */ +#define configMAX_SYSCALL_INTERRUPT_PRIORITY (configLIBRARY_MAX_SYSCALL_INTERRUPT_PRIORITY << (8 - configPRIO_BITS)) + +/* Definitions that map the FreeRTOS port interrupt handlers to their CMSIS +standard names. */ +#define vPortSVCHandler SVC_Handler +#define xPortPendSVHandler PendSV_Handler +#define xPortSysTickHandler SysTick_Handler +/*${macro:end}*/ +#endif /* FREERTOS_CONFIG_BOARD_H */ diff --git a/ports/nxp/board/evkmimxrt1064/app.h b/ports/nxp/board/evkmimxrt1064/app.h new file mode 100644 index 000000000000..4bd824db6359 --- /dev/null +++ b/ports/nxp/board/evkmimxrt1064/app.h @@ -0,0 +1,25 @@ +/* + * Copyright 2018 NXP + * All rights reserved. + * + * + * SPDX-License-Identifier: BSD-3-Clause + */ +#ifndef _APP_H_ +#define _APP_H_ + +/******************************************************************************* + * Definitions + ******************************************************************************/ +/*${macro:start}*/ + +/*${macro:end}*/ + +/******************************************************************************* + * Prototypes + ******************************************************************************/ +/*${prototype:start}*/ +void BOARD_InitHardware(void); +/*${prototype:end}*/ + +#endif /* _APP_H_ */ diff --git a/ports/nxp/board/evkmimxrt1064/board.c b/ports/nxp/board/evkmimxrt1064/board.c new file mode 100644 index 000000000000..bce67a6e69d1 --- /dev/null +++ b/ports/nxp/board/evkmimxrt1064/board.c @@ -0,0 +1,451 @@ +/* + * Copyright 2018 NXP + * All rights reserved. + * + * SPDX-License-Identifier: BSD-3-Clause + */ + +#include "fsl_common.h" +#include "fsl_debug_console.h" +#include "board.h" +#if defined(SDK_I2C_BASED_COMPONENT_USED) && SDK_I2C_BASED_COMPONENT_USED +#include "fsl_lpi2c.h" +#endif /* SDK_I2C_BASED_COMPONENT_USED */ +#if defined BOARD_USE_CODEC +#include "fsl_wm8960.h" +#endif +#include "fsl_iomuxc.h" +/******************************************************************************* + * Variables + ******************************************************************************/ +#if defined BOARD_USE_CODEC +codec_config_t boardCodecConfig = {.I2C_SendFunc = BOARD_Codec_I2C_Send, + .I2C_ReceiveFunc = BOARD_Codec_I2C_Receive, + .op.Init = WM8960_Init, + .op.Deinit = WM8960_Deinit, + .op.SetFormat = WM8960_ConfigDataFormat}; +#endif +/******************************************************************************* + * Code + ******************************************************************************/ + +/* Get debug console frequency. */ +uint32_t BOARD_DebugConsoleSrcFreq(void) +{ + uint32_t freq; + + /* To make it simple, we assume default PLL and divider settings, and the only variable + from application is use PLL3 source or OSC source */ + if (CLOCK_GetMux(kCLOCK_UartMux) == 0) /* PLL3 div6 80M */ + { + freq = (CLOCK_GetPllFreq(kCLOCK_PllUsb1) / 6U) / (CLOCK_GetDiv(kCLOCK_UartDiv) + 1U); + } + else + { + freq = CLOCK_GetOscFreq() / (CLOCK_GetDiv(kCLOCK_UartDiv) + 1U); + } + + return freq; +} + +/* Initialize debug console. */ +void BOARD_InitDebugConsole(void) +{ + uint32_t uartClkSrcFreq = BOARD_DebugConsoleSrcFreq(); + + DbgConsole_Init(BOARD_DEBUG_UART_INSTANCE, BOARD_DEBUG_UART_BAUDRATE, BOARD_DEBUG_UART_TYPE, uartClkSrcFreq); +} + +#if defined(SDK_I2C_BASED_COMPONENT_USED) && SDK_I2C_BASED_COMPONENT_USED +void BOARD_LPI2C_Init(LPI2C_Type *base, uint32_t clkSrc_Hz) +{ + lpi2c_master_config_t lpi2cConfig = {0}; + + /* + * lpi2cConfig.debugEnable = false; + * lpi2cConfig.ignoreAck = false; + * lpi2cConfig.pinConfig = kLPI2C_2PinOpenDrain; + * lpi2cConfig.baudRate_Hz = 100000U; + * lpi2cConfig.busIdleTimeout_ns = 0; + * lpi2cConfig.pinLowTimeout_ns = 0; + * lpi2cConfig.sdaGlitchFilterWidth_ns = 0; + * lpi2cConfig.sclGlitchFilterWidth_ns = 0; + */ + LPI2C_MasterGetDefaultConfig(&lpi2cConfig); + LPI2C_MasterInit(base, &lpi2cConfig, clkSrc_Hz); +} + +status_t BOARD_LPI2C_Send(LPI2C_Type *base, + uint8_t deviceAddress, + uint32_t subAddress, + uint8_t subAddressSize, + uint8_t *txBuff, + uint8_t txBuffSize) +{ + status_t reVal; + + /* Send master blocking data to slave */ + reVal = LPI2C_MasterStart(base, deviceAddress, kLPI2C_Write); + if (kStatus_Success == reVal) + { + while (LPI2C_MasterGetStatusFlags(base) & kLPI2C_MasterNackDetectFlag) + { + } + + reVal = LPI2C_MasterSend(base, &subAddress, subAddressSize); + if (reVal != kStatus_Success) + { + return reVal; + } + + reVal = LPI2C_MasterSend(base, txBuff, txBuffSize); + if (reVal != kStatus_Success) + { + return reVal; + } + + reVal = LPI2C_MasterStop(base); + if (reVal != kStatus_Success) + { + return reVal; + } + } + + return reVal; +} + +status_t BOARD_LPI2C_Receive(LPI2C_Type *base, + uint8_t deviceAddress, + uint32_t subAddress, + uint8_t subAddressSize, + uint8_t *rxBuff, + uint8_t rxBuffSize) +{ + status_t reVal; + + reVal = LPI2C_MasterStart(base, deviceAddress, kLPI2C_Write); + if (kStatus_Success == reVal) + { + while (LPI2C_MasterGetStatusFlags(base) & kLPI2C_MasterNackDetectFlag) + { + } + + reVal = LPI2C_MasterSend(base, &subAddress, subAddressSize); + if (reVal != kStatus_Success) + { + return reVal; + } + + reVal = LPI2C_MasterRepeatedStart(base, deviceAddress, kLPI2C_Read); + + if (reVal != kStatus_Success) + { + return reVal; + } + + reVal = LPI2C_MasterReceive(base, rxBuff, rxBuffSize); + if (reVal != kStatus_Success) + { + return reVal; + } + + reVal = LPI2C_MasterStop(base); + if (reVal != kStatus_Success) + { + return reVal; + } + } + return reVal; +} + +status_t BOARD_LPI2C_SendSCCB(LPI2C_Type *base, + uint8_t deviceAddress, + uint32_t subAddress, + uint8_t subAddressSize, + uint8_t *txBuff, + uint8_t txBuffSize) +{ + return BOARD_LPI2C_Send(base, deviceAddress, subAddress, subAddressSize, txBuff, txBuffSize); +} + +status_t BOARD_LPI2C_ReceiveSCCB(LPI2C_Type *base, + uint8_t deviceAddress, + uint32_t subAddress, + uint8_t subAddressSize, + uint8_t *rxBuff, + uint8_t rxBuffSize) +{ + status_t reVal; + + reVal = LPI2C_MasterStart(base, deviceAddress, kLPI2C_Write); + if (kStatus_Success == reVal) + { + while (LPI2C_MasterGetStatusFlags(base) & kLPI2C_MasterNackDetectFlag) + { + } + + reVal = LPI2C_MasterSend(base, &subAddress, subAddressSize); + if (reVal != kStatus_Success) + { + return reVal; + } + + /* SCCB does not support LPI2C repeat start, must stop then start. */ + reVal = LPI2C_MasterStop(base); + + if (reVal != kStatus_Success) + { + return reVal; + } + + reVal = LPI2C_MasterStart(base, deviceAddress, kLPI2C_Read); + + if (reVal != kStatus_Success) + { + return reVal; + } + + reVal = LPI2C_MasterReceive(base, rxBuff, rxBuffSize); + if (reVal != kStatus_Success) + { + return reVal; + } + + reVal = LPI2C_MasterStop(base); + if (reVal != kStatus_Success) + { + return reVal; + } + } + return reVal; +} + +void BOARD_Accel_I2C_Init(void) +{ + BOARD_LPI2C_Init(BOARD_ACCEL_I2C_BASEADDR, BOARD_ACCEL_I2C_CLOCK_FREQ); +} + +status_t BOARD_Accel_I2C_Send(uint8_t deviceAddress, uint32_t subAddress, uint8_t subaddressSize, uint32_t txBuff) +{ + uint8_t data = (uint8_t)txBuff; + + return BOARD_LPI2C_Send(BOARD_ACCEL_I2C_BASEADDR, deviceAddress, subAddress, subaddressSize, &data, 1); +} + +status_t BOARD_Accel_I2C_Receive( + uint8_t deviceAddress, uint32_t subAddress, uint8_t subaddressSize, uint8_t *rxBuff, uint8_t rxBuffSize) +{ + return BOARD_LPI2C_Receive(BOARD_ACCEL_I2C_BASEADDR, deviceAddress, subAddress, subaddressSize, rxBuff, rxBuffSize); +} + +void BOARD_Codec_I2C_Init(void) +{ + BOARD_LPI2C_Init(BOARD_CODEC_I2C_BASEADDR, BOARD_CODEC_I2C_CLOCK_FREQ); +} + +status_t BOARD_Codec_I2C_Send( + uint8_t deviceAddress, uint32_t subAddress, uint8_t subAddressSize, const uint8_t *txBuff, uint8_t txBuffSize) +{ + return BOARD_LPI2C_Send(BOARD_CODEC_I2C_BASEADDR, deviceAddress, subAddress, subAddressSize, (uint8_t *)txBuff, + txBuffSize); +} + +status_t BOARD_Codec_I2C_Receive( + uint8_t deviceAddress, uint32_t subAddress, uint8_t subAddressSize, uint8_t *rxBuff, uint8_t rxBuffSize) +{ + return BOARD_LPI2C_Receive(BOARD_CODEC_I2C_BASEADDR, deviceAddress, subAddress, subAddressSize, rxBuff, rxBuffSize); +} + +void BOARD_Camera_I2C_Init(void) +{ + CLOCK_SetMux(kCLOCK_Lpi2cMux, BOARD_CAMERA_I2C_CLOCK_SOURCE_SELECT); + CLOCK_SetDiv(kCLOCK_Lpi2cDiv, BOARD_CAMERA_I2C_CLOCK_SOURCE_DIVIDER); + BOARD_LPI2C_Init(BOARD_CAMERA_I2C_BASEADDR, BOARD_CAMERA_I2C_CLOCK_FREQ); +} + +status_t BOARD_Camera_I2C_Send( + uint8_t deviceAddress, uint32_t subAddress, uint8_t subAddressSize, const uint8_t *txBuff, uint8_t txBuffSize) +{ + return BOARD_LPI2C_Send(BOARD_CAMERA_I2C_BASEADDR, deviceAddress, subAddress, subAddressSize, (uint8_t *)txBuff, + txBuffSize); +} + +status_t BOARD_Camera_I2C_Receive( + uint8_t deviceAddress, uint32_t subAddress, uint8_t subAddressSize, uint8_t *rxBuff, uint8_t rxBuffSize) +{ + return BOARD_LPI2C_Receive(BOARD_CAMERA_I2C_BASEADDR, deviceAddress, subAddress, subAddressSize, rxBuff, + rxBuffSize); +} + +status_t BOARD_Camera_I2C_SendSCCB( + uint8_t deviceAddress, uint32_t subAddress, uint8_t subAddressSize, const uint8_t *txBuff, uint8_t txBuffSize) +{ + return BOARD_LPI2C_SendSCCB(BOARD_CAMERA_I2C_BASEADDR, deviceAddress, subAddress, subAddressSize, (uint8_t *)txBuff, + txBuffSize); +} + +status_t BOARD_Camera_I2C_ReceiveSCCB( + uint8_t deviceAddress, uint32_t subAddress, uint8_t subAddressSize, uint8_t *rxBuff, uint8_t rxBuffSize) +{ + return BOARD_LPI2C_ReceiveSCCB(BOARD_CAMERA_I2C_BASEADDR, deviceAddress, subAddress, subAddressSize, rxBuff, + rxBuffSize); +} +#endif /* SDK_I2C_BASED_COMPONENT_USED */ + +/* MPU configuration. */ +void BOARD_ConfigMPU(void) +{ + /* Disable I cache and D cache */ + if (SCB_CCR_IC_Msk == (SCB_CCR_IC_Msk & SCB->CCR)) + { + SCB_DisableICache(); + } + if (SCB_CCR_DC_Msk == (SCB_CCR_DC_Msk & SCB->CCR)) + { + SCB_DisableDCache(); + } + + /* Disable MPU */ + ARM_MPU_Disable(); + + /* MPU configure: + * Use ARM_MPU_RASR(DisableExec, AccessPermission, TypeExtField, IsShareable, IsCacheable, IsBufferable, + * SubRegionDisable, Size) + * API in core_cm7.h. + * param DisableExec Instruction access (XN) disable bit,0=instruction fetches enabled, 1=instruction fetches + * disabled. + * param AccessPermission Data access permissions, allows you to configure read/write access for User and + * Privileged mode. + * Use MACROS defined in core_cm7.h: + * ARM_MPU_AP_NONE/ARM_MPU_AP_PRIV/ARM_MPU_AP_URO/ARM_MPU_AP_FULL/ARM_MPU_AP_PRO/ARM_MPU_AP_RO + * Combine TypeExtField/IsShareable/IsCacheable/IsBufferable to configure MPU memory access attributes. + * TypeExtField IsShareable IsCacheable IsBufferable Memory Attribtue Shareability Cache + * 0 x 0 0 Strongly Ordered shareable + * 0 x 0 1 Device shareable + * 0 0 1 0 Normal not shareable Outer and inner write + * through no write allocate + * 0 0 1 1 Normal not shareable Outer and inner write + * back no write allocate + * 0 1 1 0 Normal shareable Outer and inner write + * through no write allocate + * 0 1 1 1 Normal shareable Outer and inner write + * back no write allocate + * 1 0 0 0 Normal not shareable outer and inner + * noncache + * 1 1 0 0 Normal shareable outer and inner + * noncache + * 1 0 1 1 Normal not shareable outer and inner write + * back write/read acllocate + * 1 1 1 1 Normal shareable outer and inner write + * back write/read acllocate + * 2 x 0 0 Device not shareable + * Above are normal use settings, if your want to see more details or want to config different inner/outter cache + * policy. + * please refer to Table 4-55 /4-56 in arm cortex-M7 generic user guide + * param SubRegionDisable Sub-region disable field. 0=sub-region is enabled, 1=sub-region is disabled. + * param Size Region size of the region to be configured. use ARM_MPU_REGION_SIZE_xxx MACRO in + * core_cm7.h. + */ + + /* Region 0 setting: Memory with Device type, not shareable, non-cacheable. */ + MPU->RBAR = ARM_MPU_RBAR(0, 0xC0000000U); + MPU->RASR = ARM_MPU_RASR(0, ARM_MPU_AP_FULL, 2, 0, 0, 0, 0, ARM_MPU_REGION_SIZE_512MB); + + /* Region 1 setting: Memory with Device type, not shareable, non-cacheable. */ + MPU->RBAR = ARM_MPU_RBAR(1, 0x80000000U); + MPU->RASR = ARM_MPU_RASR(0, ARM_MPU_AP_FULL, 2, 0, 0, 0, 0, ARM_MPU_REGION_SIZE_1GB); + +/* Region 2 setting */ +#if defined(XIP_EXTERNAL_FLASH) && (XIP_EXTERNAL_FLASH == 1) + /* Setting Memory with Normal type, not shareable, outer/inner write back. */ + MPU->RBAR = ARM_MPU_RBAR(2, 0x70000000U); + MPU->RASR = ARM_MPU_RASR(0, ARM_MPU_AP_RO, 0, 0, 1, 1, 0, ARM_MPU_REGION_SIZE_4MB); +#else + /* Setting Memory with Device type, not shareable, non-cacheable. */ + MPU->RBAR = ARM_MPU_RBAR(2, 0x70000000U); + MPU->RASR = ARM_MPU_RASR(0, ARM_MPU_AP_RO, 2, 0, 0, 0, 0, ARM_MPU_REGION_SIZE_4MB); +#endif + + /* Region 3 setting: Memory with Device type, not shareable, non-cacheable. */ + MPU->RBAR = ARM_MPU_RBAR(3, 0x00000000U); + MPU->RASR = ARM_MPU_RASR(0, ARM_MPU_AP_FULL, 2, 0, 0, 0, 0, ARM_MPU_REGION_SIZE_1GB); + + /* Region 4 setting: Memory with Normal type, not shareable, outer/inner write back */ + MPU->RBAR = ARM_MPU_RBAR(4, 0x00000000U); + MPU->RASR = ARM_MPU_RASR(0, ARM_MPU_AP_FULL, 0, 0, 1, 1, 0, ARM_MPU_REGION_SIZE_128KB); + + /* Region 5 setting: Memory with Normal type, not shareable, outer/inner write back */ + MPU->RBAR = ARM_MPU_RBAR(5, 0x20000000U); + MPU->RASR = ARM_MPU_RASR(0, ARM_MPU_AP_FULL, 0, 0, 1, 1, 0, ARM_MPU_REGION_SIZE_128KB); + + /* Region 6 setting: Memory with Normal type, not shareable, outer/inner write back */ + MPU->RBAR = ARM_MPU_RBAR(6, 0x20200000U); + MPU->RASR = ARM_MPU_RASR(0, ARM_MPU_AP_FULL, 0, 0, 1, 1, 0, ARM_MPU_REGION_SIZE_512KB); + + /* Region 7 setting: Memory with Normal type, not shareable, outer/inner write back */ + MPU->RBAR = ARM_MPU_RBAR(7, 0x20280000U); + MPU->RASR = ARM_MPU_RASR(0, ARM_MPU_AP_FULL, 0, 0, 1, 1, 0, ARM_MPU_REGION_SIZE_256KB); + +/* The define sets the cacheable memory to shareable, + * this suggestion is referred from chapter 2.2.1 Memory regions, + * types and attributes in Cortex-M7 Devices, Generic User Guide */ +#if defined(SDRAM_IS_SHAREABLE) + /* Region 8 setting: Memory with Normal type, not shareable, outer/inner write back */ + MPU->RBAR = ARM_MPU_RBAR(8, 0x80000000U); + MPU->RASR = ARM_MPU_RASR(0, ARM_MPU_AP_FULL, 0, 1, 1, 1, 0, ARM_MPU_REGION_SIZE_32MB); +#else + /* Region 8 setting: Memory with Normal type, not shareable, outer/inner write back */ + MPU->RBAR = ARM_MPU_RBAR(8, 0x80000000U); + MPU->RASR = ARM_MPU_RASR(0, ARM_MPU_AP_FULL, 0, 0, 1, 1, 0, ARM_MPU_REGION_SIZE_32MB); +#endif + + /* Region 9 setting, set last 2MB of SDRAM can't be accessed by cache, glocal variables which are not expected to be + * accessed by cache can be put here */ + /* Memory with Normal type, not shareable, non-cacheable */ + MPU->RBAR = ARM_MPU_RBAR(9, 0x81E00000U); + MPU->RASR = ARM_MPU_RASR(0, ARM_MPU_AP_FULL, 1, 0, 0, 0, 0, ARM_MPU_REGION_SIZE_2MB); + + /* Enable MPU */ + ARM_MPU_Enable(MPU_CTRL_PRIVDEFENA_Msk); + + /* Enable I cache and D cache */ + SCB_EnableDCache(); + SCB_EnableICache(); +} + +void BOARD_SD_Pin_Config(uint32_t speed, uint32_t strength) +{ + IOMUXC_SetPinConfig(IOMUXC_GPIO_SD_B0_00_USDHC1_CMD, + IOMUXC_SW_PAD_CTL_PAD_SPEED(speed) | IOMUXC_SW_PAD_CTL_PAD_SRE_MASK | + IOMUXC_SW_PAD_CTL_PAD_PKE_MASK | IOMUXC_SW_PAD_CTL_PAD_PUE_MASK | + IOMUXC_SW_PAD_CTL_PAD_HYS_MASK | IOMUXC_SW_PAD_CTL_PAD_PUS(1) | + IOMUXC_SW_PAD_CTL_PAD_DSE(strength)); + IOMUXC_SetPinConfig(IOMUXC_GPIO_SD_B0_01_USDHC1_CLK, + IOMUXC_SW_PAD_CTL_PAD_SPEED(speed) | IOMUXC_SW_PAD_CTL_PAD_SRE_MASK | + IOMUXC_SW_PAD_CTL_PAD_HYS_MASK | IOMUXC_SW_PAD_CTL_PAD_PUS(0) | + IOMUXC_SW_PAD_CTL_PAD_DSE(strength)); + IOMUXC_SetPinConfig(IOMUXC_GPIO_SD_B0_02_USDHC1_DATA0, + IOMUXC_SW_PAD_CTL_PAD_SPEED(speed) | IOMUXC_SW_PAD_CTL_PAD_SRE_MASK | + IOMUXC_SW_PAD_CTL_PAD_PKE_MASK | IOMUXC_SW_PAD_CTL_PAD_PUE_MASK | + IOMUXC_SW_PAD_CTL_PAD_HYS_MASK | IOMUXC_SW_PAD_CTL_PAD_PUS(1) | + IOMUXC_SW_PAD_CTL_PAD_DSE(strength)); + IOMUXC_SetPinConfig(IOMUXC_GPIO_SD_B0_03_USDHC1_DATA1, + IOMUXC_SW_PAD_CTL_PAD_SPEED(speed) | IOMUXC_SW_PAD_CTL_PAD_SRE_MASK | + IOMUXC_SW_PAD_CTL_PAD_PKE_MASK | IOMUXC_SW_PAD_CTL_PAD_PUE_MASK | + IOMUXC_SW_PAD_CTL_PAD_HYS_MASK | IOMUXC_SW_PAD_CTL_PAD_PUS(1) | + IOMUXC_SW_PAD_CTL_PAD_DSE(strength)); + IOMUXC_SetPinConfig(IOMUXC_GPIO_SD_B0_04_USDHC1_DATA2, + IOMUXC_SW_PAD_CTL_PAD_SPEED(speed) | IOMUXC_SW_PAD_CTL_PAD_SRE_MASK | + IOMUXC_SW_PAD_CTL_PAD_PKE_MASK | IOMUXC_SW_PAD_CTL_PAD_PUE_MASK | + IOMUXC_SW_PAD_CTL_PAD_HYS_MASK | IOMUXC_SW_PAD_CTL_PAD_PUS(1) | + IOMUXC_SW_PAD_CTL_PAD_DSE(strength)); + IOMUXC_SetPinConfig(IOMUXC_GPIO_SD_B0_05_USDHC1_DATA3, + IOMUXC_SW_PAD_CTL_PAD_SPEED(speed) | IOMUXC_SW_PAD_CTL_PAD_SRE_MASK | + IOMUXC_SW_PAD_CTL_PAD_PKE_MASK | IOMUXC_SW_PAD_CTL_PAD_PUE_MASK | + IOMUXC_SW_PAD_CTL_PAD_HYS_MASK | IOMUXC_SW_PAD_CTL_PAD_PUS(1) | + IOMUXC_SW_PAD_CTL_PAD_DSE(strength)); +} + +void BOARD_MMC_Pin_Config(uint32_t speed, uint32_t strength) +{ +} diff --git a/ports/nxp/board/evkmimxrt1064/board.h b/ports/nxp/board/evkmimxrt1064/board.h new file mode 100644 index 000000000000..e92314d60743 --- /dev/null +++ b/ports/nxp/board/evkmimxrt1064/board.h @@ -0,0 +1,277 @@ +/* + * Copyright 2018 NXP + * All rights reserved. + * + * SPDX-License-Identifier: BSD-3-Clause + */ + +#ifndef _BOARD_H_ +#define _BOARD_H_ + +#include "clock_config.h" +#include "fsl_common.h" +#include "fsl_gpio.h" +#include "fsl_clock.h" + +/******************************************************************************* + * Definitions + ******************************************************************************/ +/*! @brief The board name */ +#define BOARD_NAME "MIMXRT1064-EVK" + +/* The UART to use for debug messages. */ +#define BOARD_DEBUG_UART_TYPE kSerialPort_Uart +#define BOARD_DEBUG_UART_BASEADDR (uint32_t) LPUART1 +#define BOARD_DEBUG_UART_INSTANCE 1U + +#define BOARD_DEBUG_UART_CLK_FREQ BOARD_DebugConsoleSrcFreq() + +#define BOARD_UART_IRQ LPUART1_IRQn +#define BOARD_UART_IRQ_HANDLER LPUART1_IRQHandler + +#ifndef BOARD_DEBUG_UART_BAUDRATE +#define BOARD_DEBUG_UART_BAUDRATE (115200U) +#endif /* BOARD_DEBUG_UART_BAUDRATE */ + +/*! @brief The USER_LED used for board */ +#define LOGIC_LED_ON (0U) +#define LOGIC_LED_OFF (1U) +#ifndef BOARD_USER_LED_GPIO +#define BOARD_USER_LED_GPIO GPIO1 +#endif +#ifndef BOARD_USER_LED_GPIO_PIN +#define BOARD_USER_LED_GPIO_PIN (9U) +#endif + +#define USER_LED_INIT(output) \ + GPIO_PinWrite(BOARD_USER_LED_GPIO, BOARD_USER_LED_GPIO_PIN, output); \ + BOARD_USER_LED_GPIO->GDIR |= (1U << BOARD_USER_LED_GPIO_PIN) /*!< Enable target USER_LED */ +#define USER_LED_ON() \ + GPIO_PortClear(BOARD_USER_LED_GPIO, 1U << BOARD_USER_LED_GPIO_PIN) /*!< Turn off target USER_LED */ +#define USER_LED_OFF() GPIO_PortSet(BOARD_USER_LED_GPIO, 1U << BOARD_USER_LED_GPIO_PIN) /*!OSC_CONFIG2 |= XTALOSC24M_OSC_CONFIG2_ENABLE_1M_MASK; + /* Use free 1MHz clock output. */ + XTALOSC24M->OSC_CONFIG2 &= ~XTALOSC24M_OSC_CONFIG2_MUX_1M_MASK; + /* Set XTAL 24MHz clock frequency. */ + CLOCK_SetXtalFreq(24000000U); + /* Enable XTAL 24MHz clock source. */ + CLOCK_InitExternalClk(0); + /* Enable internal RC. */ + CLOCK_InitRcOsc24M(); + /* Switch clock source to external OSC. */ + CLOCK_SwitchOsc(kCLOCK_XtalOsc); + /* Set Oscillator ready counter value. */ + CCM->CCR = (CCM->CCR & (~CCM_CCR_OSCNT_MASK)) | CCM_CCR_OSCNT(127); + /* Setting PeriphClk2Mux and PeriphMux to provide stable clock before PLLs are initialed */ + CLOCK_SetMux(kCLOCK_PeriphClk2Mux, 1); /* Set PERIPH_CLK2 MUX to OSC */ + CLOCK_SetMux(kCLOCK_PeriphMux, 1); /* Set PERIPH_CLK MUX to PERIPH_CLK2 */ + /* Setting the VDD_SOC to 1.275V. It is necessary to config AHB to 600Mhz. */ + DCDC->REG3 = (DCDC->REG3 & (~DCDC_REG3_TRG_MASK)) | DCDC_REG3_TRG(0x13); + /* Waiting for DCDC_STS_DC_OK bit is asserted */ + while (DCDC_REG0_STS_DC_OK_MASK != (DCDC_REG0_STS_DC_OK_MASK & DCDC->REG0)) + { + } + /* Set AHB_PODF. */ + CLOCK_SetDiv(kCLOCK_AhbDiv, 0); + /* Disable IPG clock gate. */ + CLOCK_DisableClock(kCLOCK_Adc1); + CLOCK_DisableClock(kCLOCK_Adc2); + CLOCK_DisableClock(kCLOCK_Xbar1); + CLOCK_DisableClock(kCLOCK_Xbar2); + CLOCK_DisableClock(kCLOCK_Xbar3); + /* Set IPG_PODF. */ + CLOCK_SetDiv(kCLOCK_IpgDiv, 3); + /* Set ARM_PODF. */ + CLOCK_SetDiv(kCLOCK_ArmDiv, 1); + /* Set PERIPH_CLK2_PODF. */ + CLOCK_SetDiv(kCLOCK_PeriphClk2Div, 0); + /* Disable PERCLK clock gate. */ + CLOCK_DisableClock(kCLOCK_Gpt1); + CLOCK_DisableClock(kCLOCK_Gpt1S); + CLOCK_DisableClock(kCLOCK_Gpt2); + CLOCK_DisableClock(kCLOCK_Gpt2S); + CLOCK_DisableClock(kCLOCK_Pit); + /* Set PERCLK_PODF. */ + CLOCK_SetDiv(kCLOCK_PerclkDiv, 1); + /* Disable USDHC1 clock gate. */ + CLOCK_DisableClock(kCLOCK_Usdhc1); + /* Set USDHC1_PODF. */ + CLOCK_SetDiv(kCLOCK_Usdhc1Div, 1); + /* Set Usdhc1 clock source. */ + CLOCK_SetMux(kCLOCK_Usdhc1Mux, 0); + /* Disable USDHC2 clock gate. */ + CLOCK_DisableClock(kCLOCK_Usdhc2); + /* Set USDHC2_PODF. */ + CLOCK_SetDiv(kCLOCK_Usdhc2Div, 1); + /* Set Usdhc2 clock source. */ + CLOCK_SetMux(kCLOCK_Usdhc2Mux, 0); + /* In SDK projects, SDRAM (configured by SEMC) will be initialized in either debug script or dcd. + * With this macro SKIP_SYSCLK_INIT, system pll (selected to be SEMC source clock in SDK projects) will be left + * unchanged. Note: If another clock source is selected for SEMC, user may want to avoid changing that clock as + * well.*/ +#ifndef SKIP_SYSCLK_INIT + /* Disable Semc clock gate. */ + CLOCK_DisableClock(kCLOCK_Semc); + /* Set SEMC_PODF. */ + CLOCK_SetDiv(kCLOCK_SemcDiv, 7); + /* Set Semc alt clock source. */ + CLOCK_SetMux(kCLOCK_SemcAltMux, 0); + /* Set Semc clock source. */ + CLOCK_SetMux(kCLOCK_SemcMux, 0); +#endif + /* Disable Flexspi clock gate. */ + CLOCK_DisableClock(kCLOCK_FlexSpi); + /* Set FLEXSPI_PODF. */ + CLOCK_SetDiv(kCLOCK_FlexspiDiv, 1); + /* Set Flexspi clock source. */ + CLOCK_SetMux(kCLOCK_FlexspiMux, 3); + /* In SDK projects, external flash (configured by FLEXSPI2) will be initialized by dcd. + * With this macro XIP_EXTERNAL_FLASH, usb1 pll (selected to be FLEXSPI2 clock source in SDK projects) will be left + * unchanged. + * Note: If another clock source is selected for FLEXSPI2, user may want to avoid changing that clock as well.*/ +#if !(defined(XIP_EXTERNAL_FLASH) && (XIP_EXTERNAL_FLASH == 1)) + /* Disable Flexspi2 clock gate. */ + CLOCK_DisableClock(kCLOCK_FlexSpi2); + /* Set FLEXSPI2_PODF. */ + CLOCK_SetDiv(kCLOCK_Flexspi2Div, 1); + /* Set Flexspi2 clock source. */ + CLOCK_SetMux(kCLOCK_Flexspi2Mux, 1); +#endif + /* Disable CSI clock gate. */ + CLOCK_DisableClock(kCLOCK_Csi); + /* Set CSI_PODF. */ + CLOCK_SetDiv(kCLOCK_CsiDiv, 1); + /* Set Csi clock source. */ + CLOCK_SetMux(kCLOCK_CsiMux, 0); + /* Disable LPSPI clock gate. */ + CLOCK_DisableClock(kCLOCK_Lpspi1); + CLOCK_DisableClock(kCLOCK_Lpspi2); + CLOCK_DisableClock(kCLOCK_Lpspi3); + CLOCK_DisableClock(kCLOCK_Lpspi4); + /* Set LPSPI_PODF. */ + CLOCK_SetDiv(kCLOCK_LpspiDiv, 4); + /* Set Lpspi clock source. */ + CLOCK_SetMux(kCLOCK_LpspiMux, 2); + /* Disable TRACE clock gate. */ + CLOCK_DisableClock(kCLOCK_Trace); + /* Set TRACE_PODF. */ + CLOCK_SetDiv(kCLOCK_TraceDiv, 2); + /* Set Trace clock source. */ + CLOCK_SetMux(kCLOCK_TraceMux, 2); + /* Disable SAI1 clock gate. */ + CLOCK_DisableClock(kCLOCK_Sai1); + /* Set SAI1_CLK_PRED. */ + CLOCK_SetDiv(kCLOCK_Sai1PreDiv, 3); + /* Set SAI1_CLK_PODF. */ + CLOCK_SetDiv(kCLOCK_Sai1Div, 1); + /* Set Sai1 clock source. */ + CLOCK_SetMux(kCLOCK_Sai1Mux, 0); + /* Disable SAI2 clock gate. */ + CLOCK_DisableClock(kCLOCK_Sai2); + /* Set SAI2_CLK_PRED. */ + CLOCK_SetDiv(kCLOCK_Sai2PreDiv, 3); + /* Set SAI2_CLK_PODF. */ + CLOCK_SetDiv(kCLOCK_Sai2Div, 1); + /* Set Sai2 clock source. */ + CLOCK_SetMux(kCLOCK_Sai2Mux, 0); + /* Disable SAI3 clock gate. */ + CLOCK_DisableClock(kCLOCK_Sai3); + /* Set SAI3_CLK_PRED. */ + CLOCK_SetDiv(kCLOCK_Sai3PreDiv, 3); + /* Set SAI3_CLK_PODF. */ + CLOCK_SetDiv(kCLOCK_Sai3Div, 1); + /* Set Sai3 clock source. */ + CLOCK_SetMux(kCLOCK_Sai3Mux, 0); + /* Disable Lpi2c clock gate. */ + CLOCK_DisableClock(kCLOCK_Lpi2c1); + CLOCK_DisableClock(kCLOCK_Lpi2c2); + CLOCK_DisableClock(kCLOCK_Lpi2c3); + /* Set LPI2C_CLK_PODF. */ + CLOCK_SetDiv(kCLOCK_Lpi2cDiv, 0); + /* Set Lpi2c clock source. */ + CLOCK_SetMux(kCLOCK_Lpi2cMux, 0); + /* Disable CAN clock gate. */ + CLOCK_DisableClock(kCLOCK_Can1); + CLOCK_DisableClock(kCLOCK_Can2); + CLOCK_DisableClock(kCLOCK_Can3); + CLOCK_DisableClock(kCLOCK_Can1S); + CLOCK_DisableClock(kCLOCK_Can2S); + CLOCK_DisableClock(kCLOCK_Can3S); + /* Set CAN_CLK_PODF. */ + CLOCK_SetDiv(kCLOCK_CanDiv, 1); + /* Set Can clock source. */ + CLOCK_SetMux(kCLOCK_CanMux, 2); + /* Disable UART clock gate. */ + CLOCK_DisableClock(kCLOCK_Lpuart1); + CLOCK_DisableClock(kCLOCK_Lpuart2); + CLOCK_DisableClock(kCLOCK_Lpuart3); + CLOCK_DisableClock(kCLOCK_Lpuart4); + CLOCK_DisableClock(kCLOCK_Lpuart5); + CLOCK_DisableClock(kCLOCK_Lpuart6); + CLOCK_DisableClock(kCLOCK_Lpuart7); + CLOCK_DisableClock(kCLOCK_Lpuart8); + /* Set UART_CLK_PODF. */ + CLOCK_SetDiv(kCLOCK_UartDiv, 0); + /* Set Uart clock source. */ + CLOCK_SetMux(kCLOCK_UartMux, 0); + /* Disable LCDIF clock gate. */ + CLOCK_DisableClock(kCLOCK_LcdPixel); + /* Set LCDIF_PRED. */ + CLOCK_SetDiv(kCLOCK_LcdifPreDiv, 1); + /* Set LCDIF_CLK_PODF. */ + CLOCK_SetDiv(kCLOCK_LcdifDiv, 3); + /* Set Lcdif pre clock source. */ + CLOCK_SetMux(kCLOCK_LcdifPreMux, 5); + /* Disable SPDIF clock gate. */ + CLOCK_DisableClock(kCLOCK_Spdif); + /* Set SPDIF0_CLK_PRED. */ + CLOCK_SetDiv(kCLOCK_Spdif0PreDiv, 1); + /* Set SPDIF0_CLK_PODF. */ + CLOCK_SetDiv(kCLOCK_Spdif0Div, 7); + /* Set Spdif clock source. */ + CLOCK_SetMux(kCLOCK_SpdifMux, 3); + /* Disable Flexio1 clock gate. */ + CLOCK_DisableClock(kCLOCK_Flexio1); + /* Set FLEXIO1_CLK_PRED. */ + CLOCK_SetDiv(kCLOCK_Flexio1PreDiv, 1); + /* Set FLEXIO1_CLK_PODF. */ + CLOCK_SetDiv(kCLOCK_Flexio1Div, 7); + /* Set Flexio1 clock source. */ + CLOCK_SetMux(kCLOCK_Flexio1Mux, 3); + /* Disable Flexio2 clock gate. */ + CLOCK_DisableClock(kCLOCK_Flexio2); + /* Set FLEXIO2_CLK_PRED. */ + CLOCK_SetDiv(kCLOCK_Flexio2PreDiv, 1); + /* Set FLEXIO2_CLK_PODF. */ + CLOCK_SetDiv(kCLOCK_Flexio2Div, 7); + /* Set Flexio2 clock source. */ + CLOCK_SetMux(kCLOCK_Flexio2Mux, 3); + /* Set Pll3 sw clock source. */ + CLOCK_SetMux(kCLOCK_Pll3SwMux, 0); + /* Init ARM PLL. */ + CLOCK_InitArmPll(&armPllConfig_BOARD_BootClockRUN); + /* In SDK projects, SDRAM (configured by SEMC) will be initialized in either debug script or dcd. + * With this macro SKIP_SYSCLK_INIT, system pll (selected to be SEMC source clock in SDK projects) will be left + * unchanged. Note: If another clock source is selected for SEMC, user may want to avoid changing that clock as + * well.*/ +#ifndef SKIP_SYSCLK_INIT + /* Init System PLL. */ + CLOCK_InitSysPll(&sysPllConfig_BOARD_BootClockRUN); + /* Init System pfd0. */ + CLOCK_InitSysPfd(kCLOCK_Pfd0, 27); + /* Init System pfd1. */ + CLOCK_InitSysPfd(kCLOCK_Pfd1, 16); + /* Init System pfd2. */ + CLOCK_InitSysPfd(kCLOCK_Pfd2, 24); + /* Init System pfd3. */ + CLOCK_InitSysPfd(kCLOCK_Pfd3, 16); +#endif + /* In SDK projects, external flash (configured by FLEXSPI2) will be initialized by dcd. + * With this macro XIP_EXTERNAL_FLASH, usb1 pll (selected to be FLEXSPI2 clock source in SDK projects) will be left + * unchanged. + * Note: If another clock source is selected for FLEXSPI2, user may want to avoid changing that clock as well.*/ +#if !(defined(XIP_EXTERNAL_FLASH) && (XIP_EXTERNAL_FLASH == 1)) + /* Init Usb1 PLL. */ + CLOCK_InitUsb1Pll(&usb1PllConfig_BOARD_BootClockRUN); + /* Init Usb1 pfd0. */ + CLOCK_InitUsb1Pfd(kCLOCK_Pfd0, 33); + /* Init Usb1 pfd1. */ + CLOCK_InitUsb1Pfd(kCLOCK_Pfd1, 16); + /* Init Usb1 pfd2. */ + CLOCK_InitUsb1Pfd(kCLOCK_Pfd2, 17); + /* Init Usb1 pfd3. */ + CLOCK_InitUsb1Pfd(kCLOCK_Pfd3, 19); + /* Disable Usb1 PLL output for USBPHY1. */ + CCM_ANALOG->PLL_USB1 &= ~CCM_ANALOG_PLL_USB1_EN_USB_CLKS_MASK; +#endif + /* DeInit Audio PLL. */ + CLOCK_DeinitAudioPll(); + /* Bypass Audio PLL. */ + CLOCK_SetPllBypass(CCM_ANALOG, kCLOCK_PllAudio, 1); + /* Set divider for Audio PLL. */ + CCM_ANALOG->MISC2 &= ~CCM_ANALOG_MISC2_AUDIO_DIV_LSB_MASK; + CCM_ANALOG->MISC2 &= ~CCM_ANALOG_MISC2_AUDIO_DIV_MSB_MASK; + /* Enable Audio PLL output. */ + CCM_ANALOG->PLL_AUDIO |= CCM_ANALOG_PLL_AUDIO_ENABLE_MASK; + /* DeInit Video PLL. */ + CLOCK_DeinitVideoPll(); + /* Bypass Video PLL. */ + CCM_ANALOG->PLL_VIDEO |= CCM_ANALOG_PLL_VIDEO_BYPASS_MASK; + /* Set divider for Video PLL. */ + CCM_ANALOG->MISC2 = (CCM_ANALOG->MISC2 & (~CCM_ANALOG_MISC2_VIDEO_DIV_MASK)) | CCM_ANALOG_MISC2_VIDEO_DIV(0); + /* Enable Video PLL output. */ + CCM_ANALOG->PLL_VIDEO |= CCM_ANALOG_PLL_VIDEO_ENABLE_MASK; + /* DeInit Enet PLL. */ + CLOCK_DeinitEnetPll(); + /* Bypass Enet PLL. */ + CLOCK_SetPllBypass(CCM_ANALOG, kCLOCK_PllEnet, 1); + /* Set Enet output divider. */ + CCM_ANALOG->PLL_ENET = + (CCM_ANALOG->PLL_ENET & (~CCM_ANALOG_PLL_ENET_DIV_SELECT_MASK)) | CCM_ANALOG_PLL_ENET_DIV_SELECT(1); + /* Enable Enet output. */ + CCM_ANALOG->PLL_ENET |= CCM_ANALOG_PLL_ENET_ENABLE_MASK; + /* Set Enet2 output divider. */ + CCM_ANALOG->PLL_ENET = + (CCM_ANALOG->PLL_ENET & (~CCM_ANALOG_PLL_ENET_ENET2_DIV_SELECT_MASK)) | CCM_ANALOG_PLL_ENET_ENET2_DIV_SELECT(0); + /* Enable Enet2 output. */ + CCM_ANALOG->PLL_ENET |= CCM_ANALOG_PLL_ENET_ENET2_REF_EN_MASK; + /* Enable Enet25M output. */ + CCM_ANALOG->PLL_ENET |= CCM_ANALOG_PLL_ENET_ENET_25M_REF_EN_MASK; + /* DeInit Usb2 PLL. */ + CLOCK_DeinitUsb2Pll(); + /* Bypass Usb2 PLL. */ + CLOCK_SetPllBypass(CCM_ANALOG, kCLOCK_PllUsb2, 1); + /* Enable Usb2 PLL output. */ + CCM_ANALOG->PLL_USB2 |= CCM_ANALOG_PLL_USB2_ENABLE_MASK; + /* Set preperiph clock source. */ + CLOCK_SetMux(kCLOCK_PrePeriphMux, 3); + /* Set periph clock source. */ + CLOCK_SetMux(kCLOCK_PeriphMux, 0); + /* Set periph clock2 clock source. */ + CLOCK_SetMux(kCLOCK_PeriphClk2Mux, 0); + /* Set per clock source. */ + CLOCK_SetMux(kCLOCK_PerclkMux, 0); + /* Set lvds1 clock source. */ + CCM_ANALOG->MISC1 = + (CCM_ANALOG->MISC1 & (~CCM_ANALOG_MISC1_LVDS1_CLK_SEL_MASK)) | CCM_ANALOG_MISC1_LVDS1_CLK_SEL(0); + /* Set clock out1 divider. */ + CCM->CCOSR = (CCM->CCOSR & (~CCM_CCOSR_CLKO1_DIV_MASK)) | CCM_CCOSR_CLKO1_DIV(0); + /* Set clock out1 source. */ + CCM->CCOSR = (CCM->CCOSR & (~CCM_CCOSR_CLKO1_SEL_MASK)) | CCM_CCOSR_CLKO1_SEL(1); + /* Set clock out2 divider. */ + CCM->CCOSR = (CCM->CCOSR & (~CCM_CCOSR_CLKO2_DIV_MASK)) | CCM_CCOSR_CLKO2_DIV(0); + /* Set clock out2 source. */ + CCM->CCOSR = (CCM->CCOSR & (~CCM_CCOSR_CLKO2_SEL_MASK)) | CCM_CCOSR_CLKO2_SEL(18); + /* Set clock out1 drives clock out1. */ + CCM->CCOSR &= ~CCM_CCOSR_CLK_OUT_SEL_MASK; + /* Disable clock out1. */ + CCM->CCOSR &= ~CCM_CCOSR_CLKO1_EN_MASK; + /* Disable clock out2. */ + CCM->CCOSR &= ~CCM_CCOSR_CLKO2_EN_MASK; + /* Set SAI1 MCLK1 clock source. */ + IOMUXC_SetSaiMClkClockSource(IOMUXC_GPR, kIOMUXC_GPR_SAI1MClk1Sel, 0); + /* Set SAI1 MCLK2 clock source. */ + IOMUXC_SetSaiMClkClockSource(IOMUXC_GPR, kIOMUXC_GPR_SAI1MClk2Sel, 0); + /* Set SAI1 MCLK3 clock source. */ + IOMUXC_SetSaiMClkClockSource(IOMUXC_GPR, kIOMUXC_GPR_SAI1MClk3Sel, 0); + /* Set SAI2 MCLK3 clock source. */ + IOMUXC_SetSaiMClkClockSource(IOMUXC_GPR, kIOMUXC_GPR_SAI2MClk3Sel, 0); + /* Set SAI3 MCLK3 clock source. */ + IOMUXC_SetSaiMClkClockSource(IOMUXC_GPR, kIOMUXC_GPR_SAI3MClk3Sel, 0); + /* Set MQS configuration. */ + IOMUXC_MQSConfig(IOMUXC_GPR, kIOMUXC_MqsPwmOverSampleRate32, 0); + /* Set ENET1 Tx clock source. */ + IOMUXC_EnableMode(IOMUXC_GPR, kIOMUXC_GPR_ENET1RefClkMode, false); + /* Set ENET2 Tx clock source. */ +#if defined(FSL_IOMUXC_DRIVER_VERSION) && (FSL_IOMUXC_DRIVER_VERSION != (MAKE_VERSION(2, 0, 0))) + IOMUXC_EnableMode(IOMUXC_GPR, kIOMUXC_GPR_ENET2RefClkMode, false); +#else + IOMUXC_EnableMode(IOMUXC_GPR, IOMUXC_GPR_GPR1_ENET2_CLK_SEL_MASK, false); +#endif + /* Set GPT1 High frequency reference clock source. */ + IOMUXC_GPR->GPR5 &= ~IOMUXC_GPR_GPR5_VREF_1M_CLK_GPT1_MASK; + /* Set GPT2 High frequency reference clock source. */ + IOMUXC_GPR->GPR5 &= ~IOMUXC_GPR_GPR5_VREF_1M_CLK_GPT2_MASK; + /* Set SystemCoreClock variable. */ + SystemCoreClock = BOARD_BOOTCLOCKRUN_CORE_CLOCK; +} diff --git a/ports/nxp/board/evkmimxrt1064/clock_config.h b/ports/nxp/board/evkmimxrt1064/clock_config.h new file mode 100644 index 000000000000..13bc925a105c --- /dev/null +++ b/ports/nxp/board/evkmimxrt1064/clock_config.h @@ -0,0 +1,122 @@ +/* + * Copyright 2018-2019 NXP + * All rights reserved. + * + * SPDX-License-Identifier: BSD-3-Clause + */ + +#ifndef _CLOCK_CONFIG_H_ +#define _CLOCK_CONFIG_H_ + +#include "fsl_common.h" + +/******************************************************************************* + * Definitions + ******************************************************************************/ +#define BOARD_XTAL0_CLK_HZ 24000000U /*!< Board xtal0 frequency in Hz */ + +#define BOARD_XTAL32K_CLK_HZ 32768U /*!< Board xtal32k frequency in Hz */ +/******************************************************************************* + ************************ BOARD_InitBootClocks function ************************ + ******************************************************************************/ + +#if defined(__cplusplus) +extern "C" { +#endif /* __cplusplus*/ + +/*! + * @brief This function executes default configuration of clocks. + * + */ +void BOARD_InitBootClocks(void); + +#if defined(__cplusplus) +} +#endif /* __cplusplus*/ + +/******************************************************************************* + ********************** Configuration BOARD_BootClockRUN *********************** + ******************************************************************************/ +/******************************************************************************* + * Definitions for BOARD_BootClockRUN configuration + ******************************************************************************/ +#define BOARD_BOOTCLOCKRUN_CORE_CLOCK 600000000U /*!< Core clock frequency: 600000000Hz */ + +/* Clock outputs (values are in Hz): */ +#define BOARD_BOOTCLOCKRUN_AHB_CLK_ROOT 600000000UL +#define BOARD_BOOTCLOCKRUN_CAN_CLK_ROOT 40000000UL +#define BOARD_BOOTCLOCKRUN_CKIL_SYNC_CLK_ROOT 32768UL +#define BOARD_BOOTCLOCKRUN_CLKO1_CLK 0UL +#define BOARD_BOOTCLOCKRUN_CLKO2_CLK 0UL +#define BOARD_BOOTCLOCKRUN_CLK_1M 1000000UL +#define BOARD_BOOTCLOCKRUN_CLK_24M 24000000UL +#define BOARD_BOOTCLOCKRUN_CSI_CLK_ROOT 12000000UL +#define BOARD_BOOTCLOCKRUN_ENET1_TX_CLK 2400000UL +#define BOARD_BOOTCLOCKRUN_ENET2_125M_CLK 1200000UL +#define BOARD_BOOTCLOCKRUN_ENET2_TX_CLK 1200000UL +#define BOARD_BOOTCLOCKRUN_ENET_125M_CLK 2400000UL +#define BOARD_BOOTCLOCKRUN_ENET_25M_REF_CLK 1200000UL +#define BOARD_BOOTCLOCKRUN_FLEXIO1_CLK_ROOT 30000000UL +#define BOARD_BOOTCLOCKRUN_FLEXIO2_CLK_ROOT 30000000UL +#define BOARD_BOOTCLOCKRUN_FLEXSPI2_CLK_ROOT 130909090UL +#define BOARD_BOOTCLOCKRUN_FLEXSPI_CLK_ROOT 130909090UL +#define BOARD_BOOTCLOCKRUN_GPT1_IPG_CLK_HIGHFREQ 75000000UL +#define BOARD_BOOTCLOCKRUN_GPT2_IPG_CLK_HIGHFREQ 75000000UL +#define BOARD_BOOTCLOCKRUN_IPG_CLK_ROOT 150000000UL +#define BOARD_BOOTCLOCKRUN_LCDIF_CLK_ROOT 67500000UL +#define BOARD_BOOTCLOCKRUN_LPI2C_CLK_ROOT 60000000UL +#define BOARD_BOOTCLOCKRUN_LPSPI_CLK_ROOT 105600000UL +#define BOARD_BOOTCLOCKRUN_LVDS1_CLK 1200000000UL +#define BOARD_BOOTCLOCKRUN_MQS_MCLK 63529411UL +#define BOARD_BOOTCLOCKRUN_PERCLK_CLK_ROOT 75000000UL +#define BOARD_BOOTCLOCKRUN_PLL7_MAIN_CLK 24000000UL +#define BOARD_BOOTCLOCKRUN_SAI1_CLK_ROOT 63529411UL +#define BOARD_BOOTCLOCKRUN_SAI1_MCLK1 63529411UL +#define BOARD_BOOTCLOCKRUN_SAI1_MCLK2 63529411UL +#define BOARD_BOOTCLOCKRUN_SAI1_MCLK3 30000000UL +#define BOARD_BOOTCLOCKRUN_SAI2_CLK_ROOT 63529411UL +#define BOARD_BOOTCLOCKRUN_SAI2_MCLK1 63529411UL +#define BOARD_BOOTCLOCKRUN_SAI2_MCLK2 0UL +#define BOARD_BOOTCLOCKRUN_SAI2_MCLK3 30000000UL +#define BOARD_BOOTCLOCKRUN_SAI3_CLK_ROOT 63529411UL +#define BOARD_BOOTCLOCKRUN_SAI3_MCLK1 63529411UL +#define BOARD_BOOTCLOCKRUN_SAI3_MCLK2 0UL +#define BOARD_BOOTCLOCKRUN_SAI3_MCLK3 30000000UL +#define BOARD_BOOTCLOCKRUN_SEMC_CLK_ROOT 75000000UL +#define BOARD_BOOTCLOCKRUN_SPDIF0_CLK_ROOT 30000000UL +#define BOARD_BOOTCLOCKRUN_SPDIF0_EXTCLK_OUT 0UL +#define BOARD_BOOTCLOCKRUN_TRACE_CLK_ROOT 117333333UL +#define BOARD_BOOTCLOCKRUN_UART_CLK_ROOT 80000000UL +#define BOARD_BOOTCLOCKRUN_USBPHY1_CLK 0UL +#define BOARD_BOOTCLOCKRUN_USBPHY2_CLK 0UL +#define BOARD_BOOTCLOCKRUN_USDHC1_CLK_ROOT 198000000UL +#define BOARD_BOOTCLOCKRUN_USDHC2_CLK_ROOT 198000000UL + +/*! @brief Arm PLL set for BOARD_BootClockRUN configuration. + */ +extern const clock_arm_pll_config_t armPllConfig_BOARD_BootClockRUN; +/*! @brief Usb1 PLL set for BOARD_BootClockRUN configuration. + */ +extern const clock_usb_pll_config_t usb1PllConfig_BOARD_BootClockRUN; +/*! @brief Sys PLL for BOARD_BootClockRUN configuration. + */ +extern const clock_sys_pll_config_t sysPllConfig_BOARD_BootClockRUN; + +/******************************************************************************* + * API for BOARD_BootClockRUN configuration + ******************************************************************************/ +#if defined(__cplusplus) +extern "C" { +#endif /* __cplusplus*/ + +/*! + * @brief This function executes configuration of clocks. + * + */ +void BOARD_BootClockRUN(void); + +#if defined(__cplusplus) +} +#endif /* __cplusplus*/ + +#endif /* _CLOCK_CONFIG_H_ */ diff --git a/ports/nxp/board/evkmimxrt1064/common.h b/ports/nxp/board/evkmimxrt1064/common.h new file mode 100644 index 000000000000..2e211936728f --- /dev/null +++ b/ports/nxp/board/evkmimxrt1064/common.h @@ -0,0 +1,75 @@ +#ifndef __LVMP_DRV_COMMON_H +#define __LVMP_DRV_COMMON_H + +#include +#include "py/obj.h" +#include "py/runtime.h" +#include "py/binary.h" + +////////////////////////////////////////////////////////////////////////////// +// A read-only buffer that contains a C pointer +// Used to communicate function pointers to lvgl Micropython bindings +// + +typedef struct mp_ptr_t +{ + mp_obj_base_t base; + void *ptr; +} mp_ptr_t; + +STATIC mp_int_t mp_ptr_get_buffer(mp_obj_t self_in, mp_buffer_info_t *bufinfo, mp_uint_t flags) +{ + mp_ptr_t *self = MP_OBJ_TO_PTR(self_in); + + if (flags & MP_BUFFER_WRITE) { + // read-only ptr + return 1; + } + + bufinfo->buf = &self->ptr; + bufinfo->len = sizeof(self->ptr); + bufinfo->typecode = BYTEARRAY_TYPECODE; + return 0; +} + +#define PTR_OBJ(ptr_global) ptr_global ## _obj + +#define DEFINE_PTR_OBJ_TYPE(ptr_obj_type, ptr_type_qstr)\ +STATIC const mp_obj_type_t ptr_obj_type = {\ + { &mp_type_type },\ + .name = ptr_type_qstr,\ + .buffer_p = { .get_buffer = mp_ptr_get_buffer }\ +} + +#define DEFINE_PTR_OBJ(ptr_global)\ +DEFINE_PTR_OBJ_TYPE(ptr_global ## _type, MP_QSTR_ ## ptr_global);\ +STATIC const mp_ptr_t PTR_OBJ(ptr_global) = {\ + { &ptr_global ## _type },\ + &ptr_global\ +} + +#define NEW_PTR_OBJ(name, value)\ +({\ + DEFINE_PTR_OBJ_TYPE(ptr_obj_type, MP_QSTR_ ## name);\ + mp_ptr_t *ptr_obj = m_new_obj(mp_ptr_t);\ + ptr_obj->base.type = &ptr_obj_type;\ + ptr_obj->ptr = value;\ + MP_OBJ_FROM_PTR(ptr_obj);\ +}) + +STATIC inline void *PTR_FROM_OBJ(mp_obj_t obj) +{ + void *result; + if (!obj) return NULL; + mp_buffer_info_t buffer_info; + mp_get_buffer_raise(obj, &buffer_info, MP_BUFFER_READ); + if (buffer_info.len != sizeof(result) || buffer_info.typecode != BYTEARRAY_TYPECODE){ + nlr_raise( + mp_obj_new_exception_msg_varg( + &mp_type_SyntaxError, "Cannot convert %s to pointer!", mp_obj_get_type_str(obj))); + } + memcpy(&result, buffer_info.buf, sizeof(result)); + return result; +} + +#endif // __LVMP_DRV_COMMON_H diff --git a/ports/nxp/board/evkmimxrt1064/evkmimxrt1064_flexspi_nor_config.c b/ports/nxp/board/evkmimxrt1064/evkmimxrt1064_flexspi_nor_config.c new file mode 100644 index 000000000000..bfb1c2d59aa2 --- /dev/null +++ b/ports/nxp/board/evkmimxrt1064/evkmimxrt1064_flexspi_nor_config.c @@ -0,0 +1,49 @@ +/* + * Copyright 2018 NXP + * All rights reserved. + * + * SPDX-License-Identifier: BSD-3-Clause + */ + +#include "evkmimxrt1064_flexspi_nor_config.h" + +/* Component ID definition, used by tools. */ +#ifndef FSL_COMPONENT_ID +#define FSL_COMPONENT_ID "platform.drivers.xip_board" +#endif + +/******************************************************************************* + * Code + ******************************************************************************/ +#if defined(XIP_BOOT_HEADER_ENABLE) && (XIP_BOOT_HEADER_ENABLE == 1) +#if defined(__CC_ARM) || defined(__ARMCC_VERSION) || defined(__GNUC__) +__attribute__((section(".boot_hdr.conf"))) +#elif defined(__ICCARM__) +#pragma location = ".boot_hdr.conf" +#endif + +const flexspi_nor_config_t qspiflash_config = { + .memConfig = + { + .tag = FLEXSPI_CFG_BLK_TAG, + .version = FLEXSPI_CFG_BLK_VERSION, + .readSampleClkSrc = kFlexSPIReadSampleClk_LoopbackFromDqsPad, + .csHoldTime = 3u, + .csSetupTime = 3u, + // Enable DDR mode, Wordaddassable, Safe configuration, Differential clock + .sflashPadType = kSerialFlash_4Pads, + .serialClkFreq = kFlexSpiSerialClk_100MHz, + .sflashA1Size = 8u * 1024u * 1024u, + .lookupTable = + { + // Read LUTs + FLEXSPI_LUT_SEQ(CMD_SDR, FLEXSPI_1PAD, 0xEB, RADDR_SDR, FLEXSPI_4PAD, 0x18), + FLEXSPI_LUT_SEQ(DUMMY_SDR, FLEXSPI_4PAD, 0x06, READ_SDR, FLEXSPI_4PAD, 0x04), + }, + }, + .pageSize = 256u, + .sectorSize = 4u * 1024u, + .blockSize = 256u * 1024u, + .isUniformBlockSize = false, +}; +#endif /* XIP_BOOT_HEADER_ENABLE */ diff --git a/ports/nxp/board/evkmimxrt1064/evkmimxrt1064_flexspi_nor_config.h b/ports/nxp/board/evkmimxrt1064/evkmimxrt1064_flexspi_nor_config.h new file mode 100644 index 000000000000..efdfe583fb82 --- /dev/null +++ b/ports/nxp/board/evkmimxrt1064/evkmimxrt1064_flexspi_nor_config.h @@ -0,0 +1,268 @@ +/* + * Copyright 2018 NXP + * All rights reserved. + * + * SPDX-License-Identifier: BSD-3-Clause + */ + +#ifndef __EVKMIMXRT1064_FLEXSPI_NOR_CONFIG__ +#define __EVKMIMXRT1064_FLEXSPI_NOR_CONFIG__ + +#include +#include +#include "fsl_common.h" + +/*! @name Driver version */ +/*@{*/ +/*! @brief XIP_BOARD driver version 2.0.0. */ +#define FSL_XIP_BOARD_DRIVER_VERSION (MAKE_VERSION(2, 0, 0)) +/*@}*/ + +/* FLEXSPI memory config block related defintions */ +#define FLEXSPI_CFG_BLK_TAG (0x42464346UL) // ascii "FCFB" Big Endian +#define FLEXSPI_CFG_BLK_VERSION (0x56010400UL) // V1.4.0 +#define FLEXSPI_CFG_BLK_SIZE (512) + +/* FLEXSPI Feature related definitions */ +#define FLEXSPI_FEATURE_HAS_PARALLEL_MODE 1 + +/* Lookup table related defintions */ +#define CMD_INDEX_READ 0 +#define CMD_INDEX_READSTATUS 1 +#define CMD_INDEX_WRITEENABLE 2 +#define CMD_INDEX_WRITE 4 + +#define CMD_LUT_SEQ_IDX_READ 0 +#define CMD_LUT_SEQ_IDX_READSTATUS 1 +#define CMD_LUT_SEQ_IDX_WRITEENABLE 3 +#define CMD_LUT_SEQ_IDX_WRITE 9 + +#define CMD_SDR 0x01 +#define CMD_DDR 0x21 +#define RADDR_SDR 0x02 +#define RADDR_DDR 0x22 +#define CADDR_SDR 0x03 +#define CADDR_DDR 0x23 +#define MODE1_SDR 0x04 +#define MODE1_DDR 0x24 +#define MODE2_SDR 0x05 +#define MODE2_DDR 0x25 +#define MODE4_SDR 0x06 +#define MODE4_DDR 0x26 +#define MODE8_SDR 0x07 +#define MODE8_DDR 0x27 +#define WRITE_SDR 0x08 +#define WRITE_DDR 0x28 +#define READ_SDR 0x09 +#define READ_DDR 0x29 +#define LEARN_SDR 0x0A +#define LEARN_DDR 0x2A +#define DATSZ_SDR 0x0B +#define DATSZ_DDR 0x2B +#define DUMMY_SDR 0x0C +#define DUMMY_DDR 0x2C +#define DUMMY_RWDS_SDR 0x0D +#define DUMMY_RWDS_DDR 0x2D +#define JMP_ON_CS 0x1F +#define STOP 0 + +#define FLEXSPI_1PAD 0 +#define FLEXSPI_2PAD 1 +#define FLEXSPI_4PAD 2 +#define FLEXSPI_8PAD 3 + +#define FLEXSPI_LUT_SEQ(cmd0, pad0, op0, cmd1, pad1, op1) \ + (FLEXSPI_LUT_OPERAND0(op0) | FLEXSPI_LUT_NUM_PADS0(pad0) | FLEXSPI_LUT_OPCODE0(cmd0) | FLEXSPI_LUT_OPERAND1(op1) | \ + FLEXSPI_LUT_NUM_PADS1(pad1) | FLEXSPI_LUT_OPCODE1(cmd1)) + +//!@brief Definitions for FlexSPI Serial Clock Frequency +typedef enum _FlexSpiSerialClockFreq +{ + kFlexSpiSerialClk_30MHz = 1, + kFlexSpiSerialClk_50MHz = 2, + kFlexSpiSerialClk_60MHz = 3, + kFlexSpiSerialClk_75MHz = 4, + kFlexSpiSerialClk_80MHz = 5, + kFlexSpiSerialClk_100MHz = 6, + kFlexSpiSerialClk_120MHz = 7, + kFlexSpiSerialClk_133MHz = 8, + kFlexSpiSerialClk_166MHz = 9, +} flexspi_serial_clk_freq_t; + +//!@brief FlexSPI clock configuration type +enum +{ + kFlexSpiClk_SDR, //!< Clock configure for SDR mode + kFlexSpiClk_DDR, //!< Clock configurat for DDR mode +}; + +//!@brief FlexSPI Read Sample Clock Source definition +typedef enum _FlashReadSampleClkSource +{ + kFlexSPIReadSampleClk_LoopbackInternally = 0, + kFlexSPIReadSampleClk_LoopbackFromDqsPad = 1, + kFlexSPIReadSampleClk_LoopbackFromSckPad = 2, + kFlexSPIReadSampleClk_ExternalInputFromDqsPad = 3, +} flexspi_read_sample_clk_t; + +//!@brief Misc feature bit definitions +enum +{ + kFlexSpiMiscOffset_DiffClkEnable = 0, //!< Bit for Differential clock enable + kFlexSpiMiscOffset_Ck2Enable = 1, //!< Bit for CK2 enable + kFlexSpiMiscOffset_ParallelEnable = 2, //!< Bit for Parallel mode enable + kFlexSpiMiscOffset_WordAddressableEnable = 3, //!< Bit for Word Addressable enable + kFlexSpiMiscOffset_SafeConfigFreqEnable = 4, //!< Bit for Safe Configuration Frequency enable + kFlexSpiMiscOffset_PadSettingOverrideEnable = 5, //!< Bit for Pad setting override enable + kFlexSpiMiscOffset_DdrModeEnable = 6, //!< Bit for DDR clock confiuration indication. +}; + +//!@brief Flash Type Definition +enum +{ + kFlexSpiDeviceType_SerialNOR = 1, //!< Flash devices are Serial NOR + kFlexSpiDeviceType_SerialNAND = 2, //!< Flash devices are Serial NAND + kFlexSpiDeviceType_SerialRAM = 3, //!< Flash devices are Serial RAM/HyperFLASH + kFlexSpiDeviceType_MCP_NOR_NAND = 0x12, //!< Flash device is MCP device, A1 is Serial NOR, A2 is Serial NAND + kFlexSpiDeviceType_MCP_NOR_RAM = 0x13, //!< Flash deivce is MCP device, A1 is Serial NOR, A2 is Serial RAMs +}; + +//!@brief Flash Pad Definitions +enum +{ + kSerialFlash_1Pad = 1, + kSerialFlash_2Pads = 2, + kSerialFlash_4Pads = 4, + kSerialFlash_8Pads = 8, +}; + +//!@brief FlexSPI LUT Sequence structure +typedef struct _lut_sequence +{ + uint8_t seqNum; //!< Sequence Number, valid number: 1-16 + uint8_t seqId; //!< Sequence Index, valid number: 0-15 + uint16_t reserved; +} flexspi_lut_seq_t; + +//!@brief Flash Configuration Command Type +enum +{ + kDeviceConfigCmdType_Generic, //!< Generic command, for example: configure dummy cycles, drive strength, etc + kDeviceConfigCmdType_QuadEnable, //!< Quad Enable command + kDeviceConfigCmdType_Spi2Xpi, //!< Switch from SPI to DPI/QPI/OPI mode + kDeviceConfigCmdType_Xpi2Spi, //!< Switch from DPI/QPI/OPI to SPI mode + kDeviceConfigCmdType_Spi2NoCmd, //!< Switch to 0-4-4/0-8-8 mode + kDeviceConfigCmdType_Reset, //!< Reset device command +}; + +//!@brief FlexSPI Memory Configuration Block +typedef struct _FlexSPIConfig +{ + uint32_t tag; //!< [0x000-0x003] Tag, fixed value 0x42464346UL + uint32_t version; //!< [0x004-0x007] Version,[31:24] -'V', [23:16] - Major, [15:8] - Minor, [7:0] - bugfix + uint32_t reserved0; //!< [0x008-0x00b] Reserved for future use + uint8_t readSampleClkSrc; //!< [0x00c-0x00c] Read Sample Clock Source, valid value: 0/1/3 + uint8_t csHoldTime; //!< [0x00d-0x00d] CS hold time, default value: 3 + uint8_t csSetupTime; //!< [0x00e-0x00e] CS setup time, default value: 3 + uint8_t columnAddressWidth; //!< [0x00f-0x00f] Column Address with, for HyperBus protocol, it is fixed to 3, For + //! Serial NAND, need to refer to datasheet + uint8_t deviceModeCfgEnable; //!< [0x010-0x010] Device Mode Configure enable flag, 1 - Enable, 0 - Disable + uint8_t deviceModeType; //!< [0x011-0x011] Specify the configuration command type:Quad Enable, DPI/QPI/OPI switch, + //! Generic configuration, etc. + uint16_t waitTimeCfgCommands; //!< [0x012-0x013] Wait time for all configuration commands, unit: 100us, Used for + //! DPI/QPI/OPI switch or reset command + flexspi_lut_seq_t deviceModeSeq; //!< [0x014-0x017] Device mode sequence info, [7:0] - LUT sequence id, [15:8] - LUt + //! sequence number, [31:16] Reserved + uint32_t deviceModeArg; //!< [0x018-0x01b] Argument/Parameter for device configuration + uint8_t configCmdEnable; //!< [0x01c-0x01c] Configure command Enable Flag, 1 - Enable, 0 - Disable + uint8_t configModeType[3]; //!< [0x01d-0x01f] Configure Mode Type, similar as deviceModeTpe + flexspi_lut_seq_t + configCmdSeqs[3]; //!< [0x020-0x02b] Sequence info for Device Configuration command, similar as deviceModeSeq + uint32_t reserved1; //!< [0x02c-0x02f] Reserved for future use + uint32_t configCmdArgs[3]; //!< [0x030-0x03b] Arguments/Parameters for device Configuration commands + uint32_t reserved2; //!< [0x03c-0x03f] Reserved for future use + uint32_t controllerMiscOption; //!< [0x040-0x043] Controller Misc Options, see Misc feature bit definitions for more + //! details + uint8_t deviceType; //!< [0x044-0x044] Device Type: See Flash Type Definition for more details + uint8_t sflashPadType; //!< [0x045-0x045] Serial Flash Pad Type: 1 - Single, 2 - Dual, 4 - Quad, 8 - Octal + uint8_t serialClkFreq; //!< [0x046-0x046] Serial Flash Frequencey, device specific definitions, See System Boot + //! Chapter for more details + uint8_t lutCustomSeqEnable; //!< [0x047-0x047] LUT customization Enable, it is required if the program/erase cannot + //! be done using 1 LUT sequence, currently, only applicable to HyperFLASH + uint32_t reserved3[2]; //!< [0x048-0x04f] Reserved for future use + uint32_t sflashA1Size; //!< [0x050-0x053] Size of Flash connected to A1 + uint32_t sflashA2Size; //!< [0x054-0x057] Size of Flash connected to A2 + uint32_t sflashB1Size; //!< [0x058-0x05b] Size of Flash connected to B1 + uint32_t sflashB2Size; //!< [0x05c-0x05f] Size of Flash connected to B2 + uint32_t csPadSettingOverride; //!< [0x060-0x063] CS pad setting override value + uint32_t sclkPadSettingOverride; //!< [0x064-0x067] SCK pad setting override value + uint32_t dataPadSettingOverride; //!< [0x068-0x06b] data pad setting override value + uint32_t dqsPadSettingOverride; //!< [0x06c-0x06f] DQS pad setting override value + uint32_t timeoutInMs; //!< [0x070-0x073] Timeout threshold for read status command + uint32_t commandInterval; //!< [0x074-0x077] CS deselect interval between two commands + uint16_t dataValidTime[2]; //!< [0x078-0x07b] CLK edge to data valid time for PORT A and PORT B, in terms of 0.1ns + uint16_t busyOffset; //!< [0x07c-0x07d] Busy offset, valid value: 0-31 + uint16_t busyBitPolarity; //!< [0x07e-0x07f] Busy flag polarity, 0 - busy flag is 1 when flash device is busy, 1 - + //! busy flag is 0 when flash device is busy + uint32_t lookupTable[64]; //!< [0x080-0x17f] Lookup table holds Flash command sequences + flexspi_lut_seq_t lutCustomSeq[12]; //!< [0x180-0x1af] Customizable LUT Sequences + uint32_t reserved4[4]; //!< [0x1b0-0x1bf] Reserved for future use +} flexspi_mem_config_t; + +/* */ +#define NOR_CMD_INDEX_READ CMD_INDEX_READ //!< 0 +#define NOR_CMD_INDEX_READSTATUS CMD_INDEX_READSTATUS //!< 1 +#define NOR_CMD_INDEX_WRITEENABLE CMD_INDEX_WRITEENABLE //!< 2 +#define NOR_CMD_INDEX_ERASESECTOR 3 //!< 3 +#define NOR_CMD_INDEX_PAGEPROGRAM CMD_INDEX_WRITE //!< 4 +#define NOR_CMD_INDEX_CHIPERASE 5 //!< 5 +#define NOR_CMD_INDEX_DUMMY 6 //!< 6 +#define NOR_CMD_INDEX_ERASEBLOCK 7 //!< 7 + +#define NOR_CMD_LUT_SEQ_IDX_READ CMD_LUT_SEQ_IDX_READ //!< 0 READ LUT sequence id in lookupTable stored in config block +#define NOR_CMD_LUT_SEQ_IDX_READSTATUS \ + CMD_LUT_SEQ_IDX_READSTATUS //!< 1 Read Status LUT sequence id in lookupTable stored in config block +#define NOR_CMD_LUT_SEQ_IDX_READSTATUS_XPI \ + 2 //!< 2 Read status DPI/QPI/OPI sequence id in lookupTable stored in config block +#define NOR_CMD_LUT_SEQ_IDX_WRITEENABLE \ + CMD_LUT_SEQ_IDX_WRITEENABLE //!< 3 Write Enable sequence id in lookupTable stored in config block +#define NOR_CMD_LUT_SEQ_IDX_WRITEENABLE_XPI \ + 4 //!< 4 Write Enable DPI/QPI/OPI sequence id in lookupTable stored in config block +#define NOR_CMD_LUT_SEQ_IDX_ERASESECTOR 5 //!< 5 Erase Sector sequence id in lookupTable stored in config block +#define NOR_CMD_LUT_SEQ_IDX_ERASEBLOCK 8 //!< 8 Erase Block sequence id in lookupTable stored in config block +#define NOR_CMD_LUT_SEQ_IDX_PAGEPROGRAM \ + CMD_LUT_SEQ_IDX_WRITE //!< 9 Program sequence id in lookupTable stored in config block +#define NOR_CMD_LUT_SEQ_IDX_CHIPERASE 11 //!< 11 Chip Erase sequence in lookupTable id stored in config block +#define NOR_CMD_LUT_SEQ_IDX_READ_SFDP 13 //!< 13 Read SFDP sequence in lookupTable id stored in config block +#define NOR_CMD_LUT_SEQ_IDX_RESTORE_NOCMD \ + 14 //!< 14 Restore 0-4-4/0-8-8 mode sequence id in lookupTable stored in config block +#define NOR_CMD_LUT_SEQ_IDX_EXIT_NOCMD \ + 15 //!< 15 Exit 0-4-4/0-8-8 mode sequence id in lookupTable stored in config blobk + +/* + * Serial NOR configuration block + */ +typedef struct _flexspi_nor_config +{ + flexspi_mem_config_t memConfig; //!< Common memory configuration info via FlexSPI + uint32_t pageSize; //!< Page size of Serial NOR + uint32_t sectorSize; //!< Sector size of Serial NOR + uint8_t ipcmdSerialClkFreq; //!< Clock frequency for IP command + uint8_t isUniformBlockSize; //!< Sector/Block size is the same + uint8_t reserved0[2]; //!< Reserved for future use + uint8_t serialNorType; //!< Serial NOR Flash type: 0/1/2/3 + uint8_t needExitNoCmdMode; //!< Need to exit NoCmd mode before other IP command + uint8_t halfClkForNonReadCmd; //!< Half the Serial Clock for non-read command: true/false + uint8_t needRestoreNoCmdMode; //!< Need to Restore NoCmd mode after IP commmand execution + uint32_t blockSize; //!< Block size + uint32_t reserve2[11]; //!< Reserved for future use +} flexspi_nor_config_t; + +#ifdef __cplusplus +extern "C" { +#endif + +#ifdef __cplusplus +} +#endif +#endif /* __EVKMIMXRT1064_FLEXSPI_NOR_CONFIG__ */ diff --git a/ports/nxp/board/evkmimxrt1064/evkmimxrt1064_sdram_ini_dcd.c b/ports/nxp/board/evkmimxrt1064/evkmimxrt1064_sdram_ini_dcd.c new file mode 100644 index 000000000000..ffe19664c85b --- /dev/null +++ b/ports/nxp/board/evkmimxrt1064/evkmimxrt1064_sdram_ini_dcd.c @@ -0,0 +1,320 @@ +/* + * Copyright 2018 NXP + * All rights reserved. + * + * SPDX-License-Identifier: BSD-3-Clause + */ + +/*********************************************************************************************************************** + * This file was generated by the MCUXpresso Config Tools. Any manual edits made to this file + * will be overwritten if the respective MCUXpresso Config Tools is used to update this file. + **********************************************************************************************************************/ + +#include "evkmimxrt1064_sdram_ini_dcd.h" + +/* Component ID definition, used by tools. */ +#ifndef FSL_COMPONENT_ID +#define FSL_COMPONENT_ID "platform.drivers.xip_board" +#endif + +#if defined(XIP_BOOT_HEADER_ENABLE) && (XIP_BOOT_HEADER_ENABLE == 1) +#if defined(XIP_BOOT_HEADER_DCD_ENABLE) && (XIP_BOOT_HEADER_DCD_ENABLE == 1) +#if defined(__CC_ARM) || defined(__ARMCC_VERSION) || defined(__GNUC__) +__attribute__((section(".boot_hdr.dcd_data"))) +#elif defined(__ICCARM__) +#pragma location = ".boot_hdr.dcd_data" +#endif + +/* TEXT BELOW IS USED AS SETTING FOR TOOLS ************************************* +!!GlobalInfo +product: DCDx V2.0 +processor: MIMXRT1064xxxxA +mcu_data: ksdk2_0 +processor_version: 0.0.9 +output_format: c_array + * BE CAREFUL MODIFYING THIS COMMENT - IT IS YAML SETTINGS FOR TOOLS **********/ +/* COMMENTS BELOW ARE USED AS SETTINGS FOR DCD DATA */ +const uint8_t dcd_data[] = { + /* HEADER */ + /* Tag */ + 0xD2, + /* Image Length */ + 0x04, 0x30, + /* Version */ + 0x41, + + /* COMMANDS */ + + /* group: 'Imported Commands' */ + /* #1.1-117, command header bytes for merged 'Write - value' command */ + 0xCC, 0x03, 0xAC, 0x04, + /* #1.1, command: write_value, address: CCM_CCGR0, value: 0xFFFFFFFF, size: 4 */ + 0x40, 0x0F, 0xC0, 0x68, 0xFF, 0xFF, 0xFF, 0xFF, + /* #1.2, command: write_value, address: CCM_CCGR1, value: 0xFFFFFFFF, size: 4 */ + 0x40, 0x0F, 0xC0, 0x6C, 0xFF, 0xFF, 0xFF, 0xFF, + /* #1.3, command: write_value, address: CCM_CCGR2, value: 0xFFFFFFFF, size: 4 */ + 0x40, 0x0F, 0xC0, 0x70, 0xFF, 0xFF, 0xFF, 0xFF, + /* #1.4, command: write_value, address: CCM_CCGR3, value: 0xFFFFFFFF, size: 4 */ + 0x40, 0x0F, 0xC0, 0x74, 0xFF, 0xFF, 0xFF, 0xFF, + /* #1.5, command: write_value, address: CCM_CCGR4, value: 0xFFFFFFFF, size: 4 */ + 0x40, 0x0F, 0xC0, 0x78, 0xFF, 0xFF, 0xFF, 0xFF, + /* #1.6, command: write_value, address: CCM_CCGR5, value: 0xFFFFFFFF, size: 4 */ + 0x40, 0x0F, 0xC0, 0x7C, 0xFF, 0xFF, 0xFF, 0xFF, + /* #1.7, command: write_value, address: CCM_CCGR6, value: 0xFFFFFFFF, size: 4 */ + 0x40, 0x0F, 0xC0, 0x80, 0xFF, 0xFF, 0xFF, 0xFF, + /* #1.8, command: write_value, address: CCM_ANALOG_PLL_SYS, value: 0x2001, size: 4 */ + 0x40, 0x0D, 0x80, 0x30, 0x00, 0x00, 0x20, 0x01, + /* #1.9, command: write_value, address: CCM_ANALOG_PFD_528, value: 0x1D0000, size: 4 */ + 0x40, 0x0D, 0x81, 0x00, 0x00, 0x1D, 0x00, 0x00, + /* #1.10, command: write_value, address: CCM_CBCDR, value: 0x10D40, size: 4 */ + 0x40, 0x0F, 0xC0, 0x14, 0x00, 0x01, 0x0D, 0x40, + /* #1.11, command: write_value, address: IOMUXC_SW_MUX_CTL_PAD_GPIO_EMC_00, value: 0x00, size: 4 */ + 0x40, 0x1F, 0x80, 0x14, 0x00, 0x00, 0x00, 0x00, + /* #1.12, command: write_value, address: IOMUXC_SW_MUX_CTL_PAD_GPIO_EMC_01, value: 0x00, size: 4 */ + 0x40, 0x1F, 0x80, 0x18, 0x00, 0x00, 0x00, 0x00, + /* #1.13, command: write_value, address: IOMUXC_SW_MUX_CTL_PAD_GPIO_EMC_02, value: 0x00, size: 4 */ + 0x40, 0x1F, 0x80, 0x1C, 0x00, 0x00, 0x00, 0x00, + /* #1.14, command: write_value, address: IOMUXC_SW_MUX_CTL_PAD_GPIO_EMC_03, value: 0x00, size: 4 */ + 0x40, 0x1F, 0x80, 0x20, 0x00, 0x00, 0x00, 0x00, + /* #1.15, command: write_value, address: IOMUXC_SW_MUX_CTL_PAD_GPIO_EMC_04, value: 0x00, size: 4 */ + 0x40, 0x1F, 0x80, 0x24, 0x00, 0x00, 0x00, 0x00, + /* #1.16, command: write_value, address: IOMUXC_SW_MUX_CTL_PAD_GPIO_EMC_05, value: 0x00, size: 4 */ + 0x40, 0x1F, 0x80, 0x28, 0x00, 0x00, 0x00, 0x00, + /* #1.17, command: write_value, address: IOMUXC_SW_MUX_CTL_PAD_GPIO_EMC_06, value: 0x00, size: 4 */ + 0x40, 0x1F, 0x80, 0x2C, 0x00, 0x00, 0x00, 0x00, + /* #1.18, command: write_value, address: IOMUXC_SW_MUX_CTL_PAD_GPIO_EMC_07, value: 0x00, size: 4 */ + 0x40, 0x1F, 0x80, 0x30, 0x00, 0x00, 0x00, 0x00, + /* #1.19, command: write_value, address: IOMUXC_SW_MUX_CTL_PAD_GPIO_EMC_08, value: 0x00, size: 4 */ + 0x40, 0x1F, 0x80, 0x34, 0x00, 0x00, 0x00, 0x00, + /* #1.20, command: write_value, address: IOMUXC_SW_MUX_CTL_PAD_GPIO_EMC_09, value: 0x00, size: 4 */ + 0x40, 0x1F, 0x80, 0x38, 0x00, 0x00, 0x00, 0x00, + /* #1.21, command: write_value, address: IOMUXC_SW_MUX_CTL_PAD_GPIO_EMC_10, value: 0x00, size: 4 */ + 0x40, 0x1F, 0x80, 0x3C, 0x00, 0x00, 0x00, 0x00, + /* #1.22, command: write_value, address: IOMUXC_SW_MUX_CTL_PAD_GPIO_EMC_11, value: 0x00, size: 4 */ + 0x40, 0x1F, 0x80, 0x40, 0x00, 0x00, 0x00, 0x00, + /* #1.23, command: write_value, address: IOMUXC_SW_MUX_CTL_PAD_GPIO_EMC_12, value: 0x00, size: 4 */ + 0x40, 0x1F, 0x80, 0x44, 0x00, 0x00, 0x00, 0x00, + /* #1.24, command: write_value, address: IOMUXC_SW_MUX_CTL_PAD_GPIO_EMC_13, value: 0x00, size: 4 */ + 0x40, 0x1F, 0x80, 0x48, 0x00, 0x00, 0x00, 0x00, + /* #1.25, command: write_value, address: IOMUXC_SW_MUX_CTL_PAD_GPIO_EMC_14, value: 0x00, size: 4 */ + 0x40, 0x1F, 0x80, 0x4C, 0x00, 0x00, 0x00, 0x00, + /* #1.26, command: write_value, address: IOMUXC_SW_MUX_CTL_PAD_GPIO_EMC_15, value: 0x00, size: 4 */ + 0x40, 0x1F, 0x80, 0x50, 0x00, 0x00, 0x00, 0x00, + /* #1.27, command: write_value, address: IOMUXC_SW_MUX_CTL_PAD_GPIO_EMC_16, value: 0x00, size: 4 */ + 0x40, 0x1F, 0x80, 0x54, 0x00, 0x00, 0x00, 0x00, + /* #1.28, command: write_value, address: IOMUXC_SW_MUX_CTL_PAD_GPIO_EMC_17, value: 0x00, size: 4 */ + 0x40, 0x1F, 0x80, 0x58, 0x00, 0x00, 0x00, 0x00, + /* #1.29, command: write_value, address: IOMUXC_SW_MUX_CTL_PAD_GPIO_EMC_18, value: 0x00, size: 4 */ + 0x40, 0x1F, 0x80, 0x5C, 0x00, 0x00, 0x00, 0x00, + /* #1.30, command: write_value, address: IOMUXC_SW_MUX_CTL_PAD_GPIO_EMC_19, value: 0x00, size: 4 */ + 0x40, 0x1F, 0x80, 0x60, 0x00, 0x00, 0x00, 0x00, + /* #1.31, command: write_value, address: IOMUXC_SW_MUX_CTL_PAD_GPIO_EMC_20, value: 0x00, size: 4 */ + 0x40, 0x1F, 0x80, 0x64, 0x00, 0x00, 0x00, 0x00, + /* #1.32, command: write_value, address: IOMUXC_SW_MUX_CTL_PAD_GPIO_EMC_21, value: 0x00, size: 4 */ + 0x40, 0x1F, 0x80, 0x68, 0x00, 0x00, 0x00, 0x00, + /* #1.33, command: write_value, address: IOMUXC_SW_MUX_CTL_PAD_GPIO_EMC_22, value: 0x00, size: 4 */ + 0x40, 0x1F, 0x80, 0x6C, 0x00, 0x00, 0x00, 0x00, + /* #1.34, command: write_value, address: IOMUXC_SW_MUX_CTL_PAD_GPIO_EMC_23, value: 0x00, size: 4 */ + 0x40, 0x1F, 0x80, 0x70, 0x00, 0x00, 0x00, 0x00, + /* #1.35, command: write_value, address: IOMUXC_SW_MUX_CTL_PAD_GPIO_EMC_24, value: 0x00, size: 4 */ + 0x40, 0x1F, 0x80, 0x74, 0x00, 0x00, 0x00, 0x00, + /* #1.36, command: write_value, address: IOMUXC_SW_MUX_CTL_PAD_GPIO_EMC_25, value: 0x00, size: 4 */ + 0x40, 0x1F, 0x80, 0x78, 0x00, 0x00, 0x00, 0x00, + /* #1.37, command: write_value, address: IOMUXC_SW_MUX_CTL_PAD_GPIO_EMC_26, value: 0x00, size: 4 */ + 0x40, 0x1F, 0x80, 0x7C, 0x00, 0x00, 0x00, 0x00, + /* #1.38, command: write_value, address: IOMUXC_SW_MUX_CTL_PAD_GPIO_EMC_27, value: 0x00, size: 4 */ + 0x40, 0x1F, 0x80, 0x80, 0x00, 0x00, 0x00, 0x00, + /* #1.39, command: write_value, address: IOMUXC_SW_MUX_CTL_PAD_GPIO_EMC_28, value: 0x00, size: 4 */ + 0x40, 0x1F, 0x80, 0x84, 0x00, 0x00, 0x00, 0x00, + /* #1.40, command: write_value, address: IOMUXC_SW_MUX_CTL_PAD_GPIO_EMC_29, value: 0x00, size: 4 */ + 0x40, 0x1F, 0x80, 0x88, 0x00, 0x00, 0x00, 0x00, + /* #1.41, command: write_value, address: IOMUXC_SW_MUX_CTL_PAD_GPIO_EMC_30, value: 0x00, size: 4 */ + 0x40, 0x1F, 0x80, 0x8C, 0x00, 0x00, 0x00, 0x00, + /* #1.42, command: write_value, address: IOMUXC_SW_MUX_CTL_PAD_GPIO_EMC_31, value: 0x00, size: 4 */ + 0x40, 0x1F, 0x80, 0x90, 0x00, 0x00, 0x00, 0x00, + /* #1.43, command: write_value, address: IOMUXC_SW_MUX_CTL_PAD_GPIO_EMC_32, value: 0x00, size: 4 */ + 0x40, 0x1F, 0x80, 0x94, 0x00, 0x00, 0x00, 0x00, + /* #1.44, command: write_value, address: IOMUXC_SW_MUX_CTL_PAD_GPIO_EMC_33, value: 0x00, size: 4 */ + 0x40, 0x1F, 0x80, 0x98, 0x00, 0x00, 0x00, 0x00, + /* #1.45, command: write_value, address: IOMUXC_SW_MUX_CTL_PAD_GPIO_EMC_34, value: 0x00, size: 4 */ + 0x40, 0x1F, 0x80, 0x9C, 0x00, 0x00, 0x00, 0x00, + /* #1.46, command: write_value, address: IOMUXC_SW_MUX_CTL_PAD_GPIO_EMC_35, value: 0x00, size: 4 */ + 0x40, 0x1F, 0x80, 0xA0, 0x00, 0x00, 0x00, 0x00, + /* #1.47, command: write_value, address: IOMUXC_SW_MUX_CTL_PAD_GPIO_EMC_36, value: 0x00, size: 4 */ + 0x40, 0x1F, 0x80, 0xA4, 0x00, 0x00, 0x00, 0x00, + /* #1.48, command: write_value, address: IOMUXC_SW_MUX_CTL_PAD_GPIO_EMC_37, value: 0x00, size: 4 */ + 0x40, 0x1F, 0x80, 0xA8, 0x00, 0x00, 0x00, 0x00, + /* #1.49, command: write_value, address: IOMUXC_SW_MUX_CTL_PAD_GPIO_EMC_38, value: 0x00, size: 4 */ + 0x40, 0x1F, 0x80, 0xAC, 0x00, 0x00, 0x00, 0x00, + /* #1.50, command: write_value, address: IOMUXC_SW_MUX_CTL_PAD_GPIO_EMC_39, value: 0x10, size: 4 */ + 0x40, 0x1F, 0x80, 0xB0, 0x00, 0x00, 0x00, 0x10, + /* #1.51, command: write_value, address: IOMUXC_SW_MUX_CTL_PAD_GPIO_EMC_40, value: 0x00, size: 4 */ + 0x40, 0x1F, 0x80, 0xB4, 0x00, 0x00, 0x00, 0x00, + /* #1.52, command: write_value, address: IOMUXC_SW_MUX_CTL_PAD_GPIO_EMC_41, value: 0x00, size: 4 */ + 0x40, 0x1F, 0x80, 0xB8, 0x00, 0x00, 0x00, 0x00, + /* #1.53, command: write_value, address: IOMUXC_SW_PAD_CTL_PAD_GPIO_EMC_00, value: 0x110F9, size: 4 */ + 0x40, 0x1F, 0x82, 0x04, 0x00, 0x01, 0x10, 0xF9, + /* #1.54, command: write_value, address: IOMUXC_SW_PAD_CTL_PAD_GPIO_EMC_01, value: 0x110F9, size: 4 */ + 0x40, 0x1F, 0x82, 0x08, 0x00, 0x01, 0x10, 0xF9, + /* #1.55, command: write_value, address: IOMUXC_SW_PAD_CTL_PAD_GPIO_EMC_02, value: 0x110F9, size: 4 */ + 0x40, 0x1F, 0x82, 0x0C, 0x00, 0x01, 0x10, 0xF9, + /* #1.56, command: write_value, address: IOMUXC_SW_PAD_CTL_PAD_GPIO_EMC_03, value: 0x110F9, size: 4 */ + 0x40, 0x1F, 0x82, 0x10, 0x00, 0x01, 0x10, 0xF9, + /* #1.57, command: write_value, address: IOMUXC_SW_PAD_CTL_PAD_GPIO_EMC_04, value: 0x110F9, size: 4 */ + 0x40, 0x1F, 0x82, 0x14, 0x00, 0x01, 0x10, 0xF9, + /* #1.58, command: write_value, address: IOMUXC_SW_PAD_CTL_PAD_GPIO_EMC_05, value: 0x110F9, size: 4 */ + 0x40, 0x1F, 0x82, 0x18, 0x00, 0x01, 0x10, 0xF9, + /* #1.59, command: write_value, address: IOMUXC_SW_PAD_CTL_PAD_GPIO_EMC_06, value: 0x110F9, size: 4 */ + 0x40, 0x1F, 0x82, 0x1C, 0x00, 0x01, 0x10, 0xF9, + /* #1.60, command: write_value, address: IOMUXC_SW_PAD_CTL_PAD_GPIO_EMC_07, value: 0x110F9, size: 4 */ + 0x40, 0x1F, 0x82, 0x20, 0x00, 0x01, 0x10, 0xF9, + /* #1.61, command: write_value, address: IOMUXC_SW_PAD_CTL_PAD_GPIO_EMC_08, value: 0x110F9, size: 4 */ + 0x40, 0x1F, 0x82, 0x24, 0x00, 0x01, 0x10, 0xF9, + /* #1.62, command: write_value, address: IOMUXC_SW_PAD_CTL_PAD_GPIO_EMC_09, value: 0x110F9, size: 4 */ + 0x40, 0x1F, 0x82, 0x28, 0x00, 0x01, 0x10, 0xF9, + /* #1.63, command: write_value, address: IOMUXC_SW_PAD_CTL_PAD_GPIO_EMC_10, value: 0x110F9, size: 4 */ + 0x40, 0x1F, 0x82, 0x2C, 0x00, 0x01, 0x10, 0xF9, + /* #1.64, command: write_value, address: IOMUXC_SW_PAD_CTL_PAD_GPIO_EMC_11, value: 0x110F9, size: 4 */ + 0x40, 0x1F, 0x82, 0x30, 0x00, 0x01, 0x10, 0xF9, + /* #1.65, command: write_value, address: IOMUXC_SW_PAD_CTL_PAD_GPIO_EMC_12, value: 0x110F9, size: 4 */ + 0x40, 0x1F, 0x82, 0x34, 0x00, 0x01, 0x10, 0xF9, + /* #1.66, command: write_value, address: IOMUXC_SW_PAD_CTL_PAD_GPIO_EMC_13, value: 0x110F9, size: 4 */ + 0x40, 0x1F, 0x82, 0x38, 0x00, 0x01, 0x10, 0xF9, + /* #1.67, command: write_value, address: IOMUXC_SW_PAD_CTL_PAD_GPIO_EMC_14, value: 0x110F9, size: 4 */ + 0x40, 0x1F, 0x82, 0x3C, 0x00, 0x01, 0x10, 0xF9, + /* #1.68, command: write_value, address: IOMUXC_SW_PAD_CTL_PAD_GPIO_EMC_15, value: 0x110F9, size: 4 */ + 0x40, 0x1F, 0x82, 0x40, 0x00, 0x01, 0x10, 0xF9, + /* #1.69, command: write_value, address: IOMUXC_SW_PAD_CTL_PAD_GPIO_EMC_16, value: 0x110F9, size: 4 */ + 0x40, 0x1F, 0x82, 0x44, 0x00, 0x01, 0x10, 0xF9, + /* #1.70, command: write_value, address: IOMUXC_SW_PAD_CTL_PAD_GPIO_EMC_17, value: 0x110F9, size: 4 */ + 0x40, 0x1F, 0x82, 0x48, 0x00, 0x01, 0x10, 0xF9, + /* #1.71, command: write_value, address: IOMUXC_SW_PAD_CTL_PAD_GPIO_EMC_18, value: 0x110F9, size: 4 */ + 0x40, 0x1F, 0x82, 0x4C, 0x00, 0x01, 0x10, 0xF9, + /* #1.72, command: write_value, address: IOMUXC_SW_PAD_CTL_PAD_GPIO_EMC_19, value: 0x110F9, size: 4 */ + 0x40, 0x1F, 0x82, 0x50, 0x00, 0x01, 0x10, 0xF9, + /* #1.73, command: write_value, address: IOMUXC_SW_PAD_CTL_PAD_GPIO_EMC_20, value: 0x110F9, size: 4 */ + 0x40, 0x1F, 0x82, 0x54, 0x00, 0x01, 0x10, 0xF9, + /* #1.74, command: write_value, address: IOMUXC_SW_PAD_CTL_PAD_GPIO_EMC_21, value: 0x110F9, size: 4 */ + 0x40, 0x1F, 0x82, 0x58, 0x00, 0x01, 0x10, 0xF9, + /* #1.75, command: write_value, address: IOMUXC_SW_PAD_CTL_PAD_GPIO_EMC_22, value: 0x110F9, size: 4 */ + 0x40, 0x1F, 0x82, 0x5C, 0x00, 0x01, 0x10, 0xF9, + /* #1.76, command: write_value, address: IOMUXC_SW_PAD_CTL_PAD_GPIO_EMC_23, value: 0x110F9, size: 4 */ + 0x40, 0x1F, 0x82, 0x60, 0x00, 0x01, 0x10, 0xF9, + /* #1.77, command: write_value, address: IOMUXC_SW_PAD_CTL_PAD_GPIO_EMC_24, value: 0x110F9, size: 4 */ + 0x40, 0x1F, 0x82, 0x64, 0x00, 0x01, 0x10, 0xF9, + /* #1.78, command: write_value, address: IOMUXC_SW_PAD_CTL_PAD_GPIO_EMC_25, value: 0x110F9, size: 4 */ + 0x40, 0x1F, 0x82, 0x68, 0x00, 0x01, 0x10, 0xF9, + /* #1.79, command: write_value, address: IOMUXC_SW_PAD_CTL_PAD_GPIO_EMC_26, value: 0x110F9, size: 4 */ + 0x40, 0x1F, 0x82, 0x6C, 0x00, 0x01, 0x10, 0xF9, + /* #1.80, command: write_value, address: IOMUXC_SW_PAD_CTL_PAD_GPIO_EMC_27, value: 0x110F9, size: 4 */ + 0x40, 0x1F, 0x82, 0x70, 0x00, 0x01, 0x10, 0xF9, + /* #1.81, command: write_value, address: IOMUXC_SW_PAD_CTL_PAD_GPIO_EMC_28, value: 0x110F9, size: 4 */ + 0x40, 0x1F, 0x82, 0x74, 0x00, 0x01, 0x10, 0xF9, + /* #1.82, command: write_value, address: IOMUXC_SW_PAD_CTL_PAD_GPIO_EMC_29, value: 0x110F9, size: 4 */ + 0x40, 0x1F, 0x82, 0x78, 0x00, 0x01, 0x10, 0xF9, + /* #1.83, command: write_value, address: IOMUXC_SW_PAD_CTL_PAD_GPIO_EMC_30, value: 0x110F9, size: 4 */ + 0x40, 0x1F, 0x82, 0x7C, 0x00, 0x01, 0x10, 0xF9, + /* #1.84, command: write_value, address: IOMUXC_SW_PAD_CTL_PAD_GPIO_EMC_31, value: 0x110F9, size: 4 */ + 0x40, 0x1F, 0x82, 0x80, 0x00, 0x01, 0x10, 0xF9, + /* #1.85, command: write_value, address: IOMUXC_SW_PAD_CTL_PAD_GPIO_EMC_32, value: 0x110F9, size: 4 */ + 0x40, 0x1F, 0x82, 0x84, 0x00, 0x01, 0x10, 0xF9, + /* #1.86, command: write_value, address: IOMUXC_SW_PAD_CTL_PAD_GPIO_EMC_33, value: 0x110F9, size: 4 */ + 0x40, 0x1F, 0x82, 0x88, 0x00, 0x01, 0x10, 0xF9, + /* #1.87, command: write_value, address: IOMUXC_SW_PAD_CTL_PAD_GPIO_EMC_34, value: 0x110F9, size: 4 */ + 0x40, 0x1F, 0x82, 0x8C, 0x00, 0x01, 0x10, 0xF9, + /* #1.88, command: write_value, address: IOMUXC_SW_PAD_CTL_PAD_GPIO_EMC_35, value: 0x110F9, size: 4 */ + 0x40, 0x1F, 0x82, 0x90, 0x00, 0x01, 0x10, 0xF9, + /* #1.89, command: write_value, address: IOMUXC_SW_PAD_CTL_PAD_GPIO_EMC_36, value: 0x110F9, size: 4 */ + 0x40, 0x1F, 0x82, 0x94, 0x00, 0x01, 0x10, 0xF9, + /* #1.90, command: write_value, address: IOMUXC_SW_PAD_CTL_PAD_GPIO_EMC_37, value: 0x110F9, size: 4 */ + 0x40, 0x1F, 0x82, 0x98, 0x00, 0x01, 0x10, 0xF9, + /* #1.91, command: write_value, address: IOMUXC_SW_PAD_CTL_PAD_GPIO_EMC_38, value: 0x110F9, size: 4 */ + 0x40, 0x1F, 0x82, 0x9C, 0x00, 0x01, 0x10, 0xF9, + /* #1.92, command: write_value, address: IOMUXC_SW_PAD_CTL_PAD_GPIO_EMC_39, value: 0x110F9, size: 4 */ + 0x40, 0x1F, 0x82, 0xA0, 0x00, 0x01, 0x10, 0xF9, + /* #1.93, command: write_value, address: IOMUXC_SW_PAD_CTL_PAD_GPIO_EMC_40, value: 0x110F9, size: 4 */ + 0x40, 0x1F, 0x82, 0xA4, 0x00, 0x01, 0x10, 0xF9, + /* #1.94, command: write_value, address: IOMUXC_SW_PAD_CTL_PAD_GPIO_EMC_41, value: 0x110F9, size: 4 */ + 0x40, 0x1F, 0x82, 0xA8, 0x00, 0x01, 0x10, 0xF9, + /* #1.95, command: write_value, address: SEMC_MCR, value: 0x10000004, size: 4 */ + 0x40, 0x2F, 0x00, 0x00, 0x10, 0x00, 0x00, 0x04, + /* #1.96, command: write_value, address: SEMC_BMCR0, value: 0x30524, size: 4 */ + 0x40, 0x2F, 0x00, 0x08, 0x00, 0x03, 0x05, 0x24, + /* #1.97, command: write_value, address: SEMC_BMCR1, value: 0x6030524, size: 4 */ + 0x40, 0x2F, 0x00, 0x0C, 0x06, 0x03, 0x05, 0x24, + /* #1.98, command: write_value, address: SEMC_BR0, value: 0x8000001B, size: 4 */ + 0x40, 0x2F, 0x00, 0x10, 0x80, 0x00, 0x00, 0x1B, + /* #1.99, command: write_value, address: SEMC_BR1, value: 0x8200001B, size: 4 */ + 0x40, 0x2F, 0x00, 0x14, 0x82, 0x00, 0x00, 0x1B, + /* #1.100, command: write_value, address: SEMC_BR2, value: 0x8400001B, size: 4 */ + 0x40, 0x2F, 0x00, 0x18, 0x84, 0x00, 0x00, 0x1B, + /* #1.101, command: write_value, address: SEMC_BR3, value: 0x8600001B, size: 4 */ + 0x40, 0x2F, 0x00, 0x1C, 0x86, 0x00, 0x00, 0x1B, + /* #1.102, command: write_value, address: SEMC_BR4, value: 0x90000021, size: 4 */ + 0x40, 0x2F, 0x00, 0x20, 0x90, 0x00, 0x00, 0x21, + /* #1.103, command: write_value, address: SEMC_BR5, value: 0xA0000019, size: 4 */ + 0x40, 0x2F, 0x00, 0x24, 0xA0, 0x00, 0x00, 0x19, + /* #1.104, command: write_value, address: SEMC_BR6, value: 0xA8000017, size: 4 */ + 0x40, 0x2F, 0x00, 0x28, 0xA8, 0x00, 0x00, 0x17, + /* #1.105, command: write_value, address: SEMC_BR7, value: 0xA900001B, size: 4 */ + 0x40, 0x2F, 0x00, 0x2C, 0xA9, 0x00, 0x00, 0x1B, + /* #1.106, command: write_value, address: SEMC_BR8, value: 0x21, size: 4 */ + 0x40, 0x2F, 0x00, 0x30, 0x00, 0x00, 0x00, 0x21, + /* #1.107, command: write_value, address: SEMC_IOCR, value: 0x79A8, size: 4 */ + 0x40, 0x2F, 0x00, 0x04, 0x00, 0x00, 0x79, 0xA8, + /* #1.108, command: write_value, address: SEMC_SDRAMCR0, value: 0xF31, size: 4 */ + 0x40, 0x2F, 0x00, 0x40, 0x00, 0x00, 0x0F, 0x31, + /* #1.109, command: write_value, address: SEMC_SDRAMCR1, value: 0x652922, size: 4 */ + 0x40, 0x2F, 0x00, 0x44, 0x00, 0x65, 0x29, 0x22, + /* #1.110, command: write_value, address: SEMC_SDRAMCR2, value: 0x10920, size: 4 */ + 0x40, 0x2F, 0x00, 0x48, 0x00, 0x01, 0x09, 0x20, + /* #1.111, command: write_value, address: SEMC_SDRAMCR3, value: 0x50210A08, size: 4 */ + 0x40, 0x2F, 0x00, 0x4C, 0x50, 0x21, 0x0A, 0x08, + /* #1.112, command: write_value, address: SEMC_DBICR0, value: 0x21, size: 4 */ + 0x40, 0x2F, 0x00, 0x80, 0x00, 0x00, 0x00, 0x21, + /* #1.113, command: write_value, address: SEMC_DBICR1, value: 0x888888, size: 4 */ + 0x40, 0x2F, 0x00, 0x84, 0x00, 0x88, 0x88, 0x88, + /* #1.114, command: write_value, address: SEMC_IPCR1, value: 0x02, size: 4 */ + 0x40, 0x2F, 0x00, 0x94, 0x00, 0x00, 0x00, 0x02, + /* #1.115, command: write_value, address: SEMC_IPCR2, value: 0x00, size: 4 */ + 0x40, 0x2F, 0x00, 0x98, 0x00, 0x00, 0x00, 0x00, + /* #1.116, command: write_value, address: SEMC_IPCR0, value: 0x80000000, size: 4 */ + 0x40, 0x2F, 0x00, 0x90, 0x80, 0x00, 0x00, 0x00, + /* #1.117, command: write_value, address: SEMC_IPCMD, value: 0xA55A000F, size: 4 */ + 0x40, 0x2F, 0x00, 0x9C, 0xA5, 0x5A, 0x00, 0x0F, + /* #2, command: check_any_bit_set, address: SEMC_INTR, value: 0x01, size: 4 */ + 0xCF, 0x00, 0x0C, 0x1C, 0x40, 0x2F, 0x00, 0x3C, 0x00, 0x00, 0x00, 0x01, + /* #3.1-2, command header bytes for merged 'Write - value' command */ + 0xCC, 0x00, 0x14, 0x04, + /* #3.1, command: write_value, address: SEMC_IPCR0, value: 0x80000000, size: 4 */ + 0x40, 0x2F, 0x00, 0x90, 0x80, 0x00, 0x00, 0x00, + /* #3.2, command: write_value, address: SEMC_IPCMD, value: 0xA55A000C, size: 4 */ + 0x40, 0x2F, 0x00, 0x9C, 0xA5, 0x5A, 0x00, 0x0C, + /* #4, command: check_any_bit_set, address: SEMC_INTR, value: 0x01, size: 4 */ + 0xCF, 0x00, 0x0C, 0x1C, 0x40, 0x2F, 0x00, 0x3C, 0x00, 0x00, 0x00, 0x01, + /* #5.1-2, command header bytes for merged 'Write - value' command */ + 0xCC, 0x00, 0x14, 0x04, + /* #5.1, command: write_value, address: SEMC_IPCR0, value: 0x80000000, size: 4 */ + 0x40, 0x2F, 0x00, 0x90, 0x80, 0x00, 0x00, 0x00, + /* #5.2, command: write_value, address: SEMC_IPCMD, value: 0xA55A000C, size: 4 */ + 0x40, 0x2F, 0x00, 0x9C, 0xA5, 0x5A, 0x00, 0x0C, + /* #6, command: check_any_bit_set, address: SEMC_INTR, value: 0x01, size: 4 */ + 0xCF, 0x00, 0x0C, 0x1C, 0x40, 0x2F, 0x00, 0x3C, 0x00, 0x00, 0x00, 0x01, + /* #7.1-3, command header bytes for merged 'Write - value' command */ + 0xCC, 0x00, 0x1C, 0x04, + /* #7.1, command: write_value, address: SEMC_IPTXDAT, value: 0x33, size: 4 */ + 0x40, 0x2F, 0x00, 0xA0, 0x00, 0x00, 0x00, 0x33, + /* #7.2, command: write_value, address: SEMC_IPCR0, value: 0x80000000, size: 4 */ + 0x40, 0x2F, 0x00, 0x90, 0x80, 0x00, 0x00, 0x00, + /* #7.3, command: write_value, address: SEMC_IPCMD, value: 0xA55A000A, size: 4 */ + 0x40, 0x2F, 0x00, 0x9C, 0xA5, 0x5A, 0x00, 0x0A, + /* #8, command: check_any_bit_set, address: SEMC_INTR, value: 0x01, size: 4 */ + 0xCF, 0x00, 0x0C, 0x1C, 0x40, 0x2F, 0x00, 0x3C, 0x00, 0x00, 0x00, 0x01, + /* #9, command: write_value, address: SEMC_SDRAMCR3, value: 0x50210A09, size: 4 */ + 0xCC, 0x00, 0x0C, 0x04, 0x40, 0x2F, 0x00, 0x4C, 0x50, 0x21, 0x0A, 0x09}; +/* BE CAREFUL MODIFYING THIS SETTINGS - IT IS YAML SETTINGS FOR TOOLS */ + +#else +const uint8_t dcd_data[] = {0x00}; +#endif /* XIP_BOOT_HEADER_DCD_ENABLE */ +#endif /* XIP_BOOT_HEADER_ENABLE */ diff --git a/ports/nxp/board/evkmimxrt1064/evkmimxrt1064_sdram_ini_dcd.h b/ports/nxp/board/evkmimxrt1064/evkmimxrt1064_sdram_ini_dcd.h new file mode 100644 index 000000000000..96158293af82 --- /dev/null +++ b/ports/nxp/board/evkmimxrt1064/evkmimxrt1064_sdram_ini_dcd.h @@ -0,0 +1,32 @@ +/* + * Copyright 2019 NXP + * All rights reserved. + * + * SPDX-License-Identifier: BSD-3-Clause + */ + +/*********************************************************************************************************************** + * This file was generated by the MCUXpresso Config Tools. Any manual edits made to this file + * will be overwritten if the respective MCUXpresso Config Tools is used to update this file. + **********************************************************************************************************************/ + +#ifndef __EVKMIMXRT1064_SDRAM_INI_DCD__ +#define __EVKMIMXRT1064_SDRAM_INI_DCD__ + +#include + +/*! @name Driver version */ +/*@{*/ +/*! @brief XIP_BOARD driver version 2.0.0. */ +#define FSL_XIP_BOARD_DRIVER_VERSION (MAKE_VERSION(2, 0, 0)) +/*@}*/ + +/************************************* + * DCD Data + *************************************/ +#define DCD_TAG_HEADER (0xD2) +#define DCD_VERSION (0x41) +#define DCD_TAG_HEADER_SHIFT (24) +#define DCD_ARRAY_SIZE 1 + +#endif /* __EVKMIMXRT1064_SDRAM_INI_DCD__ */ diff --git a/ports/nxp/board/evkmimxrt1064/fsl_clock.c b/ports/nxp/board/evkmimxrt1064/fsl_clock.c new file mode 100644 index 000000000000..3a0f5de829d1 --- /dev/null +++ b/ports/nxp/board/evkmimxrt1064/fsl_clock.c @@ -0,0 +1,1228 @@ +/* + * Copyright 2018 NXP + * All rights reserved. + * + * SPDX-License-Identifier: BSD-3-Clause + */ + +#include "fsl_clock.h" +/* Component ID definition, used by tools. */ +#ifndef FSL_COMPONENT_ID +#define FSL_COMPONENT_ID "platform.drivers.clock" +#endif + +/******************************************************************************* + * Definitions + ******************************************************************************/ +/* To make full use of CM7 hardware FPU, use double instead of uint64_t in clock driver to +achieve better performance, it is depend on the IDE Floating point settings, if double precision is selected +in IDE, clock_64b_t will switch to double type automatically. only support IAR and MDK here */ +#if __FPU_USED + +#if ((defined(__ICCARM__)) || (defined(__GNUC__))) + +#if (__ARMVFP__ >= __ARMFPV5__) && \ + (__ARM_FP == 0xE) /*0xe implies support for half, single and double precision operations*/ +typedef double clock_64b_t; +#else +typedef uint64_t clock_64b_t; +#endif + +#elif defined(__CC_ARM) || defined(__ARMCC_VERSION) + +#if defined __TARGET_FPU_FPV5_D16 +typedef double clock_64b_t; +#else +typedef uint64_t clock_64b_t; +#endif + +#else +typedef uint64_t clock_64b_t; +#endif + +#else +typedef uint64_t clock_64b_t; +#endif + +/******************************************************************************* + * Variables + ******************************************************************************/ + +/* External XTAL (OSC) clock frequency. */ +volatile uint32_t g_xtalFreq; +/* External RTC XTAL clock frequency. */ +volatile uint32_t g_rtcXtalFreq; + +/******************************************************************************* + * Prototypes + ******************************************************************************/ + +/*! + * @brief Get the periph clock frequency. + * + * @return Periph clock frequency in Hz. + */ +static uint32_t CLOCK_GetPeriphClkFreq(void); + +/******************************************************************************* + * Code + ******************************************************************************/ + +static uint32_t CLOCK_GetPeriphClkFreq(void) +{ + uint32_t freq; + + /* Periph_clk2_clk ---> Periph_clk */ + if (CCM->CBCDR & CCM_CBCDR_PERIPH_CLK_SEL_MASK) + { + switch (CCM->CBCMR & CCM_CBCMR_PERIPH_CLK2_SEL_MASK) + { + /* Pll3_sw_clk ---> Periph_clk2_clk ---> Periph_clk */ + case CCM_CBCMR_PERIPH_CLK2_SEL(0U): + freq = CLOCK_GetPllFreq(kCLOCK_PllUsb1); + break; + + /* Osc_clk ---> Periph_clk2_clk ---> Periph_clk */ + case CCM_CBCMR_PERIPH_CLK2_SEL(1U): + freq = CLOCK_GetOscFreq(); + break; + + case CCM_CBCMR_PERIPH_CLK2_SEL(2U): + freq = CLOCK_GetPllFreq(kCLOCK_PllSys); + break; + + case CCM_CBCMR_PERIPH_CLK2_SEL(3U): + default: + freq = 0U; + break; + } + + freq /= (((CCM->CBCDR & CCM_CBCDR_PERIPH_CLK2_PODF_MASK) >> CCM_CBCDR_PERIPH_CLK2_PODF_SHIFT) + 1U); + } + /* Pre_Periph_clk ---> Periph_clk */ + else + { + switch (CCM->CBCMR & CCM_CBCMR_PRE_PERIPH_CLK_SEL_MASK) + { + /* PLL2 ---> Pre_Periph_clk ---> Periph_clk */ + case CCM_CBCMR_PRE_PERIPH_CLK_SEL(0U): + freq = CLOCK_GetPllFreq(kCLOCK_PllSys); + break; + + /* PLL2 PFD2 ---> Pre_Periph_clk ---> Periph_clk */ + case CCM_CBCMR_PRE_PERIPH_CLK_SEL(1U): + freq = CLOCK_GetSysPfdFreq(kCLOCK_Pfd2); + break; + + /* PLL2 PFD0 ---> Pre_Periph_clk ---> Periph_clk */ + case CCM_CBCMR_PRE_PERIPH_CLK_SEL(2U): + freq = CLOCK_GetSysPfdFreq(kCLOCK_Pfd0); + break; + + /* PLL1 divided(/2) ---> Pre_Periph_clk ---> Periph_clk */ + case CCM_CBCMR_PRE_PERIPH_CLK_SEL(3U): + freq = CLOCK_GetPllFreq(kCLOCK_PllArm) / + (((CCM->CACRR & CCM_CACRR_ARM_PODF_MASK) >> CCM_CACRR_ARM_PODF_SHIFT) + 1U); + break; + + default: + freq = 0U; + break; + } + } + + return freq; +} + +/*! + * brief Initialize the external 24MHz clock. + * + * This function supports two modes: + * 1. Use external crystal oscillator. + * 2. Bypass the external crystal oscillator, using input source clock directly. + * + * After this function, please call ref CLOCK_SetXtal0Freq to inform clock driver + * the external clock frequency. + * + * param bypassXtalOsc Pass in true to bypass the external crystal oscillator. + * note This device does not support bypass external crystal oscillator, so + * the input parameter should always be false. + */ +void CLOCK_InitExternalClk(bool bypassXtalOsc) +{ + /* This device does not support bypass XTAL OSC. */ + assert(!bypassXtalOsc); + + CCM_ANALOG->MISC0_CLR = CCM_ANALOG_MISC0_XTAL_24M_PWD_MASK; /* Power up */ + while ((XTALOSC24M->LOWPWR_CTRL & XTALOSC24M_LOWPWR_CTRL_XTALOSC_PWRUP_STAT_MASK) == 0) + { + } + CCM_ANALOG->MISC0_SET = CCM_ANALOG_MISC0_OSC_XTALOK_EN_MASK; /* detect freq */ + while ((CCM_ANALOG->MISC0 & CCM_ANALOG_MISC0_OSC_XTALOK_MASK) == 0) + { + } + CCM_ANALOG->MISC0_CLR = CCM_ANALOG_MISC0_OSC_XTALOK_EN_MASK; +} + +/*! + * brief Deinitialize the external 24MHz clock. + * + * This function disables the external 24MHz clock. + * + * After this function, please call ref CLOCK_SetXtal0Freq to set external clock + * frequency to 0. + */ +void CLOCK_DeinitExternalClk(void) +{ + CCM_ANALOG->MISC0_SET = CCM_ANALOG_MISC0_XTAL_24M_PWD_MASK; /* Power down */ +} + +/*! + * brief Switch the OSC. + * + * This function switches the OSC source for SoC. + * + * param osc OSC source to switch to. + */ +void CLOCK_SwitchOsc(clock_osc_t osc) +{ + if (osc == kCLOCK_RcOsc) + XTALOSC24M->LOWPWR_CTRL_SET = XTALOSC24M_LOWPWR_CTRL_SET_OSC_SEL_MASK; + else + XTALOSC24M->LOWPWR_CTRL_CLR = XTALOSC24M_LOWPWR_CTRL_CLR_OSC_SEL_MASK; +} + +/*! + * brief Initialize the RC oscillator 24MHz clock. + */ +void CLOCK_InitRcOsc24M(void) +{ + XTALOSC24M->LOWPWR_CTRL |= XTALOSC24M_LOWPWR_CTRL_RC_OSC_EN_MASK; +} + +/*! + * brief Power down the RCOSC 24M clock. + */ +void CLOCK_DeinitRcOsc24M(void) +{ + XTALOSC24M->LOWPWR_CTRL &= ~XTALOSC24M_LOWPWR_CTRL_RC_OSC_EN_MASK; +} + +/*! + * brief Gets the AHB clock frequency. + * + * return The AHB clock frequency value in hertz. + */ +uint32_t CLOCK_GetAhbFreq(void) +{ + return CLOCK_GetPeriphClkFreq() / (((CCM->CBCDR & CCM_CBCDR_AHB_PODF_MASK) >> CCM_CBCDR_AHB_PODF_SHIFT) + 1U); +} + +/*! + * brief Gets the SEMC clock frequency. + * + * return The SEMC clock frequency value in hertz. + */ +uint32_t CLOCK_GetSemcFreq(void) +{ + uint32_t freq; + + /* SEMC alternative clock ---> SEMC Clock */ + if (CCM->CBCDR & CCM_CBCDR_SEMC_CLK_SEL_MASK) + { + /* PLL3 PFD1 ---> SEMC alternative clock ---> SEMC Clock */ + if (CCM->CBCDR & CCM_CBCDR_SEMC_ALT_CLK_SEL_MASK) + { + freq = CLOCK_GetUsb1PfdFreq(kCLOCK_Pfd1); + } + /* PLL2 PFD2 ---> SEMC alternative clock ---> SEMC Clock */ + else + { + freq = CLOCK_GetSysPfdFreq(kCLOCK_Pfd2); + } + } + /* Periph_clk ---> SEMC Clock */ + else + { + freq = CLOCK_GetPeriphClkFreq(); + } + + freq /= (((CCM->CBCDR & CCM_CBCDR_SEMC_PODF_MASK) >> CCM_CBCDR_SEMC_PODF_SHIFT) + 1U); + + return freq; +} + +/*! + * brief Gets the IPG clock frequency. + * + * return The IPG clock frequency value in hertz. + */ +uint32_t CLOCK_GetIpgFreq(void) +{ + return CLOCK_GetAhbFreq() / (((CCM->CBCDR & CCM_CBCDR_IPG_PODF_MASK) >> CCM_CBCDR_IPG_PODF_SHIFT) + 1U); +} + +/*! + * brief Gets the PER clock frequency. + * + * return The PER clock frequency value in hertz. + */ +uint32_t CLOCK_GetPerClkFreq(void) +{ + uint32_t freq; + + /* Osc_clk ---> PER Clock*/ + if (CCM->CSCMR1 & CCM_CSCMR1_PERCLK_CLK_SEL_MASK) + { + freq = CLOCK_GetOscFreq(); + } + /* Periph_clk ---> AHB Clock ---> IPG Clock ---> PER Clock */ + else + { + freq = CLOCK_GetFreq(kCLOCK_IpgClk); + } + + freq /= (((CCM->CSCMR1 & CCM_CSCMR1_PERCLK_PODF_MASK) >> CCM_CSCMR1_PERCLK_PODF_SHIFT) + 1U); + + return freq; +} + +/*! + * brief Gets the clock frequency for a specific clock name. + * + * This function checks the current clock configurations and then calculates + * the clock frequency for a specific clock name defined in clock_name_t. + * + * param clockName Clock names defined in clock_name_t + * return Clock frequency value in hertz + */ +uint32_t CLOCK_GetFreq(clock_name_t name) +{ + uint32_t freq; + + switch (name) + { + case kCLOCK_CpuClk: + case kCLOCK_AhbClk: + freq = CLOCK_GetAhbFreq(); + break; + + case kCLOCK_SemcClk: + freq = CLOCK_GetSemcFreq(); + break; + + case kCLOCK_IpgClk: + freq = CLOCK_GetIpgFreq(); + break; + + case kCLOCK_PerClk: + freq = CLOCK_GetPerClkFreq(); + break; + + case kCLOCK_OscClk: + freq = CLOCK_GetOscFreq(); + break; + case kCLOCK_RtcClk: + freq = CLOCK_GetRtcFreq(); + break; + case kCLOCK_ArmPllClk: + freq = CLOCK_GetPllFreq(kCLOCK_PllArm); + break; + case kCLOCK_Usb1PllClk: + freq = CLOCK_GetPllFreq(kCLOCK_PllUsb1); + break; + case kCLOCK_Usb1PllPfd0Clk: + freq = CLOCK_GetUsb1PfdFreq(kCLOCK_Pfd0); + break; + case kCLOCK_Usb1PllPfd1Clk: + freq = CLOCK_GetUsb1PfdFreq(kCLOCK_Pfd1); + break; + case kCLOCK_Usb1PllPfd2Clk: + freq = CLOCK_GetUsb1PfdFreq(kCLOCK_Pfd2); + break; + case kCLOCK_Usb1PllPfd3Clk: + freq = CLOCK_GetUsb1PfdFreq(kCLOCK_Pfd3); + break; + case kCLOCK_Usb2PllClk: + freq = CLOCK_GetPllFreq(kCLOCK_PllUsb2); + break; + case kCLOCK_SysPllClk: + freq = CLOCK_GetPllFreq(kCLOCK_PllSys); + break; + case kCLOCK_SysPllPfd0Clk: + freq = CLOCK_GetSysPfdFreq(kCLOCK_Pfd0); + break; + case kCLOCK_SysPllPfd1Clk: + freq = CLOCK_GetSysPfdFreq(kCLOCK_Pfd1); + break; + case kCLOCK_SysPllPfd2Clk: + freq = CLOCK_GetSysPfdFreq(kCLOCK_Pfd2); + break; + case kCLOCK_SysPllPfd3Clk: + freq = CLOCK_GetSysPfdFreq(kCLOCK_Pfd3); + break; + case kCLOCK_EnetPll0Clk: + freq = CLOCK_GetPllFreq(kCLOCK_PllEnet); + break; + case kCLOCK_EnetPll1Clk: + freq = CLOCK_GetPllFreq(kCLOCK_PllEnet2); + break; + case kCLOCK_EnetPll2Clk: + freq = CLOCK_GetPllFreq(kCLOCK_PllEnet25M); + break; + case kCLOCK_AudioPllClk: + freq = CLOCK_GetPllFreq(kCLOCK_PllAudio); + break; + case kCLOCK_VideoPllClk: + freq = CLOCK_GetPllFreq(kCLOCK_PllVideo); + break; + default: + freq = 0U; + break; + } + + return freq; +} + +/*! brief Enable USB HS clock. + * + * This function only enables the access to USB HS prepheral, upper layer + * should first call the ref CLOCK_EnableUsbhs0PhyPllClock to enable the PHY + * clock to use USB HS. + * + * param src USB HS does not care about the clock source, here must be ref kCLOCK_UsbSrcUnused. + * param freq USB HS does not care about the clock source, so this parameter is ignored. + * retval true The clock is set successfully. + * retval false The clock source is invalid to get proper USB HS clock. + */ +bool CLOCK_EnableUsbhs0Clock(clock_usb_src_t src, uint32_t freq) +{ + CCM->CCGR6 |= CCM_CCGR6_CG0_MASK; + USB1->USBCMD |= USBHS_USBCMD_RST_MASK; + for (volatile uint32_t i = 0; i < 400000; + i++) /* Add a delay between RST and RS so make sure there is a DP pullup sequence*/ + { + __ASM("nop"); + } + PMU->REG_3P0 = (PMU->REG_3P0 & (~PMU_REG_3P0_OUTPUT_TRG_MASK)) | + (PMU_REG_3P0_OUTPUT_TRG(0x17) | PMU_REG_3P0_ENABLE_LINREG_MASK); + return true; +} + +/*! brief Enable USB HS clock. + * + * This function only enables the access to USB HS prepheral, upper layer + * should first call the ref CLOCK_EnableUsbhs0PhyPllClock to enable the PHY + * clock to use USB HS. + * + * param src USB HS does not care about the clock source, here must be ref kCLOCK_UsbSrcUnused. + * param freq USB HS does not care about the clock source, so this parameter is ignored. + * retval true The clock is set successfully. + * retval false The clock source is invalid to get proper USB HS clock. + */ +bool CLOCK_EnableUsbhs1Clock(clock_usb_src_t src, uint32_t freq) +{ + CCM->CCGR6 |= CCM_CCGR6_CG0_MASK; + USB2->USBCMD |= USBHS_USBCMD_RST_MASK; + for (volatile uint32_t i = 0; i < 400000; + i++) /* Add a delay between RST and RS so make sure there is a DP pullup sequence*/ + { + __ASM("nop"); + } + PMU->REG_3P0 = (PMU->REG_3P0 & (~PMU_REG_3P0_OUTPUT_TRG_MASK)) | + (PMU_REG_3P0_OUTPUT_TRG(0x17) | PMU_REG_3P0_ENABLE_LINREG_MASK); + return true; +} + +/*! brief Enable USB HS PHY PLL clock. + * + * This function enables the internal 480MHz USB PHY PLL clock. + * + * param src USB HS PHY PLL clock source. + * param freq The frequency specified by src. + * retval true The clock is set successfully. + * retval false The clock source is invalid to get proper USB HS clock. + */ +bool CLOCK_EnableUsbhs0PhyPllClock(clock_usb_phy_src_t src, uint32_t freq) +{ + const clock_usb_pll_config_t g_ccmConfigUsbPll = {.loopDivider = 0U}; + if (CCM_ANALOG->PLL_USB1 & CCM_ANALOG_PLL_USB1_ENABLE_MASK) + { + CCM_ANALOG->PLL_USB1 |= CCM_ANALOG_PLL_USB1_EN_USB_CLKS_MASK; + } + else + { + CLOCK_InitUsb1Pll(&g_ccmConfigUsbPll); + } + USBPHY1->CTRL &= ~USBPHY_CTRL_SFTRST_MASK; /* release PHY from reset */ + USBPHY1->CTRL &= ~USBPHY_CTRL_CLKGATE_MASK; + + USBPHY1->PWD = 0; + USBPHY1->CTRL |= USBPHY_CTRL_ENAUTOCLR_PHY_PWD_MASK | USBPHY_CTRL_ENAUTOCLR_CLKGATE_MASK | + USBPHY_CTRL_ENUTMILEVEL2_MASK | USBPHY_CTRL_ENUTMILEVEL3_MASK; + return true; +} + +/*! brief Disable USB HS PHY PLL clock. + * + * This function disables USB HS PHY PLL clock. + */ +void CLOCK_DisableUsbhs0PhyPllClock(void) +{ + CCM_ANALOG->PLL_USB1 &= ~CCM_ANALOG_PLL_USB1_EN_USB_CLKS_MASK; + USBPHY1->CTRL |= USBPHY_CTRL_CLKGATE_MASK; /* Set to 1U to gate clocks */ +} + +/*! + * brief Initialize the ARM PLL. + * + * This function initialize the ARM PLL with specific settings + * + * param config configuration to set to PLL. + */ +void CLOCK_InitArmPll(const clock_arm_pll_config_t *config) +{ + /* Bypass PLL first */ + CCM_ANALOG->PLL_ARM = (CCM_ANALOG->PLL_ARM & (~CCM_ANALOG_PLL_ARM_BYPASS_CLK_SRC_MASK)) | + CCM_ANALOG_PLL_ARM_BYPASS_MASK | CCM_ANALOG_PLL_ARM_BYPASS_CLK_SRC(config->src); + + CCM_ANALOG->PLL_ARM = + (CCM_ANALOG->PLL_ARM & (~(CCM_ANALOG_PLL_ARM_DIV_SELECT_MASK | CCM_ANALOG_PLL_ARM_POWERDOWN_MASK))) | + CCM_ANALOG_PLL_ARM_ENABLE_MASK | CCM_ANALOG_PLL_ARM_DIV_SELECT(config->loopDivider); + + while ((CCM_ANALOG->PLL_ARM & CCM_ANALOG_PLL_ARM_LOCK_MASK) == 0) + { + } + + /* Disable Bypass */ + CCM_ANALOG->PLL_ARM &= ~CCM_ANALOG_PLL_ARM_BYPASS_MASK; +} + +/*! + * brief De-initialize the ARM PLL. + */ +void CLOCK_DeinitArmPll(void) +{ + CCM_ANALOG->PLL_ARM = CCM_ANALOG_PLL_ARM_POWERDOWN_MASK; +} + +/*! + * brief Initialize the System PLL. + * + * This function initializes the System PLL with specific settings + * + * param config Configuration to set to PLL. + */ +void CLOCK_InitSysPll(const clock_sys_pll_config_t *config) +{ + /* Bypass PLL first */ + CCM_ANALOG->PLL_SYS = (CCM_ANALOG->PLL_SYS & (~CCM_ANALOG_PLL_SYS_BYPASS_CLK_SRC_MASK)) | + CCM_ANALOG_PLL_SYS_BYPASS_MASK | CCM_ANALOG_PLL_SYS_BYPASS_CLK_SRC(config->src); + + CCM_ANALOG->PLL_SYS = + (CCM_ANALOG->PLL_SYS & (~(CCM_ANALOG_PLL_SYS_DIV_SELECT_MASK | CCM_ANALOG_PLL_SYS_POWERDOWN_MASK))) | + CCM_ANALOG_PLL_SYS_ENABLE_MASK | CCM_ANALOG_PLL_SYS_DIV_SELECT(config->loopDivider); + + /* Initialize the fractional mode */ + CCM_ANALOG->PLL_SYS_NUM = CCM_ANALOG_PLL_SYS_NUM_A(config->numerator); + CCM_ANALOG->PLL_SYS_DENOM = CCM_ANALOG_PLL_SYS_DENOM_B(config->denominator); + + /* Initialize the spread spectrum mode */ + CCM_ANALOG->PLL_SYS_SS = CCM_ANALOG_PLL_SYS_SS_STEP(config->ss_step) | + CCM_ANALOG_PLL_SYS_SS_ENABLE(config->ss_enable) | + CCM_ANALOG_PLL_SYS_SS_STOP(config->ss_stop); + + while ((CCM_ANALOG->PLL_SYS & CCM_ANALOG_PLL_SYS_LOCK_MASK) == 0) + { + } + + /* Disable Bypass */ + CCM_ANALOG->PLL_SYS &= ~CCM_ANALOG_PLL_SYS_BYPASS_MASK; +} + +/*! + * brief De-initialize the System PLL. + */ +void CLOCK_DeinitSysPll(void) +{ + CCM_ANALOG->PLL_SYS = CCM_ANALOG_PLL_SYS_POWERDOWN_MASK; +} + +/*! + * brief Initialize the USB1 PLL. + * + * This function initializes the USB1 PLL with specific settings + * + * param config Configuration to set to PLL. + */ +void CLOCK_InitUsb1Pll(const clock_usb_pll_config_t *config) +{ + /* Bypass PLL first */ + CCM_ANALOG->PLL_USB1 = (CCM_ANALOG->PLL_USB1 & (~CCM_ANALOG_PLL_USB1_BYPASS_CLK_SRC_MASK)) | + CCM_ANALOG_PLL_USB1_BYPASS_MASK | CCM_ANALOG_PLL_USB1_BYPASS_CLK_SRC(config->src); + + CCM_ANALOG->PLL_USB1 = (CCM_ANALOG->PLL_USB1 & (~CCM_ANALOG_PLL_USB1_DIV_SELECT_MASK)) | + CCM_ANALOG_PLL_USB1_ENABLE_MASK | CCM_ANALOG_PLL_USB1_POWER_MASK | + CCM_ANALOG_PLL_USB1_EN_USB_CLKS_MASK | CCM_ANALOG_PLL_USB1_DIV_SELECT(config->loopDivider); + + while ((CCM_ANALOG->PLL_USB1 & CCM_ANALOG_PLL_USB1_LOCK_MASK) == 0) + { + } + + /* Disable Bypass */ + CCM_ANALOG->PLL_USB1 &= ~CCM_ANALOG_PLL_USB1_BYPASS_MASK; +} + +/*! + * brief Deinitialize the USB1 PLL. + */ +void CLOCK_DeinitUsb1Pll(void) +{ + CCM_ANALOG->PLL_USB1 = 0U; +} + +/*! + * brief Initialize the USB2 PLL. + * + * This function initializes the USB2 PLL with specific settings + * + * param config Configuration to set to PLL. + */ +void CLOCK_InitUsb2Pll(const clock_usb_pll_config_t *config) +{ + /* Bypass PLL first */ + CCM_ANALOG->PLL_USB2 = (CCM_ANALOG->PLL_USB2 & (~CCM_ANALOG_PLL_USB2_BYPASS_CLK_SRC_MASK)) | + CCM_ANALOG_PLL_USB2_BYPASS_MASK | CCM_ANALOG_PLL_USB2_BYPASS_CLK_SRC(config->src); + + CCM_ANALOG->PLL_USB2 = (CCM_ANALOG->PLL_USB2 & (~CCM_ANALOG_PLL_USB2_DIV_SELECT_MASK)) | + CCM_ANALOG_PLL_USB2_ENABLE_MASK | CCM_ANALOG_PLL_USB2_POWER_MASK | + CCM_ANALOG_PLL_USB2_EN_USB_CLKS_MASK | CCM_ANALOG_PLL_USB2_DIV_SELECT(config->loopDivider); + + while ((CCM_ANALOG->PLL_USB2 & CCM_ANALOG_PLL_USB2_LOCK_MASK) == 0) + { + } + + /* Disable Bypass */ + CCM_ANALOG->PLL_USB2 &= ~CCM_ANALOG_PLL_USB2_BYPASS_MASK; +} + +/*! + * brief Deinitialize the USB2 PLL. + */ +void CLOCK_DeinitUsb2Pll(void) +{ + CCM_ANALOG->PLL_USB2 = 0U; +} + +/*! + * brief Initializes the Audio PLL. + * + * This function initializes the Audio PLL with specific settings + * + * param config Configuration to set to PLL. + */ +void CLOCK_InitAudioPll(const clock_audio_pll_config_t *config) +{ + uint32_t pllAudio; + uint32_t misc2 = 0; + + /* Bypass PLL first */ + CCM_ANALOG->PLL_AUDIO = (CCM_ANALOG->PLL_AUDIO & (~CCM_ANALOG_PLL_AUDIO_BYPASS_CLK_SRC_MASK)) | + CCM_ANALOG_PLL_AUDIO_BYPASS_MASK | CCM_ANALOG_PLL_AUDIO_BYPASS_CLK_SRC(config->src); + + CCM_ANALOG->PLL_AUDIO_NUM = CCM_ANALOG_PLL_AUDIO_NUM_A(config->numerator); + CCM_ANALOG->PLL_AUDIO_DENOM = CCM_ANALOG_PLL_AUDIO_DENOM_B(config->denominator); + + /* + * Set post divider: + * + * ------------------------------------------------------------------------ + * | config->postDivider | PLL_AUDIO[POST_DIV_SELECT] | MISC2[AUDIO_DIV] | + * ------------------------------------------------------------------------ + * | 1 | 2 | 0 | + * ------------------------------------------------------------------------ + * | 2 | 1 | 0 | + * ------------------------------------------------------------------------ + * | 4 | 2 | 3 | + * ------------------------------------------------------------------------ + * | 8 | 1 | 3 | + * ------------------------------------------------------------------------ + * | 16 | 0 | 3 | + * ------------------------------------------------------------------------ + */ + pllAudio = + (CCM_ANALOG->PLL_AUDIO & (~(CCM_ANALOG_PLL_AUDIO_DIV_SELECT_MASK | CCM_ANALOG_PLL_AUDIO_POWERDOWN_MASK))) | + CCM_ANALOG_PLL_AUDIO_ENABLE_MASK | CCM_ANALOG_PLL_AUDIO_DIV_SELECT(config->loopDivider); + + switch (config->postDivider) + { + case 16: + pllAudio |= CCM_ANALOG_PLL_AUDIO_POST_DIV_SELECT(0); + misc2 = CCM_ANALOG_MISC2_AUDIO_DIV_MSB_MASK | CCM_ANALOG_MISC2_AUDIO_DIV_LSB_MASK; + break; + + case 8: + pllAudio |= CCM_ANALOG_PLL_AUDIO_POST_DIV_SELECT(1); + misc2 = CCM_ANALOG_MISC2_AUDIO_DIV_MSB_MASK | CCM_ANALOG_MISC2_AUDIO_DIV_LSB_MASK; + break; + + case 4: + pllAudio |= CCM_ANALOG_PLL_AUDIO_POST_DIV_SELECT(2); + misc2 = CCM_ANALOG_MISC2_AUDIO_DIV_MSB_MASK | CCM_ANALOG_MISC2_AUDIO_DIV_LSB_MASK; + break; + + case 2: + pllAudio |= CCM_ANALOG_PLL_AUDIO_POST_DIV_SELECT(1); + break; + + default: + pllAudio |= CCM_ANALOG_PLL_AUDIO_POST_DIV_SELECT(2); + break; + } + + CCM_ANALOG->MISC2 = + (CCM_ANALOG->MISC2 & ~(CCM_ANALOG_MISC2_AUDIO_DIV_LSB_MASK | CCM_ANALOG_MISC2_AUDIO_DIV_MSB_MASK)) | misc2; + + CCM_ANALOG->PLL_AUDIO = pllAudio; + + while ((CCM_ANALOG->PLL_AUDIO & CCM_ANALOG_PLL_AUDIO_LOCK_MASK) == 0) + { + } + + /* Disable Bypass */ + CCM_ANALOG->PLL_AUDIO &= ~CCM_ANALOG_PLL_AUDIO_BYPASS_MASK; +} + +/*! + * brief De-initialize the Audio PLL. + */ +void CLOCK_DeinitAudioPll(void) +{ + CCM_ANALOG->PLL_AUDIO = CCM_ANALOG_PLL_AUDIO_POWERDOWN_MASK; +} + +/*! + * brief Initialize the video PLL. + * + * This function configures the Video PLL with specific settings + * + * param config configuration to set to PLL. + */ +void CLOCK_InitVideoPll(const clock_video_pll_config_t *config) +{ + uint32_t pllVideo; + uint32_t misc2 = 0; + + /* Bypass PLL first */ + CCM_ANALOG->PLL_VIDEO = (CCM_ANALOG->PLL_VIDEO & (~CCM_ANALOG_PLL_VIDEO_BYPASS_CLK_SRC_MASK)) | + CCM_ANALOG_PLL_VIDEO_BYPASS_MASK | CCM_ANALOG_PLL_VIDEO_BYPASS_CLK_SRC(config->src); + + CCM_ANALOG->PLL_VIDEO_NUM = CCM_ANALOG_PLL_VIDEO_NUM_A(config->numerator); + CCM_ANALOG->PLL_VIDEO_DENOM = CCM_ANALOG_PLL_VIDEO_DENOM_B(config->denominator); + + /* + * Set post divider: + * + * ------------------------------------------------------------------------ + * | config->postDivider | PLL_VIDEO[POST_DIV_SELECT] | MISC2[VIDEO_DIV] | + * ------------------------------------------------------------------------ + * | 1 | 2 | 0 | + * ------------------------------------------------------------------------ + * | 2 | 1 | 0 | + * ------------------------------------------------------------------------ + * | 4 | 2 | 3 | + * ------------------------------------------------------------------------ + * | 8 | 1 | 3 | + * ------------------------------------------------------------------------ + * | 16 | 0 | 3 | + * ------------------------------------------------------------------------ + */ + pllVideo = + (CCM_ANALOG->PLL_VIDEO & (~(CCM_ANALOG_PLL_VIDEO_DIV_SELECT_MASK | CCM_ANALOG_PLL_VIDEO_POWERDOWN_MASK))) | + CCM_ANALOG_PLL_VIDEO_ENABLE_MASK | CCM_ANALOG_PLL_VIDEO_DIV_SELECT(config->loopDivider); + + switch (config->postDivider) + { + case 16: + pllVideo |= CCM_ANALOG_PLL_VIDEO_POST_DIV_SELECT(0); + misc2 = CCM_ANALOG_MISC2_VIDEO_DIV(3); + break; + + case 8: + pllVideo |= CCM_ANALOG_PLL_VIDEO_POST_DIV_SELECT(1); + misc2 = CCM_ANALOG_MISC2_VIDEO_DIV(3); + break; + + case 4: + pllVideo |= CCM_ANALOG_PLL_VIDEO_POST_DIV_SELECT(2); + misc2 = CCM_ANALOG_MISC2_VIDEO_DIV(3); + break; + + case 2: + pllVideo |= CCM_ANALOG_PLL_VIDEO_POST_DIV_SELECT(1); + break; + + default: + pllVideo |= CCM_ANALOG_PLL_VIDEO_POST_DIV_SELECT(2); + break; + } + + CCM_ANALOG->MISC2 = (CCM_ANALOG->MISC2 & ~CCM_ANALOG_MISC2_VIDEO_DIV_MASK) | misc2; + + CCM_ANALOG->PLL_VIDEO = pllVideo; + + while ((CCM_ANALOG->PLL_VIDEO & CCM_ANALOG_PLL_VIDEO_LOCK_MASK) == 0) + { + } + + /* Disable Bypass */ + CCM_ANALOG->PLL_VIDEO &= ~CCM_ANALOG_PLL_VIDEO_BYPASS_MASK; +} + +/*! + * brief De-initialize the Video PLL. + */ +void CLOCK_DeinitVideoPll(void) +{ + CCM_ANALOG->PLL_VIDEO = CCM_ANALOG_PLL_VIDEO_POWERDOWN_MASK; +} + +/*! + * brief Initialize the ENET PLL. + * + * This function initializes the ENET PLL with specific settings. + * + * param config Configuration to set to PLL. + */ +void CLOCK_InitEnetPll(const clock_enet_pll_config_t *config) +{ + uint32_t enet_pll = CCM_ANALOG_PLL_ENET_DIV_SELECT(config->loopDivider) | + CCM_ANALOG_PLL_ENET_ENET2_DIV_SELECT(config->loopDivider1); + + CCM_ANALOG->PLL_ENET = (CCM_ANALOG->PLL_ENET & (~CCM_ANALOG_PLL_ENET_BYPASS_CLK_SRC_MASK)) | + CCM_ANALOG_PLL_ENET_BYPASS_MASK | CCM_ANALOG_PLL_ENET_BYPASS_CLK_SRC(config->src); + + if (config->enableClkOutput) + { + enet_pll |= CCM_ANALOG_PLL_ENET_ENABLE_MASK; + } + + if (config->enableClkOutput1) + { + enet_pll |= CCM_ANALOG_PLL_ENET_ENET2_REF_EN_MASK; + } + + if (config->enableClkOutput25M) + { + enet_pll |= CCM_ANALOG_PLL_ENET_ENET_25M_REF_EN_MASK; + } + + CCM_ANALOG->PLL_ENET = + (CCM_ANALOG->PLL_ENET & (~(CCM_ANALOG_PLL_ENET_DIV_SELECT_MASK | CCM_ANALOG_PLL_ENET_ENET2_DIV_SELECT_MASK | + CCM_ANALOG_PLL_ENET_POWERDOWN_MASK))) | + enet_pll; + + /* Wait for stable */ + while ((CCM_ANALOG->PLL_ENET & CCM_ANALOG_PLL_ENET_LOCK_MASK) == 0) + { + } + + /* Disable Bypass */ + CCM_ANALOG->PLL_ENET &= ~CCM_ANALOG_PLL_ENET_BYPASS_MASK; +} + +/*! + * brief Deinitialize the ENET PLL. + * + * This function disables the ENET PLL. + */ +void CLOCK_DeinitEnetPll(void) +{ + CCM_ANALOG->PLL_ENET = CCM_ANALOG_PLL_ENET_POWERDOWN_MASK; +} + +/*! + * brief Get current PLL output frequency. + * + * This function get current output frequency of specific PLL + * + * param pll pll name to get frequency. + * return The PLL output frequency in hertz. + */ +uint32_t CLOCK_GetPllFreq(clock_pll_t pll) +{ + uint32_t freq; + uint32_t divSelect; + clock_64b_t freqTmp; + + const uint32_t enetRefClkFreq[] = { + 25000000U, /* 25M */ + 50000000U, /* 50M */ + 100000000U, /* 100M */ + 125000000U /* 125M */ + }; + + /* check if PLL is enabled */ + if (!CLOCK_IsPllEnabled(CCM_ANALOG, pll)) + { + return 0U; + } + + /* get pll reference clock */ + freq = CLOCK_GetPllBypassRefClk(CCM_ANALOG, pll); + + /* check if pll is bypassed */ + if (CLOCK_IsPllBypassed(CCM_ANALOG, pll)) + { + return freq; + } + + switch (pll) + { + case kCLOCK_PllArm: + freq = ((freq * ((CCM_ANALOG->PLL_ARM & CCM_ANALOG_PLL_ARM_DIV_SELECT_MASK) >> + CCM_ANALOG_PLL_ARM_DIV_SELECT_SHIFT)) >> + 1U); + break; + case kCLOCK_PllSys: + /* PLL output frequency = Fref * (DIV_SELECT + NUM/DENOM). */ + freqTmp = ((clock_64b_t)freq * ((clock_64b_t)(CCM_ANALOG->PLL_SYS_NUM))) / + ((clock_64b_t)(CCM_ANALOG->PLL_SYS_DENOM)); + + if (CCM_ANALOG->PLL_SYS & CCM_ANALOG_PLL_SYS_DIV_SELECT_MASK) + { + freq *= 22U; + } + else + { + freq *= 20U; + } + + freq += (uint32_t)freqTmp; + break; + + case kCLOCK_PllUsb1: + freq = (freq * ((CCM_ANALOG->PLL_USB1 & CCM_ANALOG_PLL_USB1_DIV_SELECT_MASK) ? 22U : 20U)); + break; + + case kCLOCK_PllAudio: + /* PLL output frequency = Fref * (DIV_SELECT + NUM/DENOM). */ + divSelect = + (CCM_ANALOG->PLL_AUDIO & CCM_ANALOG_PLL_AUDIO_DIV_SELECT_MASK) >> CCM_ANALOG_PLL_AUDIO_DIV_SELECT_SHIFT; + + freqTmp = ((clock_64b_t)freq * ((clock_64b_t)(CCM_ANALOG->PLL_AUDIO_NUM))) / + ((clock_64b_t)(CCM_ANALOG->PLL_AUDIO_DENOM)); + + freq = freq * divSelect + (uint32_t)freqTmp; + + /* AUDIO PLL output = PLL output frequency / POSTDIV. */ + + /* + * Post divider: + * + * PLL_AUDIO[POST_DIV_SELECT]: + * 0x00: 4 + * 0x01: 2 + * 0x02: 1 + * + * MISC2[AUDO_DIV]: + * 0x00: 1 + * 0x01: 2 + * 0x02: 1 + * 0x03: 4 + */ + switch (CCM_ANALOG->PLL_AUDIO & CCM_ANALOG_PLL_AUDIO_POST_DIV_SELECT_MASK) + { + case CCM_ANALOG_PLL_AUDIO_POST_DIV_SELECT(0U): + freq = freq >> 2U; + break; + + case CCM_ANALOG_PLL_AUDIO_POST_DIV_SELECT(1U): + freq = freq >> 1U; + break; + + default: + break; + } + + switch (CCM_ANALOG->MISC2 & (CCM_ANALOG_MISC2_AUDIO_DIV_MSB_MASK | CCM_ANALOG_MISC2_AUDIO_DIV_LSB_MASK)) + { + case CCM_ANALOG_MISC2_AUDIO_DIV_MSB(1) | CCM_ANALOG_MISC2_AUDIO_DIV_LSB(1): + freq >>= 2U; + break; + + case CCM_ANALOG_MISC2_AUDIO_DIV_MSB(0) | CCM_ANALOG_MISC2_AUDIO_DIV_LSB(1): + freq >>= 1U; + break; + + default: + break; + } + break; + + case kCLOCK_PllVideo: + /* PLL output frequency = Fref * (DIV_SELECT + NUM/DENOM). */ + divSelect = + (CCM_ANALOG->PLL_VIDEO & CCM_ANALOG_PLL_VIDEO_DIV_SELECT_MASK) >> CCM_ANALOG_PLL_VIDEO_DIV_SELECT_SHIFT; + + freqTmp = ((clock_64b_t)freq * ((clock_64b_t)(CCM_ANALOG->PLL_VIDEO_NUM))) / + ((clock_64b_t)(CCM_ANALOG->PLL_VIDEO_DENOM)); + + freq = freq * divSelect + (uint32_t)freqTmp; + + /* VIDEO PLL output = PLL output frequency / POSTDIV. */ + + /* + * Post divider: + * + * PLL_VIDEO[POST_DIV_SELECT]: + * 0x00: 4 + * 0x01: 2 + * 0x02: 1 + * + * MISC2[VIDEO_DIV]: + * 0x00: 1 + * 0x01: 2 + * 0x02: 1 + * 0x03: 4 + */ + switch (CCM_ANALOG->PLL_VIDEO & CCM_ANALOG_PLL_VIDEO_POST_DIV_SELECT_MASK) + { + case CCM_ANALOG_PLL_VIDEO_POST_DIV_SELECT(0U): + freq = freq >> 2U; + break; + + case CCM_ANALOG_PLL_VIDEO_POST_DIV_SELECT(1U): + freq = freq >> 1U; + break; + + default: + break; + } + + switch (CCM_ANALOG->MISC2 & CCM_ANALOG_MISC2_VIDEO_DIV_MASK) + { + case CCM_ANALOG_MISC2_VIDEO_DIV(3): + freq >>= 2U; + break; + + case CCM_ANALOG_MISC2_VIDEO_DIV(1): + freq >>= 1U; + break; + + default: + break; + } + break; + case kCLOCK_PllEnet: + divSelect = + (CCM_ANALOG->PLL_ENET & CCM_ANALOG_PLL_ENET_DIV_SELECT_MASK) >> CCM_ANALOG_PLL_ENET_DIV_SELECT_SHIFT; + freq = enetRefClkFreq[divSelect]; + break; + + case kCLOCK_PllEnet2: + divSelect = (CCM_ANALOG->PLL_ENET & CCM_ANALOG_PLL_ENET_ENET2_DIV_SELECT_MASK) >> + CCM_ANALOG_PLL_ENET_ENET2_DIV_SELECT_SHIFT; + freq = enetRefClkFreq[divSelect]; + break; + + case kCLOCK_PllEnet25M: + /* ref_enetpll1 if fixed at 25MHz. */ + freq = 25000000UL; + break; + + case kCLOCK_PllUsb2: + freq = (freq * ((CCM_ANALOG->PLL_USB2 & CCM_ANALOG_PLL_USB2_DIV_SELECT_MASK) ? 22U : 20U)); + break; + default: + freq = 0U; + break; + } + + return freq; +} + +/*! + * brief Initialize the System PLL PFD. + * + * This function initializes the System PLL PFD. During new value setting, + * the clock output is disabled to prevent glitch. + * + * param pfd Which PFD clock to enable. + * param pfdFrac The PFD FRAC value. + * note It is recommended that PFD settings are kept between 12-35. + */ +void CLOCK_InitSysPfd(clock_pfd_t pfd, uint8_t pfdFrac) +{ + uint32_t pfdIndex = (uint32_t)pfd; + uint32_t pfd528; + + pfd528 = CCM_ANALOG->PFD_528 & + ~((CCM_ANALOG_PFD_528_PFD0_CLKGATE_MASK | CCM_ANALOG_PFD_528_PFD0_FRAC_MASK) << (8 * pfdIndex)); + + /* Disable the clock output first. */ + CCM_ANALOG->PFD_528 = pfd528 | (CCM_ANALOG_PFD_528_PFD0_CLKGATE_MASK << (8 * pfdIndex)); + + /* Set the new value and enable output. */ + CCM_ANALOG->PFD_528 = pfd528 | (CCM_ANALOG_PFD_528_PFD0_FRAC(pfdFrac) << (8 * pfdIndex)); +} + +/*! + * brief De-initialize the System PLL PFD. + * + * This function disables the System PLL PFD. + * + * param pfd Which PFD clock to disable. + */ +void CLOCK_DeinitSysPfd(clock_pfd_t pfd) +{ + CCM_ANALOG->PFD_528 |= CCM_ANALOG_PFD_528_PFD0_CLKGATE_MASK << (8 * pfd); +} + +/*! + * brief Initialize the USB1 PLL PFD. + * + * This function initializes the USB1 PLL PFD. During new value setting, + * the clock output is disabled to prevent glitch. + * + * param pfd Which PFD clock to enable. + * param pfdFrac The PFD FRAC value. + * note It is recommended that PFD settings are kept between 12-35. + */ +void CLOCK_InitUsb1Pfd(clock_pfd_t pfd, uint8_t pfdFrac) +{ + uint32_t pfdIndex = (uint32_t)pfd; + uint32_t pfd480; + + pfd480 = CCM_ANALOG->PFD_480 & + ~((CCM_ANALOG_PFD_480_PFD0_CLKGATE_MASK | CCM_ANALOG_PFD_480_PFD0_FRAC_MASK) << (8 * pfdIndex)); + + /* Disable the clock output first. */ + CCM_ANALOG->PFD_480 = pfd480 | (CCM_ANALOG_PFD_480_PFD0_CLKGATE_MASK << (8 * pfdIndex)); + + /* Set the new value and enable output. */ + CCM_ANALOG->PFD_480 = pfd480 | (CCM_ANALOG_PFD_480_PFD0_FRAC(pfdFrac) << (8 * pfdIndex)); +} + +/*! + * brief De-initialize the USB1 PLL PFD. + * + * This function disables the USB1 PLL PFD. + * + * param pfd Which PFD clock to disable. + */ +void CLOCK_DeinitUsb1Pfd(clock_pfd_t pfd) +{ + CCM_ANALOG->PFD_480 |= CCM_ANALOG_PFD_480_PFD0_CLKGATE_MASK << (8 * pfd); +} + +/*! + * brief Get current System PLL PFD output frequency. + * + * This function get current output frequency of specific System PLL PFD + * + * param pfd pfd name to get frequency. + * return The PFD output frequency in hertz. + */ +uint32_t CLOCK_GetSysPfdFreq(clock_pfd_t pfd) +{ + uint32_t freq = CLOCK_GetPllFreq(kCLOCK_PllSys); + + switch (pfd) + { + case kCLOCK_Pfd0: + freq /= ((CCM_ANALOG->PFD_528 & CCM_ANALOG_PFD_528_PFD0_FRAC_MASK) >> CCM_ANALOG_PFD_528_PFD0_FRAC_SHIFT); + break; + + case kCLOCK_Pfd1: + freq /= ((CCM_ANALOG->PFD_528 & CCM_ANALOG_PFD_528_PFD1_FRAC_MASK) >> CCM_ANALOG_PFD_528_PFD1_FRAC_SHIFT); + break; + + case kCLOCK_Pfd2: + freq /= ((CCM_ANALOG->PFD_528 & CCM_ANALOG_PFD_528_PFD2_FRAC_MASK) >> CCM_ANALOG_PFD_528_PFD2_FRAC_SHIFT); + break; + + case kCLOCK_Pfd3: + freq /= ((CCM_ANALOG->PFD_528 & CCM_ANALOG_PFD_528_PFD3_FRAC_MASK) >> CCM_ANALOG_PFD_528_PFD3_FRAC_SHIFT); + break; + + default: + freq = 0U; + break; + } + freq *= 18U; + + return freq; +} + +/*! + * brief Get current USB1 PLL PFD output frequency. + * + * This function get current output frequency of specific USB1 PLL PFD + * + * param pfd pfd name to get frequency. + * return The PFD output frequency in hertz. + */ +uint32_t CLOCK_GetUsb1PfdFreq(clock_pfd_t pfd) +{ + uint32_t freq = CLOCK_GetPllFreq(kCLOCK_PllUsb1); + + switch (pfd) + { + case kCLOCK_Pfd0: + freq /= ((CCM_ANALOG->PFD_480 & CCM_ANALOG_PFD_480_PFD0_FRAC_MASK) >> CCM_ANALOG_PFD_480_PFD0_FRAC_SHIFT); + break; + + case kCLOCK_Pfd1: + freq /= ((CCM_ANALOG->PFD_480 & CCM_ANALOG_PFD_480_PFD1_FRAC_MASK) >> CCM_ANALOG_PFD_480_PFD1_FRAC_SHIFT); + break; + + case kCLOCK_Pfd2: + freq /= ((CCM_ANALOG->PFD_480 & CCM_ANALOG_PFD_480_PFD2_FRAC_MASK) >> CCM_ANALOG_PFD_480_PFD2_FRAC_SHIFT); + break; + + case kCLOCK_Pfd3: + freq /= ((CCM_ANALOG->PFD_480 & CCM_ANALOG_PFD_480_PFD3_FRAC_MASK) >> CCM_ANALOG_PFD_480_PFD3_FRAC_SHIFT); + break; + + default: + freq = 0U; + break; + } + freq *= 18U; + + return freq; +} + +/*! brief Enable USB HS PHY PLL clock. + * + * This function enables the internal 480MHz USB PHY PLL clock. + * + * param src USB HS PHY PLL clock source. + * param freq The frequency specified by src. + * retval true The clock is set successfully. + * retval false The clock source is invalid to get proper USB HS clock. + */ +bool CLOCK_EnableUsbhs1PhyPllClock(clock_usb_phy_src_t src, uint32_t freq) +{ + const clock_usb_pll_config_t g_ccmConfigUsbPll = {.loopDivider = 0U}; + CLOCK_InitUsb2Pll(&g_ccmConfigUsbPll); + USBPHY2->CTRL &= ~USBPHY_CTRL_SFTRST_MASK; /* release PHY from reset */ + USBPHY2->CTRL &= ~USBPHY_CTRL_CLKGATE_MASK; + + USBPHY2->PWD = 0; + USBPHY2->CTRL |= USBPHY_CTRL_ENAUTOCLR_PHY_PWD_MASK | USBPHY_CTRL_ENAUTOCLR_CLKGATE_MASK | + USBPHY_CTRL_ENUTMILEVEL2_MASK | USBPHY_CTRL_ENUTMILEVEL3_MASK; + + return true; +} + +/*! brief Disable USB HS PHY PLL clock. + * + * This function disables USB HS PHY PLL clock. + */ +void CLOCK_DisableUsbhs1PhyPllClock(void) +{ + CCM_ANALOG->PLL_USB2 &= ~CCM_ANALOG_PLL_USB2_EN_USB_CLKS_MASK; + USBPHY2->CTRL |= USBPHY_CTRL_CLKGATE_MASK; /* Set to 1U to gate clocks */ +} diff --git a/ports/nxp/board/evkmimxrt1064/fsl_clock.h b/ports/nxp/board/evkmimxrt1064/fsl_clock.h new file mode 100644 index 000000000000..ef2426804997 --- /dev/null +++ b/ports/nxp/board/evkmimxrt1064/fsl_clock.h @@ -0,0 +1,1567 @@ +/* + * Copyright 2018 NXP + * All rights reserved. + * + * SPDX-License-Identifier: BSD-3-Clause + */ + +#ifndef _FSL_CLOCK_H_ +#define _FSL_CLOCK_H_ + +#include "fsl_common.h" + +/*! @addtogroup clock */ +/*! @{ */ + +/*! @file */ + +/******************************************************************************* + * Configurations + ******************************************************************************/ + +/*! @brief Configure whether driver controls clock + * + * When set to 0, peripheral drivers will enable clock in initialize function + * and disable clock in de-initialize function. When set to 1, peripheral + * driver will not control the clock, application could control the clock out of + * the driver. + * + * @note All drivers share this feature switcher. If it is set to 1, application + * should handle clock enable and disable for all drivers. + */ +#if !(defined(FSL_SDK_DISABLE_DRIVER_CLOCK_CONTROL)) +#define FSL_SDK_DISABLE_DRIVER_CLOCK_CONTROL 0 +#endif + +/******************************************************************************* + * Definitions + ******************************************************************************/ + +/*! @name Driver version */ +/*@{*/ +/*! @brief CLOCK driver version 2.1.7. */ +#define FSL_CLOCK_DRIVER_VERSION (MAKE_VERSION(2, 1, 7)) + +/* analog pll definition */ +#define CCM_ANALOG_PLL_BYPASS_SHIFT (16U) +#define CCM_ANALOG_PLL_BYPASS_CLK_SRC_MASK (0xC000U) +#define CCM_ANALOG_PLL_BYPASS_CLK_SRC_SHIFT (14U) + +/*@}*/ + +/*! + * @brief CCM registers offset. + */ +#define CCSR_OFFSET 0x0C +#define CBCDR_OFFSET 0x14 +#define CBCMR_OFFSET 0x18 +#define CSCMR1_OFFSET 0x1C +#define CSCMR2_OFFSET 0x20 +#define CSCDR1_OFFSET 0x24 +#define CDCDR_OFFSET 0x30 +#define CSCDR2_OFFSET 0x38 +#define CSCDR3_OFFSET 0x3C +#define CACRR_OFFSET 0x10 +#define CS1CDR_OFFSET 0x28 +#define CS2CDR_OFFSET 0x2C + +/*! + * @brief CCM Analog registers offset. + */ +#define PLL_ARM_OFFSET 0x00 +#define PLL_SYS_OFFSET 0x30 +#define PLL_USB1_OFFSET 0x10 +#define PLL_AUDIO_OFFSET 0x70 +#define PLL_VIDEO_OFFSET 0xA0 +#define PLL_ENET_OFFSET 0xE0 +#define PLL_USB2_OFFSET 0x20 + +#define CCM_TUPLE(reg, shift, mask, busyShift) \ + (int)((reg & 0xFFU) | ((shift) << 8U) | ((((mask) >> (shift)) & 0x1FFFU) << 13U) | ((busyShift) << 26U)) +#define CCM_TUPLE_REG(base, tuple) (*((volatile uint32_t *)(((uint32_t)(base)) + ((tuple)&0xFFU)))) +#define CCM_TUPLE_SHIFT(tuple) (((tuple) >> 8U) & 0x1FU) +#define CCM_TUPLE_MASK(tuple) ((uint32_t)((((tuple) >> 13U) & 0x1FFFU) << ((((tuple) >> 8U) & 0x1FU)))) +#define CCM_TUPLE_BUSY_SHIFT(tuple) (((tuple) >> 26U) & 0x3FU) + +#define CCM_NO_BUSY_WAIT (0x20U) + +/*! + * @brief CCM ANALOG tuple macros to map corresponding registers and bit fields. + */ +#define CCM_ANALOG_TUPLE(reg, shift) (((reg & 0xFFFU) << 16U) | (shift)) +#define CCM_ANALOG_TUPLE_SHIFT(tuple) (((uint32_t)tuple) & 0x1FU) +#define CCM_ANALOG_TUPLE_REG_OFF(base, tuple, off) \ + (*((volatile uint32_t *)((uint32_t)base + (((uint32_t)tuple >> 16U) & 0xFFFU) + off))) +#define CCM_ANALOG_TUPLE_REG(base, tuple) CCM_ANALOG_TUPLE_REG_OFF(base, tuple, 0U) + +/*! + * @brief clock1PN frequency. + */ +#define CLKPN_FREQ 0U + +/*! @brief External XTAL (24M OSC/SYSOSC) clock frequency. + * + * The XTAL (24M OSC/SYSOSC) clock frequency in Hz, when the clock is setup, use the + * function CLOCK_SetXtalFreq to set the value in to clock driver. For example, + * if XTAL is 24MHz, + * @code + * CLOCK_InitExternalClk(false); // Setup the 24M OSC/SYSOSC + * CLOCK_SetXtalFreq(240000000); // Set the XTAL value to clock driver. + * @endcode + */ +extern volatile uint32_t g_xtalFreq; + +/*! @brief External RTC XTAL (32K OSC) clock frequency. + * + * The RTC XTAL (32K OSC) clock frequency in Hz, when the clock is setup, use the + * function CLOCK_SetRtcXtalFreq to set the value in to clock driver. + */ +extern volatile uint32_t g_rtcXtalFreq; + +/* For compatible with other platforms */ +#define CLOCK_SetXtal0Freq CLOCK_SetXtalFreq +#define CLOCK_SetXtal32Freq CLOCK_SetRtcXtalFreq + +/*! @brief Clock ip name array for ADC. */ +#define ADC_CLOCKS \ + { \ + kCLOCK_IpInvalid, kCLOCK_Adc1, kCLOCK_Adc2 \ + } + +/*! @brief Clock ip name array for AOI. */ +#define AOI_CLOCKS \ + { \ + kCLOCK_IpInvalid, kCLOCK_Aoi1, kCLOCK_Aoi2 \ + } + +/*! @brief Clock ip name array for BEE. */ +#define BEE_CLOCKS \ + { \ + kCLOCK_Bee \ + } + +/*! @brief Clock ip name array for CMP. */ +#define CMP_CLOCKS \ + { \ + kCLOCK_IpInvalid, kCLOCK_Acmp1, kCLOCK_Acmp2, kCLOCK_Acmp3, kCLOCK_Acmp4 \ + } + +/*! @brief Clock ip name array for CSI. */ +#define CSI_CLOCKS \ + { \ + kCLOCK_Csi \ + } + +/*! @brief Clock ip name array for DCDC. */ +#define DCDC_CLOCKS \ + { \ + kCLOCK_Dcdc \ + } + +/*! @brief Clock ip name array for DCP. */ +#define DCP_CLOCKS \ + { \ + kCLOCK_Dcp \ + } + +/*! @brief Clock ip name array for DMAMUX_CLOCKS. */ +#define DMAMUX_CLOCKS \ + { \ + kCLOCK_Dma \ + } + +/*! @brief Clock ip name array for DMA. */ +#define EDMA_CLOCKS \ + { \ + kCLOCK_Dma \ + } + +/*! @brief Clock ip name array for ENC. */ +#define ENC_CLOCKS \ + { \ + kCLOCK_IpInvalid, kCLOCK_Enc1, kCLOCK_Enc2, kCLOCK_Enc3, kCLOCK_Enc4 \ + } + +/*! @brief Clock ip name array for ENET. */ +#define ENET_CLOCKS \ + { \ + kCLOCK_Enet, kCLOCK_IpInvalid, kCLOCK_Enet2 \ + } + +/*! @brief Clock ip name array for EWM. */ +#define EWM_CLOCKS \ + { \ + kCLOCK_Ewm0 \ + } + +/*! @brief Clock ip name array for FLEXCAN. */ +#define FLEXCAN_CLOCKS \ + { \ + kCLOCK_IpInvalid, kCLOCK_Can1, kCLOCK_Can2, kCLOCK_Can3 \ + } + +/*! @brief Clock ip name array for FLEXCAN Peripheral clock. */ +#define FLEXCAN_PERIPH_CLOCKS \ + { \ + kCLOCK_IpInvalid, kCLOCK_Can1S, kCLOCK_Can2S, kCLOCK_Can3S \ + } + +/*! @brief Clock ip name array for FLEXIO. */ +#define FLEXIO_CLOCKS \ + { \ + kCLOCK_IpInvalid, kCLOCK_Flexio1, kCLOCK_Flexio2, kCLOCK_Flexio3 \ + } + +/*! @brief Clock ip name array for FLEXRAM. */ +#define FLEXRAM_CLOCKS \ + { \ + kCLOCK_FlexRam \ + } + +/*! @brief Clock ip name array for FLEXSPI. */ +#define FLEXSPI_CLOCKS \ + { \ + kCLOCK_FlexSpi, kCLOCK_IpInvalid, kCLOCK_FlexSpi2 \ + } + +/*! @brief Clock ip name array for FLEXSPI EXSC. */ +#define FLEXSPI_EXSC_CLOCKS \ + { \ + kCLOCK_FlexSpiExsc \ + } + +/*! @brief Clock ip name array for GPIO. */ +#define GPIO_CLOCKS \ + { \ + kCLOCK_IpInvalid, kCLOCK_Gpio1, kCLOCK_Gpio2, kCLOCK_Gpio3, kCLOCK_Gpio4, kCLOCK_Gpio5 \ + } + +/*! @brief Clock ip name array for GPT. */ +#define GPT_CLOCKS \ + { \ + kCLOCK_IpInvalid, kCLOCK_Gpt1, kCLOCK_Gpt2 \ + } + +/*! @brief Clock ip name array for KPP. */ +#define KPP_CLOCKS \ + { \ + kCLOCK_Kpp \ + } + +/*! @brief Clock ip name array for LCDIF. */ +#define LCDIF_CLOCKS \ + { \ + kCLOCK_Lcd \ + } + +/*! @brief Clock ip name array for LCDIF PIXEL. */ +#define LCDIF_PERIPH_CLOCKS \ + { \ + kCLOCK_LcdPixel \ + } + +/*! @brief Clock ip name array for LPI2C. */ +#define LPI2C_CLOCKS \ + { \ + kCLOCK_IpInvalid, kCLOCK_Lpi2c1, kCLOCK_Lpi2c2, kCLOCK_Lpi2c3, kCLOCK_Lpi2c4 \ + } + +/*! @brief Clock ip name array for LPSPI. */ +#define LPSPI_CLOCKS \ + { \ + kCLOCK_IpInvalid, kCLOCK_Lpspi1, kCLOCK_Lpspi2, kCLOCK_Lpspi3, kCLOCK_Lpspi4 \ + } + +/*! @brief Clock ip name array for LPUART. */ +#define LPUART_CLOCKS \ + { \ + kCLOCK_IpInvalid, kCLOCK_Lpuart1, kCLOCK_Lpuart2, kCLOCK_Lpuart3, kCLOCK_Lpuart4, kCLOCK_Lpuart5, \ + kCLOCK_Lpuart6, kCLOCK_Lpuart7, kCLOCK_Lpuart8 \ + } + +/*! @brief Clock ip name array for MQS. */ +#define MQS_CLOCKS \ + { \ + kCLOCK_Mqs \ + } + +/*! @brief Clock ip name array for OCRAM EXSC. */ +#define OCRAM_EXSC_CLOCKS \ + { \ + kCLOCK_OcramExsc \ + } + +/*! @brief Clock ip name array for PIT. */ +#define PIT_CLOCKS \ + { \ + kCLOCK_Pit \ + } + +/*! @brief Clock ip name array for PWM. */ +#define PWM_CLOCKS \ + { \ + { \ + kCLOCK_IpInvalid, kCLOCK_IpInvalid, kCLOCK_IpInvalid, kCLOCK_IpInvalid \ + } \ + , {kCLOCK_Pwm1, kCLOCK_Pwm1, kCLOCK_Pwm1, kCLOCK_Pwm1}, {kCLOCK_Pwm2, kCLOCK_Pwm2, kCLOCK_Pwm2, kCLOCK_Pwm2}, \ + {kCLOCK_Pwm3, kCLOCK_Pwm3, kCLOCK_Pwm3, kCLOCK_Pwm3}, \ + { \ + kCLOCK_Pwm4, kCLOCK_Pwm4, kCLOCK_Pwm4, kCLOCK_Pwm4 \ + } \ + } + +/*! @brief Clock ip name array for PXP. */ +#define PXP_CLOCKS \ + { \ + kCLOCK_Pxp \ + } + +/*! @brief Clock ip name array for RTWDOG. */ +#define RTWDOG_CLOCKS \ + { \ + kCLOCK_Wdog3 \ + } + +/*! @brief Clock ip name array for SAI. */ +#define SAI_CLOCKS \ + { \ + kCLOCK_IpInvalid, kCLOCK_Sai1, kCLOCK_Sai2, kCLOCK_Sai3 \ + } + +/*! @brief Clock ip name array for SEMC. */ +#define SEMC_CLOCKS \ + { \ + kCLOCK_Semc \ + } + +/*! @brief Clock ip name array for SEMC EXSC. */ +#define SEMC_EXSC_CLOCKS \ + { \ + kCLOCK_SemcExsc \ + } + +/*! @brief Clock ip name array for QTIMER. */ +#define TMR_CLOCKS \ + { \ + kCLOCK_IpInvalid, kCLOCK_Timer1, kCLOCK_Timer2, kCLOCK_Timer3, kCLOCK_Timer4 \ + } + +/*! @brief Clock ip name array for TRNG. */ +#define TRNG_CLOCKS \ + { \ + kCLOCK_Trng \ + } + +/*! @brief Clock ip name array for TSC. */ +#define TSC_CLOCKS \ + { \ + kCLOCK_Tsc \ + } + +/*! @brief Clock ip name array for WDOG. */ +#define WDOG_CLOCKS \ + { \ + kCLOCK_IpInvalid, kCLOCK_Wdog1, kCLOCK_Wdog2 \ + } + +/*! @brief Clock ip name array for USDHC. */ +#define USDHC_CLOCKS \ + { \ + kCLOCK_IpInvalid, kCLOCK_Usdhc1, kCLOCK_Usdhc2 \ + } + +/*! @brief Clock ip name array for SPDIF. */ +#define SPDIF_CLOCKS \ + { \ + kCLOCK_Spdif \ + } + +/*! @brief Clock ip name array for XBARA. */ +#define XBARA_CLOCKS \ + { \ + kCLOCK_Xbar1 \ + } + +/*! @brief Clock ip name array for XBARB. */ +#define XBARB_CLOCKS \ + { \ + kCLOCK_IpInvalid, kCLOCK_IpInvalid, kCLOCK_Xbar2, kCLOCK_Xbar3 \ + } + +/*! @brief Clock name used to get clock frequency. */ +typedef enum _clock_name +{ + kCLOCK_CpuClk = 0x0U, /*!< CPU clock */ + kCLOCK_AhbClk = 0x1U, /*!< AHB clock */ + kCLOCK_SemcClk = 0x2U, /*!< SEMC clock */ + kCLOCK_IpgClk = 0x3U, /*!< IPG clock */ + kCLOCK_PerClk = 0x4U, /*!< PER clock */ + + kCLOCK_OscClk = 0x5U, /*!< OSC clock selected by PMU_LOWPWR_CTRL[OSC_SEL]. */ + kCLOCK_RtcClk = 0x6U, /*!< RTC clock. (RTCCLK) */ + + kCLOCK_ArmPllClk = 0x7U, /*!< ARMPLLCLK. */ + + kCLOCK_Usb1PllClk = 0x8U, /*!< USB1PLLCLK. */ + kCLOCK_Usb1PllPfd0Clk = 0x9U, /*!< USB1PLLPDF0CLK. */ + kCLOCK_Usb1PllPfd1Clk = 0xAU, /*!< USB1PLLPFD1CLK. */ + kCLOCK_Usb1PllPfd2Clk = 0xBU, /*!< USB1PLLPFD2CLK. */ + kCLOCK_Usb1PllPfd3Clk = 0xCU, /*!< USB1PLLPFD3CLK. */ + + kCLOCK_Usb2PllClk = 0xDU, /*!< USB2PLLCLK. */ + + kCLOCK_SysPllClk = 0xEU, /*!< SYSPLLCLK. */ + kCLOCK_SysPllPfd0Clk = 0xFU, /*!< SYSPLLPDF0CLK. */ + kCLOCK_SysPllPfd1Clk = 0x10U, /*!< SYSPLLPFD1CLK. */ + kCLOCK_SysPllPfd2Clk = 0x11U, /*!< SYSPLLPFD2CLK. */ + kCLOCK_SysPllPfd3Clk = 0x12U, /*!< SYSPLLPFD3CLK. */ + + kCLOCK_EnetPll0Clk = 0x13U, /*!< Enet PLLCLK ref_enetpll0. */ + kCLOCK_EnetPll1Clk = 0x14U, /*!< Enet PLLCLK ref_enetpll1. */ + kCLOCK_EnetPll2Clk = 0x15U, /*!< Enet PLLCLK ref_enetpll2. */ + + kCLOCK_AudioPllClk = 0x16U, /*!< Audio PLLCLK. */ + kCLOCK_VideoPllClk = 0x17U, /*!< Video PLLCLK. */ +} clock_name_t; + +#define kCLOCK_CoreSysClk kCLOCK_CpuClk /*!< For compatible with other platforms without CCM. */ +#define CLOCK_GetCoreSysClkFreq CLOCK_GetCpuClkFreq /*!< For compatible with other platforms without CCM. */ + +/*! + * @brief CCM CCGR gate control for each module independently. + */ +typedef enum _clock_ip_name +{ + kCLOCK_IpInvalid = -1, + + /* CCM CCGR0 */ + kCLOCK_Aips_tz1 = (0U << 8U) | CCM_CCGR0_CG0_SHIFT, /*!< CCGR0, CG0 */ + kCLOCK_Aips_tz2 = (0U << 8U) | CCM_CCGR0_CG1_SHIFT, /*!< CCGR0, CG1 */ + kCLOCK_Mqs = (0U << 8U) | CCM_CCGR0_CG2_SHIFT, /*!< CCGR0, CG2 */ + kCLOCK_FlexSpiExsc = (0U << 8U) | CCM_CCGR0_CG3_SHIFT, /*!< CCGR0, CG3 */ + kCLOCK_Sim_M_Main = (0U << 8U) | CCM_CCGR0_CG4_SHIFT, /*!< CCGR0, CG4 */ + kCLOCK_Dcp = (0U << 8U) | CCM_CCGR0_CG5_SHIFT, /*!< CCGR0, CG5 */ + kCLOCK_Lpuart3 = (0U << 8U) | CCM_CCGR0_CG6_SHIFT, /*!< CCGR0, CG6 */ + kCLOCK_Can1 = (0U << 8U) | CCM_CCGR0_CG7_SHIFT, /*!< CCGR0, CG7 */ + kCLOCK_Can1S = (0U << 8U) | CCM_CCGR0_CG8_SHIFT, /*!< CCGR0, CG8 */ + kCLOCK_Can2 = (0U << 8U) | CCM_CCGR0_CG9_SHIFT, /*!< CCGR0, CG9 */ + kCLOCK_Can2S = (0U << 8U) | CCM_CCGR0_CG10_SHIFT, /*!< CCGR0, CG10 */ + kCLOCK_Trace = (0U << 8U) | CCM_CCGR0_CG11_SHIFT, /*!< CCGR0, CG11 */ + kCLOCK_Gpt2 = (0U << 8U) | CCM_CCGR0_CG12_SHIFT, /*!< CCGR0, CG12 */ + kCLOCK_Gpt2S = (0U << 8U) | CCM_CCGR0_CG13_SHIFT, /*!< CCGR0, CG13 */ + kCLOCK_Lpuart2 = (0U << 8U) | CCM_CCGR0_CG14_SHIFT, /*!< CCGR0, CG14 */ + kCLOCK_Gpio2 = (0U << 8U) | CCM_CCGR0_CG15_SHIFT, /*!< CCGR0, CG15 */ + + /* CCM CCGR1 */ + kCLOCK_Lpspi1 = (1U << 8U) | CCM_CCGR1_CG0_SHIFT, /*!< CCGR1, CG0 */ + kCLOCK_Lpspi2 = (1U << 8U) | CCM_CCGR1_CG1_SHIFT, /*!< CCGR1, CG1 */ + kCLOCK_Lpspi3 = (1U << 8U) | CCM_CCGR1_CG2_SHIFT, /*!< CCGR1, CG2 */ + kCLOCK_Lpspi4 = (1U << 8U) | CCM_CCGR1_CG3_SHIFT, /*!< CCGR1, CG3 */ + kCLOCK_Adc2 = (1U << 8U) | CCM_CCGR1_CG4_SHIFT, /*!< CCGR1, CG4 */ + kCLOCK_Enet = (1U << 8U) | CCM_CCGR1_CG5_SHIFT, /*!< CCGR1, CG5 */ + kCLOCK_Pit = (1U << 8U) | CCM_CCGR1_CG6_SHIFT, /*!< CCGR1, CG6 */ + kCLOCK_Aoi2 = (1U << 8U) | CCM_CCGR1_CG7_SHIFT, /*!< CCGR1, CG7 */ + kCLOCK_Adc1 = (1U << 8U) | CCM_CCGR1_CG8_SHIFT, /*!< CCGR1, CG8 */ + kCLOCK_SemcExsc = (1U << 8U) | CCM_CCGR1_CG9_SHIFT, /*!< CCGR1, CG9 */ + kCLOCK_Gpt1 = (1U << 8U) | CCM_CCGR1_CG10_SHIFT, /*!< CCGR1, CG10 */ + kCLOCK_Gpt1S = (1U << 8U) | CCM_CCGR1_CG11_SHIFT, /*!< CCGR1, CG11 */ + kCLOCK_Lpuart4 = (1U << 8U) | CCM_CCGR1_CG12_SHIFT, /*!< CCGR1, CG12 */ + kCLOCK_Gpio1 = (1U << 8U) | CCM_CCGR1_CG13_SHIFT, /*!< CCGR1, CG13 */ + kCLOCK_Csu = (1U << 8U) | CCM_CCGR1_CG14_SHIFT, /*!< CCGR1, CG14 */ + kCLOCK_Gpio5 = (1U << 8U) | CCM_CCGR1_CG15_SHIFT, /*!< CCGR1, CG15 */ + + /* CCM CCGR2 */ + kCLOCK_OcramExsc = (2U << 8U) | CCM_CCGR2_CG0_SHIFT, /*!< CCGR2, CG0 */ + kCLOCK_Csi = (2U << 8U) | CCM_CCGR2_CG1_SHIFT, /*!< CCGR2, CG1 */ + kCLOCK_IomuxcSnvs = (2U << 8U) | CCM_CCGR2_CG2_SHIFT, /*!< CCGR2, CG2 */ + kCLOCK_Lpi2c1 = (2U << 8U) | CCM_CCGR2_CG3_SHIFT, /*!< CCGR2, CG3 */ + kCLOCK_Lpi2c2 = (2U << 8U) | CCM_CCGR2_CG4_SHIFT, /*!< CCGR2, CG4 */ + kCLOCK_Lpi2c3 = (2U << 8U) | CCM_CCGR2_CG5_SHIFT, /*!< CCGR2, CG5 */ + kCLOCK_Ocotp = (2U << 8U) | CCM_CCGR2_CG6_SHIFT, /*!< CCGR2, CG6 */ + kCLOCK_Xbar3 = (2U << 8U) | CCM_CCGR2_CG7_SHIFT, /*!< CCGR2, CG7 */ + kCLOCK_Ipmux1 = (2U << 8U) | CCM_CCGR2_CG8_SHIFT, /*!< CCGR2, CG8 */ + kCLOCK_Ipmux2 = (2U << 8U) | CCM_CCGR2_CG9_SHIFT, /*!< CCGR2, CG9 */ + kCLOCK_Ipmux3 = (2U << 8U) | CCM_CCGR2_CG10_SHIFT, /*!< CCGR2, CG10 */ + kCLOCK_Xbar1 = (2U << 8U) | CCM_CCGR2_CG11_SHIFT, /*!< CCGR2, CG11 */ + kCLOCK_Xbar2 = (2U << 8U) | CCM_CCGR2_CG12_SHIFT, /*!< CCGR2, CG12 */ + kCLOCK_Gpio3 = (2U << 8U) | CCM_CCGR2_CG13_SHIFT, /*!< CCGR2, CG13 */ + kCLOCK_Lcd = (2U << 8U) | CCM_CCGR2_CG14_SHIFT, /*!< CCGR2, CG14 */ + kCLOCK_Pxp = (2U << 8U) | CCM_CCGR2_CG15_SHIFT, /*!< CCGR2, CG15 */ + + /* CCM CCGR3 */ + kCLOCK_Flexio2 = (3U << 8U) | CCM_CCGR3_CG0_SHIFT, /*!< CCGR3, CG0 */ + kCLOCK_Lpuart5 = (3U << 8U) | CCM_CCGR3_CG1_SHIFT, /*!< CCGR3, CG1 */ + kCLOCK_Semc = (3U << 8U) | CCM_CCGR3_CG2_SHIFT, /*!< CCGR3, CG2 */ + kCLOCK_Lpuart6 = (3U << 8U) | CCM_CCGR3_CG3_SHIFT, /*!< CCGR3, CG3 */ + kCLOCK_Aoi1 = (3U << 8U) | CCM_CCGR3_CG4_SHIFT, /*!< CCGR3, CG4 */ + kCLOCK_LcdPixel = (3U << 8U) | CCM_CCGR3_CG5_SHIFT, /*!< CCGR3, CG5 */ + kCLOCK_Gpio4 = (3U << 8U) | CCM_CCGR3_CG6_SHIFT, /*!< CCGR3, CG6 */ + kCLOCK_Ewm0 = (3U << 8U) | CCM_CCGR3_CG7_SHIFT, /*!< CCGR3, CG7 */ + kCLOCK_Wdog1 = (3U << 8U) | CCM_CCGR3_CG8_SHIFT, /*!< CCGR3, CG8 */ + kCLOCK_FlexRam = (3U << 8U) | CCM_CCGR3_CG9_SHIFT, /*!< CCGR3, CG9 */ + kCLOCK_Acmp1 = (3U << 8U) | CCM_CCGR3_CG10_SHIFT, /*!< CCGR3, CG10 */ + kCLOCK_Acmp2 = (3U << 8U) | CCM_CCGR3_CG11_SHIFT, /*!< CCGR3, CG11 */ + kCLOCK_Acmp3 = (3U << 8U) | CCM_CCGR3_CG12_SHIFT, /*!< CCGR3, CG12 */ + kCLOCK_Acmp4 = (3U << 8U) | CCM_CCGR3_CG13_SHIFT, /*!< CCGR3, CG13 */ + kCLOCK_Ocram = (3U << 8U) | CCM_CCGR3_CG14_SHIFT, /*!< CCGR3, CG14 */ + kCLOCK_IomuxcSnvsGpr = (3U << 8U) | CCM_CCGR3_CG15_SHIFT, /*!< CCGR3, CG15 */ + + /* CCM CCGR4 */ + kCLOCK_Iomuxc = (4U << 8U) | CCM_CCGR4_CG1_SHIFT, /*!< CCGR4, CG1 */ + kCLOCK_IomuxcGpr = (4U << 8U) | CCM_CCGR4_CG2_SHIFT, /*!< CCGR4, CG2 */ + kCLOCK_Bee = (4U << 8U) | CCM_CCGR4_CG3_SHIFT, /*!< CCGR4, CG3 */ + kCLOCK_SimM7 = (4U << 8U) | CCM_CCGR4_CG4_SHIFT, /*!< CCGR4, CG4 */ + kCLOCK_Tsc = (4U << 8U) | CCM_CCGR4_CG5_SHIFT, /*!< CCGR4, CG5 */ + kCLOCK_SimM = (4U << 8U) | CCM_CCGR4_CG6_SHIFT, /*!< CCGR4, CG6 */ + kCLOCK_SimEms = (4U << 8U) | CCM_CCGR4_CG7_SHIFT, /*!< CCGR4, CG7 */ + kCLOCK_Pwm1 = (4U << 8U) | CCM_CCGR4_CG8_SHIFT, /*!< CCGR4, CG8 */ + kCLOCK_Pwm2 = (4U << 8U) | CCM_CCGR4_CG9_SHIFT, /*!< CCGR4, CG9 */ + kCLOCK_Pwm3 = (4U << 8U) | CCM_CCGR4_CG10_SHIFT, /*!< CCGR4, CG10 */ + kCLOCK_Pwm4 = (4U << 8U) | CCM_CCGR4_CG11_SHIFT, /*!< CCGR4, CG11 */ + kCLOCK_Enc1 = (4U << 8U) | CCM_CCGR4_CG12_SHIFT, /*!< CCGR4, CG12 */ + kCLOCK_Enc2 = (4U << 8U) | CCM_CCGR4_CG13_SHIFT, /*!< CCGR4, CG13 */ + kCLOCK_Enc3 = (4U << 8U) | CCM_CCGR4_CG14_SHIFT, /*!< CCGR4, CG14 */ + kCLOCK_Enc4 = (4U << 8U) | CCM_CCGR4_CG15_SHIFT, /*!< CCGR4, CG15 */ + + /* CCM CCGR5 */ + kCLOCK_Rom = (5U << 8U) | CCM_CCGR5_CG0_SHIFT, /*!< CCGR5, CG0 */ + kCLOCK_Flexio1 = (5U << 8U) | CCM_CCGR5_CG1_SHIFT, /*!< CCGR5, CG1 */ + kCLOCK_Wdog3 = (5U << 8U) | CCM_CCGR5_CG2_SHIFT, /*!< CCGR5, CG2 */ + kCLOCK_Dma = (5U << 8U) | CCM_CCGR5_CG3_SHIFT, /*!< CCGR5, CG3 */ + kCLOCK_Kpp = (5U << 8U) | CCM_CCGR5_CG4_SHIFT, /*!< CCGR5, CG4 */ + kCLOCK_Wdog2 = (5U << 8U) | CCM_CCGR5_CG5_SHIFT, /*!< CCGR5, CG5 */ + kCLOCK_Aips_tz4 = (5U << 8U) | CCM_CCGR5_CG6_SHIFT, /*!< CCGR5, CG6 */ + kCLOCK_Spdif = (5U << 8U) | CCM_CCGR5_CG7_SHIFT, /*!< CCGR5, CG7 */ + kCLOCK_SimMain = (5U << 8U) | CCM_CCGR5_CG8_SHIFT, /*!< CCGR5, CG8 */ + kCLOCK_Sai1 = (5U << 8U) | CCM_CCGR5_CG9_SHIFT, /*!< CCGR5, CG9 */ + kCLOCK_Sai2 = (5U << 8U) | CCM_CCGR5_CG10_SHIFT, /*!< CCGR5, CG10 */ + kCLOCK_Sai3 = (5U << 8U) | CCM_CCGR5_CG11_SHIFT, /*!< CCGR5, CG11 */ + kCLOCK_Lpuart1 = (5U << 8U) | CCM_CCGR5_CG12_SHIFT, /*!< CCGR5, CG12 */ + kCLOCK_Lpuart7 = (5U << 8U) | CCM_CCGR5_CG13_SHIFT, /*!< CCGR5, CG13 */ + kCLOCK_SnvsHp = (5U << 8U) | CCM_CCGR5_CG14_SHIFT, /*!< CCGR5, CG14 */ + kCLOCK_SnvsLp = (5U << 8U) | CCM_CCGR5_CG15_SHIFT, /*!< CCGR5, CG15 */ + + /* CCM CCGR6 */ + kCLOCK_UsbOh3 = (6U << 8U) | CCM_CCGR6_CG0_SHIFT, /*!< CCGR6, CG0 */ + kCLOCK_Usdhc1 = (6U << 8U) | CCM_CCGR6_CG1_SHIFT, /*!< CCGR6, CG1 */ + kCLOCK_Usdhc2 = (6U << 8U) | CCM_CCGR6_CG2_SHIFT, /*!< CCGR6, CG2 */ + kCLOCK_Dcdc = (6U << 8U) | CCM_CCGR6_CG3_SHIFT, /*!< CCGR6, CG3 */ + kCLOCK_Ipmux4 = (6U << 8U) | CCM_CCGR6_CG4_SHIFT, /*!< CCGR6, CG4 */ + kCLOCK_FlexSpi = (6U << 8U) | CCM_CCGR6_CG5_SHIFT, /*!< CCGR6, CG5 */ + kCLOCK_Trng = (6U << 8U) | CCM_CCGR6_CG6_SHIFT, /*!< CCGR6, CG6 */ + kCLOCK_Lpuart8 = (6U << 8U) | CCM_CCGR6_CG7_SHIFT, /*!< CCGR6, CG7 */ + kCLOCK_Timer4 = (6U << 8U) | CCM_CCGR6_CG8_SHIFT, /*!< CCGR6, CG8 */ + kCLOCK_Aips_tz3 = (6U << 8U) | CCM_CCGR6_CG9_SHIFT, /*!< CCGR6, CG9 */ + kCLOCK_SimPer = (6U << 8U) | CCM_CCGR6_CG10_SHIFT, /*!< CCGR6, CG10 */ + kCLOCK_Anadig = (6U << 8U) | CCM_CCGR6_CG11_SHIFT, /*!< CCGR6, CG11 */ + kCLOCK_Lpi2c4 = (6U << 8U) | CCM_CCGR6_CG12_SHIFT, /*!< CCGR6, CG12 */ + kCLOCK_Timer1 = (6U << 8U) | CCM_CCGR6_CG13_SHIFT, /*!< CCGR6, CG13 */ + kCLOCK_Timer2 = (6U << 8U) | CCM_CCGR6_CG14_SHIFT, /*!< CCGR6, CG14 */ + kCLOCK_Timer3 = (6U << 8U) | CCM_CCGR6_CG15_SHIFT, /*!< CCGR6, CG15 */ + + /* CCM CCGR7 */ + kCLOCK_Enet2 = (7U << 8U) | CCM_CCGR7_CG0_SHIFT, /*!< CCGR7, CG0 */ + kCLOCK_FlexSpi2 = (7U << 8U) | CCM_CCGR7_CG1_SHIFT, /*!< CCGR7, CG1 */ + kCLOCK_Axbs_l = (7U << 8U) | CCM_CCGR7_CG2_SHIFT, /*!< CCGR7, CG2 */ + kCLOCK_Can3 = (7U << 8U) | CCM_CCGR7_CG3_SHIFT, /*!< CCGR7, CG3 */ + kCLOCK_Can3S = (7U << 8U) | CCM_CCGR7_CG4_SHIFT, /*!< CCGR7, CG4 */ + kCLOCK_Aips_lite = (7U << 8U) | CCM_CCGR7_CG5_SHIFT, /*!< CCGR7, CG5 */ + kCLOCK_Flexio3 = (7U << 8U) | CCM_CCGR7_CG6_SHIFT, /*!< CCGR7, CG6 */ + +} clock_ip_name_t; + +/*! @brief OSC 24M sorce select */ +typedef enum _clock_osc +{ + kCLOCK_RcOsc = 0U, /*!< On chip OSC. */ + kCLOCK_XtalOsc = 1U, /*!< 24M Xtal OSC */ +} clock_osc_t; + +/*! @brief Clock gate value */ +typedef enum _clock_gate_value +{ + kCLOCK_ClockNotNeeded = 0U, /*!< Clock is off during all modes. */ + kCLOCK_ClockNeededRun = 1U, /*!< Clock is on in run mode, but off in WAIT and STOP modes */ + kCLOCK_ClockNeededRunWait = 3U, /*!< Clock is on during all modes, except STOP mode */ +} clock_gate_value_t; + +/*! @brief System clock mode */ +typedef enum _clock_mode_t +{ + kCLOCK_ModeRun = 0U, /*!< Remain in run mode. */ + kCLOCK_ModeWait = 1U, /*!< Transfer to wait mode. */ + kCLOCK_ModeStop = 2U, /*!< Transfer to stop mode. */ +} clock_mode_t; + +/*! + * @brief MUX control names for clock mux setting. + * + * These constants define the mux control names for clock mux setting.\n + * - 0:7: REG offset to CCM_BASE in bytes. + * - 8:15: Root clock setting bit field shift. + * - 16:31: Root clock setting bit field width. + */ +typedef enum _clock_mux +{ + kCLOCK_Pll3SwMux = CCM_TUPLE(CCSR_OFFSET, + CCM_CCSR_PLL3_SW_CLK_SEL_SHIFT, + CCM_CCSR_PLL3_SW_CLK_SEL_MASK, + CCM_NO_BUSY_WAIT), /*!< pll3_sw_clk mux name */ + + kCLOCK_PeriphMux = CCM_TUPLE(CBCDR_OFFSET, + CCM_CBCDR_PERIPH_CLK_SEL_SHIFT, + CCM_CBCDR_PERIPH_CLK_SEL_MASK, + CCM_CDHIPR_PERIPH_CLK_SEL_BUSY_SHIFT), /*!< periph mux name */ + kCLOCK_SemcAltMux = CCM_TUPLE(CBCDR_OFFSET, + CCM_CBCDR_SEMC_ALT_CLK_SEL_SHIFT, + CCM_CBCDR_SEMC_ALT_CLK_SEL_MASK, + CCM_NO_BUSY_WAIT), /*!< semc mux name */ + kCLOCK_SemcMux = CCM_TUPLE(CBCDR_OFFSET, + CCM_CBCDR_SEMC_CLK_SEL_SHIFT, + CCM_CBCDR_SEMC_CLK_SEL_MASK, + CCM_NO_BUSY_WAIT), /*!< semc mux name */ + + kCLOCK_PrePeriphMux = CCM_TUPLE(CBCMR_OFFSET, + CCM_CBCMR_PRE_PERIPH_CLK_SEL_SHIFT, + CCM_CBCMR_PRE_PERIPH_CLK_SEL_MASK, + CCM_NO_BUSY_WAIT), /*!< pre-periph mux name */ + kCLOCK_TraceMux = CCM_TUPLE(CBCMR_OFFSET, + CCM_CBCMR_TRACE_CLK_SEL_SHIFT, + CCM_CBCMR_TRACE_CLK_SEL_MASK, + CCM_NO_BUSY_WAIT), /*!< trace mux name */ + kCLOCK_PeriphClk2Mux = CCM_TUPLE(CBCMR_OFFSET, + CCM_CBCMR_PERIPH_CLK2_SEL_SHIFT, + CCM_CBCMR_PERIPH_CLK2_SEL_MASK, + CCM_NO_BUSY_WAIT), /*!< periph clock2 mux name */ + kCLOCK_Flexspi2Mux = CCM_TUPLE(CBCMR_OFFSET, + CCM_CBCMR_FLEXSPI2_CLK_SEL_SHIFT, + CCM_CBCMR_FLEXSPI2_CLK_SEL_MASK, + CCM_NO_BUSY_WAIT), /*!< flexspi2 mux name */ + kCLOCK_LpspiMux = CCM_TUPLE(CBCMR_OFFSET, + CCM_CBCMR_LPSPI_CLK_SEL_SHIFT, + CCM_CBCMR_LPSPI_CLK_SEL_MASK, + CCM_NO_BUSY_WAIT), /*!< lpspi mux name */ + + kCLOCK_FlexspiMux = CCM_TUPLE(CSCMR1_OFFSET, + CCM_CSCMR1_FLEXSPI_CLK_SEL_SHIFT, + CCM_CSCMR1_FLEXSPI_CLK_SEL_MASK, + CCM_NO_BUSY_WAIT), /*!< flexspi mux name */ + kCLOCK_Usdhc2Mux = CCM_TUPLE(CSCMR1_OFFSET, + CCM_CSCMR1_USDHC2_CLK_SEL_SHIFT, + CCM_CSCMR1_USDHC2_CLK_SEL_MASK, + CCM_NO_BUSY_WAIT), /*!< usdhc2 mux name */ + kCLOCK_Usdhc1Mux = CCM_TUPLE(CSCMR1_OFFSET, + CCM_CSCMR1_USDHC1_CLK_SEL_SHIFT, + CCM_CSCMR1_USDHC1_CLK_SEL_MASK, + CCM_NO_BUSY_WAIT), /*!< usdhc1 mux name */ + kCLOCK_Sai3Mux = CCM_TUPLE(CSCMR1_OFFSET, + CCM_CSCMR1_SAI3_CLK_SEL_SHIFT, + CCM_CSCMR1_SAI3_CLK_SEL_MASK, + CCM_NO_BUSY_WAIT), /*!< sai3 mux name */ + kCLOCK_Sai2Mux = CCM_TUPLE(CSCMR1_OFFSET, + CCM_CSCMR1_SAI2_CLK_SEL_SHIFT, + CCM_CSCMR1_SAI2_CLK_SEL_MASK, + CCM_NO_BUSY_WAIT), /*!< sai2 mux name */ + kCLOCK_Sai1Mux = CCM_TUPLE(CSCMR1_OFFSET, + CCM_CSCMR1_SAI1_CLK_SEL_SHIFT, + CCM_CSCMR1_SAI1_CLK_SEL_MASK, + CCM_NO_BUSY_WAIT), /*!< sai1 mux name */ + kCLOCK_PerclkMux = CCM_TUPLE(CSCMR1_OFFSET, + CCM_CSCMR1_PERCLK_CLK_SEL_SHIFT, + CCM_CSCMR1_PERCLK_CLK_SEL_MASK, + CCM_NO_BUSY_WAIT), /*!< perclk mux name */ + + kCLOCK_Flexio2Mux = CCM_TUPLE(CSCMR2_OFFSET, + CCM_CSCMR2_FLEXIO2_CLK_SEL_SHIFT, + CCM_CSCMR2_FLEXIO2_CLK_SEL_MASK, + CCM_NO_BUSY_WAIT), /*!< flexio2 mux name */ + kCLOCK_CanMux = CCM_TUPLE(CSCMR2_OFFSET, + CCM_CSCMR2_CAN_CLK_SEL_SHIFT, + CCM_CSCMR2_CAN_CLK_SEL_MASK, + CCM_NO_BUSY_WAIT), /*!< can mux name */ + + kCLOCK_UartMux = CCM_TUPLE(CSCDR1_OFFSET, + CCM_CSCDR1_UART_CLK_SEL_SHIFT, + CCM_CSCDR1_UART_CLK_SEL_MASK, + CCM_NO_BUSY_WAIT), /*!< uart mux name */ + + kCLOCK_SpdifMux = CCM_TUPLE(CDCDR_OFFSET, + CCM_CDCDR_SPDIF0_CLK_SEL_SHIFT, + CCM_CDCDR_SPDIF0_CLK_SEL_MASK, + CCM_NO_BUSY_WAIT), /*!< spdif mux name */ + kCLOCK_Flexio1Mux = CCM_TUPLE(CDCDR_OFFSET, + CCM_CDCDR_FLEXIO1_CLK_SEL_SHIFT, + CCM_CDCDR_FLEXIO1_CLK_SEL_MASK, + CCM_NO_BUSY_WAIT), /*!< flexio1 mux name */ + + kCLOCK_Lpi2cMux = CCM_TUPLE(CSCDR2_OFFSET, + CCM_CSCDR2_LPI2C_CLK_SEL_SHIFT, + CCM_CSCDR2_LPI2C_CLK_SEL_MASK, + CCM_NO_BUSY_WAIT), /*!< lpi2c mux name */ + kCLOCK_LcdifPreMux = CCM_TUPLE(CSCDR2_OFFSET, + CCM_CSCDR2_LCDIF_PRE_CLK_SEL_SHIFT, + CCM_CSCDR2_LCDIF_PRE_CLK_SEL_MASK, + CCM_NO_BUSY_WAIT), /*!< lcdif pre mux name */ + + kCLOCK_CsiMux = CCM_TUPLE(CSCDR3_OFFSET, + CCM_CSCDR3_CSI_CLK_SEL_SHIFT, + CCM_CSCDR3_CSI_CLK_SEL_MASK, + CCM_NO_BUSY_WAIT), /*!< csi mux name */ +} clock_mux_t; + +/*! + * @brief DIV control names for clock div setting. + * + * These constants define div control names for clock div setting.\n + * - 0:7: REG offset to CCM_BASE in bytes. + * - 8:15: Root clock setting bit field shift. + * - 16:31: Root clock setting bit field width. + */ +typedef enum _clock_div +{ + kCLOCK_ArmDiv = CCM_TUPLE(CACRR_OFFSET, + CCM_CACRR_ARM_PODF_SHIFT, + CCM_CACRR_ARM_PODF_MASK, + CCM_CDHIPR_ARM_PODF_BUSY_SHIFT), /*!< core div name */ + + kCLOCK_PeriphClk2Div = CCM_TUPLE(CBCDR_OFFSET, + CCM_CBCDR_PERIPH_CLK2_PODF_SHIFT, + CCM_CBCDR_PERIPH_CLK2_PODF_MASK, + CCM_NO_BUSY_WAIT), /*!< periph clock2 div name */ + kCLOCK_SemcDiv = CCM_TUPLE(CBCDR_OFFSET, + CCM_CBCDR_SEMC_PODF_SHIFT, + CCM_CBCDR_SEMC_PODF_MASK, + CCM_CDHIPR_SEMC_PODF_BUSY_SHIFT), /*!< semc div name */ + kCLOCK_AhbDiv = CCM_TUPLE(CBCDR_OFFSET, + CCM_CBCDR_AHB_PODF_SHIFT, + CCM_CBCDR_AHB_PODF_MASK, + CCM_CDHIPR_AHB_PODF_BUSY_SHIFT), /*!< ahb div name */ + kCLOCK_IpgDiv = CCM_TUPLE( + CBCDR_OFFSET, CCM_CBCDR_IPG_PODF_SHIFT, CCM_CBCDR_IPG_PODF_MASK, CCM_NO_BUSY_WAIT), /*!< ipg div name */ + + kCLOCK_Flexspi2Div = CCM_TUPLE(CBCMR_OFFSET, + CCM_CBCMR_FLEXSPI2_PODF_SHIFT, + CCM_CBCMR_FLEXSPI2_PODF_MASK, + CCM_NO_BUSY_WAIT), /*!< flexspi2 div name */ + kCLOCK_LpspiDiv = CCM_TUPLE( + CBCMR_OFFSET, CCM_CBCMR_LPSPI_PODF_SHIFT, CCM_CBCMR_LPSPI_PODF_MASK, CCM_NO_BUSY_WAIT), /*!< lpspi div name */ + kCLOCK_LcdifDiv = CCM_TUPLE( + CBCMR_OFFSET, CCM_CBCMR_LCDIF_PODF_SHIFT, CCM_CBCMR_LCDIF_PODF_MASK, CCM_NO_BUSY_WAIT), /*!< lcdif div name */ + + kCLOCK_FlexspiDiv = CCM_TUPLE(CSCMR1_OFFSET, + CCM_CSCMR1_FLEXSPI_PODF_SHIFT, + CCM_CSCMR1_FLEXSPI_PODF_MASK, + CCM_NO_BUSY_WAIT), /*!< flexspi div name */ + kCLOCK_PerclkDiv = CCM_TUPLE(CSCMR1_OFFSET, + CCM_CSCMR1_PERCLK_PODF_SHIFT, + CCM_CSCMR1_PERCLK_PODF_MASK, + CCM_NO_BUSY_WAIT), /*!< perclk div name */ + + kCLOCK_CanDiv = CCM_TUPLE(CSCMR2_OFFSET, + CCM_CSCMR2_CAN_CLK_PODF_SHIFT, + CCM_CSCMR2_CAN_CLK_PODF_MASK, + CCM_NO_BUSY_WAIT), /*!< can div name */ + + kCLOCK_TraceDiv = CCM_TUPLE(CSCDR1_OFFSET, + CCM_CSCDR1_TRACE_PODF_SHIFT, + CCM_CSCDR1_TRACE_PODF_MASK, + CCM_NO_BUSY_WAIT), /*!< trace div name */ + kCLOCK_Usdhc2Div = CCM_TUPLE(CSCDR1_OFFSET, + CCM_CSCDR1_USDHC2_PODF_SHIFT, + CCM_CSCDR1_USDHC2_PODF_MASK, + CCM_NO_BUSY_WAIT), /*!< usdhc2 div name */ + kCLOCK_Usdhc1Div = CCM_TUPLE(CSCDR1_OFFSET, + CCM_CSCDR1_USDHC1_PODF_SHIFT, + CCM_CSCDR1_USDHC1_PODF_MASK, + CCM_NO_BUSY_WAIT), /*!< usdhc1 div name */ + kCLOCK_UartDiv = CCM_TUPLE(CSCDR1_OFFSET, + CCM_CSCDR1_UART_CLK_PODF_SHIFT, + CCM_CSCDR1_UART_CLK_PODF_MASK, + CCM_NO_BUSY_WAIT), /*!< uart div name */ + + kCLOCK_Flexio2Div = CCM_TUPLE(CS1CDR_OFFSET, + CCM_CS1CDR_FLEXIO2_CLK_PODF_SHIFT, + CCM_CS1CDR_FLEXIO2_CLK_PODF_MASK, + CCM_NO_BUSY_WAIT), /*!< flexio2 pre div name */ + kCLOCK_Sai3PreDiv = CCM_TUPLE(CS1CDR_OFFSET, + CCM_CS1CDR_SAI3_CLK_PRED_SHIFT, + CCM_CS1CDR_SAI3_CLK_PRED_MASK, + CCM_NO_BUSY_WAIT), /*!< sai3 pre div name */ + kCLOCK_Sai3Div = CCM_TUPLE(CS1CDR_OFFSET, + CCM_CS1CDR_SAI3_CLK_PODF_SHIFT, + CCM_CS1CDR_SAI3_CLK_PODF_MASK, + CCM_NO_BUSY_WAIT), /*!< sai3 div name */ + kCLOCK_Flexio2PreDiv = CCM_TUPLE(CS1CDR_OFFSET, + CCM_CS1CDR_FLEXIO2_CLK_PRED_SHIFT, + CCM_CS1CDR_FLEXIO2_CLK_PRED_MASK, + CCM_NO_BUSY_WAIT), /*!< sai3 pre div name */ + kCLOCK_Sai1PreDiv = CCM_TUPLE(CS1CDR_OFFSET, + CCM_CS1CDR_SAI1_CLK_PRED_SHIFT, + CCM_CS1CDR_SAI1_CLK_PRED_MASK, + CCM_NO_BUSY_WAIT), /*!< sai1 pre div name */ + kCLOCK_Sai1Div = CCM_TUPLE(CS1CDR_OFFSET, + CCM_CS1CDR_SAI1_CLK_PODF_SHIFT, + CCM_CS1CDR_SAI1_CLK_PODF_MASK, + CCM_NO_BUSY_WAIT), /*!< sai1 div name */ + + kCLOCK_Sai2PreDiv = CCM_TUPLE(CS2CDR_OFFSET, + CCM_CS2CDR_SAI2_CLK_PRED_SHIFT, + CCM_CS2CDR_SAI2_CLK_PRED_MASK, + CCM_NO_BUSY_WAIT), /*!< sai2 pre div name */ + kCLOCK_Sai2Div = CCM_TUPLE(CS2CDR_OFFSET, + CCM_CS2CDR_SAI2_CLK_PODF_SHIFT, + CCM_CS2CDR_SAI2_CLK_PODF_MASK, + CCM_NO_BUSY_WAIT), /*!< sai2 div name */ + + kCLOCK_Spdif0PreDiv = CCM_TUPLE(CDCDR_OFFSET, + CCM_CDCDR_SPDIF0_CLK_PRED_SHIFT, + CCM_CDCDR_SPDIF0_CLK_PRED_MASK, + CCM_NO_BUSY_WAIT), /*!< spdif pre div name */ + kCLOCK_Spdif0Div = CCM_TUPLE(CDCDR_OFFSET, + CCM_CDCDR_SPDIF0_CLK_PODF_SHIFT, + CCM_CDCDR_SPDIF0_CLK_PODF_MASK, + CCM_NO_BUSY_WAIT), /*!< spdif div name */ + kCLOCK_Flexio1PreDiv = CCM_TUPLE(CDCDR_OFFSET, + CCM_CDCDR_FLEXIO1_CLK_PRED_SHIFT, + CCM_CDCDR_FLEXIO1_CLK_PRED_MASK, + CCM_NO_BUSY_WAIT), /*!< flexio1 pre div name */ + kCLOCK_Flexio1Div = CCM_TUPLE(CDCDR_OFFSET, + CCM_CDCDR_FLEXIO1_CLK_PODF_SHIFT, + CCM_CDCDR_FLEXIO1_CLK_PODF_MASK, + CCM_NO_BUSY_WAIT), /*!< flexio1 div name */ + + kCLOCK_Lpi2cDiv = CCM_TUPLE(CSCDR2_OFFSET, + CCM_CSCDR2_LPI2C_CLK_PODF_SHIFT, + CCM_CSCDR2_LPI2C_CLK_PODF_MASK, + CCM_NO_BUSY_WAIT), /*!< lpi2c div name */ + kCLOCK_LcdifPreDiv = CCM_TUPLE(CSCDR2_OFFSET, + CCM_CSCDR2_LCDIF_PRED_SHIFT, + CCM_CSCDR2_LCDIF_PRED_MASK, + CCM_NO_BUSY_WAIT), /*!< lcdif pre div name */ + + kCLOCK_CsiDiv = CCM_TUPLE( + CSCDR3_OFFSET, CCM_CSCDR3_CSI_PODF_SHIFT, CCM_CSCDR3_CSI_PODF_MASK, CCM_NO_BUSY_WAIT), /*!< csi div name */ +} clock_div_t; + +/*! @brief USB clock source definition. */ +typedef enum _clock_usb_src +{ + kCLOCK_Usb480M = 0, /*!< Use 480M. */ + kCLOCK_UsbSrcUnused = (int)0xFFFFFFFFU, /*!< Used when the function does not + care the clock source. */ +} clock_usb_src_t; + +/*! @brief Source of the USB HS PHY. */ +typedef enum _clock_usb_phy_src +{ + kCLOCK_Usbphy480M = 0, /*!< Use 480M. */ +} clock_usb_phy_src_t; + +/*!@brief PLL clock source, bypass cloco source also */ +enum _clock_pll_clk_src +{ + kCLOCK_PllClkSrc24M = 0U, /*!< Pll clock source 24M */ + kCLOCK_PllSrcClkPN = 1U, /*!< Pll clock source CLK1_P and CLK1_N */ +}; + +/*! @brief PLL configuration for ARM */ +typedef struct _clock_arm_pll_config +{ + uint32_t loopDivider; /*!< PLL loop divider. Valid range for divider value: 54-108. Fout=Fin*loopDivider/2. */ + uint8_t src; /*!< Pll clock source, reference _clock_pll_clk_src */ +} clock_arm_pll_config_t; + +/*! @brief PLL configuration for USB */ +typedef struct _clock_usb_pll_config +{ + uint8_t loopDivider; /*!< PLL loop divider. + 0 - Fout=Fref*20; + 1 - Fout=Fref*22 */ + uint8_t src; /*!< Pll clock source, reference _clock_pll_clk_src */ + +} clock_usb_pll_config_t; + +/*! @brief PLL configuration for System */ +typedef struct _clock_sys_pll_config +{ + uint8_t loopDivider; /*!< PLL loop divider. Intended to be 1 (528M). + 0 - Fout=Fref*20; + 1 - Fout=Fref*22 */ + uint32_t numerator; /*!< 30 bit numerator of fractional loop divider.*/ + uint32_t denominator; /*!< 30 bit denominator of fractional loop divider */ + uint8_t src; /*!< Pll clock source, reference _clock_pll_clk_src */ + uint16_t ss_stop; /*!< Stop value to get frequency change. */ + uint8_t ss_enable; /*!< Enable spread spectrum modulation */ + uint16_t ss_step; /*!< Step value to get frequency change step. */ +} clock_sys_pll_config_t; + +/*! @brief PLL configuration for AUDIO and VIDEO */ +typedef struct _clock_audio_pll_config +{ + uint8_t loopDivider; /*!< PLL loop divider. Valid range for DIV_SELECT divider value: 27~54. */ + uint8_t postDivider; /*!< Divider after the PLL, should only be 1, 2, 4, 8, 16. */ + uint32_t numerator; /*!< 30 bit numerator of fractional loop divider.*/ + uint32_t denominator; /*!< 30 bit denominator of fractional loop divider */ + uint8_t src; /*!< Pll clock source, reference _clock_pll_clk_src */ +} clock_audio_pll_config_t; + +/*! @brief PLL configuration for AUDIO and VIDEO */ +typedef struct _clock_video_pll_config +{ + uint8_t loopDivider; /*!< PLL loop divider. Valid range for DIV_SELECT divider value: 27~54. */ + uint8_t postDivider; /*!< Divider after the PLL, should only be 1, 2, 4, 8, 16. */ + uint32_t numerator; /*!< 30 bit numerator of fractional loop divider.*/ + uint32_t denominator; /*!< 30 bit denominator of fractional loop divider */ + uint8_t src; /*!< Pll clock source, reference _clock_pll_clk_src */ + +} clock_video_pll_config_t; + +/*! @brief PLL configuration for ENET */ +typedef struct _clock_enet_pll_config +{ + bool enableClkOutput; /*!< Power on and enable PLL clock output for ENET0 (ref_enetpll0). */ + bool enableClkOutput25M; /*!< Power on and enable PLL clock output for ENET2 (ref_enetpll2). */ + uint8_t loopDivider; /*!< Controls the frequency of the ENET0 reference clock. + b00 25MHz + b01 50MHz + b10 100MHz (not 50% duty cycle) + b11 125MHz */ + uint8_t src; /*!< Pll clock source, reference _clock_pll_clk_src */ + bool enableClkOutput1; /*!< Power on and enable PLL clock output for ENET1 (ref_enetpll1). */ + uint8_t loopDivider1; /*!< Controls the frequency of the ENET1 reference clock. + b00 25MHz + b01 50MHz + b10 100MHz (not 50% duty cycle) + b11 125MHz */ +} clock_enet_pll_config_t; + +/*! @brief PLL name */ +typedef enum _clock_pll +{ + kCLOCK_PllArm = CCM_ANALOG_TUPLE(PLL_ARM_OFFSET, CCM_ANALOG_PLL_ARM_ENABLE_SHIFT), /*!< PLL ARM */ + kCLOCK_PllSys = CCM_ANALOG_TUPLE(PLL_SYS_OFFSET, CCM_ANALOG_PLL_SYS_ENABLE_SHIFT), /*!< PLL SYS */ + kCLOCK_PllUsb1 = CCM_ANALOG_TUPLE(PLL_USB1_OFFSET, CCM_ANALOG_PLL_USB1_ENABLE_SHIFT), /*!< PLL USB1 */ + kCLOCK_PllAudio = CCM_ANALOG_TUPLE(PLL_AUDIO_OFFSET, CCM_ANALOG_PLL_AUDIO_ENABLE_SHIFT), /*!< PLL Audio */ + kCLOCK_PllVideo = CCM_ANALOG_TUPLE(PLL_VIDEO_OFFSET, CCM_ANALOG_PLL_VIDEO_ENABLE_SHIFT), /*!< PLL Video */ + + kCLOCK_PllEnet = CCM_ANALOG_TUPLE(PLL_ENET_OFFSET, CCM_ANALOG_PLL_ENET_ENABLE_SHIFT), /*!< PLL Enet0 */ + kCLOCK_PllEnet2 = CCM_ANALOG_TUPLE(PLL_ENET_OFFSET, CCM_ANALOG_PLL_ENET_ENET2_REF_EN_SHIFT), /*!< PLL Enet1 */ + kCLOCK_PllEnet25M = CCM_ANALOG_TUPLE(PLL_ENET_OFFSET, CCM_ANALOG_PLL_ENET_ENET_25M_REF_EN_SHIFT), /*!< PLL Enet2 */ + + kCLOCK_PllUsb2 = CCM_ANALOG_TUPLE(PLL_USB2_OFFSET, CCM_ANALOG_PLL_USB2_ENABLE_SHIFT), /*!< PLL USB2 */ + +} clock_pll_t; + +/*! @brief PLL PFD name */ +typedef enum _clock_pfd +{ + kCLOCK_Pfd0 = 0U, /*!< PLL PFD0 */ + kCLOCK_Pfd1 = 1U, /*!< PLL PFD1 */ + kCLOCK_Pfd2 = 2U, /*!< PLL PFD2 */ + kCLOCK_Pfd3 = 3U, /*!< PLL PFD3 */ +} clock_pfd_t; + +/******************************************************************************* + * API + ******************************************************************************/ + +#if defined(__cplusplus) +extern "C" { +#endif /* __cplusplus */ + +/*! + * @brief Set CCM MUX node to certain value. + * + * @param mux Which mux node to set, see \ref clock_mux_t. + * @param value Clock mux value to set, different mux has different value range. + */ +static inline void CLOCK_SetMux(clock_mux_t mux, uint32_t value) +{ + uint32_t busyShift; + + busyShift = CCM_TUPLE_BUSY_SHIFT(mux); + CCM_TUPLE_REG(CCM, mux) = (CCM_TUPLE_REG(CCM, mux) & (~CCM_TUPLE_MASK(mux))) | + (((uint32_t)((value) << CCM_TUPLE_SHIFT(mux))) & CCM_TUPLE_MASK(mux)); + + assert(busyShift <= CCM_NO_BUSY_WAIT); + + /* Clock switch need Handshake? */ + if (CCM_NO_BUSY_WAIT != busyShift) + { + /* Wait until CCM internal handshake finish. */ + while (CCM->CDHIPR & (1U << busyShift)) + { + } + } +} + +/*! + * @brief Get CCM MUX value. + * + * @param mux Which mux node to get, see \ref clock_mux_t. + * @return Clock mux value. + */ +static inline uint32_t CLOCK_GetMux(clock_mux_t mux) +{ + return (CCM_TUPLE_REG(CCM, mux) & CCM_TUPLE_MASK(mux)) >> CCM_TUPLE_SHIFT(mux); +} + +/*! + * @brief Set CCM DIV node to certain value. + * + * @param divider Which div node to set, see \ref clock_div_t. + * @param value Clock div value to set, different divider has different value range. + */ +static inline void CLOCK_SetDiv(clock_div_t divider, uint32_t value) +{ + uint32_t busyShift; + + busyShift = CCM_TUPLE_BUSY_SHIFT(divider); + CCM_TUPLE_REG(CCM, divider) = (CCM_TUPLE_REG(CCM, divider) & (~CCM_TUPLE_MASK(divider))) | + (((uint32_t)((value) << CCM_TUPLE_SHIFT(divider))) & CCM_TUPLE_MASK(divider)); + + assert(busyShift <= CCM_NO_BUSY_WAIT); + + /* Clock switch need Handshake? */ + if (CCM_NO_BUSY_WAIT != busyShift) + { + /* Wait until CCM internal handshake finish. */ + while (CCM->CDHIPR & (1U << busyShift)) + { + } + } +} + +/*! + * @brief Get CCM DIV node value. + * + * @param divider Which div node to get, see \ref clock_div_t. + */ +static inline uint32_t CLOCK_GetDiv(clock_div_t divider) +{ + return ((CCM_TUPLE_REG(CCM, divider) & CCM_TUPLE_MASK(divider)) >> CCM_TUPLE_SHIFT(divider)); +} + +/*! + * @brief Control the clock gate for specific IP. + * + * @param name Which clock to enable, see \ref clock_ip_name_t. + * @param value Clock gate value to set, see \ref clock_gate_value_t. + */ +static inline void CLOCK_ControlGate(clock_ip_name_t name, clock_gate_value_t value) +{ + uint32_t index = ((uint32_t)name) >> 8U; + uint32_t shift = ((uint32_t)name) & 0x1FU; + volatile uint32_t *reg; + + assert(index <= 7); + + reg = ((volatile uint32_t *)&CCM->CCGR0) + index; + *reg = ((*reg) & ~(3U << shift)) | (((uint32_t)value) << shift); +} + +/*! + * @brief Enable the clock for specific IP. + * + * @param name Which clock to enable, see \ref clock_ip_name_t. + */ +static inline void CLOCK_EnableClock(clock_ip_name_t name) +{ + CLOCK_ControlGate(name, kCLOCK_ClockNeededRunWait); +} + +/*! + * @brief Disable the clock for specific IP. + * + * @param name Which clock to disable, see \ref clock_ip_name_t. + */ +static inline void CLOCK_DisableClock(clock_ip_name_t name) +{ + CLOCK_ControlGate(name, kCLOCK_ClockNotNeeded); +} + +/*! + * @brief Setting the low power mode that system will enter on next assertion of dsm_request signal. + * + * @param mode Which mode to enter, see \ref clock_mode_t. + */ +static inline void CLOCK_SetMode(clock_mode_t mode) +{ + CCM->CLPCR = (CCM->CLPCR & ~CCM_CLPCR_LPM_MASK) | CCM_CLPCR_LPM((uint32_t)mode); +} + +/*! + * @brief Gets the OSC clock frequency. + * + * This function will return the external XTAL OSC frequency if it is selected as the source of OSC, + * otherwise internal 24MHz RC OSC frequency will be returned. + * + * @param osc OSC type to get frequency. + * + * @return Clock frequency; If the clock is invalid, returns 0. + */ +static inline uint32_t CLOCK_GetOscFreq(void) +{ + return (XTALOSC24M->LOWPWR_CTRL & XTALOSC24M_LOWPWR_CTRL_OSC_SEL_MASK) ? 24000000UL : g_xtalFreq; +} + +/*! + * @brief Gets the AHB clock frequency. + * + * @return The AHB clock frequency value in hertz. + */ +uint32_t CLOCK_GetAhbFreq(void); + +/*! + * @brief Gets the SEMC clock frequency. + * + * @return The SEMC clock frequency value in hertz. + */ +uint32_t CLOCK_GetSemcFreq(void); + +/*! + * @brief Gets the IPG clock frequency. + * + * @return The IPG clock frequency value in hertz. + */ +uint32_t CLOCK_GetIpgFreq(void); + +/*! + * @brief Gets the PER clock frequency. + * + * @return The PER clock frequency value in hertz. + */ +uint32_t CLOCK_GetPerClkFreq(void); + +/*! + * @brief Gets the clock frequency for a specific clock name. + * + * This function checks the current clock configurations and then calculates + * the clock frequency for a specific clock name defined in clock_name_t. + * + * @param clockName Clock names defined in clock_name_t + * @return Clock frequency value in hertz + */ +uint32_t CLOCK_GetFreq(clock_name_t name); + +/*! + * @brief Get the CCM CPU/core/system frequency. + * + * @return Clock frequency; If the clock is invalid, returns 0. + */ +static inline uint32_t CLOCK_GetCpuClkFreq(void) +{ + return CLOCK_GetFreq(kCLOCK_CpuClk); +} + +/*! + * @name OSC operations + * @{ + */ + +/*! + * @brief Initialize the external 24MHz clock. + * + * This function supports two modes: + * 1. Use external crystal oscillator. + * 2. Bypass the external crystal oscillator, using input source clock directly. + * + * After this function, please call @ref CLOCK_SetXtal0Freq to inform clock driver + * the external clock frequency. + * + * @param bypassXtalOsc Pass in true to bypass the external crystal oscillator. + * @note This device does not support bypass external crystal oscillator, so + * the input parameter should always be false. + */ +void CLOCK_InitExternalClk(bool bypassXtalOsc); + +/*! + * @brief Deinitialize the external 24MHz clock. + * + * This function disables the external 24MHz clock. + * + * After this function, please call @ref CLOCK_SetXtal0Freq to set external clock + * frequency to 0. + */ +void CLOCK_DeinitExternalClk(void); + +/*! + * @brief Switch the OSC. + * + * This function switches the OSC source for SoC. + * + * @param osc OSC source to switch to. + */ +void CLOCK_SwitchOsc(clock_osc_t osc); + +/*! + * @brief Gets the RTC clock frequency. + * + * @return Clock frequency; If the clock is invalid, returns 0. + */ +static inline uint32_t CLOCK_GetRtcFreq(void) +{ + return 32768U; +} + +/*! + * @brief Set the XTAL (24M OSC) frequency based on board setting. + * + * @param freq The XTAL input clock frequency in Hz. + */ +static inline void CLOCK_SetXtalFreq(uint32_t freq) +{ + g_xtalFreq = freq; +} + +/*! + * @brief Set the RTC XTAL (32K OSC) frequency based on board setting. + * + * @param freq The RTC XTAL input clock frequency in Hz. + */ +static inline void CLOCK_SetRtcXtalFreq(uint32_t freq) +{ + g_rtcXtalFreq = freq; +} + +/*! + * @brief Initialize the RC oscillator 24MHz clock. + */ +void CLOCK_InitRcOsc24M(void); + +/*! + * @brief Power down the RCOSC 24M clock. + */ +void CLOCK_DeinitRcOsc24M(void); +/* @} */ + +/*! @brief Enable USB HS clock. + * + * This function only enables the access to USB HS prepheral, upper layer + * should first call the @ref CLOCK_EnableUsbhs0PhyPllClock to enable the PHY + * clock to use USB HS. + * + * @param src USB HS does not care about the clock source, here must be @ref kCLOCK_UsbSrcUnused. + * @param freq USB HS does not care about the clock source, so this parameter is ignored. + * @retval true The clock is set successfully. + * @retval false The clock source is invalid to get proper USB HS clock. + */ +bool CLOCK_EnableUsbhs0Clock(clock_usb_src_t src, uint32_t freq); + +/*! @brief Enable USB HS clock. + * + * This function only enables the access to USB HS prepheral, upper layer + * should first call the @ref CLOCK_EnableUsbhs0PhyPllClock to enable the PHY + * clock to use USB HS. + * + * @param src USB HS does not care about the clock source, here must be @ref kCLOCK_UsbSrcUnused. + * @param freq USB HS does not care about the clock source, so this parameter is ignored. + * @retval true The clock is set successfully. + * @retval false The clock source is invalid to get proper USB HS clock. + */ +bool CLOCK_EnableUsbhs1Clock(clock_usb_src_t src, uint32_t freq); + +/*! @brief Disable USB HS PHY PLL clock. + * + * This function disables USB HS PHY PLL clock. + */ +void CLOCK_DisableUsbhs1PhyPllClock(void); + +/* @} */ + +/*! + * @name PLL/PFD operations + * @{ + */ +/*! + * @brief PLL bypass setting + * + * @param base CCM_ANALOG base pointer. + * @param pll PLL control name (see @ref ccm_analog_pll_control_t enumeration) + * @param bypass Bypass the PLL. + * - true: Bypass the PLL. + * - false:Not bypass the PLL. + */ +static inline void CLOCK_SetPllBypass(CCM_ANALOG_Type *base, clock_pll_t pll, bool bypass) +{ + if (bypass) + { + CCM_ANALOG_TUPLE_REG_OFF(base, pll, 4U) = 1U << CCM_ANALOG_PLL_BYPASS_SHIFT; + } + else + { + CCM_ANALOG_TUPLE_REG_OFF(base, pll, 8U) = 1U << CCM_ANALOG_PLL_BYPASS_SHIFT; + } +} + +/*! + * @brief Check if PLL is bypassed + * + * @param base CCM_ANALOG base pointer. + * @param pll PLL control name (see @ref ccm_analog_pll_control_t enumeration) + * @return PLL bypass status. + * - true: The PLL is bypassed. + * - false: The PLL is not bypassed. + */ +static inline bool CLOCK_IsPllBypassed(CCM_ANALOG_Type *base, clock_pll_t pll) +{ + return (bool)(CCM_ANALOG_TUPLE_REG(base, pll) & (1U << CCM_ANALOG_PLL_BYPASS_SHIFT)); +} + +/*! + * @brief Check if PLL is enabled + * + * @param base CCM_ANALOG base pointer. + * @param pll PLL control name (see @ref ccm_analog_pll_control_t enumeration) + * @return PLL bypass status. + * - true: The PLL is enabled. + * - false: The PLL is not enabled. + */ +static inline bool CLOCK_IsPllEnabled(CCM_ANALOG_Type *base, clock_pll_t pll) +{ + return (bool)(CCM_ANALOG_TUPLE_REG(base, pll) & (1U << CCM_ANALOG_TUPLE_SHIFT(pll))); +} + +/*! + * @brief PLL bypass clock source setting. + * Note: change the bypass clock source also change the pll reference clock source. + * + * @param base CCM_ANALOG base pointer. + * @param pll PLL control name (see @ref ccm_analog_pll_control_t enumeration) + * @param src Bypass clock source, reference _clock_pll_bypass_clk_src. + */ +static inline void CLOCK_SetPllBypassRefClkSrc(CCM_ANALOG_Type *base, clock_pll_t pll, uint32_t src) +{ + CCM_ANALOG_TUPLE_REG(base, pll) |= (CCM_ANALOG_TUPLE_REG(base, pll) & (~CCM_ANALOG_PLL_BYPASS_CLK_SRC_MASK)) | src; +} + +/*! + * @brief Get PLL bypass clock value, it is PLL reference clock actually. + * If CLOCK1_P,CLOCK1_N is choose as the pll bypass clock source, please implement the CLKPN_FREQ define, otherwise 0 + * will be returned. + * @param base CCM_ANALOG base pointer. + * @param pll PLL control name (see @ref ccm_analog_pll_control_t enumeration) + * @retval bypass reference clock frequency value. + */ +static inline uint32_t CLOCK_GetPllBypassRefClk(CCM_ANALOG_Type *base, clock_pll_t pll) +{ + return (((CCM_ANALOG_TUPLE_REG(base, pll) & CCM_ANALOG_PLL_BYPASS_CLK_SRC_MASK) >> + CCM_ANALOG_PLL_BYPASS_CLK_SRC_SHIFT) == kCLOCK_PllClkSrc24M) ? + CLOCK_GetOscFreq() : + CLKPN_FREQ; +} + +/*! + * @brief Initialize the ARM PLL. + * + * This function initialize the ARM PLL with specific settings + * + * @param config configuration to set to PLL. + */ +void CLOCK_InitArmPll(const clock_arm_pll_config_t *config); + +/*! + * @brief De-initialize the ARM PLL. + */ +void CLOCK_DeinitArmPll(void); + +/*! + * @brief Initialize the System PLL. + * + * This function initializes the System PLL with specific settings + * + * @param config Configuration to set to PLL. + */ +void CLOCK_InitSysPll(const clock_sys_pll_config_t *config); + +/*! + * @brief De-initialize the System PLL. + */ +void CLOCK_DeinitSysPll(void); + +/*! + * @brief Initialize the USB1 PLL. + * + * This function initializes the USB1 PLL with specific settings + * + * @param config Configuration to set to PLL. + */ +void CLOCK_InitUsb1Pll(const clock_usb_pll_config_t *config); + +/*! + * @brief Deinitialize the USB1 PLL. + */ +void CLOCK_DeinitUsb1Pll(void); + +/*! + * @brief Initialize the USB2 PLL. + * + * This function initializes the USB2 PLL with specific settings + * + * @param config Configuration to set to PLL. + */ +void CLOCK_InitUsb2Pll(const clock_usb_pll_config_t *config); + +/*! + * @brief Deinitialize the USB2 PLL. + */ +void CLOCK_DeinitUsb2Pll(void); + +/*! + * @brief Initializes the Audio PLL. + * + * This function initializes the Audio PLL with specific settings + * + * @param config Configuration to set to PLL. + */ +void CLOCK_InitAudioPll(const clock_audio_pll_config_t *config); + +/*! + * @brief De-initialize the Audio PLL. + */ +void CLOCK_DeinitAudioPll(void); + +/*! + * @brief Initialize the video PLL. + * + * This function configures the Video PLL with specific settings + * + * @param config configuration to set to PLL. + */ +void CLOCK_InitVideoPll(const clock_video_pll_config_t *config); + +/*! + * @brief De-initialize the Video PLL. + */ +void CLOCK_DeinitVideoPll(void); +/*! + * @brief Initialize the ENET PLL. + * + * This function initializes the ENET PLL with specific settings. + * + * @param config Configuration to set to PLL. + */ +void CLOCK_InitEnetPll(const clock_enet_pll_config_t *config); + +/*! + * @brief Deinitialize the ENET PLL. + * + * This function disables the ENET PLL. + */ +void CLOCK_DeinitEnetPll(void); + +/*! + * @brief Get current PLL output frequency. + * + * This function get current output frequency of specific PLL + * + * @param pll pll name to get frequency. + * @return The PLL output frequency in hertz. + */ +uint32_t CLOCK_GetPllFreq(clock_pll_t pll); + +/*! + * @brief Initialize the System PLL PFD. + * + * This function initializes the System PLL PFD. During new value setting, + * the clock output is disabled to prevent glitch. + * + * @param pfd Which PFD clock to enable. + * @param pfdFrac The PFD FRAC value. + * @note It is recommended that PFD settings are kept between 12-35. + */ +void CLOCK_InitSysPfd(clock_pfd_t pfd, uint8_t pfdFrac); + +/*! + * @brief De-initialize the System PLL PFD. + * + * This function disables the System PLL PFD. + * + * @param pfd Which PFD clock to disable. + */ +void CLOCK_DeinitSysPfd(clock_pfd_t pfd); + +/*! + * @brief Initialize the USB1 PLL PFD. + * + * This function initializes the USB1 PLL PFD. During new value setting, + * the clock output is disabled to prevent glitch. + * + * @param pfd Which PFD clock to enable. + * @param pfdFrac The PFD FRAC value. + * @note It is recommended that PFD settings are kept between 12-35. + */ +void CLOCK_InitUsb1Pfd(clock_pfd_t pfd, uint8_t pfdFrac); + +/*! + * @brief De-initialize the USB1 PLL PFD. + * + * This function disables the USB1 PLL PFD. + * + * @param pfd Which PFD clock to disable. + */ +void CLOCK_DeinitUsb1Pfd(clock_pfd_t pfd); + +/*! + * @brief Get current System PLL PFD output frequency. + * + * This function get current output frequency of specific System PLL PFD + * + * @param pfd pfd name to get frequency. + * @return The PFD output frequency in hertz. + */ +uint32_t CLOCK_GetSysPfdFreq(clock_pfd_t pfd); + +/*! + * @brief Get current USB1 PLL PFD output frequency. + * + * This function get current output frequency of specific USB1 PLL PFD + * + * @param pfd pfd name to get frequency. + * @return The PFD output frequency in hertz. + */ +uint32_t CLOCK_GetUsb1PfdFreq(clock_pfd_t pfd); + +/*! @brief Enable USB HS PHY PLL clock. + * + * This function enables the internal 480MHz USB PHY PLL clock. + * + * @param src USB HS PHY PLL clock source. + * @param freq The frequency specified by src. + * @retval true The clock is set successfully. + * @retval false The clock source is invalid to get proper USB HS clock. + */ +bool CLOCK_EnableUsbhs0PhyPllClock(clock_usb_phy_src_t src, uint32_t freq); + +/*! @brief Disable USB HS PHY PLL clock. + * + * This function disables USB HS PHY PLL clock. + */ +void CLOCK_DisableUsbhs0PhyPllClock(void); + +/*! @brief Enable USB HS PHY PLL clock. + * + * This function enables the internal 480MHz USB PHY PLL clock. + * + * @param src USB HS PHY PLL clock source. + * @param freq The frequency specified by src. + * @retval true The clock is set successfully. + * @retval false The clock source is invalid to get proper USB HS clock. + */ +bool CLOCK_EnableUsbhs1PhyPllClock(clock_usb_phy_src_t src, uint32_t freq); + +/*! @brief Disable USB HS PHY PLL clock. + * + * This function disables USB HS PHY PLL clock. + */ +void CLOCK_DisableUsbhs1PhyPllClock(void); + +/* @} */ + +#if defined(__cplusplus) +} +#endif /* __cplusplus */ + +/*! @} */ + +#endif /* _FSL_CLOCK_H_ */ diff --git a/ports/nxp/board/evkmimxrt1064/fsl_iomuxc.h b/ports/nxp/board/evkmimxrt1064/fsl_iomuxc.h new file mode 100644 index 000000000000..4e9ac84eda2e --- /dev/null +++ b/ports/nxp/board/evkmimxrt1064/fsl_iomuxc.h @@ -0,0 +1,1405 @@ +/* + * Copyright 2016 Freescale Semiconductor, Inc. + * Copyright 2016-2018 NXP + * All rights reserved. + * + * SPDX-License-Identifier: BSD-3-Clause + */ + +#ifndef _FSL_IOMUXC_H_ +#define _FSL_IOMUXC_H_ + +#include "fsl_common.h" + +/*! + * @addtogroup iomuxc_driver + * @{ + */ + +/*! @file */ + +/******************************************************************************* + * Definitions + ******************************************************************************/ +/* Component ID definition, used by tools. */ +#ifndef FSL_COMPONENT_ID +#define FSL_COMPONENT_ID "platform.drivers.iomuxc" +#endif + +/*! @name Driver version */ +/*@{*/ +/*! @brief IOMUXC driver version 2.0.1. */ +#define FSL_IOMUXC_DRIVER_VERSION (MAKE_VERSION(2, 0, 1)) +/*@}*/ + +/*! @name Pin function ID */ +/*@{*/ +/*! @brief The pin function ID is a tuple of */ +#define IOMUXC_SNVS_WAKEUP_GPIO5_IO00 0x400A8000U, 0x5U, 0, 0, 0x400A8018U +#define IOMUXC_SNVS_WAKEUP_NMI_GLUE_NMI 0x400A8000U, 0x7U, 0x401F8568U, 0x1U, 0x400A8018U + +#define IOMUXC_SNVS_PMIC_ON_REQ_SNVS_LP_PMIC_ON_REQ 0x400A8004U, 0x0U, 0, 0, 0x400A801CU +#define IOMUXC_SNVS_PMIC_ON_REQ_GPIO5_IO01 0x400A8004U, 0x5U, 0, 0, 0x400A801CU + +#define IOMUXC_SNVS_PMIC_STBY_REQ_CCM_PMIC_VSTBY_REQ 0x400A8008U, 0x0U, 0, 0, 0x400A8020U +#define IOMUXC_SNVS_PMIC_STBY_REQ_GPIO5_IO02 0x400A8008U, 0x5U, 0, 0, 0x400A8020U + +#define IOMUXC_SNVS_TEST_MODE 0, 0, 0, 0, 0x400A800CU + +#define IOMUXC_SNVS_POR_B 0, 0, 0, 0, 0x400A8010U + +#define IOMUXC_SNVS_ONOFF 0, 0, 0, 0, 0x400A8014U + +#define IOMUXC_GPIO_EMC_00_SEMC_DATA00 0x401F8014U, 0x0U, 0, 0, 0x401F8204U +#define IOMUXC_GPIO_EMC_00_FLEXPWM4_PWMA00 0x401F8014U, 0x1U, 0x401F8494U, 0x0U, 0x401F8204U +#define IOMUXC_GPIO_EMC_00_LPSPI2_SCK 0x401F8014U, 0x2U, 0x401F8500U, 0x1U, 0x401F8204U +#define IOMUXC_GPIO_EMC_00_XBAR1_XBAR_IN02 0x401F8014U, 0x3U, 0x401F860CU, 0x0U, 0x401F8204U +#define IOMUXC_GPIO_EMC_00_FLEXIO1_FLEXIO00 0x401F8014U, 0x4U, 0, 0, 0x401F8204U +#define IOMUXC_GPIO_EMC_00_GPIO4_IO00 0x401F8014U, 0x5U, 0, 0, 0x401F8204U + +#define IOMUXC_GPIO_EMC_01_SEMC_DATA01 0x401F8018U, 0x0U, 0, 0, 0x401F8208U +#define IOMUXC_GPIO_EMC_01_FLEXPWM4_PWMB00 0x401F8018U, 0x1U, 0, 0, 0x401F8208U +#define IOMUXC_GPIO_EMC_01_LPSPI2_PCS0 0x401F8018U, 0x2U, 0x401F84FCU, 0x1U, 0x401F8208U +#define IOMUXC_GPIO_EMC_01_XBAR1_IN03 0x401F8018U, 0x3U, 0x401F8610U, 0x0U, 0x401F8208U +#define IOMUXC_GPIO_EMC_01_FLEXIO1_FLEXIO01 0x401F8018U, 0x4U, 0, 0, 0x401F8208U +#define IOMUXC_GPIO_EMC_01_GPIO4_IO01 0x401F8018U, 0x5U, 0, 0, 0x401F8208U + +#define IOMUXC_GPIO_EMC_02_SEMC_DATA02 0x401F801CU, 0x0U, 0, 0, 0x401F820CU +#define IOMUXC_GPIO_EMC_02_FLEXPWM4_PWMA01 0x401F801CU, 0x1U, 0x401F8498U, 0x0U, 0x401F820CU +#define IOMUXC_GPIO_EMC_02_LPSPI2_SDO 0x401F801CU, 0x2U, 0x401F8508U, 0x1U, 0x401F820CU +#define IOMUXC_GPIO_EMC_02_XBAR1_INOUT04 0x401F801CU, 0x3U, 0x401F8614U, 0x0U, 0x401F820CU +#define IOMUXC_GPIO_EMC_02_FLEXIO1_FLEXIO02 0x401F801CU, 0x4U, 0, 0, 0x401F820CU +#define IOMUXC_GPIO_EMC_02_GPIO4_IO02 0x401F801CU, 0x5U, 0, 0, 0x401F820CU + +#define IOMUXC_GPIO_EMC_03_SEMC_DATA03 0x401F8020U, 0x0U, 0, 0, 0x401F8210U +#define IOMUXC_GPIO_EMC_03_FLEXPWM4_PWMB01 0x401F8020U, 0x1U, 0, 0, 0x401F8210U +#define IOMUXC_GPIO_EMC_03_LPSPI2_SDI 0x401F8020U, 0x2U, 0x401F8504U, 0x1U, 0x401F8210U +#define IOMUXC_GPIO_EMC_03_XBAR1_INOUT05 0x401F8020U, 0x3U, 0x401F8618U, 0x0U, 0x401F8210U +#define IOMUXC_GPIO_EMC_03_FLEXIO1_FLEXIO03 0x401F8020U, 0x4U, 0, 0, 0x401F8210U +#define IOMUXC_GPIO_EMC_03_GPIO4_IO03 0x401F8020U, 0x5U, 0, 0, 0x401F8210U + +#define IOMUXC_GPIO_EMC_04_SEMC_DATA04 0x401F8024U, 0x0U, 0, 0, 0x401F8214U +#define IOMUXC_GPIO_EMC_04_FLEXPWM4_PWMA02 0x401F8024U, 0x1U, 0x401F849CU, 0x0U, 0x401F8214U +#define IOMUXC_GPIO_EMC_04_SAI2_TX_DATA 0x401F8024U, 0x2U, 0, 0, 0x401F8214U +#define IOMUXC_GPIO_EMC_04_XBAR1_INOUT06 0x401F8024U, 0x3U, 0x401F861CU, 0x0U, 0x401F8214U +#define IOMUXC_GPIO_EMC_04_FLEXIO1_FLEXIO04 0x401F8024U, 0x4U, 0, 0, 0x401F8214U +#define IOMUXC_GPIO_EMC_04_GPIO4_IO04 0x401F8024U, 0x5U, 0, 0, 0x401F8214U + +#define IOMUXC_GPIO_EMC_05_SEMC_DATA05 0x401F8028U, 0x0U, 0, 0, 0x401F8218U +#define IOMUXC_GPIO_EMC_05_FLEXPWM4_PWMB02 0x401F8028U, 0x1U, 0, 0, 0x401F8218U +#define IOMUXC_GPIO_EMC_05_SAI2_TX_SYNC 0x401F8028U, 0x2U, 0x401F85C4U, 0x0U, 0x401F8218U +#define IOMUXC_GPIO_EMC_05_XBAR1_INOUT07 0x401F8028U, 0x3U, 0x401F8620U, 0x0U, 0x401F8218U +#define IOMUXC_GPIO_EMC_05_FLEXIO1_FLEXIO05 0x401F8028U, 0x4U, 0, 0, 0x401F8218U +#define IOMUXC_GPIO_EMC_05_GPIO4_IO05 0x401F8028U, 0x5U, 0, 0, 0x401F8218U + +#define IOMUXC_GPIO_EMC_06_SEMC_DATA06 0x401F802CU, 0x0U, 0, 0, 0x401F821CU +#define IOMUXC_GPIO_EMC_06_FLEXPWM2_PWMA00 0x401F802CU, 0x1U, 0x401F8478U, 0x0U, 0x401F821CU +#define IOMUXC_GPIO_EMC_06_SAI2_TX_BCLK 0x401F802CU, 0x2U, 0x401F85C0U, 0x0U, 0x401F821CU +#define IOMUXC_GPIO_EMC_06_XBAR1_INOUT08 0x401F802CU, 0x3U, 0x401F8624U, 0x0U, 0x401F821CU +#define IOMUXC_GPIO_EMC_06_FLEXIO1_FLEXIO06 0x401F802CU, 0x4U, 0, 0, 0x401F821CU +#define IOMUXC_GPIO_EMC_06_GPIO4_IO06 0x401F802CU, 0x5U, 0, 0, 0x401F821CU + +#define IOMUXC_GPIO_EMC_07_SEMC_DATA07 0x401F8030U, 0x0U, 0, 0, 0x401F8220U +#define IOMUXC_GPIO_EMC_07_FLEXPWM2_PWMB00 0x401F8030U, 0x1U, 0x401F8488U, 0x0U, 0x401F8220U +#define IOMUXC_GPIO_EMC_07_SAI2_MCLK 0x401F8030U, 0x2U, 0x401F85B0U, 0x0U, 0x401F8220U +#define IOMUXC_GPIO_EMC_07_XBAR1_INOUT09 0x401F8030U, 0x3U, 0x401F8628U, 0x0U, 0x401F8220U +#define IOMUXC_GPIO_EMC_07_FLEXIO1_FLEXIO07 0x401F8030U, 0x4U, 0, 0, 0x401F8220U +#define IOMUXC_GPIO_EMC_07_GPIO4_IO07 0x401F8030U, 0x5U, 0, 0, 0x401F8220U + +#define IOMUXC_GPIO_EMC_08_SEMC_DM00 0x401F8034U, 0x0U, 0, 0, 0x401F8224U +#define IOMUXC_GPIO_EMC_08_FLEXPWM2_PWMA01 0x401F8034U, 0x1U, 0x401F847CU, 0x0U, 0x401F8224U +#define IOMUXC_GPIO_EMC_08_SAI2_RX_DATA 0x401F8034U, 0x2U, 0x401F85B8U, 0x0U, 0x401F8224U +#define IOMUXC_GPIO_EMC_08_XBAR1_INOUT17 0x401F8034U, 0x3U, 0x401F862CU, 0x0U, 0x401F8224U +#define IOMUXC_GPIO_EMC_08_FLEXIO1_FLEXIO08 0x401F8034U, 0x4U, 0, 0, 0x401F8224U +#define IOMUXC_GPIO_EMC_08_GPIO4_IO08 0x401F8034U, 0x5U, 0, 0, 0x401F8224U + +#define IOMUXC_GPIO_EMC_09_SEMC_ADDR00 0x401F8038U, 0x0U, 0, 0, 0x401F8228U +#define IOMUXC_GPIO_EMC_09_FLEXPWM2_PWMB01 0x401F8038U, 0x1U, 0x401F848CU, 0x0U, 0x401F8228U +#define IOMUXC_GPIO_EMC_09_SAI2_RX_SYNC 0x401F8038U, 0x2U, 0x401F85BCU, 0x0U, 0x401F8228U +#define IOMUXC_GPIO_EMC_09_FLEXCAN2_TX 0x401F8038U, 0x3U, 0, 0, 0x401F8228U +#define IOMUXC_GPIO_EMC_09_FLEXIO1_FLEXIO09 0x401F8038U, 0x4U, 0, 0, 0x401F8228U +#define IOMUXC_GPIO_EMC_09_GPIO4_IO09 0x401F8038U, 0x5U, 0, 0, 0x401F8228U + +#define IOMUXC_GPIO_EMC_10_SEMC_ADDR01 0x401F803CU, 0x0U, 0, 0, 0x401F822CU +#define IOMUXC_GPIO_EMC_10_FLEXPWM2_PWMA02 0x401F803CU, 0x1U, 0x401F8480U, 0x0U, 0x401F822CU +#define IOMUXC_GPIO_EMC_10_SAI2_RX_BCLK 0x401F803CU, 0x2U, 0x401F85B4U, 0x0U, 0x401F822CU +#define IOMUXC_GPIO_EMC_10_FLEXCAN2_RX 0x401F803CU, 0x3U, 0x401F8450U, 0x0U, 0x401F822CU +#define IOMUXC_GPIO_EMC_10_FLEXIO1_FLEXIO10 0x401F803CU, 0x4U, 0, 0, 0x401F822CU +#define IOMUXC_GPIO_EMC_10_GPIO4_IO10 0x401F803CU, 0x5U, 0, 0, 0x401F822CU + +#define IOMUXC_GPIO_EMC_11_SEMC_ADDR02 0x401F8040U, 0x0U, 0, 0, 0x401F8230U +#define IOMUXC_GPIO_EMC_11_FLEXPWM2_PWMB02 0x401F8040U, 0x1U, 0x401F8490U, 0x0U, 0x401F8230U +#define IOMUXC_GPIO_EMC_11_LPI2C4_SDA 0x401F8040U, 0x2U, 0x401F84E8U, 0x0U, 0x401F8230U +#define IOMUXC_GPIO_EMC_11_USDHC2_RESET_B 0x401F8040U, 0x3U, 0, 0, 0x401F8230U +#define IOMUXC_GPIO_EMC_11_FLEXIO1_FLEXIO11 0x401F8040U, 0x4U, 0, 0, 0x401F8230U +#define IOMUXC_GPIO_EMC_11_GPIO4_IO11 0x401F8040U, 0x5U, 0, 0, 0x401F8230U + +#define IOMUXC_GPIO_EMC_12_SEMC_ADDR03 0x401F8044U, 0x0U, 0, 0, 0x401F8234U +#define IOMUXC_GPIO_EMC_12_XBAR1_IN24 0x401F8044U, 0x1U, 0x401F8640U, 0x0U, 0x401F8234U +#define IOMUXC_GPIO_EMC_12_LPI2C4_SCL 0x401F8044U, 0x2U, 0x401F84E4U, 0x0U, 0x401F8234U +#define IOMUXC_GPIO_EMC_12_USDHC1_WP 0x401F8044U, 0x3U, 0x401F85D8U, 0x0U, 0x401F8234U +#define IOMUXC_GPIO_EMC_12_FLEXPWM1_PWMA03 0x401F8044U, 0x4U, 0x401F8454U, 0x1U, 0x401F8234U +#define IOMUXC_GPIO_EMC_12_GPIO4_IO12 0x401F8044U, 0x5U, 0, 0, 0x401F8234U + +#define IOMUXC_GPIO_EMC_13_SEMC_ADDR04 0x401F8048U, 0x0U, 0, 0, 0x401F8238U +#define IOMUXC_GPIO_EMC_13_XBAR1_IN25 0x401F8048U, 0x1U, 0x401F8650U, 0x1U, 0x401F8238U +#define IOMUXC_GPIO_EMC_13_LPUART3_TX 0x401F8048U, 0x2U, 0x401F853CU, 0x1U, 0x401F8238U +#define IOMUXC_GPIO_EMC_13_MQS_RIGHT 0x401F8048U, 0x3U, 0, 0, 0x401F8238U +#define IOMUXC_GPIO_EMC_13_FLEXPWM1_PWMB03 0x401F8048U, 0x4U, 0x401F8464U, 0x1U, 0x401F8238U +#define IOMUXC_GPIO_EMC_13_GPIO4_IO13 0x401F8048U, 0x5U, 0, 0, 0x401F8238U + +#define IOMUXC_GPIO_EMC_14_SEMC_ADDR05 0x401F804CU, 0x0U, 0, 0, 0x401F823CU +#define IOMUXC_GPIO_EMC_14_XBAR1_INOUT19 0x401F804CU, 0x1U, 0x401F8654U, 0x0U, 0x401F823CU +#define IOMUXC_GPIO_EMC_14_LPUART3_RX 0x401F804CU, 0x2U, 0x401F8538U, 0x1U, 0x401F823CU +#define IOMUXC_GPIO_EMC_14_MQS_LEFT 0x401F804CU, 0x3U, 0, 0, 0x401F823CU +#define IOMUXC_GPIO_EMC_14_LPSPI2_PCS1 0x401F804CU, 0x4U, 0, 0, 0x401F823CU +#define IOMUXC_GPIO_EMC_14_GPIO4_IO14 0x401F804CU, 0x5U, 0, 0, 0x401F823CU + +#define IOMUXC_GPIO_EMC_15_SEMC_ADDR06 0x401F8050U, 0x0U, 0, 0, 0x401F8240U +#define IOMUXC_GPIO_EMC_15_XBAR1_IN20 0x401F8050U, 0x1U, 0x401F8634U, 0x0U, 0x401F8240U +#define IOMUXC_GPIO_EMC_15_LPUART3_CTS_B 0x401F8050U, 0x2U, 0x401F8534U, 0x0U, 0x401F8240U +#define IOMUXC_GPIO_EMC_15_SPDIF_OUT 0x401F8050U, 0x3U, 0, 0, 0x401F8240U +#define IOMUXC_GPIO_EMC_15_QTIMER3_TIMER0 0x401F8050U, 0x4U, 0x401F857CU, 0x0U, 0x401F8240U +#define IOMUXC_GPIO_EMC_15_GPIO4_IO15 0x401F8050U, 0x5U, 0, 0, 0x401F8240U + +#define IOMUXC_GPIO_EMC_16_SEMC_ADDR07 0x401F8054U, 0x0U, 0, 0, 0x401F8244U +#define IOMUXC_GPIO_EMC_16_XBAR1_IN21 0x401F8054U, 0x1U, 0x401F8658U, 0x0U, 0x401F8244U +#define IOMUXC_GPIO_EMC_16_LPUART3_RTS_B 0x401F8054U, 0x2U, 0, 0, 0x401F8244U +#define IOMUXC_GPIO_EMC_16_SPDIF_IN 0x401F8054U, 0x3U, 0x401F85C8U, 0x1U, 0x401F8244U +#define IOMUXC_GPIO_EMC_16_QTIMER3_TIMER1 0x401F8054U, 0x4U, 0x401F8580U, 0x1U, 0x401F8244U +#define IOMUXC_GPIO_EMC_16_GPIO4_IO16 0x401F8054U, 0x5U, 0, 0, 0x401F8244U + +#define IOMUXC_GPIO_EMC_17_SEMC_ADDR08 0x401F8058U, 0x0U, 0, 0, 0x401F8248U +#define IOMUXC_GPIO_EMC_17_FLEXPWM4_PWMA03 0x401F8058U, 0x1U, 0x401F84A0U, 0x0U, 0x401F8248U +#define IOMUXC_GPIO_EMC_17_LPUART4_CTS_B 0x401F8058U, 0x2U, 0, 0, 0x401F8248U +#define IOMUXC_GPIO_EMC_17_FLEXCAN1_TX 0x401F8058U, 0x3U, 0, 0, 0x401F8248U +#define IOMUXC_GPIO_EMC_17_QTIMER3_TIMER2 0x401F8058U, 0x4U, 0x401F8584U, 0x0U, 0x401F8248U +#define IOMUXC_GPIO_EMC_17_GPIO4_IO17 0x401F8058U, 0x5U, 0, 0, 0x401F8248U + +#define IOMUXC_GPIO_EMC_18_SEMC_ADDR09 0x401F805CU, 0x0U, 0, 0, 0x401F824CU +#define IOMUXC_GPIO_EMC_18_FLEXPWM4_PWMB03 0x401F805CU, 0x1U, 0, 0, 0x401F824CU +#define IOMUXC_GPIO_EMC_18_LPUART4_RTS_B 0x401F805CU, 0x2U, 0, 0, 0x401F824CU +#define IOMUXC_GPIO_EMC_18_FLEXCAN1_RX 0x401F805CU, 0x3U, 0x401F844CU, 0x1U, 0x401F824CU +#define IOMUXC_GPIO_EMC_18_QTIMER3_TIMER3 0x401F805CU, 0x4U, 0x401F8588U, 0x0U, 0x401F824CU +#define IOMUXC_GPIO_EMC_18_GPIO4_IO18 0x401F805CU, 0x5U, 0, 0, 0x401F824CU +#define IOMUXC_GPIO_EMC_18_SNVS_VIO_5_CTL 0x401F805CU, 0x6U, 0, 0, 0x401F824CU + +#define IOMUXC_GPIO_EMC_19_SEMC_ADDR11 0x401F8060U, 0x0U, 0, 0, 0x401F8250U +#define IOMUXC_GPIO_EMC_19_FLEXPWM2_PWMA03 0x401F8060U, 0x1U, 0x401F8474U, 0x1U, 0x401F8250U +#define IOMUXC_GPIO_EMC_19_LPUART4_TX 0x401F8060U, 0x2U, 0x401F8544U, 0x1U, 0x401F8250U +#define IOMUXC_GPIO_EMC_19_ENET_RDATA01 0x401F8060U, 0x3U, 0x401F8438U, 0x0U, 0x401F8250U +#define IOMUXC_GPIO_EMC_19_QTIMER2_TIMER0 0x401F8060U, 0x4U, 0x401F856CU, 0x0U, 0x401F8250U +#define IOMUXC_GPIO_EMC_19_GPIO4_IO19 0x401F8060U, 0x5U, 0, 0, 0x401F8250U +#define IOMUXC_GPIO_EMC_19_SNVS_VIO_5 0x401F8060U, 0x6U, 0, 0, 0x401F8250U + +#define IOMUXC_GPIO_EMC_20_SEMC_ADDR12 0x401F8064U, 0x0U, 0, 0, 0x401F8254U +#define IOMUXC_GPIO_EMC_20_FLEXPWM2_PWMB03 0x401F8064U, 0x1U, 0x401F8484U, 0x1U, 0x401F8254U +#define IOMUXC_GPIO_EMC_20_LPUART4_RX 0x401F8064U, 0x2U, 0x401F8540U, 0x1U, 0x401F8254U +#define IOMUXC_GPIO_EMC_20_ENET_RDATA00 0x401F8064U, 0x3U, 0x401F8434U, 0x0U, 0x401F8254U +#define IOMUXC_GPIO_EMC_20_QTIMER2_TIMER1 0x401F8064U, 0x4U, 0x401F8570U, 0x0U, 0x401F8254U +#define IOMUXC_GPIO_EMC_20_GPIO4_IO20 0x401F8064U, 0x5U, 0, 0, 0x401F8254U + +#define IOMUXC_GPIO_EMC_21_SEMC_BA0 0x401F8068U, 0x0U, 0, 0, 0x401F8258U +#define IOMUXC_GPIO_EMC_21_FLEXPWM3_PWMA03 0x401F8068U, 0x1U, 0, 0, 0x401F8258U +#define IOMUXC_GPIO_EMC_21_LPI2C3_SDA 0x401F8068U, 0x2U, 0x401F84E0U, 0x0U, 0x401F8258U +#define IOMUXC_GPIO_EMC_21_ENET_TDATA01 0x401F8068U, 0x3U, 0, 0, 0x401F8258U +#define IOMUXC_GPIO_EMC_21_QTIMER2_TIMER2 0x401F8068U, 0x4U, 0x401F8574U, 0x0U, 0x401F8258U +#define IOMUXC_GPIO_EMC_21_GPIO4_IO21 0x401F8068U, 0x5U, 0, 0, 0x401F8258U + +#define IOMUXC_GPIO_EMC_22_SEMC_BA1 0x401F806CU, 0x0U, 0, 0, 0x401F825CU +#define IOMUXC_GPIO_EMC_22_FLEXPWM3_PWMB03 0x401F806CU, 0x1U, 0, 0, 0x401F825CU +#define IOMUXC_GPIO_EMC_22_LPI2C3_SCL 0x401F806CU, 0x2U, 0x401F84DCU, 0x0U, 0x401F825CU +#define IOMUXC_GPIO_EMC_22_ENET_TDATA00 0x401F806CU, 0x3U, 0, 0, 0x401F825CU +#define IOMUXC_GPIO_EMC_22_QTIMER2_TIMER3 0x401F806CU, 0x4U, 0x401F8578U, 0x0U, 0x401F825CU +#define IOMUXC_GPIO_EMC_22_GPIO4_IO22 0x401F806CU, 0x5U, 0, 0, 0x401F825CU + +#define IOMUXC_GPIO_EMC_23_SEMC_ADDR10 0x401F8070U, 0x0U, 0, 0, 0x401F8260U +#define IOMUXC_GPIO_EMC_23_FLEXPWM1_PWMA00 0x401F8070U, 0x1U, 0x401F8458U, 0x0U, 0x401F8260U +#define IOMUXC_GPIO_EMC_23_LPUART5_TX 0x401F8070U, 0x2U, 0x401F854CU, 0x0U, 0x401F8260U +#define IOMUXC_GPIO_EMC_23_ENET_RX_EN 0x401F8070U, 0x3U, 0x401F843CU, 0x0U, 0x401F8260U +#define IOMUXC_GPIO_EMC_23_GPT1_CAPTURE2 0x401F8070U, 0x4U, 0x401F875CU, 0x0U, 0x401F8260U +#define IOMUXC_GPIO_EMC_23_GPIO4_IO23 0x401F8070U, 0x5U, 0, 0, 0x401F8260U + +#define IOMUXC_GPIO_EMC_24_SEMC_CAS 0x401F8074U, 0x0U, 0, 0, 0x401F8264U +#define IOMUXC_GPIO_EMC_24_FLEXPWM1_PWMB00 0x401F8074U, 0x1U, 0x401F8468U, 0x0U, 0x401F8264U +#define IOMUXC_GPIO_EMC_24_LPUART5_RX 0x401F8074U, 0x2U, 0x401F8548U, 0x0U, 0x401F8264U +#define IOMUXC_GPIO_EMC_24_ENET_TX_EN 0x401F8074U, 0x3U, 0, 0, 0x401F8264U +#define IOMUXC_GPIO_EMC_24_GPT1_CAPTURE1 0x401F8074U, 0x4U, 0x401F8758U, 0x0U, 0x401F8264U +#define IOMUXC_GPIO_EMC_24_GPIO4_IO24 0x401F8074U, 0x5U, 0, 0, 0x401F8264U + +#define IOMUXC_GPIO_EMC_25_SEMC_RAS 0x401F8078U, 0x0U, 0, 0, 0x401F8268U +#define IOMUXC_GPIO_EMC_25_FLEXPWM1_PWMA01 0x401F8078U, 0x1U, 0x401F845CU, 0x0U, 0x401F8268U +#define IOMUXC_GPIO_EMC_25_LPUART6_TX 0x401F8078U, 0x2U, 0x401F8554U, 0x0U, 0x401F8268U +#define IOMUXC_GPIO_EMC_25_ENET_TX_CLK 0x401F8078U, 0x3U, 0x401F8448U, 0x0U, 0x401F8268U +#define IOMUXC_GPIO_EMC_25_ENET_REF_CLK 0x401F8078U, 0x4U, 0x401F842CU, 0x0U, 0x401F8268U +#define IOMUXC_GPIO_EMC_25_GPIO4_IO25 0x401F8078U, 0x5U, 0, 0, 0x401F8268U + +#define IOMUXC_GPIO_EMC_26_SEMC_CLK 0x401F807CU, 0x0U, 0, 0, 0x401F826CU +#define IOMUXC_GPIO_EMC_26_FLEXPWM1_PWMB01 0x401F807CU, 0x1U, 0x401F846CU, 0x0U, 0x401F826CU +#define IOMUXC_GPIO_EMC_26_LPUART6_RX 0x401F807CU, 0x2U, 0x401F8550U, 0x0U, 0x401F826CU +#define IOMUXC_GPIO_EMC_26_ENET_RX_ER 0x401F807CU, 0x3U, 0x401F8440U, 0x0U, 0x401F826CU +#define IOMUXC_GPIO_EMC_26_FLEXIO1_FLEXIO12 0x401F807CU, 0x4U, 0, 0, 0x401F826CU +#define IOMUXC_GPIO_EMC_26_GPIO4_IO26 0x401F807CU, 0x5U, 0, 0, 0x401F826CU + +#define IOMUXC_GPIO_EMC_27_SEMC_CKE 0x401F8080U, 0x0U, 0, 0, 0x401F8270U +#define IOMUXC_GPIO_EMC_27_FLEXPWM1_PWMA02 0x401F8080U, 0x1U, 0x401F8460U, 0x0U, 0x401F8270U +#define IOMUXC_GPIO_EMC_27_LPUART5_RTS_B 0x401F8080U, 0x2U, 0, 0, 0x401F8270U +#define IOMUXC_GPIO_EMC_27_LPSPI1_SCK 0x401F8080U, 0x3U, 0x401F84F0U, 0x0U, 0x401F8270U +#define IOMUXC_GPIO_EMC_27_FLEXIO1_FLEXIO13 0x401F8080U, 0x4U, 0, 0, 0x401F8270U +#define IOMUXC_GPIO_EMC_27_GPIO4_IO27 0x401F8080U, 0x5U, 0, 0, 0x401F8270U + +#define IOMUXC_GPIO_EMC_28_SEMC_WE 0x401F8084U, 0x0U, 0, 0, 0x401F8274U +#define IOMUXC_GPIO_EMC_28_FLEXPWM1_PWMB02 0x401F8084U, 0x1U, 0x401F8470U, 0x0U, 0x401F8274U +#define IOMUXC_GPIO_EMC_28_LPUART5_CTS_B 0x401F8084U, 0x2U, 0, 0, 0x401F8274U +#define IOMUXC_GPIO_EMC_28_LPSPI1_SDO 0x401F8084U, 0x3U, 0x401F84F8U, 0x0U, 0x401F8274U +#define IOMUXC_GPIO_EMC_28_FLEXIO1_FLEXIO14 0x401F8084U, 0x4U, 0, 0, 0x401F8274U +#define IOMUXC_GPIO_EMC_28_GPIO4_IO28 0x401F8084U, 0x5U, 0, 0, 0x401F8274U + +#define IOMUXC_GPIO_EMC_29_SEMC_CS0 0x401F8088U, 0x0U, 0, 0, 0x401F8278U +#define IOMUXC_GPIO_EMC_29_FLEXPWM3_PWMA00 0x401F8088U, 0x1U, 0, 0, 0x401F8278U +#define IOMUXC_GPIO_EMC_29_LPUART6_RTS_B 0x401F8088U, 0x2U, 0, 0, 0x401F8278U +#define IOMUXC_GPIO_EMC_29_LPSPI1_SDI 0x401F8088U, 0x3U, 0x401F84F4U, 0x0U, 0x401F8278U +#define IOMUXC_GPIO_EMC_29_FLEXIO1_FLEXIO15 0x401F8088U, 0x4U, 0, 0, 0x401F8278U +#define IOMUXC_GPIO_EMC_29_GPIO4_IO29 0x401F8088U, 0x5U, 0, 0, 0x401F8278U + +#define IOMUXC_GPIO_EMC_30_SEMC_DATA08 0x401F808CU, 0x0U, 0, 0, 0x401F827CU +#define IOMUXC_GPIO_EMC_30_FLEXPWM3_PWMB00 0x401F808CU, 0x1U, 0, 0, 0x401F827CU +#define IOMUXC_GPIO_EMC_30_LPUART6_CTS_B 0x401F808CU, 0x2U, 0, 0, 0x401F827CU +#define IOMUXC_GPIO_EMC_30_LPSPI1_PCS0 0x401F808CU, 0x3U, 0x401F84ECU, 0x1U, 0x401F827CU +#define IOMUXC_GPIO_EMC_30_CSI_DATA23 0x401F808CU, 0x4U, 0, 0, 0x401F827CU +#define IOMUXC_GPIO_EMC_30_GPIO4_IO30 0x401F808CU, 0x5U, 0, 0, 0x401F827CU +#define IOMUXC_GPIO_EMC_30_ENET2_TDATA00 0x401F808CU, 0x8U, 0, 0, 0x401F827CU + +#define IOMUXC_GPIO_EMC_31_SEMC_DATA09 0x401F8090U, 0x0U, 0, 0, 0x401F8280U +#define IOMUXC_GPIO_EMC_31_FLEXPWM3_PWMA01 0x401F8090U, 0x1U, 0, 0, 0x401F8280U +#define IOMUXC_GPIO_EMC_31_LPUART7_TX 0x401F8090U, 0x2U, 0x401F855CU, 0x1U, 0x401F8280U +#define IOMUXC_GPIO_EMC_31_LPSPI1_PCS1 0x401F8090U, 0x3U, 0, 0, 0x401F8280U +#define IOMUXC_GPIO_EMC_31_CSI_DATA22 0x401F8090U, 0x4U, 0, 0, 0x401F8280U +#define IOMUXC_GPIO_EMC_31_GPIO4_IO31 0x401F8090U, 0x5U, 0, 0, 0x401F8280U +#define IOMUXC_GPIO_EMC_31_ENET2_TDATA01 0x401F8090U, 0x8U, 0, 0, 0x401F8280U + +#define IOMUXC_GPIO_EMC_32_SEMC_DATA10 0x401F8094U, 0x0U, 0, 0, 0x401F8284U +#define IOMUXC_GPIO_EMC_32_FLEXPWM3_PWMB01 0x401F8094U, 0x1U, 0, 0, 0x401F8284U +#define IOMUXC_GPIO_EMC_32_LPUART7_RX 0x401F8094U, 0x2U, 0x401F8558U, 0x1U, 0x401F8284U +#define IOMUXC_GPIO_EMC_32_CCM_PMIC_RDY 0x401F8094U, 0x3U, 0x401F83FCU, 0x4U, 0x401F8284U +#define IOMUXC_GPIO_EMC_32_CSI_DATA21 0x401F8094U, 0x4U, 0, 0, 0x401F8284U +#define IOMUXC_GPIO_EMC_32_GPIO3_IO18 0x401F8094U, 0x5U, 0, 0, 0x401F8284U +#define IOMUXC_GPIO_EMC_32_ENET2_TX_EN 0x401F8094U, 0x8U, 0, 0, 0x401F8284U + +#define IOMUXC_GPIO_EMC_33_SEMC_DATA11 0x401F8098U, 0x0U, 0, 0, 0x401F8288U +#define IOMUXC_GPIO_EMC_33_FLEXPWM3_PWMA02 0x401F8098U, 0x1U, 0, 0, 0x401F8288U +#define IOMUXC_GPIO_EMC_33_USDHC1_RESET_B 0x401F8098U, 0x2U, 0, 0, 0x401F8288U +#define IOMUXC_GPIO_EMC_33_SAI3_RX_DATA 0x401F8098U, 0x3U, 0x401F8778U, 0x0U, 0x401F8288U +#define IOMUXC_GPIO_EMC_33_CSI_DATA20 0x401F8098U, 0x4U, 0, 0, 0x401F8288U +#define IOMUXC_GPIO_EMC_33_GPIO3_IO19 0x401F8098U, 0x5U, 0, 0, 0x401F8288U +#define IOMUXC_GPIO_EMC_33_ENET2_TX_CLK 0x401F8098U, 0x8U, 0x401F8728U, 0x0U, 0x401F8288U +#define IOMUXC_GPIO_EMC_33_ENET2_REF_CLK2 0x401F8098U, 0x9U, 0x401F870CU, 0x0U, 0x401F8288U + +#define IOMUXC_GPIO_EMC_34_SEMC_DATA12 0x401F809CU, 0x0U, 0, 0, 0x401F828CU +#define IOMUXC_GPIO_EMC_34_FLEXPWM3_PWMB02 0x401F809CU, 0x1U, 0, 0, 0x401F828CU +#define IOMUXC_GPIO_EMC_34_USDHC1_VSELECT 0x401F809CU, 0x2U, 0, 0, 0x401F828CU +#define IOMUXC_GPIO_EMC_34_SAI3_RX_SYNC 0x401F809CU, 0x3U, 0x401F877CU, 0x0U, 0x401F828CU +#define IOMUXC_GPIO_EMC_34_CSI_DATA19 0x401F809CU, 0x4U, 0, 0, 0x401F828CU +#define IOMUXC_GPIO_EMC_34_GPIO3_IO20 0x401F809CU, 0x5U, 0, 0, 0x401F828CU +#define IOMUXC_GPIO_EMC_34_ENET2_RX_ER 0x401F809CU, 0x8U, 0x401F8720U, 0x0U, 0x401F828CU + +#define IOMUXC_GPIO_EMC_35_SEMC_DATA13 0x401F80A0U, 0x0U, 0, 0, 0x401F8290U +#define IOMUXC_GPIO_EMC_35_XBAR1_INOUT18 0x401F80A0U, 0x1U, 0x401F8630U, 0x0U, 0x401F8290U +#define IOMUXC_GPIO_EMC_35_GPT1_COMPARE1 0x401F80A0U, 0x2U, 0, 0, 0x401F8290U +#define IOMUXC_GPIO_EMC_35_SAI3_RX_BCLK 0x401F80A0U, 0x3U, 0x401F8774U, 0x0U, 0x401F8290U +#define IOMUXC_GPIO_EMC_35_CSI_DATA18 0x401F80A0U, 0x4U, 0, 0, 0x401F8290U +#define IOMUXC_GPIO_EMC_35_GPIO3_IO21 0x401F80A0U, 0x5U, 0, 0, 0x401F8290U +#define IOMUXC_GPIO_EMC_35_USDHC1_CD_B 0x401F80A0U, 0x6U, 0x401F85D4U, 0x0U, 0x401F8290U +#define IOMUXC_GPIO_EMC_35_ENET2_RDATA00 0x401F80A0U, 0x8U, 0x401F8714U, 0x0U, 0x401F8290U + +#define IOMUXC_GPIO_EMC_36_SEMC_DATA14 0x401F80A4U, 0x0U, 0, 0, 0x401F8294U +#define IOMUXC_GPIO_EMC_36_XBAR1_IN22 0x401F80A4U, 0x1U, 0x401F8638U, 0x0U, 0x401F8294U +#define IOMUXC_GPIO_EMC_36_GPT1_COMPARE2 0x401F80A4U, 0x2U, 0, 0, 0x401F8294U +#define IOMUXC_GPIO_EMC_36_SAI3_TX_DATA 0x401F80A4U, 0x3U, 0, 0, 0x401F8294U +#define IOMUXC_GPIO_EMC_36_CSI_DATA17 0x401F80A4U, 0x4U, 0, 0, 0x401F8294U +#define IOMUXC_GPIO_EMC_36_GPIO3_IO22 0x401F80A4U, 0x5U, 0, 0, 0x401F8294U +#define IOMUXC_GPIO_EMC_36_USDHC1_WP 0x401F80A4U, 0x6U, 0x401F85D8U, 0x1U, 0x401F8294U +#define IOMUXC_GPIO_EMC_36_ENET2_RDATA01 0x401F80A4U, 0x8U, 0x401F8718U, 0x0U, 0x401F8294U +#define IOMUXC_GPIO_EMC_36_FLEXCAN3_TX 0x401F80A4U, 0x9U, 0, 0, 0x401F8294U + +#define IOMUXC_GPIO_EMC_37_SEMC_DATA15 0x401F80A8U, 0x0U, 0, 0, 0x401F8298U +#define IOMUXC_GPIO_EMC_37_XBAR1_IN23 0x401F80A8U, 0x1U, 0x401F863CU, 0x0U, 0x401F8298U +#define IOMUXC_GPIO_EMC_37_GPT1_COMPARE3 0x401F80A8U, 0x2U, 0, 0, 0x401F8298U +#define IOMUXC_GPIO_EMC_37_SAI3_MCLK 0x401F80A8U, 0x3U, 0x401F8770U, 0x0U, 0x401F8298U +#define IOMUXC_GPIO_EMC_37_CSI_DATA16 0x401F80A8U, 0x4U, 0, 0, 0x401F8298U +#define IOMUXC_GPIO_EMC_37_GPIO3_IO23 0x401F80A8U, 0x5U, 0, 0, 0x401F8298U +#define IOMUXC_GPIO_EMC_37_USDHC2_WP 0x401F80A8U, 0x6U, 0x401F8608U, 0x0U, 0x401F8298U +#define IOMUXC_GPIO_EMC_37_ENET2_RX_EN 0x401F80A8U, 0x8U, 0x401F871CU, 0x0U, 0x401F8298U +#define IOMUXC_GPIO_EMC_37_FLEXCAN3_RX 0x401F80A8U, 0x9U, 0x401F878CU, 0x0U, 0x401F8298U + +#define IOMUXC_GPIO_EMC_38_SEMC_DM01 0x401F80ACU, 0x0U, 0, 0, 0x401F829CU +#define IOMUXC_GPIO_EMC_38_FLEXPWM1_PWMA03 0x401F80ACU, 0x1U, 0x401F8454U, 0x2U, 0x401F829CU +#define IOMUXC_GPIO_EMC_38_LPUART8_TX 0x401F80ACU, 0x2U, 0x401F8564U, 0x2U, 0x401F829CU +#define IOMUXC_GPIO_EMC_38_SAI3_TX_BCLK 0x401F80ACU, 0x3U, 0x401F8780U, 0x0U, 0x401F829CU +#define IOMUXC_GPIO_EMC_38_CSI_FIELD 0x401F80ACU, 0x4U, 0, 0, 0x401F829CU +#define IOMUXC_GPIO_EMC_38_GPIO3_IO24 0x401F80ACU, 0x5U, 0, 0, 0x401F829CU +#define IOMUXC_GPIO_EMC_38_USDHC2_VSELECT 0x401F80ACU, 0x6U, 0, 0, 0x401F829CU +#define IOMUXC_GPIO_EMC_38_ENET2_MDC 0x401F80ACU, 0x8U, 0, 0, 0x401F829CU + +#define IOMUXC_GPIO_EMC_39_SEMC_DQS 0x401F80B0U, 0x0U, 0, 0, 0x401F82A0U +#define IOMUXC_GPIO_EMC_39_FLEXPWM1_PWMB03 0x401F80B0U, 0x1U, 0x401F8464U, 0x2U, 0x401F82A0U +#define IOMUXC_GPIO_EMC_39_LPUART8_RX 0x401F80B0U, 0x2U, 0x401F8560U, 0x2U, 0x401F82A0U +#define IOMUXC_GPIO_EMC_39_SAI3_TX_SYNC 0x401F80B0U, 0x3U, 0x401F8784U, 0x0U, 0x401F82A0U +#define IOMUXC_GPIO_EMC_39_WDOG1_WDOG_B 0x401F80B0U, 0x4U, 0, 0, 0x401F82A0U +#define IOMUXC_GPIO_EMC_39_GPIO3_IO25 0x401F80B0U, 0x5U, 0, 0, 0x401F82A0U +#define IOMUXC_GPIO_EMC_39_USDHC2_CD_B 0x401F80B0U, 0x6U, 0x401F85E0U, 0x1U, 0x401F82A0U +#define IOMUXC_GPIO_EMC_39_ENET2_MDIO 0x401F80B0U, 0x8U, 0x401F8710U, 0x0U, 0x401F82A0U +#define IOMUXC_GPIO_EMC_39_SEMC_DQS4 0x401F80B0U, 0x9U, 0x401F8788U, 0x1U, 0x401F82A0U + +#define IOMUXC_GPIO_EMC_40_SEMC_RDY 0x401F80B4U, 0x0U, 0, 0, 0x401F82A4U +#define IOMUXC_GPIO_EMC_40_GPT2_CAPTURE2 0x401F80B4U, 0x1U, 0x401F8768U, 0x0U, 0x401F82A4U +#define IOMUXC_GPIO_EMC_40_LPSPI1_PCS2 0x401F80B4U, 0x2U, 0, 0, 0x401F82A4U +#define IOMUXC_GPIO_EMC_40_USB_OTG2_OC 0x401F80B4U, 0x3U, 0x401F85CCU, 0x1U, 0x401F82A4U +#define IOMUXC_GPIO_EMC_40_ENET_MDC 0x401F80B4U, 0x4U, 0, 0, 0x401F82A4U +#define IOMUXC_GPIO_EMC_40_GPIO3_IO26 0x401F80B4U, 0x5U, 0, 0, 0x401F82A4U +#define IOMUXC_GPIO_EMC_40_USDHC2_RESET_B 0x401F80B4U, 0x6U, 0, 0, 0x401F82A4U +#define IOMUXC_GPIO_EMC_40_SEMC_CLK5 0x401F80B4U, 0x9U, 0, 0, 0x401F82A4U + +#define IOMUXC_GPIO_EMC_41_SEMC_CSX00 0x401F80B8U, 0x0U, 0, 0, 0x401F82A8U +#define IOMUXC_GPIO_EMC_41_GPT2_CAPTURE1 0x401F80B8U, 0x1U, 0x401F8764U, 0x0U, 0x401F82A8U +#define IOMUXC_GPIO_EMC_41_LPSPI1_PCS3 0x401F80B8U, 0x2U, 0, 0, 0x401F82A8U +#define IOMUXC_GPIO_EMC_41_USB_OTG2_PWR 0x401F80B8U, 0x3U, 0, 0, 0x401F82A8U +#define IOMUXC_GPIO_EMC_41_ENET_MDIO 0x401F80B8U, 0x4U, 0x401F8430U, 0x1U, 0x401F82A8U +#define IOMUXC_GPIO_EMC_41_GPIO3_IO27 0x401F80B8U, 0x5U, 0, 0, 0x401F82A8U +#define IOMUXC_GPIO_EMC_41_USDHC1_VSELECT 0x401F80B8U, 0x6U, 0, 0, 0x401F82A8U + +#define IOMUXC_GPIO_AD_B0_00_FLEXPWM2_PWMA03 0x401F80BCU, 0x0U, 0x401F8474U, 0x2U, 0x401F82ACU +#define IOMUXC_GPIO_AD_B0_00_XBAR1_INOUT14 0x401F80BCU, 0x1U, 0x401F8644U, 0x0U, 0x401F82ACU +#define IOMUXC_GPIO_AD_B0_00_REF_CLK_32K 0x401F80BCU, 0x2U, 0, 0, 0x401F82ACU +#define IOMUXC_GPIO_AD_B0_00_USB_OTG2_ID 0x401F80BCU, 0x3U, 0x401F83F8U, 0x0U, 0x401F82ACU +#define IOMUXC_GPIO_AD_B0_00_LPI2C1_SCLS 0x401F80BCU, 0x4U, 0, 0, 0x401F82ACU +#define IOMUXC_GPIO_AD_B0_00_GPIO1_IO00 0x401F80BCU, 0x5U, 0, 0, 0x401F82ACU +#define IOMUXC_GPIO_AD_B0_00_USDHC1_RESET_B 0x401F80BCU, 0x6U, 0, 0, 0x401F82ACU +#define IOMUXC_GPIO_AD_B0_00_LPSPI3_SCK 0x401F80BCU, 0x7U, 0x401F8510U, 0x0U, 0x401F82ACU + +#define IOMUXC_GPIO_AD_B0_01_FLEXPWM2_PWMB03 0x401F80C0U, 0x0U, 0x401F8484U, 0x2U, 0x401F82B0U +#define IOMUXC_GPIO_AD_B0_01_XBAR1_INOUT15 0x401F80C0U, 0x1U, 0x401F8648U, 0x0U, 0x401F82B0U +#define IOMUXC_GPIO_AD_B0_01_REF_CLK_24M 0x401F80C0U, 0x2U, 0, 0, 0x401F82B0U +#define IOMUXC_GPIO_AD_B0_01_USB_OTG1_ID 0x401F80C0U, 0x3U, 0x401F83F4U, 0x0U, 0x401F82B0U +#define IOMUXC_GPIO_AD_B0_01_LPI2C1_SDAS 0x401F80C0U, 0x4U, 0, 0, 0x401F82B0U +#define IOMUXC_GPIO_AD_B0_01_GPIO1_IO01 0x401F80C0U, 0x5U, 0, 0, 0x401F82B0U +#define IOMUXC_GPIO_AD_B0_01_EWM_OUT_B 0x401F80C0U, 0x6U, 0, 0, 0x401F82B0U +#define IOMUXC_GPIO_AD_B0_01_LPSPI3_SDO 0x401F80C0U, 0x7U, 0x401F8518U, 0x0U, 0x401F82B0U + +#define IOMUXC_GPIO_AD_B0_02_FLEXCAN2_TX 0x401F80C4U, 0x0U, 0, 0, 0x401F82B4U +#define IOMUXC_GPIO_AD_B0_02_XBAR1_INOUT16 0x401F80C4U, 0x1U, 0x401F864CU, 0x0U, 0x401F82B4U +#define IOMUXC_GPIO_AD_B0_02_LPUART6_TX 0x401F80C4U, 0x2U, 0x401F8554U, 0x1U, 0x401F82B4U +#define IOMUXC_GPIO_AD_B0_02_USB_OTG1_PWR 0x401F80C4U, 0x3U, 0, 0, 0x401F82B4U +#define IOMUXC_GPIO_AD_B0_02_FLEXPWM1_PWMX00 0x401F80C4U, 0x4U, 0, 0, 0x401F82B4U +#define IOMUXC_GPIO_AD_B0_02_GPIO1_IO02 0x401F80C4U, 0x5U, 0, 0, 0x401F82B4U +#define IOMUXC_GPIO_AD_B0_02_LPI2C1_HREQ 0x401F80C4U, 0x6U, 0, 0, 0x401F82B4U +#define IOMUXC_GPIO_AD_B0_02_LPSPI3_SDI 0x401F80C4U, 0x7U, 0x401F8514U, 0x0U, 0x401F82B4U + +#define IOMUXC_GPIO_AD_B0_03_FLEXCAN2_RX 0x401F80C8U, 0x0U, 0x401F8450U, 0x1U, 0x401F82B8U +#define IOMUXC_GPIO_AD_B0_03_XBAR1_INOUT17 0x401F80C8U, 0x1U, 0x401F862CU, 0x1U, 0x401F82B8U +#define IOMUXC_GPIO_AD_B0_03_LPUART6_RX 0x401F80C8U, 0x2U, 0x401F8550U, 0x1U, 0x401F82B8U +#define IOMUXC_GPIO_AD_B0_03_USB_OTG1_OC 0x401F80C8U, 0x3U, 0x401F85D0U, 0x0U, 0x401F82B8U +#define IOMUXC_GPIO_AD_B0_03_FLEXPWM1_PWMX01 0x401F80C8U, 0x4U, 0, 0, 0x401F82B8U +#define IOMUXC_GPIO_AD_B0_03_GPIO1_IO03 0x401F80C8U, 0x5U, 0, 0, 0x401F82B8U +#define IOMUXC_GPIO_AD_B0_03_REF_CLK_24M 0x401F80C8U, 0x6U, 0, 0, 0x401F82B8U +#define IOMUXC_GPIO_AD_B0_03_LPSPI3_PCS0 0x401F80C8U, 0x7U, 0x401F850CU, 0x0U, 0x401F82B8U + +#define IOMUXC_GPIO_AD_B0_04_SRC_BOOT_MODE00 0x401F80CCU, 0x0U, 0, 0, 0x401F82BCU +#define IOMUXC_GPIO_AD_B0_04_MQS_RIGHT 0x401F80CCU, 0x1U, 0, 0, 0x401F82BCU +#define IOMUXC_GPIO_AD_B0_04_ENET_TX_DATA03 0x401F80CCU, 0x2U, 0, 0, 0x401F82BCU +#define IOMUXC_GPIO_AD_B0_04_SAI2_TX_SYNC 0x401F80CCU, 0x3U, 0x401F85C4U, 0x1U, 0x401F82BCU +#define IOMUXC_GPIO_AD_B0_04_CSI_DATA09 0x401F80CCU, 0x4U, 0x401F841CU, 0x1U, 0x401F82BCU +#define IOMUXC_GPIO_AD_B0_04_GPIO1_IO04 0x401F80CCU, 0x5U, 0, 0, 0x401F82BCU +#define IOMUXC_GPIO_AD_B0_04_PIT_TRIGGER00 0x401F80CCU, 0x6U, 0, 0, 0x401F82BCU +#define IOMUXC_GPIO_AD_B0_04_LPSPI3_PCS1 0x401F80CCU, 0x7U, 0, 0, 0x401F82BCU + +#define IOMUXC_GPIO_AD_B0_05_SRC_BOOT_MODE01 0x401F80D0U, 0x0U, 0, 0, 0x401F82C0U +#define IOMUXC_GPIO_AD_B0_05_MQS_LEFT 0x401F80D0U, 0x1U, 0, 0, 0x401F82C0U +#define IOMUXC_GPIO_AD_B0_05_ENET_TX_DATA02 0x401F80D0U, 0x2U, 0, 0, 0x401F82C0U +#define IOMUXC_GPIO_AD_B0_05_SAI2_TX_BCLK 0x401F80D0U, 0x3U, 0x401F85C0U, 0x1U, 0x401F82C0U +#define IOMUXC_GPIO_AD_B0_05_CSI_DATA08 0x401F80D0U, 0x4U, 0x401F8418U, 0x1U, 0x401F82C0U +#define IOMUXC_GPIO_AD_B0_05_GPIO1_IO05 0x401F80D0U, 0x5U, 0, 0, 0x401F82C0U +#define IOMUXC_GPIO_AD_B0_05_XBAR1_INOUT17 0x401F80D0U, 0x6U, 0x401F862CU, 0x2U, 0x401F82C0U +#define IOMUXC_GPIO_AD_B0_05_LPSPI3_PCS2 0x401F80D0U, 0x7U, 0, 0, 0x401F82C0U + +#define IOMUXC_GPIO_AD_B0_06_JTAG_TMS 0x401F80D4U, 0x0U, 0, 0, 0x401F82C4U +#define IOMUXC_GPIO_AD_B0_06_GPT2_COMPARE1 0x401F80D4U, 0x1U, 0, 0, 0x401F82C4U +#define IOMUXC_GPIO_AD_B0_06_ENET_RX_CLK 0x401F80D4U, 0x2U, 0, 0, 0x401F82C4U +#define IOMUXC_GPIO_AD_B0_06_SAI2_RX_BCLK 0x401F80D4U, 0x3U, 0x401F85B4U, 0x1U, 0x401F82C4U +#define IOMUXC_GPIO_AD_B0_06_CSI_DATA07 0x401F80D4U, 0x4U, 0x401F8414U, 0x1U, 0x401F82C4U +#define IOMUXC_GPIO_AD_B0_06_GPIO1_IO06 0x401F80D4U, 0x5U, 0, 0, 0x401F82C4U +#define IOMUXC_GPIO_AD_B0_06_XBAR1_INOUT18 0x401F80D4U, 0x6U, 0x401F8630U, 0x1U, 0x401F82C4U +#define IOMUXC_GPIO_AD_B0_06_LPSPI3_PCS3 0x401F80D4U, 0x7U, 0, 0, 0x401F82C4U + +#define IOMUXC_GPIO_AD_B0_07_JTAG_TCK 0x401F80D8U, 0x0U, 0, 0, 0x401F82C8U +#define IOMUXC_GPIO_AD_B0_07_GPT2_COMPARE2 0x401F80D8U, 0x1U, 0, 0, 0x401F82C8U +#define IOMUXC_GPIO_AD_B0_07_ENET_TX_ER 0x401F80D8U, 0x2U, 0, 0, 0x401F82C8U +#define IOMUXC_GPIO_AD_B0_07_SAI2_RX_SYNC 0x401F80D8U, 0x3U, 0x401F85BCU, 0x1U, 0x401F82C8U +#define IOMUXC_GPIO_AD_B0_07_CSI_DATA06 0x401F80D8U, 0x4U, 0x401F8410U, 0x1U, 0x401F82C8U +#define IOMUXC_GPIO_AD_B0_07_GPIO1_IO07 0x401F80D8U, 0x5U, 0, 0, 0x401F82C8U +#define IOMUXC_GPIO_AD_B0_07_XBAR1_INOUT19 0x401F80D8U, 0x6U, 0x401F8654U, 0x1U, 0x401F82C8U +#define IOMUXC_GPIO_AD_B0_07_ENET_1588_EVENT3_OUT 0x401F80D8U, 0x7U, 0, 0, 0x401F82C8U + +#define IOMUXC_GPIO_AD_B0_08_JTAG_MOD 0x401F80DCU, 0x0U, 0, 0, 0x401F82CCU +#define IOMUXC_GPIO_AD_B0_08_GPT2_COMPARE3 0x401F80DCU, 0x1U, 0, 0, 0x401F82CCU +#define IOMUXC_GPIO_AD_B0_08_ENET_RX_DATA03 0x401F80DCU, 0x2U, 0, 0, 0x401F82CCU +#define IOMUXC_GPIO_AD_B0_08_SAI2_RX_DATA 0x401F80DCU, 0x3U, 0x401F85B8U, 0x1U, 0x401F82CCU +#define IOMUXC_GPIO_AD_B0_08_CSI_DATA05 0x401F80DCU, 0x4U, 0x401F840CU, 0x1U, 0x401F82CCU +#define IOMUXC_GPIO_AD_B0_08_GPIO1_IO08 0x401F80DCU, 0x5U, 0, 0, 0x401F82CCU +#define IOMUXC_GPIO_AD_B0_08_XBAR1_IN20 0x401F80DCU, 0x6U, 0x401F8634U, 0x1U, 0x401F82CCU +#define IOMUXC_GPIO_AD_B0_08_ENET_1588_EVENT3_IN 0x401F80DCU, 0x7U, 0, 0, 0x401F82CCU + +#define IOMUXC_GPIO_AD_B0_09_JTAG_TDI 0x401F80E0U, 0x0U, 0, 0, 0x401F82D0U +#define IOMUXC_GPIO_AD_B0_09_FLEXPWM2_PWMA03 0x401F80E0U, 0x1U, 0x401F8474U, 0x3U, 0x401F82D0U +#define IOMUXC_GPIO_AD_B0_09_ENET_RX_DATA02 0x401F80E0U, 0x2U, 0, 0, 0x401F82D0U +#define IOMUXC_GPIO_AD_B0_09_SAI2_TX_DATA 0x401F80E0U, 0x3U, 0, 0, 0x401F82D0U +#define IOMUXC_GPIO_AD_B0_09_CSI_DATA04 0x401F80E0U, 0x4U, 0x401F8408U, 0x1U, 0x401F82D0U +#define IOMUXC_GPIO_AD_B0_09_GPIO1_IO09 0x401F80E0U, 0x5U, 0, 0, 0x401F82D0U +#define IOMUXC_GPIO_AD_B0_09_XBAR1_IN21 0x401F80E0U, 0x6U, 0x401F8658U, 0x1U, 0x401F82D0U +#define IOMUXC_GPIO_AD_B0_09_GPT2_CLK 0x401F80E0U, 0x7U, 0x401F876CU, 0x0U, 0x401F82D0U +#define IOMUXC_GPIO_AD_B0_09_SEMC_DQS4 0x401F80E0U, 0x9U, 0x401F8788U, 0x2U, 0x401F82D0U + +#define IOMUXC_GPIO_AD_B0_10_JTAG_TDO 0x401F80E4U, 0x0U, 0, 0, 0x401F82D4U +#define IOMUXC_GPIO_AD_B0_10_FLEXPWM1_PWMA03 0x401F80E4U, 0x1U, 0x401F8454U, 0x3U, 0x401F82D4U +#define IOMUXC_GPIO_AD_B0_10_ENET_CRS 0x401F80E4U, 0x2U, 0, 0, 0x401F82D4U +#define IOMUXC_GPIO_AD_B0_10_SAI2_MCLK 0x401F80E4U, 0x3U, 0x401F85B0U, 0x1U, 0x401F82D4U +#define IOMUXC_GPIO_AD_B0_10_CSI_DATA03 0x401F80E4U, 0x4U, 0x401F8404U, 0x1U, 0x401F82D4U +#define IOMUXC_GPIO_AD_B0_10_GPIO1_IO10 0x401F80E4U, 0x5U, 0, 0, 0x401F82D4U +#define IOMUXC_GPIO_AD_B0_10_XBAR1_IN22 0x401F80E4U, 0x6U, 0x401F8638U, 0x1U, 0x401F82D4U +#define IOMUXC_GPIO_AD_B0_10_ENET_1588_EVENT0_OUT 0x401F80E4U, 0x7U, 0, 0, 0x401F82D4U +#define IOMUXC_GPIO_AD_B0_10_FLEXCAN3_TX 0x401F80E4U, 0x8U, 0, 0, 0x401F82D4U +#define IOMUXC_GPIO_AD_B0_10_ARM_TRACE_SWO 0x401F80E4U, 0x9U, 0, 0, 0x401F82D4U + +#define IOMUXC_GPIO_AD_B0_11_JTAG_TRSTB 0x401F80E8U, 0x0U, 0, 0, 0x401F82D8U +#define IOMUXC_GPIO_AD_B0_11_FLEXPWM1_PWMB03 0x401F80E8U, 0x1U, 0x401F8464U, 0x3U, 0x401F82D8U +#define IOMUXC_GPIO_AD_B0_11_ENET_COL 0x401F80E8U, 0x2U, 0, 0, 0x401F82D8U +#define IOMUXC_GPIO_AD_B0_11_WDOG1_WDOG_B 0x401F80E8U, 0x3U, 0, 0, 0x401F82D8U +#define IOMUXC_GPIO_AD_B0_11_CSI_DATA02 0x401F80E8U, 0x4U, 0x401F8400U, 0x1U, 0x401F82D8U +#define IOMUXC_GPIO_AD_B0_11_GPIO1_IO11 0x401F80E8U, 0x5U, 0, 0, 0x401F82D8U +#define IOMUXC_GPIO_AD_B0_11_XBAR1_IN23 0x401F80E8U, 0x6U, 0x401F863CU, 0x1U, 0x401F82D8U +#define IOMUXC_GPIO_AD_B0_11_ENET_1588_EVENT0_IN 0x401F80E8U, 0x7U, 0x401F8444U, 0x1U, 0x401F82D8U +#define IOMUXC_GPIO_AD_B0_11_FLEXCAN3_RX 0x401F80E8U, 0x8U, 0x401F878CU, 0x2U, 0x401F82D8U +#define IOMUXC_GPIO_AD_B0_11_SEMC_CLK6 0x401F80E8U, 0x9U, 0, 0, 0x401F82D8U + +#define IOMUXC_GPIO_AD_B0_12_LPI2C4_SCL 0x401F80ECU, 0x0U, 0x401F84E4U, 0x1U, 0x401F82DCU +#define IOMUXC_GPIO_AD_B0_12_CCM_PMIC_READY 0x401F80ECU, 0x1U, 0x401F83FCU, 0x1U, 0x401F82DCU +#define IOMUXC_GPIO_AD_B0_12_LPUART1_TX 0x401F80ECU, 0x2U, 0, 0, 0x401F82DCU +#define IOMUXC_GPIO_AD_B0_12_WDOG2_WDOG_B 0x401F80ECU, 0x3U, 0, 0, 0x401F82DCU +#define IOMUXC_GPIO_AD_B0_12_FLEXPWM1_PWMX02 0x401F80ECU, 0x4U, 0, 0, 0x401F82DCU +#define IOMUXC_GPIO_AD_B0_12_GPIO1_IO12 0x401F80ECU, 0x5U, 0, 0, 0x401F82DCU +#define IOMUXC_GPIO_AD_B0_12_ENET_1588_EVENT1_OUT 0x401F80ECU, 0x6U, 0, 0, 0x401F82DCU +#define IOMUXC_GPIO_AD_B0_12_NMI_GLUE_NMI 0x401F80ECU, 0x7U, 0x401F8568U, 0x0U, 0x401F82DCU + +#define IOMUXC_GPIO_AD_B0_13_LPI2C4_SDA 0x401F80F0U, 0x0U, 0x401F84E8U, 0x1U, 0x401F82E0U +#define IOMUXC_GPIO_AD_B0_13_GPT1_CLK 0x401F80F0U, 0x1U, 0x401F8760U, 0x0U, 0x401F82E0U +#define IOMUXC_GPIO_AD_B0_13_LPUART1_RX 0x401F80F0U, 0x2U, 0, 0, 0x401F82E0U +#define IOMUXC_GPIO_AD_B0_13_EWM_OUT_B 0x401F80F0U, 0x3U, 0, 0, 0x401F82E0U +#define IOMUXC_GPIO_AD_B0_13_FLEXPWM1_PWMX03 0x401F80F0U, 0x4U, 0, 0, 0x401F82E0U +#define IOMUXC_GPIO_AD_B0_13_GPIO1_IO13 0x401F80F0U, 0x5U, 0, 0, 0x401F82E0U +#define IOMUXC_GPIO_AD_B0_13_ENET_1588_EVENT1_IN 0x401F80F0U, 0x6U, 0, 0, 0x401F82E0U +#define IOMUXC_GPIO_AD_B0_13_REF_CLK_24M 0x401F80F0U, 0x7U, 0, 0, 0x401F82E0U + +#define IOMUXC_GPIO_AD_B0_14_USB_OTG2_OC 0x401F80F4U, 0x0U, 0x401F85CCU, 0x0U, 0x401F82E4U +#define IOMUXC_GPIO_AD_B0_14_XBAR1_IN24 0x401F80F4U, 0x1U, 0x401F8640U, 0x1U, 0x401F82E4U +#define IOMUXC_GPIO_AD_B0_14_LPUART1_CTS_B 0x401F80F4U, 0x2U, 0, 0, 0x401F82E4U +#define IOMUXC_GPIO_AD_B0_14_ENET_1588_EVENT0_OUT 0x401F80F4U, 0x3U, 0, 0, 0x401F82E4U +#define IOMUXC_GPIO_AD_B0_14_CSI_VSYNC 0x401F80F4U, 0x4U, 0x401F8428U, 0x0U, 0x401F82E4U +#define IOMUXC_GPIO_AD_B0_14_GPIO1_IO14 0x401F80F4U, 0x5U, 0, 0, 0x401F82E4U +#define IOMUXC_GPIO_AD_B0_14_FLEXCAN2_TX 0x401F80F4U, 0x6U, 0, 0, 0x401F82E4U +#define IOMUXC_GPIO_AD_B0_14_FLEXCAN3_TX 0x401F80F4U, 0x8U, 0, 0, 0x401F82E4U + +#define IOMUXC_GPIO_AD_B0_15_USB_OTG2_PWR 0x401F80F8U, 0x0U, 0, 0, 0x401F82E8U +#define IOMUXC_GPIO_AD_B0_15_XBAR1_IN25 0x401F80F8U, 0x1U, 0x401F8650U, 0x0U, 0x401F82E8U +#define IOMUXC_GPIO_AD_B0_15_LPUART1_RTS_B 0x401F80F8U, 0x2U, 0, 0, 0x401F82E8U +#define IOMUXC_GPIO_AD_B0_15_ENET_1588_EVENT0_IN 0x401F80F8U, 0x3U, 0x401F8444U, 0x0U, 0x401F82E8U +#define IOMUXC_GPIO_AD_B0_15_CSI_HSYNC 0x401F80F8U, 0x4U, 0x401F8420U, 0x0U, 0x401F82E8U +#define IOMUXC_GPIO_AD_B0_15_GPIO1_IO15 0x401F80F8U, 0x5U, 0, 0, 0x401F82E8U +#define IOMUXC_GPIO_AD_B0_15_FLEXCAN2_RX 0x401F80F8U, 0x6U, 0x401F8450U, 0x2U, 0x401F82E8U +#define IOMUXC_GPIO_AD_B0_15_WDOG1_WDOG_RST_B_DEB 0x401F80F8U, 0x7U, 0, 0, 0x401F82E8U +#define IOMUXC_GPIO_AD_B0_15_FLEXCAN3_RX 0x401F80F8U, 0x8U, 0x401F878CU, 0x1U, 0x401F82E8U + +#define IOMUXC_GPIO_AD_B1_00_USB_OTG2_ID 0x401F80FCU, 0x0U, 0x401F83F8U, 0x1U, 0x401F82ECU +#define IOMUXC_GPIO_AD_B1_00_QTIMER3_TIMER0 0x401F80FCU, 0x1U, 0x401F857CU, 0x1U, 0x401F82ECU +#define IOMUXC_GPIO_AD_B1_00_LPUART2_CTS_B 0x401F80FCU, 0x2U, 0, 0, 0x401F82ECU +#define IOMUXC_GPIO_AD_B1_00_LPI2C1_SCL 0x401F80FCU, 0x3U, 0x401F84CCU, 0x1U, 0x401F82ECU +#define IOMUXC_GPIO_AD_B1_00_WDOG1_B 0x401F80FCU, 0x4U, 0, 0, 0x401F82ECU +#define IOMUXC_GPIO_AD_B1_00_GPIO1_IO16 0x401F80FCU, 0x5U, 0, 0, 0x401F82ECU +#define IOMUXC_GPIO_AD_B1_00_USDHC1_WP 0x401F80FCU, 0x6U, 0x401F85D8U, 0x2U, 0x401F82ECU +#define IOMUXC_GPIO_AD_B1_00_KPP_ROW07 0x401F80FCU, 0x7U, 0, 0, 0x401F82ECU +#define IOMUXC_GPIO_AD_B1_00_ENET2_1588_EVENT0_OUT 0x401F80FCU, 0x8U, 0, 0, 0x401F82ECU +#define IOMUXC_GPIO_AD_B1_00_FLEXIO3_FLEXIO00 0x401F80FCU, 0x9U, 0, 0, 0x401F82ECU + +#define IOMUXC_GPIO_AD_B1_01_USB_OTG1_PWR 0x401F8100U, 0x0U, 0, 0, 0x401F82F0U +#define IOMUXC_GPIO_AD_B1_01_QTIMER3_TIMER1 0x401F8100U, 0x1U, 0x401F8580U, 0x0U, 0x401F82F0U +#define IOMUXC_GPIO_AD_B1_01_LPUART2_RTS_B 0x401F8100U, 0x2U, 0, 0, 0x401F82F0U +#define IOMUXC_GPIO_AD_B1_01_LPI2C1_SDA 0x401F8100U, 0x3U, 0x401F84D0U, 0x1U, 0x401F82F0U +#define IOMUXC_GPIO_AD_B1_01_CCM_PMIC_READY 0x401F8100U, 0x4U, 0x401F83FCU, 0x2U, 0x401F82F0U +#define IOMUXC_GPIO_AD_B1_01_GPIO1_IO17 0x401F8100U, 0x5U, 0, 0, 0x401F82F0U +#define IOMUXC_GPIO_AD_B1_01_USDHC1_VSELECT 0x401F8100U, 0x6U, 0, 0, 0x401F82F0U +#define IOMUXC_GPIO_AD_B1_01_KPP_COL07 0x401F8100U, 0x7U, 0, 0, 0x401F82F0U +#define IOMUXC_GPIO_AD_B1_01_ENET2_1588_EVENT0_IN 0x401F8100U, 0x8U, 0x401F8724U, 0x0U, 0x401F82F0U +#define IOMUXC_GPIO_AD_B1_01_FLEXIO3_FLEXIO01 0x401F8100U, 0x9U, 0, 0, 0x401F82F0U + +#define IOMUXC_GPIO_AD_B1_02_USB_OTG1_ID 0x401F8104U, 0x0U, 0x401F83F4U, 0x1U, 0x401F82F4U +#define IOMUXC_GPIO_AD_B1_02_QTIMER3_TIMER2 0x401F8104U, 0x1U, 0x401F8584U, 0x1U, 0x401F82F4U +#define IOMUXC_GPIO_AD_B1_02_LPUART2_TX 0x401F8104U, 0x2U, 0x401F8530U, 0x1U, 0x401F82F4U +#define IOMUXC_GPIO_AD_B1_02_SPDIF_OUT 0x401F8104U, 0x3U, 0, 0, 0x401F82F4U +#define IOMUXC_GPIO_AD_B1_02_ENET_1588_EVENT2_OUT 0x401F8104U, 0x4U, 0, 0, 0x401F82F4U +#define IOMUXC_GPIO_AD_B1_02_GPIO1_IO18 0x401F8104U, 0x5U, 0, 0, 0x401F82F4U +#define IOMUXC_GPIO_AD_B1_02_USDHC1_CD_B 0x401F8104U, 0x6U, 0x401F85D4U, 0x1U, 0x401F82F4U +#define IOMUXC_GPIO_AD_B1_02_KPP_ROW06 0x401F8104U, 0x7U, 0, 0, 0x401F82F4U +#define IOMUXC_GPIO_AD_B1_02_GPT2_CLK 0x401F8104U, 0x8U, 0x401F876CU, 0x1U, 0x401F82F4U +#define IOMUXC_GPIO_AD_B1_02_FLEXIO3_FLEXIO02 0x401F8104U, 0x9U, 0, 0, 0x401F82F4U + +#define IOMUXC_GPIO_AD_B1_03_USB_OTG1_OC 0x401F8108U, 0x0U, 0x401F85D0U, 0x1U, 0x401F82F8U +#define IOMUXC_GPIO_AD_B1_03_QTIMER3_TIMER3 0x401F8108U, 0x1U, 0x401F8588U, 0x1U, 0x401F82F8U +#define IOMUXC_GPIO_AD_B1_03_LPUART2_RX 0x401F8108U, 0x2U, 0x401F852CU, 0x1U, 0x401F82F8U +#define IOMUXC_GPIO_AD_B1_03_SPDIF_IN 0x401F8108U, 0x3U, 0x401F85C8U, 0x0U, 0x401F82F8U +#define IOMUXC_GPIO_AD_B1_03_ENET_1588_EVENT2_IN 0x401F8108U, 0x4U, 0, 0, 0x401F82F8U +#define IOMUXC_GPIO_AD_B1_03_GPIO1_IO19 0x401F8108U, 0x5U, 0, 0, 0x401F82F8U +#define IOMUXC_GPIO_AD_B1_03_USDHC2_CD_B 0x401F8108U, 0x6U, 0x401F85E0U, 0x0U, 0x401F82F8U +#define IOMUXC_GPIO_AD_B1_03_KPP_COL06 0x401F8108U, 0x7U, 0, 0, 0x401F82F8U +#define IOMUXC_GPIO_AD_B1_03_GPT2_CAPTURE1 0x401F8108U, 0x8U, 0x401F8764U, 0x1U, 0x401F82F8U +#define IOMUXC_GPIO_AD_B1_03_FLEXIO3_FLEXIO03 0x401F8108U, 0x9U, 0, 0, 0x401F82F8U + +#define IOMUXC_GPIO_AD_B1_04_FLEXSPIB_DATA03 0x401F810CU, 0x0U, 0x401F84C4U, 0x1U, 0x401F82FCU +#define IOMUXC_GPIO_AD_B1_04_ENET_MDC 0x401F810CU, 0x1U, 0, 0, 0x401F82FCU +#define IOMUXC_GPIO_AD_B1_04_LPUART3_CTS_B 0x401F810CU, 0x2U, 0x401F8534U, 0x1U, 0x401F82FCU +#define IOMUXC_GPIO_AD_B1_04_SPDIF_SR_CLK 0x401F810CU, 0x3U, 0, 0, 0x401F82FCU +#define IOMUXC_GPIO_AD_B1_04_CSI_PIXCLK 0x401F810CU, 0x4U, 0x401F8424U, 0x0U, 0x401F82FCU +#define IOMUXC_GPIO_AD_B1_04_GPIO1_IO20 0x401F810CU, 0x5U, 0, 0, 0x401F82FCU +#define IOMUXC_GPIO_AD_B1_04_USDHC2_DATA0 0x401F810CU, 0x6U, 0x401F85E8U, 0x1U, 0x401F82FCU +#define IOMUXC_GPIO_AD_B1_04_KPP_ROW05 0x401F810CU, 0x7U, 0, 0, 0x401F82FCU +#define IOMUXC_GPIO_AD_B1_04_GPT2_CAPTURE2 0x401F810CU, 0x8U, 0x401F8768U, 0x1U, 0x401F82FCU +#define IOMUXC_GPIO_AD_B1_04_FLEXIO3_FLEXIO04 0x401F810CU, 0x9U, 0, 0, 0x401F82FCU + +#define IOMUXC_GPIO_AD_B1_05_FLEXSPIB_DATA02 0x401F8110U, 0x0U, 0x401F84C0U, 0x1U, 0x401F8300U +#define IOMUXC_GPIO_AD_B1_05_ENET_MDIO 0x401F8110U, 0x1U, 0x401F8430U, 0x0U, 0x401F8300U +#define IOMUXC_GPIO_AD_B1_05_LPUART3_RTS_B 0x401F8110U, 0x2U, 0, 0, 0x401F8300U +#define IOMUXC_GPIO_AD_B1_05_SPDIF_OUT 0x401F8110U, 0x3U, 0, 0, 0x401F8300U +#define IOMUXC_GPIO_AD_B1_05_CSI_MCLK 0x401F8110U, 0x4U, 0, 0, 0x401F8300U +#define IOMUXC_GPIO_AD_B1_05_GPIO1_IO21 0x401F8110U, 0x5U, 0, 0, 0x401F8300U +#define IOMUXC_GPIO_AD_B1_05_USDHC2_DATA1 0x401F8110U, 0x6U, 0x401F85ECU, 0x1U, 0x401F8300U +#define IOMUXC_GPIO_AD_B1_05_KPP_COL05 0x401F8110U, 0x7U, 0, 0, 0x401F8300U +#define IOMUXC_GPIO_AD_B1_05_GPT2_COMPARE1 0x401F8110U, 0x8U, 0, 0, 0x401F8300U +#define IOMUXC_GPIO_AD_B1_05_FLEXIO3_FLEXIO05 0x401F8110U, 0x9U, 0, 0, 0x401F8300U + +#define IOMUXC_GPIO_AD_B1_06_FLEXSPIB_DATA01 0x401F8114U, 0x0U, 0x401F84BCU, 0x1U, 0x401F8304U +#define IOMUXC_GPIO_AD_B1_06_LPI2C3_SDA 0x401F8114U, 0x1U, 0x401F84E0U, 0x2U, 0x401F8304U +#define IOMUXC_GPIO_AD_B1_06_LPUART3_TX 0x401F8114U, 0x2U, 0x401F853CU, 0x0U, 0x401F8304U +#define IOMUXC_GPIO_AD_B1_06_SPDIF_LOCK 0x401F8114U, 0x3U, 0, 0, 0x401F8304U +#define IOMUXC_GPIO_AD_B1_06_CSI_VSYNC 0x401F8114U, 0x4U, 0x401F8428U, 0x1U, 0x401F8304U +#define IOMUXC_GPIO_AD_B1_06_GPIO1_IO22 0x401F8114U, 0x5U, 0, 0, 0x401F8304U +#define IOMUXC_GPIO_AD_B1_06_USDHC2_DATA2 0x401F8114U, 0x6U, 0x401F85F0U, 0x1U, 0x401F8304U +#define IOMUXC_GPIO_AD_B1_06_KPP_ROW04 0x401F8114U, 0x7U, 0, 0, 0x401F8304U +#define IOMUXC_GPIO_AD_B1_06_GPT2_COMPARE2 0x401F8114U, 0x8U, 0, 0, 0x401F8304U +#define IOMUXC_GPIO_AD_B1_06_FLEXIO3_FLEXIO06 0x401F8114U, 0x9U, 0, 0, 0x401F8304U + +#define IOMUXC_GPIO_AD_B1_07_FLEXSPIB_DATA00 0x401F8118U, 0x0U, 0x401F84B8U, 0x1U, 0x401F8308U +#define IOMUXC_GPIO_AD_B1_07_LPI2C3_SCL 0x401F8118U, 0x1U, 0x401F84DCU, 0x2U, 0x401F8308U +#define IOMUXC_GPIO_AD_B1_07_LPUART3_RX 0x401F8118U, 0x2U, 0x401F8538U, 0x0U, 0x401F8308U +#define IOMUXC_GPIO_AD_B1_07_SPDIF_EXT_CLK 0x401F8118U, 0x3U, 0, 0, 0x401F8308U +#define IOMUXC_GPIO_AD_B1_07_CSI_HSYNC 0x401F8118U, 0x4U, 0x401F8420U, 0x1U, 0x401F8308U +#define IOMUXC_GPIO_AD_B1_07_GPIO1_IO23 0x401F8118U, 0x5U, 0, 0, 0x401F8308U +#define IOMUXC_GPIO_AD_B1_07_USDHC2_DATA3 0x401F8118U, 0x6U, 0x401F85F4U, 0x1U, 0x401F8308U +#define IOMUXC_GPIO_AD_B1_07_KPP_COL04 0x401F8118U, 0x7U, 0, 0, 0x401F8308U +#define IOMUXC_GPIO_AD_B1_07_GPT2_COMPARE3 0x401F8118U, 0x8U, 0, 0, 0x401F8308U +#define IOMUXC_GPIO_AD_B1_07_FLEXIO3_FLEXIO07 0x401F8118U, 0x9U, 0, 0, 0x401F8308U + +#define IOMUXC_GPIO_AD_B1_08_FLEXSPIA_SS1_B 0x401F811CU, 0x0U, 0, 0, 0x401F830CU +#define IOMUXC_GPIO_AD_B1_08_FLEXPWM4_PWMA00 0x401F811CU, 0x1U, 0x401F8494U, 0x1U, 0x401F830CU +#define IOMUXC_GPIO_AD_B1_08_FLEXCAN1_TX 0x401F811CU, 0x2U, 0, 0, 0x401F830CU +#define IOMUXC_GPIO_AD_B1_08_CCM_PMIC_READY 0x401F811CU, 0x3U, 0x401F83FCU, 0x3U, 0x401F830CU +#define IOMUXC_GPIO_AD_B1_08_CSI_DATA09 0x401F811CU, 0x4U, 0x401F841CU, 0x0U, 0x401F830CU +#define IOMUXC_GPIO_AD_B1_08_GPIO1_IO24 0x401F811CU, 0x5U, 0, 0, 0x401F830CU +#define IOMUXC_GPIO_AD_B1_08_USDHC2_CMD 0x401F811CU, 0x6U, 0x401F85E4U, 0x1U, 0x401F830CU +#define IOMUXC_GPIO_AD_B1_08_KPP_ROW03 0x401F811CU, 0x7U, 0, 0, 0x401F830CU +#define IOMUXC_GPIO_AD_B1_08_FLEXIO3_FLEXIO08 0x401F811CU, 0x9U, 0, 0, 0x401F830CU + +#define IOMUXC_GPIO_AD_B1_09_FLEXSPIA_DQS 0x401F8120U, 0x0U, 0x401F84A4U, 0x1U, 0x401F8310U +#define IOMUXC_GPIO_AD_B1_09_FLEXPWM4_PWMA01 0x401F8120U, 0x1U, 0x401F8498U, 0x1U, 0x401F8310U +#define IOMUXC_GPIO_AD_B1_09_FLEXCAN1_RX 0x401F8120U, 0x2U, 0x401F844CU, 0x2U, 0x401F8310U +#define IOMUXC_GPIO_AD_B1_09_SAI1_MCLK 0x401F8120U, 0x3U, 0x401F858CU, 0x1U, 0x401F8310U +#define IOMUXC_GPIO_AD_B1_09_CSI_DATA08 0x401F8120U, 0x4U, 0x401F8418U, 0x0U, 0x401F8310U +#define IOMUXC_GPIO_AD_B1_09_GPIO1_IO25 0x401F8120U, 0x5U, 0, 0, 0x401F8310U +#define IOMUXC_GPIO_AD_B1_09_USDHC2_CLK 0x401F8120U, 0x6U, 0x401F85DCU, 0x1U, 0x401F8310U +#define IOMUXC_GPIO_AD_B1_09_KPP_COL03 0x401F8120U, 0x7U, 0, 0, 0x401F8310U +#define IOMUXC_GPIO_AD_B1_09_FLEXIO3_FLEXIO09 0x401F8120U, 0x9U, 0, 0, 0x401F8310U + +#define IOMUXC_GPIO_AD_B1_10_FLEXSPIA_DATA03 0x401F8124U, 0x0U, 0x401F84B4U, 0x1U, 0x401F8314U +#define IOMUXC_GPIO_AD_B1_10_WDOG1_B 0x401F8124U, 0x1U, 0, 0, 0x401F8314U +#define IOMUXC_GPIO_AD_B1_10_LPUART8_TX 0x401F8124U, 0x2U, 0x401F8564U, 0x1U, 0x401F8314U +#define IOMUXC_GPIO_AD_B1_10_SAI1_RX_SYNC 0x401F8124U, 0x3U, 0x401F85A4U, 0x1U, 0x401F8314U +#define IOMUXC_GPIO_AD_B1_10_CSI_DATA07 0x401F8124U, 0x4U, 0x401F8414U, 0x0U, 0x401F8314U +#define IOMUXC_GPIO_AD_B1_10_GPIO1_IO26 0x401F8124U, 0x5U, 0, 0, 0x401F8314U +#define IOMUXC_GPIO_AD_B1_10_USDHC2_WP 0x401F8124U, 0x6U, 0x401F8608U, 0x1U, 0x401F8314U +#define IOMUXC_GPIO_AD_B1_10_KPP_ROW02 0x401F8124U, 0x7U, 0, 0, 0x401F8314U +#define IOMUXC_GPIO_AD_B1_10_ENET2_1588_EVENT1_OUT 0x401F8124U, 0x8U, 0, 0, 0x401F8314U +#define IOMUXC_GPIO_AD_B1_10_FLEXIO3_FLEXIO10 0x401F8124U, 0x9U, 0, 0, 0x401F8314U + +#define IOMUXC_GPIO_AD_B1_11_FLEXSPIA_DATA02 0x401F8128U, 0x0U, 0x401F84B0U, 0x1U, 0x401F8318U +#define IOMUXC_GPIO_AD_B1_11_EWM_OUT_B 0x401F8128U, 0x1U, 0, 0, 0x401F8318U +#define IOMUXC_GPIO_AD_B1_11_LPUART8_RX 0x401F8128U, 0x2U, 0x401F8560U, 0x1U, 0x401F8318U +#define IOMUXC_GPIO_AD_B1_11_SAI1_RX_BCLK 0x401F8128U, 0x3U, 0x401F8590U, 0x1U, 0x401F8318U +#define IOMUXC_GPIO_AD_B1_11_CSI_DATA06 0x401F8128U, 0x4U, 0x401F8410U, 0x0U, 0x401F8318U +#define IOMUXC_GPIO_AD_B1_11_GPIO1_IO27 0x401F8128U, 0x5U, 0, 0, 0x401F8318U +#define IOMUXC_GPIO_AD_B1_11_USDHC2_RESET_B 0x401F8128U, 0x6U, 0, 0, 0x401F8318U +#define IOMUXC_GPIO_AD_B1_11_KPP_COL02 0x401F8128U, 0x7U, 0, 0, 0x401F8318U +#define IOMUXC_GPIO_AD_B1_11_ENET2_1588_EVENT1_IN 0x401F8128U, 0x8U, 0, 0, 0x401F8318U +#define IOMUXC_GPIO_AD_B1_11_FLEXIO3_FLEXIO11 0x401F8128U, 0x9U, 0, 0, 0x401F8318U + +#define IOMUXC_GPIO_AD_B1_12_FLEXSPIA_DATA01 0x401F812CU, 0x0U, 0x401F84ACU, 0x1U, 0x401F831CU +#define IOMUXC_GPIO_AD_B1_12_ACMP_OUT00 0x401F812CU, 0x1U, 0, 0, 0x401F831CU +#define IOMUXC_GPIO_AD_B1_12_LPSPI3_PCS0 0x401F812CU, 0x2U, 0x401F850CU, 0x1U, 0x401F831CU +#define IOMUXC_GPIO_AD_B1_12_SAI1_RX_DATA00 0x401F812CU, 0x3U, 0x401F8594U, 0x1U, 0x401F831CU +#define IOMUXC_GPIO_AD_B1_12_CSI_DATA05 0x401F812CU, 0x4U, 0x401F840CU, 0x0U, 0x401F831CU +#define IOMUXC_GPIO_AD_B1_12_GPIO1_IO28 0x401F812CU, 0x5U, 0, 0, 0x401F831CU +#define IOMUXC_GPIO_AD_B1_12_USDHC2_DATA4 0x401F812CU, 0x6U, 0x401F85F8U, 0x1U, 0x401F831CU +#define IOMUXC_GPIO_AD_B1_12_KPP_ROW01 0x401F812CU, 0x7U, 0, 0, 0x401F831CU +#define IOMUXC_GPIO_AD_B1_12_ENET2_1588_EVENT2_OUT 0x401F812CU, 0x8U, 0, 0, 0x401F831CU +#define IOMUXC_GPIO_AD_B1_12_FLEXIO3_FLEXIO12 0x401F812CU, 0x9U, 0, 0, 0x401F831CU + +#define IOMUXC_GPIO_AD_B1_13_FLEXSPIA_DATA00 0x401F8130U, 0x0U, 0x401F84A8U, 0x1U, 0x401F8320U +#define IOMUXC_GPIO_AD_B1_13_ACMP_OUT01 0x401F8130U, 0x1U, 0, 0, 0x401F8320U +#define IOMUXC_GPIO_AD_B1_13_LPSPI3_SDI 0x401F8130U, 0x2U, 0x401F8514U, 0x1U, 0x401F8320U +#define IOMUXC_GPIO_AD_B1_13_SAI1_TX_DATA00 0x401F8130U, 0x3U, 0, 0, 0x401F8320U +#define IOMUXC_GPIO_AD_B1_13_CSI_DATA04 0x401F8130U, 0x4U, 0x401F8408U, 0x0U, 0x401F8320U +#define IOMUXC_GPIO_AD_B1_13_GPIO1_IO29 0x401F8130U, 0x5U, 0, 0, 0x401F8320U +#define IOMUXC_GPIO_AD_B1_13_USDHC2_DATA5 0x401F8130U, 0x6U, 0x401F85FCU, 0x1U, 0x401F8320U +#define IOMUXC_GPIO_AD_B1_13_KPP_COL01 0x401F8130U, 0x7U, 0, 0, 0x401F8320U +#define IOMUXC_GPIO_AD_B1_13_ENET2_1588_EVENT2_IN 0x401F8130U, 0x8U, 0, 0, 0x401F8320U +#define IOMUXC_GPIO_AD_B1_13_FLEXIO3_FLEXIO13 0x401F8130U, 0x9U, 0, 0, 0x401F8320U + +#define IOMUXC_GPIO_AD_B1_14_FLEXSPIA_SCLK 0x401F8134U, 0x0U, 0x401F84C8U, 0x1U, 0x401F8324U +#define IOMUXC_GPIO_AD_B1_14_ACMP_OUT02 0x401F8134U, 0x1U, 0, 0, 0x401F8324U +#define IOMUXC_GPIO_AD_B1_14_LPSPI3_SDO 0x401F8134U, 0x2U, 0x401F8518U, 0x1U, 0x401F8324U +#define IOMUXC_GPIO_AD_B1_14_SAI1_TX_BCLK 0x401F8134U, 0x3U, 0x401F85A8U, 0x1U, 0x401F8324U +#define IOMUXC_GPIO_AD_B1_14_CSI_DATA03 0x401F8134U, 0x4U, 0x401F8404U, 0x0U, 0x401F8324U +#define IOMUXC_GPIO_AD_B1_14_GPIO1_IO30 0x401F8134U, 0x5U, 0, 0, 0x401F8324U +#define IOMUXC_GPIO_AD_B1_14_USDHC2_DATA6 0x401F8134U, 0x6U, 0x401F8600U, 0x1U, 0x401F8324U +#define IOMUXC_GPIO_AD_B1_14_KPP_ROW00 0x401F8134U, 0x7U, 0, 0, 0x401F8324U +#define IOMUXC_GPIO_AD_B1_14_ENET2_1588_EVENT3_OUT 0x401F8134U, 0x8U, 0, 0, 0x401F8324U +#define IOMUXC_GPIO_AD_B1_14_FLEXIO3_FLEXIO14 0x401F8134U, 0x9U, 0, 0, 0x401F8324U + +#define IOMUXC_GPIO_AD_B1_15_FLEXSPIA_SS0_B 0x401F8138U, 0x0U, 0, 0, 0x401F8328U +#define IOMUXC_GPIO_AD_B1_15_ACMP_OUT03 0x401F8138U, 0x1U, 0, 0, 0x401F8328U +#define IOMUXC_GPIO_AD_B1_15_LPSPI3_SCK 0x401F8138U, 0x2U, 0, 0, 0x401F8328U +#define IOMUXC_GPIO_AD_B1_15_SAI1_TX_SYNC 0x401F8138U, 0x3U, 0x401F85ACU, 0x1U, 0x401F8328U +#define IOMUXC_GPIO_AD_B1_15_CSI_DATA02 0x401F8138U, 0x4U, 0x401F8400U, 0x0U, 0x401F8328U +#define IOMUXC_GPIO_AD_B1_15_GPIO1_IO31 0x401F8138U, 0x5U, 0, 0, 0x401F8328U +#define IOMUXC_GPIO_AD_B1_15_USDHC2_DATA7 0x401F8138U, 0x6U, 0x401F8604U, 0x1U, 0x401F8328U +#define IOMUXC_GPIO_AD_B1_15_KPP_COL00 0x401F8138U, 0x7U, 0, 0, 0x401F8328U +#define IOMUXC_GPIO_AD_B1_15_ENET2_1588_EVENT3_IN 0x401F8138U, 0x8U, 0, 0, 0x401F8328U +#define IOMUXC_GPIO_AD_B1_15_FLEXIO3_FLEXIO15 0x401F8138U, 0x9U, 0, 0, 0x401F8328U + +#define IOMUXC_GPIO_B0_00_LCD_CLK 0x401F813CU, 0x0U, 0, 0, 0x401F832CU +#define IOMUXC_GPIO_B0_00_QTIMER1_TIMER0 0x401F813CU, 0x1U, 0, 0, 0x401F832CU +#define IOMUXC_GPIO_B0_00_MQS_RIGHT 0x401F813CU, 0x2U, 0, 0, 0x401F832CU +#define IOMUXC_GPIO_B0_00_LPSPI4_PCS0 0x401F813CU, 0x3U, 0x401F851CU, 0x0U, 0x401F832CU +#define IOMUXC_GPIO_B0_00_FLEXIO2_FLEXIO00 0x401F813CU, 0x4U, 0, 0, 0x401F832CU +#define IOMUXC_GPIO_B0_00_GPIO2_IO00 0x401F813CU, 0x5U, 0, 0, 0x401F832CU +#define IOMUXC_GPIO_B0_00_SEMC_CSX01 0x401F813CU, 0x6U, 0, 0, 0x401F832CU +#define IOMUXC_GPIO_B0_00_ENET2_MDC 0x401F813CU, 0x8U, 0, 0, 0x401F832CU + +#define IOMUXC_GPIO_B0_01_LCD_ENABLE 0x401F8140U, 0x0U, 0, 0, 0x401F8330U +#define IOMUXC_GPIO_B0_01_QTIMER1_TIMER1 0x401F8140U, 0x1U, 0, 0, 0x401F8330U +#define IOMUXC_GPIO_B0_01_MQS_LEFT 0x401F8140U, 0x2U, 0, 0, 0x401F8330U +#define IOMUXC_GPIO_B0_01_LPSPI4_SDI 0x401F8140U, 0x3U, 0x401F8524U, 0x0U, 0x401F8330U +#define IOMUXC_GPIO_B0_01_FLEXIO2_FLEXIO01 0x401F8140U, 0x4U, 0, 0, 0x401F8330U +#define IOMUXC_GPIO_B0_01_GPIO2_IO01 0x401F8140U, 0x5U, 0, 0, 0x401F8330U +#define IOMUXC_GPIO_B0_01_SEMC_CSX02 0x401F8140U, 0x6U, 0, 0, 0x401F8330U +#define IOMUXC_GPIO_B0_01_ENET2_MDIO 0x401F8140U, 0x8U, 0x401F8710U, 0x1U, 0x401F8330U + +#define IOMUXC_GPIO_B0_02_LCD_HSYNC 0x401F8144U, 0x0U, 0, 0, 0x401F8334U +#define IOMUXC_GPIO_B0_02_QTIMER1_TIMER2 0x401F8144U, 0x1U, 0, 0, 0x401F8334U +#define IOMUXC_GPIO_B0_02_FLEXCAN1_TX 0x401F8144U, 0x2U, 0, 0, 0x401F8334U +#define IOMUXC_GPIO_B0_02_LPSPI4_SDO 0x401F8144U, 0x3U, 0x401F8528U, 0x0U, 0x401F8334U +#define IOMUXC_GPIO_B0_02_FLEXIO2_FLEXIO02 0x401F8144U, 0x4U, 0, 0, 0x401F8334U +#define IOMUXC_GPIO_B0_02_GPIO2_IO02 0x401F8144U, 0x5U, 0, 0, 0x401F8334U +#define IOMUXC_GPIO_B0_02_SEMC_CSX03 0x401F8144U, 0x6U, 0, 0, 0x401F8334U +#define IOMUXC_GPIO_B0_02_ENET2_1588_EVENT0_OUT 0x401F8144U, 0x8U, 0, 0, 0x401F8334U + +#define IOMUXC_GPIO_B0_03_LCD_VSYNC 0x401F8148U, 0x0U, 0, 0, 0x401F8338U +#define IOMUXC_GPIO_B0_03_QTIMER2_TIMER0 0x401F8148U, 0x1U, 0x401F856CU, 0x1U, 0x401F8338U +#define IOMUXC_GPIO_B0_03_FLEXCAN1_RX 0x401F8148U, 0x2U, 0x401F844CU, 0x3U, 0x401F8338U +#define IOMUXC_GPIO_B0_03_LPSPI4_SCK 0x401F8148U, 0x3U, 0x401F8520U, 0x0U, 0x401F8338U +#define IOMUXC_GPIO_B0_03_FLEXIO2_FLEXIO03 0x401F8148U, 0x4U, 0, 0, 0x401F8338U +#define IOMUXC_GPIO_B0_03_GPIO2_IO03 0x401F8148U, 0x5U, 0, 0, 0x401F8338U +#define IOMUXC_GPIO_B0_03_WDOG2_RESET_B_DEB 0x401F8148U, 0x6U, 0, 0, 0x401F8338U +#define IOMUXC_GPIO_B0_03_ENET2_1588_EVENT0_IN 0x401F8148U, 0x8U, 0x401F8724U, 0x1U, 0x401F8338U + +#define IOMUXC_GPIO_B0_04_LCD_DATA00 0x401F814CU, 0x0U, 0, 0, 0x401F833CU +#define IOMUXC_GPIO_B0_04_QTIMER2_TIMER1 0x401F814CU, 0x1U, 0x401F8570U, 0x1U, 0x401F833CU +#define IOMUXC_GPIO_B0_04_LPI2C2_SCL 0x401F814CU, 0x2U, 0x401F84D4U, 0x1U, 0x401F833CU +#define IOMUXC_GPIO_B0_04_ARM_TRACE0 0x401F814CU, 0x3U, 0, 0, 0x401F833CU +#define IOMUXC_GPIO_B0_04_FLEXIO2_FLEXIO04 0x401F814CU, 0x4U, 0, 0, 0x401F833CU +#define IOMUXC_GPIO_B0_04_GPIO2_IO04 0x401F814CU, 0x5U, 0, 0, 0x401F833CU +#define IOMUXC_GPIO_B0_04_SRC_BOOT_CFG00 0x401F814CU, 0x6U, 0, 0, 0x401F833CU +#define IOMUXC_GPIO_B0_04_ENET2_TDATA03 0x401F814CU, 0x8U, 0, 0, 0x401F833CU + +#define IOMUXC_GPIO_B0_05_LCD_DATA01 0x401F8150U, 0x0U, 0, 0, 0x401F8340U +#define IOMUXC_GPIO_B0_05_QTIMER2_TIMER2 0x401F8150U, 0x1U, 0x401F8574U, 0x1U, 0x401F8340U +#define IOMUXC_GPIO_B0_05_LPI2C2_SDA 0x401F8150U, 0x2U, 0x401F84D8U, 0x1U, 0x401F8340U +#define IOMUXC_GPIO_B0_05_ARM_TRACE1 0x401F8150U, 0x3U, 0, 0, 0x401F8340U +#define IOMUXC_GPIO_B0_05_FLEXIO2_FLEXIO05 0x401F8150U, 0x4U, 0, 0, 0x401F8340U +#define IOMUXC_GPIO_B0_05_GPIO2_IO05 0x401F8150U, 0x5U, 0, 0, 0x401F8340U +#define IOMUXC_GPIO_B0_05_SRC_BOOT_CFG01 0x401F8150U, 0x6U, 0, 0, 0x401F8340U +#define IOMUXC_GPIO_B0_05_ENET2_TDATA02 0x401F8150U, 0x8U, 0, 0, 0x401F8340U + +#define IOMUXC_GPIO_B0_06_LCD_DATA02 0x401F8154U, 0x0U, 0, 0, 0x401F8344U +#define IOMUXC_GPIO_B0_06_QTIMER3_TIMER0 0x401F8154U, 0x1U, 0x401F857CU, 0x2U, 0x401F8344U +#define IOMUXC_GPIO_B0_06_FLEXPWM2_PWMA00 0x401F8154U, 0x2U, 0x401F8478U, 0x1U, 0x401F8344U +#define IOMUXC_GPIO_B0_06_ARM_TRACE2 0x401F8154U, 0x3U, 0, 0, 0x401F8344U +#define IOMUXC_GPIO_B0_06_FLEXIO2_FLEXIO06 0x401F8154U, 0x4U, 0, 0, 0x401F8344U +#define IOMUXC_GPIO_B0_06_GPIO2_IO06 0x401F8154U, 0x5U, 0, 0, 0x401F8344U +#define IOMUXC_GPIO_B0_06_SRC_BOOT_CFG02 0x401F8154U, 0x6U, 0, 0, 0x401F8344U +#define IOMUXC_GPIO_B0_06_ENET2_RX_CLK 0x401F8154U, 0x8U, 0, 0, 0x401F8344U + +#define IOMUXC_GPIO_B0_07_LCD_DATA03 0x401F8158U, 0x0U, 0, 0, 0x401F8348U +#define IOMUXC_GPIO_B0_07_QTIMER3_TIMER1 0x401F8158U, 0x1U, 0x401F8580U, 0x2U, 0x401F8348U +#define IOMUXC_GPIO_B0_07_FLEXPWM2_PWMB00 0x401F8158U, 0x2U, 0x401F8488U, 0x1U, 0x401F8348U +#define IOMUXC_GPIO_B0_07_ARM_TRACE3 0x401F8158U, 0x3U, 0, 0, 0x401F8348U +#define IOMUXC_GPIO_B0_07_FLEXIO2_FLEXIO07 0x401F8158U, 0x4U, 0, 0, 0x401F8348U +#define IOMUXC_GPIO_B0_07_GPIO2_IO07 0x401F8158U, 0x5U, 0, 0, 0x401F8348U +#define IOMUXC_GPIO_B0_07_SRC_BOOT_CFG03 0x401F8158U, 0x6U, 0, 0, 0x401F8348U +#define IOMUXC_GPIO_B0_07_ENET2_TX_ER 0x401F8158U, 0x8U, 0, 0, 0x401F8348U + +#define IOMUXC_GPIO_B0_08_LCD_DATA04 0x401F815CU, 0x0U, 0, 0, 0x401F834CU +#define IOMUXC_GPIO_B0_08_QTIMER3_TIMER2 0x401F815CU, 0x1U, 0x401F8584U, 0x2U, 0x401F834CU +#define IOMUXC_GPIO_B0_08_FLEXPWM2_PWMA01 0x401F815CU, 0x2U, 0x401F847CU, 0x1U, 0x401F834CU +#define IOMUXC_GPIO_B0_08_LPUART3_TX 0x401F815CU, 0x3U, 0x401F853CU, 0x2U, 0x401F834CU +#define IOMUXC_GPIO_B0_08_FLEXIO2_FLEXIO08 0x401F815CU, 0x4U, 0, 0, 0x401F834CU +#define IOMUXC_GPIO_B0_08_GPIO2_IO08 0x401F815CU, 0x5U, 0, 0, 0x401F834CU +#define IOMUXC_GPIO_B0_08_SRC_BOOT_CFG04 0x401F815CU, 0x6U, 0, 0, 0x401F834CU +#define IOMUXC_GPIO_B0_08_ENET2_RDATA03 0x401F815CU, 0x8U, 0, 0, 0x401F834CU + +#define IOMUXC_GPIO_B0_09_LCD_DATA05 0x401F8160U, 0x0U, 0, 0, 0x401F8350U +#define IOMUXC_GPIO_B0_09_QTIMER4_TIMER0 0x401F8160U, 0x1U, 0, 0, 0x401F8350U +#define IOMUXC_GPIO_B0_09_FLEXPWM2_PWMB01 0x401F8160U, 0x2U, 0x401F848CU, 0x1U, 0x401F8350U +#define IOMUXC_GPIO_B0_09_LPUART3_RX 0x401F8160U, 0x3U, 0x401F8538U, 0x2U, 0x401F8350U +#define IOMUXC_GPIO_B0_09_FLEXIO2_FLEXIO09 0x401F8160U, 0x4U, 0, 0, 0x401F8350U +#define IOMUXC_GPIO_B0_09_GPIO2_IO09 0x401F8160U, 0x5U, 0, 0, 0x401F8350U +#define IOMUXC_GPIO_B0_09_SRC_BOOT_CFG05 0x401F8160U, 0x6U, 0, 0, 0x401F8350U +#define IOMUXC_GPIO_B0_09_ENET2_RDATA02 0x401F8160U, 0x8U, 0, 0, 0x401F8350U + +#define IOMUXC_GPIO_B0_10_LCD_DATA06 0x401F8164U, 0x0U, 0, 0, 0x401F8354U +#define IOMUXC_GPIO_B0_10_QTIMER4_TIMER1 0x401F8164U, 0x1U, 0, 0, 0x401F8354U +#define IOMUXC_GPIO_B0_10_FLEXPWM2_PWMA02 0x401F8164U, 0x2U, 0x401F8480U, 0x1U, 0x401F8354U +#define IOMUXC_GPIO_B0_10_SAI1_TX_DATA03 0x401F8164U, 0x3U, 0x401F8598U, 0x1U, 0x401F8354U +#define IOMUXC_GPIO_B0_10_FLEXIO2_FLEXIO10 0x401F8164U, 0x4U, 0, 0, 0x401F8354U +#define IOMUXC_GPIO_B0_10_GPIO2_IO10 0x401F8164U, 0x5U, 0, 0, 0x401F8354U +#define IOMUXC_GPIO_B0_10_SRC_BOOT_CFG06 0x401F8164U, 0x6U, 0, 0, 0x401F8354U +#define IOMUXC_GPIO_B0_10_ENET2_CRS 0x401F8164U, 0x8U, 0, 0, 0x401F8354U + +#define IOMUXC_GPIO_B0_11_LCD_DATA07 0x401F8168U, 0x0U, 0, 0, 0x401F8358U +#define IOMUXC_GPIO_B0_11_QTIMER4_TIMER2 0x401F8168U, 0x1U, 0, 0, 0x401F8358U +#define IOMUXC_GPIO_B0_11_FLEXPWM2_PWMB02 0x401F8168U, 0x2U, 0x401F8490U, 0x1U, 0x401F8358U +#define IOMUXC_GPIO_B0_11_SAI1_TX_DATA02 0x401F8168U, 0x3U, 0x401F859CU, 0x1U, 0x401F8358U +#define IOMUXC_GPIO_B0_11_FLEXIO2_FLEXIO11 0x401F8168U, 0x4U, 0, 0, 0x401F8358U +#define IOMUXC_GPIO_B0_11_GPIO2_IO11 0x401F8168U, 0x5U, 0, 0, 0x401F8358U +#define IOMUXC_GPIO_B0_11_SRC_BOOT_CFG07 0x401F8168U, 0x6U, 0, 0, 0x401F8358U +#define IOMUXC_GPIO_B0_11_ENET2_COL 0x401F8168U, 0x8U, 0, 0, 0x401F8358U + +#define IOMUXC_GPIO_B0_12_LCD_DATA08 0x401F816CU, 0x0U, 0, 0, 0x401F835CU +#define IOMUXC_GPIO_B0_12_XBAR1_INOUT10 0x401F816CU, 0x1U, 0, 0, 0x401F835CU +#define IOMUXC_GPIO_B0_12_ARM_TRACE_CLK 0x401F816CU, 0x2U, 0, 0, 0x401F835CU +#define IOMUXC_GPIO_B0_12_SAI1_TX_DATA01 0x401F816CU, 0x3U, 0x401F85A0U, 0x1U, 0x401F835CU +#define IOMUXC_GPIO_B0_12_FLEXIO2_FLEXIO12 0x401F816CU, 0x4U, 0, 0, 0x401F835CU +#define IOMUXC_GPIO_B0_12_GPIO2_IO12 0x401F816CU, 0x5U, 0, 0, 0x401F835CU +#define IOMUXC_GPIO_B0_12_SRC_BOOT_CFG08 0x401F816CU, 0x6U, 0, 0, 0x401F835CU +#define IOMUXC_GPIO_B0_12_ENET2_TDATA00 0x401F816CU, 0x8U, 0, 0, 0x401F835CU + +#define IOMUXC_GPIO_B0_13_LCD_DATA09 0x401F8170U, 0x0U, 0, 0, 0x401F8360U +#define IOMUXC_GPIO_B0_13_XBAR1_INOUT11 0x401F8170U, 0x1U, 0, 0, 0x401F8360U +#define IOMUXC_GPIO_B0_13_ARM_TRACE_SWO 0x401F8170U, 0x2U, 0, 0, 0x401F8360U +#define IOMUXC_GPIO_B0_13_SAI1_MCLK 0x401F8170U, 0x3U, 0x401F858CU, 0x2U, 0x401F8360U +#define IOMUXC_GPIO_B0_13_FLEXIO2_FLEXIO13 0x401F8170U, 0x4U, 0, 0, 0x401F8360U +#define IOMUXC_GPIO_B0_13_GPIO2_IO13 0x401F8170U, 0x5U, 0, 0, 0x401F8360U +#define IOMUXC_GPIO_B0_13_SRC_BOOT_CFG09 0x401F8170U, 0x6U, 0, 0, 0x401F8360U +#define IOMUXC_GPIO_B0_13_ENET2_TDATA01 0x401F8170U, 0x8U, 0, 0, 0x401F8360U + +#define IOMUXC_GPIO_B0_14_LCD_DATA10 0x401F8174U, 0x0U, 0, 0, 0x401F8364U +#define IOMUXC_GPIO_B0_14_XBAR1_INOUT12 0x401F8174U, 0x1U, 0, 0, 0x401F8364U +#define IOMUXC_GPIO_B0_14_ARM_TXEV 0x401F8174U, 0x2U, 0, 0, 0x401F8364U +#define IOMUXC_GPIO_B0_14_SAI1_RX_SYNC 0x401F8174U, 0x3U, 0x401F85A4U, 0x2U, 0x401F8364U +#define IOMUXC_GPIO_B0_14_FLEXIO2_FLEXIO14 0x401F8174U, 0x4U, 0, 0, 0x401F8364U +#define IOMUXC_GPIO_B0_14_GPIO2_IO14 0x401F8174U, 0x5U, 0, 0, 0x401F8364U +#define IOMUXC_GPIO_B0_14_SRC_BOOT_CFG10 0x401F8174U, 0x6U, 0, 0, 0x401F8364U +#define IOMUXC_GPIO_B0_14_ENET2_TX_EN 0x401F8174U, 0x8U, 0, 0, 0x401F8364U + +#define IOMUXC_GPIO_B0_15_LCD_DATA11 0x401F8178U, 0x0U, 0, 0, 0x401F8368U +#define IOMUXC_GPIO_B0_15_XBAR1_INOUT13 0x401F8178U, 0x1U, 0, 0, 0x401F8368U +#define IOMUXC_GPIO_B0_15_ARM_RXEV 0x401F8178U, 0x2U, 0, 0, 0x401F8368U +#define IOMUXC_GPIO_B0_15_SAI1_RX_BCLK 0x401F8178U, 0x3U, 0x401F8590U, 0x2U, 0x401F8368U +#define IOMUXC_GPIO_B0_15_FLEXIO2_FLEXIO15 0x401F8178U, 0x4U, 0, 0, 0x401F8368U +#define IOMUXC_GPIO_B0_15_GPIO2_IO15 0x401F8178U, 0x5U, 0, 0, 0x401F8368U +#define IOMUXC_GPIO_B0_15_SRC_BOOT_CFG11 0x401F8178U, 0x6U, 0, 0, 0x401F8368U +#define IOMUXC_GPIO_B0_15_ENET2_TX_CLK 0x401F8178U, 0x8U, 0x401F8728U, 0x2U, 0x401F8368U +#define IOMUXC_GPIO_B0_15_ENET2_REF_CLK2 0x401F8178U, 0x9U, 0x401F870CU, 0x2U, 0x401F8368U + +#define IOMUXC_GPIO_B1_00_LCD_DATA12 0x401F817CU, 0x0U, 0, 0, 0x401F836CU +#define IOMUXC_GPIO_B1_00_XBAR1_INOUT14 0x401F817CU, 0x1U, 0x401F8644U, 0x1U, 0x401F836CU +#define IOMUXC_GPIO_B1_00_LPUART4_TX 0x401F817CU, 0x2U, 0x401F8544U, 0x2U, 0x401F836CU +#define IOMUXC_GPIO_B1_00_SAI1_RX_DATA00 0x401F817CU, 0x3U, 0x401F8594U, 0x2U, 0x401F836CU +#define IOMUXC_GPIO_B1_00_FLEXIO2_FLEXIO16 0x401F817CU, 0x4U, 0, 0, 0x401F836CU +#define IOMUXC_GPIO_B1_00_GPIO2_IO16 0x401F817CU, 0x5U, 0, 0, 0x401F836CU +#define IOMUXC_GPIO_B1_00_FLEXPWM1_PWMA03 0x401F817CU, 0x6U, 0x401F8454U, 0x4U, 0x401F836CU +#define IOMUXC_GPIO_B1_00_ENET2_RX_ER 0x401F817CU, 0x8U, 0x401F8720U, 0x2U, 0x401F836CU +#define IOMUXC_GPIO_B1_00_FLEXIO3_FLEXIO16 0x401F817CU, 0x9U, 0, 0, 0x401F836CU + +#define IOMUXC_GPIO_B1_01_LCD_DATA13 0x401F8180U, 0x0U, 0, 0, 0x401F8370U +#define IOMUXC_GPIO_B1_01_XBAR1_INOUT15 0x401F8180U, 0x1U, 0x401F8648U, 0x1U, 0x401F8370U +#define IOMUXC_GPIO_B1_01_LPUART4_RX 0x401F8180U, 0x2U, 0x401F8540U, 0x2U, 0x401F8370U +#define IOMUXC_GPIO_B1_01_SAI1_TX_DATA00 0x401F8180U, 0x3U, 0, 0, 0x401F8370U +#define IOMUXC_GPIO_B1_01_FLEXIO2_FLEXIO17 0x401F8180U, 0x4U, 0, 0, 0x401F8370U +#define IOMUXC_GPIO_B1_01_GPIO2_IO17 0x401F8180U, 0x5U, 0, 0, 0x401F8370U +#define IOMUXC_GPIO_B1_01_FLEXPWM1_PWMB03 0x401F8180U, 0x6U, 0x401F8464U, 0x4U, 0x401F8370U +#define IOMUXC_GPIO_B1_01_ENET2_RDATA00 0x401F8180U, 0x8U, 0x401F8714U, 0x2U, 0x401F8370U +#define IOMUXC_GPIO_B1_01_FLEXIO3_FLEXIO17 0x401F8180U, 0x9U, 0, 0, 0x401F8370U + +#define IOMUXC_GPIO_B1_02_LCD_DATA14 0x401F8184U, 0x0U, 0, 0, 0x401F8374U +#define IOMUXC_GPIO_B1_02_XBAR1_INOUT16 0x401F8184U, 0x1U, 0x401F864CU, 0x1U, 0x401F8374U +#define IOMUXC_GPIO_B1_02_LPSPI4_PCS2 0x401F8184U, 0x2U, 0, 0, 0x401F8374U +#define IOMUXC_GPIO_B1_02_SAI1_TX_BCLK 0x401F8184U, 0x3U, 0x401F85A8U, 0x2U, 0x401F8374U +#define IOMUXC_GPIO_B1_02_FLEXIO2_FLEXIO18 0x401F8184U, 0x4U, 0, 0, 0x401F8374U +#define IOMUXC_GPIO_B1_02_GPIO2_IO18 0x401F8184U, 0x5U, 0, 0, 0x401F8374U +#define IOMUXC_GPIO_B1_02_FLEXPWM2_PWMA03 0x401F8184U, 0x6U, 0x401F8474U, 0x4U, 0x401F8374U +#define IOMUXC_GPIO_B1_02_ENET2_RDATA01 0x401F8184U, 0x8U, 0x401F8718U, 0x2U, 0x401F8374U +#define IOMUXC_GPIO_B1_02_FLEXIO3_FLEXIO18 0x401F8184U, 0x9U, 0, 0, 0x401F8374U + +#define IOMUXC_GPIO_B1_03_LCD_DATA15 0x401F8188U, 0x0U, 0, 0, 0x401F8378U +#define IOMUXC_GPIO_B1_03_XBAR1_INOUT17 0x401F8188U, 0x1U, 0x401F862CU, 0x3U, 0x401F8378U +#define IOMUXC_GPIO_B1_03_LPSPI4_PCS1 0x401F8188U, 0x2U, 0, 0, 0x401F8378U +#define IOMUXC_GPIO_B1_03_SAI1_TX_SYNC 0x401F8188U, 0x3U, 0x401F85ACU, 0x2U, 0x401F8378U +#define IOMUXC_GPIO_B1_03_FLEXIO2_FLEXIO19 0x401F8188U, 0x4U, 0, 0, 0x401F8378U +#define IOMUXC_GPIO_B1_03_GPIO2_IO19 0x401F8188U, 0x5U, 0, 0, 0x401F8378U +#define IOMUXC_GPIO_B1_03_FLEXPWM2_PWMB03 0x401F8188U, 0x6U, 0x401F8484U, 0x3U, 0x401F8378U +#define IOMUXC_GPIO_B1_03_ENET2_RX_EN 0x401F8188U, 0x8U, 0x401F871CU, 0x2U, 0x401F8378U +#define IOMUXC_GPIO_B1_03_FLEXIO3_FLEXIO19 0x401F8188U, 0x9U, 0, 0, 0x401F8378U + +#define IOMUXC_GPIO_B1_04_LCD_DATA16 0x401F818CU, 0x0U, 0, 0, 0x401F837CU +#define IOMUXC_GPIO_B1_04_LPSPI4_PCS0 0x401F818CU, 0x1U, 0x401F851CU, 0x1U, 0x401F837CU +#define IOMUXC_GPIO_B1_04_CSI_DATA15 0x401F818CU, 0x2U, 0, 0, 0x401F837CU +#define IOMUXC_GPIO_B1_04_ENET_RX_DATA00 0x401F818CU, 0x3U, 0x401F8434U, 0x1U, 0x401F837CU +#define IOMUXC_GPIO_B1_04_FLEXIO2_FLEXIO20 0x401F818CU, 0x4U, 0, 0, 0x401F837CU +#define IOMUXC_GPIO_B1_04_GPIO2_IO20 0x401F818CU, 0x5U, 0, 0, 0x401F837CU +#define IOMUXC_GPIO_B1_04_GPT1_CLK 0x401F818CU, 0x8U, 0x401F8760U, 0x1U, 0x401F837CU +#define IOMUXC_GPIO_B1_04_FLEXIO3_FLEXIO20 0x401F818CU, 0x9U, 0, 0, 0x401F837CU + +#define IOMUXC_GPIO_B1_05_LCD_DATA17 0x401F8190U, 0x0U, 0, 0, 0x401F8380U +#define IOMUXC_GPIO_B1_05_LPSPI4_SDI 0x401F8190U, 0x1U, 0x401F8524U, 0x1U, 0x401F8380U +#define IOMUXC_GPIO_B1_05_CSI_DATA14 0x401F8190U, 0x2U, 0, 0, 0x401F8380U +#define IOMUXC_GPIO_B1_05_ENET_RX_DATA01 0x401F8190U, 0x3U, 0x401F8438U, 0x1U, 0x401F8380U +#define IOMUXC_GPIO_B1_05_FLEXIO2_FLEXIO21 0x401F8190U, 0x4U, 0, 0, 0x401F8380U +#define IOMUXC_GPIO_B1_05_GPIO2_IO21 0x401F8190U, 0x5U, 0, 0, 0x401F8380U +#define IOMUXC_GPIO_B1_05_GPT1_CAPTURE1 0x401F8190U, 0x8U, 0x401F8758U, 0x1U, 0x401F8380U +#define IOMUXC_GPIO_B1_05_FLEXIO3_FLEXIO21 0x401F8190U, 0x9U, 0, 0, 0x401F8380U + +#define IOMUXC_GPIO_B1_06_LCD_DATA18 0x401F8194U, 0x0U, 0, 0, 0x401F8384U +#define IOMUXC_GPIO_B1_06_LPSPI4_SDO 0x401F8194U, 0x1U, 0x401F8528U, 0x1U, 0x401F8384U +#define IOMUXC_GPIO_B1_06_CSI_DATA13 0x401F8194U, 0x2U, 0, 0, 0x401F8384U +#define IOMUXC_GPIO_B1_06_ENET_RX_EN 0x401F8194U, 0x3U, 0x401F843CU, 0x1U, 0x401F8384U +#define IOMUXC_GPIO_B1_06_FLEXIO2_FLEXIO22 0x401F8194U, 0x4U, 0, 0, 0x401F8384U +#define IOMUXC_GPIO_B1_06_GPIO2_IO22 0x401F8194U, 0x5U, 0, 0, 0x401F8384U +#define IOMUXC_GPIO_B1_06_GPT1_CAPTURE2 0x401F8194U, 0x8U, 0x401F875CU, 0x1U, 0x401F8384U +#define IOMUXC_GPIO_B1_06_FLEXIO3_FLEXIO22 0x401F8194U, 0x9U, 0, 0, 0x401F8384U + +#define IOMUXC_GPIO_B1_07_LCD_DATA19 0x401F8198U, 0x0U, 0, 0, 0x401F8388U +#define IOMUXC_GPIO_B1_07_LPSPI4_SCK 0x401F8198U, 0x1U, 0x401F8520U, 0x1U, 0x401F8388U +#define IOMUXC_GPIO_B1_07_CSI_DATA12 0x401F8198U, 0x2U, 0, 0, 0x401F8388U +#define IOMUXC_GPIO_B1_07_ENET_TX_DATA00 0x401F8198U, 0x3U, 0, 0, 0x401F8388U +#define IOMUXC_GPIO_B1_07_FLEXIO2_FLEXIO23 0x401F8198U, 0x4U, 0, 0, 0x401F8388U +#define IOMUXC_GPIO_B1_07_GPIO2_IO23 0x401F8198U, 0x5U, 0, 0, 0x401F8388U +#define IOMUXC_GPIO_B1_07_GPT1_COMPARE1 0x401F8198U, 0x8U, 0, 0, 0x401F8388U +#define IOMUXC_GPIO_B1_07_FLEXIO3_FLEXIO23 0x401F8198U, 0x9U, 0, 0, 0x401F8388U + +#define IOMUXC_GPIO_B1_08_LCD_DATA20 0x401F819CU, 0x0U, 0, 0, 0x401F838CU +#define IOMUXC_GPIO_B1_08_QTIMER1_TIMER3 0x401F819CU, 0x1U, 0, 0, 0x401F838CU +#define IOMUXC_GPIO_B1_08_CSI_DATA11 0x401F819CU, 0x2U, 0, 0, 0x401F838CU +#define IOMUXC_GPIO_B1_08_ENET_TX_DATA01 0x401F819CU, 0x3U, 0, 0, 0x401F838CU +#define IOMUXC_GPIO_B1_08_FLEXIO2_FLEXIO24 0x401F819CU, 0x4U, 0, 0, 0x401F838CU +#define IOMUXC_GPIO_B1_08_GPIO2_IO24 0x401F819CU, 0x5U, 0, 0, 0x401F838CU +#define IOMUXC_GPIO_B1_08_FLEXCAN2_TX 0x401F819CU, 0x6U, 0, 0, 0x401F838CU +#define IOMUXC_GPIO_B1_08_GPT1_COMPARE2 0x401F819CU, 0x8U, 0, 0, 0x401F838CU +#define IOMUXC_GPIO_B1_08_FLEXIO3_FLEXIO24 0x401F819CU, 0x9U, 0, 0, 0x401F838CU + +#define IOMUXC_GPIO_B1_09_LCD_DATA21 0x401F81A0U, 0x0U, 0, 0, 0x401F8390U +#define IOMUXC_GPIO_B1_09_QTIMER2_TIMER3 0x401F81A0U, 0x1U, 0x401F8578U, 0x1U, 0x401F8390U +#define IOMUXC_GPIO_B1_09_CSI_DATA10 0x401F81A0U, 0x2U, 0, 0, 0x401F8390U +#define IOMUXC_GPIO_B1_09_ENET_TX_EN 0x401F81A0U, 0x3U, 0, 0, 0x401F8390U +#define IOMUXC_GPIO_B1_09_FLEXIO2_FLEXIO25 0x401F81A0U, 0x4U, 0, 0, 0x401F8390U +#define IOMUXC_GPIO_B1_09_GPIO2_IO25 0x401F81A0U, 0x5U, 0, 0, 0x401F8390U +#define IOMUXC_GPIO_B1_09_FLEXCAN2_RX 0x401F81A0U, 0x6U, 0x401F8450U, 0x3U, 0x401F8390U +#define IOMUXC_GPIO_B1_09_GPT1_COMPARE3 0x401F81A0U, 0x8U, 0, 0, 0x401F8390U +#define IOMUXC_GPIO_B1_09_FLEXIO3_FLEXIO25 0x401F81A0U, 0x9U, 0, 0, 0x401F8390U + +#define IOMUXC_GPIO_B1_10_LCD_DATA22 0x401F81A4U, 0x0U, 0, 0, 0x401F8394U +#define IOMUXC_GPIO_B1_10_QTIMER3_TIMER3 0x401F81A4U, 0x1U, 0x401F8588U, 0x2U, 0x401F8394U +#define IOMUXC_GPIO_B1_10_CSI_DATA00 0x401F81A4U, 0x2U, 0, 0, 0x401F8394U +#define IOMUXC_GPIO_B1_10_ENET_TX_CLK 0x401F81A4U, 0x3U, 0x401F8448U, 0x1U, 0x401F8394U +#define IOMUXC_GPIO_B1_10_FLEXIO2_FLEXIO26 0x401F81A4U, 0x4U, 0, 0, 0x401F8394U +#define IOMUXC_GPIO_B1_10_GPIO2_IO26 0x401F81A4U, 0x5U, 0, 0, 0x401F8394U +#define IOMUXC_GPIO_B1_10_ENET_REF_CLK 0x401F81A4U, 0x6U, 0x401F842CU, 0x1U, 0x401F8394U +#define IOMUXC_GPIO_B1_10_FLEXIO3_FLEXIO26 0x401F81A4U, 0x9U, 0, 0, 0x401F8394U + +#define IOMUXC_GPIO_B1_11_LCD_DATA23 0x401F81A8U, 0x0U, 0, 0, 0x401F8398U +#define IOMUXC_GPIO_B1_11_QTIMER4_TIMER3 0x401F81A8U, 0x1U, 0, 0, 0x401F8398U +#define IOMUXC_GPIO_B1_11_CSI_DATA01 0x401F81A8U, 0x2U, 0, 0, 0x401F8398U +#define IOMUXC_GPIO_B1_11_ENET_RX_ER 0x401F81A8U, 0x3U, 0x401F8440U, 0x1U, 0x401F8398U +#define IOMUXC_GPIO_B1_11_FLEXIO2_FLEXIO27 0x401F81A8U, 0x4U, 0, 0, 0x401F8398U +#define IOMUXC_GPIO_B1_11_GPIO2_IO27 0x401F81A8U, 0x5U, 0, 0, 0x401F8398U +#define IOMUXC_GPIO_B1_11_LPSPI4_PCS3 0x401F81A8U, 0x6U, 0, 0, 0x401F8398U +#define IOMUXC_GPIO_B1_11_FLEXIO3_FLEXIO27 0x401F81A8U, 0x9U, 0, 0, 0x401F8398U + +#define IOMUXC_GPIO_B1_12_LPUART5_TX 0x401F81ACU, 0x1U, 0x401F854CU, 0x1U, 0x401F839CU +#define IOMUXC_GPIO_B1_12_CSI_PIXCLK 0x401F81ACU, 0x2U, 0x401F8424U, 0x1U, 0x401F839CU +#define IOMUXC_GPIO_B1_12_ENET_1588_EVENT0_IN 0x401F81ACU, 0x3U, 0x401F8444U, 0x2U, 0x401F839CU +#define IOMUXC_GPIO_B1_12_FLEXIO2_FLEXIO28 0x401F81ACU, 0x4U, 0, 0, 0x401F839CU +#define IOMUXC_GPIO_B1_12_GPIO2_IO28 0x401F81ACU, 0x5U, 0, 0, 0x401F839CU +#define IOMUXC_GPIO_B1_12_USDHC1_CD_B 0x401F81ACU, 0x6U, 0x401F85D4U, 0x2U, 0x401F839CU +#define IOMUXC_GPIO_B1_12_FLEXIO3_FLEXIO28 0x401F81ACU, 0x9U, 0, 0, 0x401F839CU + +#define IOMUXC_GPIO_B1_13_WDOG1_B 0x401F81B0U, 0x0U, 0, 0, 0x401F83A0U +#define IOMUXC_GPIO_B1_13_LPUART5_RX 0x401F81B0U, 0x1U, 0x401F8548U, 0x1U, 0x401F83A0U +#define IOMUXC_GPIO_B1_13_CSI_VSYNC 0x401F81B0U, 0x2U, 0x401F8428U, 0x2U, 0x401F83A0U +#define IOMUXC_GPIO_B1_13_ENET_1588_EVENT0_OUT 0x401F81B0U, 0x3U, 0, 0, 0x401F83A0U +#define IOMUXC_GPIO_B1_13_FLEXIO2_FLEXIO29 0x401F81B0U, 0x4U, 0, 0, 0x401F83A0U +#define IOMUXC_GPIO_B1_13_GPIO2_IO29 0x401F81B0U, 0x5U, 0, 0, 0x401F83A0U +#define IOMUXC_GPIO_B1_13_USDHC1_WP 0x401F81B0U, 0x6U, 0x401F85D8U, 0x3U, 0x401F83A0U +#define IOMUXC_GPIO_B1_13_SEMC_DQS4 0x401F81B0U, 0x8U, 0x401F8788U, 0x3U, 0x401F83A0U +#define IOMUXC_GPIO_B1_13_FLEXIO3_FLEXIO29 0x401F81B0U, 0x9U, 0, 0, 0x401F83A0U + +#define IOMUXC_GPIO_B1_14_ENET_MDC 0x401F81B4U, 0x0U, 0, 0, 0x401F83A4U +#define IOMUXC_GPIO_B1_14_FLEXPWM4_PWMA02 0x401F81B4U, 0x1U, 0x401F849CU, 0x1U, 0x401F83A4U +#define IOMUXC_GPIO_B1_14_CSI_HSYNC 0x401F81B4U, 0x2U, 0x401F8420U, 0x2U, 0x401F83A4U +#define IOMUXC_GPIO_B1_14_XBAR1_IN02 0x401F81B4U, 0x3U, 0x401F860CU, 0x1U, 0x401F83A4U +#define IOMUXC_GPIO_B1_14_FLEXIO2_FLEXIO30 0x401F81B4U, 0x4U, 0, 0, 0x401F83A4U +#define IOMUXC_GPIO_B1_14_GPIO2_IO30 0x401F81B4U, 0x5U, 0, 0, 0x401F83A4U +#define IOMUXC_GPIO_B1_14_USDHC1_VSELECT 0x401F81B4U, 0x6U, 0, 0, 0x401F83A4U +#define IOMUXC_GPIO_B1_14_ENET2_TDATA00 0x401F81B4U, 0x8U, 0, 0, 0x401F83A4U +#define IOMUXC_GPIO_B1_14_FLEXIO3_FLEXIO30 0x401F81B4U, 0x9U, 0, 0, 0x401F83A4U + +#define IOMUXC_GPIO_B1_15_ENET_MDIO 0x401F81B8U, 0x0U, 0x401F8430U, 0x2U, 0x401F83A8U +#define IOMUXC_GPIO_B1_15_FLEXPWM4_PWMA03 0x401F81B8U, 0x1U, 0x401F84A0U, 0x1U, 0x401F83A8U +#define IOMUXC_GPIO_B1_15_CSI_MCLK 0x401F81B8U, 0x2U, 0, 0, 0x401F83A8U +#define IOMUXC_GPIO_B1_15_XBAR1_IN03 0x401F81B8U, 0x3U, 0x401F8610U, 0x1U, 0x401F83A8U +#define IOMUXC_GPIO_B1_15_FLEXIO2_FLEXIO31 0x401F81B8U, 0x4U, 0, 0, 0x401F83A8U +#define IOMUXC_GPIO_B1_15_GPIO2_IO31 0x401F81B8U, 0x5U, 0, 0, 0x401F83A8U +#define IOMUXC_GPIO_B1_15_USDHC1_RESET_B 0x401F81B8U, 0x6U, 0, 0, 0x401F83A8U +#define IOMUXC_GPIO_B1_15_ENET2_TDATA01 0x401F81B8U, 0x8U, 0, 0, 0x401F83A8U +#define IOMUXC_GPIO_B1_15_FLEXIO3_FLEXIO31 0x401F81B8U, 0x9U, 0, 0, 0x401F83A8U + +#define IOMUXC_GPIO_SD_B0_00_USDHC1_CMD 0x401F81BCU, 0x0U, 0, 0, 0x401F83ACU +#define IOMUXC_GPIO_SD_B0_00_FLEXPWM1_PWMA00 0x401F81BCU, 0x1U, 0x401F8458U, 0x1U, 0x401F83ACU +#define IOMUXC_GPIO_SD_B0_00_LPI2C3_SCL 0x401F81BCU, 0x2U, 0x401F84DCU, 0x1U, 0x401F83ACU +#define IOMUXC_GPIO_SD_B0_00_XBAR1_INOUT04 0x401F81BCU, 0x3U, 0x401F8614U, 0x1U, 0x401F83ACU +#define IOMUXC_GPIO_SD_B0_00_LPSPI1_SCK 0x401F81BCU, 0x4U, 0x401F84F0U, 0x1U, 0x401F83ACU +#define IOMUXC_GPIO_SD_B0_00_GPIO3_IO12 0x401F81BCU, 0x5U, 0, 0, 0x401F83ACU +#define IOMUXC_GPIO_SD_B0_00_FLEXSPIA_SS1_B 0x401F81BCU, 0x6U, 0, 0, 0x401F83ACU +#define IOMUXC_GPIO_SD_B0_00_ENET2_TX_EN 0x401F81BCU, 0x8U, 0, 0, 0x401F83ACU +#define IOMUXC_GPIO_SD_B0_00_SEMC_DQS4 0x401F81BCU, 0x9U, 0x401F8788U, 0x0U, 0x401F83ACU + +#define IOMUXC_GPIO_SD_B0_01_USDHC1_CLK 0x401F81C0U, 0x0U, 0, 0, 0x401F83B0U +#define IOMUXC_GPIO_SD_B0_01_FLEXPWM1_PWMB00 0x401F81C0U, 0x1U, 0x401F8468U, 0x1U, 0x401F83B0U +#define IOMUXC_GPIO_SD_B0_01_LPI2C3_SDA 0x401F81C0U, 0x2U, 0x401F84E0U, 0x1U, 0x401F83B0U +#define IOMUXC_GPIO_SD_B0_01_XBAR1_INOUT05 0x401F81C0U, 0x3U, 0x401F8618U, 0x1U, 0x401F83B0U +#define IOMUXC_GPIO_SD_B0_01_LPSPI1_PCS0 0x401F81C0U, 0x4U, 0x401F84ECU, 0x0U, 0x401F83B0U +#define IOMUXC_GPIO_SD_B0_01_GPIO3_IO13 0x401F81C0U, 0x5U, 0, 0, 0x401F83B0U +#define IOMUXC_GPIO_SD_B0_01_FLEXSPIB_SS1_B 0x401F81C0U, 0x6U, 0, 0, 0x401F83B0U +#define IOMUXC_GPIO_SD_B0_01_ENET2_TX_CLK 0x401F81C0U, 0x8U, 0x401F8728U, 0x1U, 0x401F83B0U +#define IOMUXC_GPIO_SD_B0_01_ENET2_REF_CLK2 0x401F81C0U, 0x9U, 0x401F870CU, 0x1U, 0x401F83B0U + +#define IOMUXC_GPIO_SD_B0_02_USDHC1_DATA0 0x401F81C4U, 0x0U, 0, 0, 0x401F83B4U +#define IOMUXC_GPIO_SD_B0_02_FLEXPWM1_PWMA01 0x401F81C4U, 0x1U, 0x401F845CU, 0x1U, 0x401F83B4U +#define IOMUXC_GPIO_SD_B0_02_LPUART8_CTS_B 0x401F81C4U, 0x2U, 0, 0, 0x401F83B4U +#define IOMUXC_GPIO_SD_B0_02_XBAR1_INOUT06 0x401F81C4U, 0x3U, 0x401F861CU, 0x1U, 0x401F83B4U +#define IOMUXC_GPIO_SD_B0_02_LPSPI1_SDO 0x401F81C4U, 0x4U, 0x401F84F8U, 0x1U, 0x401F83B4U +#define IOMUXC_GPIO_SD_B0_02_GPIO3_IO14 0x401F81C4U, 0x5U, 0, 0, 0x401F83B4U +#define IOMUXC_GPIO_SD_B0_02_ENET2_RX_ER 0x401F81C4U, 0x8U, 0x401F8720U, 0x1U, 0x401F83B4U +#define IOMUXC_GPIO_SD_B0_02_SEMC_CLK5 0x401F81C4U, 0x9U, 0, 0, 0x401F83B4U + +#define IOMUXC_GPIO_SD_B0_03_USDHC1_DATA1 0x401F81C8U, 0x0U, 0, 0, 0x401F83B8U +#define IOMUXC_GPIO_SD_B0_03_FLEXPWM1_PWMB01 0x401F81C8U, 0x1U, 0x401F846CU, 0x1U, 0x401F83B8U +#define IOMUXC_GPIO_SD_B0_03_LPUART8_RTS_B 0x401F81C8U, 0x2U, 0, 0, 0x401F83B8U +#define IOMUXC_GPIO_SD_B0_03_XBAR1_INOUT07 0x401F81C8U, 0x3U, 0x401F8620U, 0x1U, 0x401F83B8U +#define IOMUXC_GPIO_SD_B0_03_LPSPI1_SDI 0x401F81C8U, 0x4U, 0x401F84F4U, 0x1U, 0x401F83B8U +#define IOMUXC_GPIO_SD_B0_03_GPIO3_IO15 0x401F81C8U, 0x5U, 0, 0, 0x401F83B8U +#define IOMUXC_GPIO_SD_B0_03_ENET2_RDATA00 0x401F81C8U, 0x8U, 0x401F8714U, 0x1U, 0x401F83B8U +#define IOMUXC_GPIO_SD_B0_03_SEMC_CLK6 0x401F81C8U, 0x9U, 0, 0, 0x401F83B8U + +#define IOMUXC_GPIO_SD_B0_04_USDHC1_DATA2 0x401F81CCU, 0x0U, 0, 0, 0x401F83BCU +#define IOMUXC_GPIO_SD_B0_04_FLEXPWM1_PWMA02 0x401F81CCU, 0x1U, 0x401F8460U, 0x1U, 0x401F83BCU +#define IOMUXC_GPIO_SD_B0_04_LPUART8_TX 0x401F81CCU, 0x2U, 0x401F8564U, 0x0U, 0x401F83BCU +#define IOMUXC_GPIO_SD_B0_04_XBAR1_INOUT08 0x401F81CCU, 0x3U, 0x401F8624U, 0x1U, 0x401F83BCU +#define IOMUXC_GPIO_SD_B0_04_FLEXSPIB_SS0_B 0x401F81CCU, 0x4U, 0, 0, 0x401F83BCU +#define IOMUXC_GPIO_SD_B0_04_GPIO3_IO16 0x401F81CCU, 0x5U, 0, 0, 0x401F83BCU +#define IOMUXC_GPIO_SD_B0_04_CCM_CLKO1 0x401F81CCU, 0x6U, 0, 0, 0x401F83BCU +#define IOMUXC_GPIO_SD_B0_04_ENET2_RDATA01 0x401F81CCU, 0x8U, 0x401F8718U, 0x1U, 0x401F83BCU + +#define IOMUXC_GPIO_SD_B0_05_USDHC1_DATA3 0x401F81D0U, 0x0U, 0, 0, 0x401F83C0U +#define IOMUXC_GPIO_SD_B0_05_FLEXPWM1_PWMB02 0x401F81D0U, 0x1U, 0x401F8470U, 0x1U, 0x401F83C0U +#define IOMUXC_GPIO_SD_B0_05_LPUART8_RX 0x401F81D0U, 0x2U, 0x401F8560U, 0x0U, 0x401F83C0U +#define IOMUXC_GPIO_SD_B0_05_XBAR1_INOUT09 0x401F81D0U, 0x3U, 0x401F8628U, 0x1U, 0x401F83C0U +#define IOMUXC_GPIO_SD_B0_05_FLEXSPIB_DQS 0x401F81D0U, 0x4U, 0, 0, 0x401F83C0U +#define IOMUXC_GPIO_SD_B0_05_GPIO3_IO17 0x401F81D0U, 0x5U, 0, 0, 0x401F83C0U +#define IOMUXC_GPIO_SD_B0_05_CCM_CLKO2 0x401F81D0U, 0x6U, 0, 0, 0x401F83C0U +#define IOMUXC_GPIO_SD_B0_05_ENET2_RX_EN 0x401F81D0U, 0x8U, 0x401F871CU, 0x1U, 0x401F83C0U + +#define IOMUXC_GPIO_SD_B1_00_USDHC2_DATA3 0x401F81D4U, 0x0U, 0x401F85F4U, 0x0U, 0x401F83C4U +#define IOMUXC_GPIO_SD_B1_00_FLEXSPIB_DATA03 0x401F81D4U, 0x1U, 0x401F84C4U, 0x0U, 0x401F83C4U +#define IOMUXC_GPIO_SD_B1_00_FLEXPWM1_PWMA03 0x401F81D4U, 0x2U, 0x401F8454U, 0x0U, 0x401F83C4U +#define IOMUXC_GPIO_SD_B1_00_SAI1_TX_DATA03 0x401F81D4U, 0x3U, 0x401F8598U, 0x0U, 0x401F83C4U +#define IOMUXC_GPIO_SD_B1_00_LPUART4_TX 0x401F81D4U, 0x4U, 0x401F8544U, 0x0U, 0x401F83C4U +#define IOMUXC_GPIO_SD_B1_00_GPIO3_IO00 0x401F81D4U, 0x5U, 0, 0, 0x401F83C4U +#define IOMUXC_GPIO_SD_B1_00_SAI3_RX_DATA 0x401F81D4U, 0x8U, 0x401F8778U, 0x1U, 0x401F83C4U + +#define IOMUXC_GPIO_SD_B1_01_USDHC2_DATA2 0x401F81D8U, 0x0U, 0x401F85F0U, 0x0U, 0x401F83C8U +#define IOMUXC_GPIO_SD_B1_01_FLEXSPIB_DATA02 0x401F81D8U, 0x1U, 0x401F84C0U, 0x0U, 0x401F83C8U +#define IOMUXC_GPIO_SD_B1_01_FLEXPWM1_PWMB03 0x401F81D8U, 0x2U, 0x401F8464U, 0x0U, 0x401F83C8U +#define IOMUXC_GPIO_SD_B1_01_SAI1_TX_DATA02 0x401F81D8U, 0x3U, 0x401F859CU, 0x0U, 0x401F83C8U +#define IOMUXC_GPIO_SD_B1_01_LPUART4_RX 0x401F81D8U, 0x4U, 0x401F8540U, 0x0U, 0x401F83C8U +#define IOMUXC_GPIO_SD_B1_01_GPIO3_IO01 0x401F81D8U, 0x5U, 0, 0, 0x401F83C8U +#define IOMUXC_GPIO_SD_B1_01_SAI3_TX_DATA 0x401F81D8U, 0x8U, 0, 0, 0x401F83C8U + +#define IOMUXC_GPIO_SD_B1_02_USDHC2_DATA1 0x401F81DCU, 0x0U, 0x401F85ECU, 0x0U, 0x401F83CCU +#define IOMUXC_GPIO_SD_B1_02_FLEXSPIB_DATA01 0x401F81DCU, 0x1U, 0x401F84BCU, 0x0U, 0x401F83CCU +#define IOMUXC_GPIO_SD_B1_02_FLEXPWM2_PWMA03 0x401F81DCU, 0x2U, 0x401F8474U, 0x0U, 0x401F83CCU +#define IOMUXC_GPIO_SD_B1_02_SAI1_TX_DATA01 0x401F81DCU, 0x3U, 0x401F85A0U, 0x0U, 0x401F83CCU +#define IOMUXC_GPIO_SD_B1_02_FLEXCAN1_TX 0x401F81DCU, 0x4U, 0, 0, 0x401F83CCU +#define IOMUXC_GPIO_SD_B1_02_GPIO3_IO02 0x401F81DCU, 0x5U, 0, 0, 0x401F83CCU +#define IOMUXC_GPIO_SD_B1_02_CCM_WAIT 0x401F81DCU, 0x6U, 0, 0, 0x401F83CCU +#define IOMUXC_GPIO_SD_B1_02_SAI3_TX_SYNC 0x401F81DCU, 0x8U, 0x401F8784U, 0x1U, 0x401F83CCU + +#define IOMUXC_GPIO_SD_B1_03_USDHC2_DATA0 0x401F81E0U, 0x0U, 0x401F85E8U, 0x0U, 0x401F83D0U +#define IOMUXC_GPIO_SD_B1_03_FLEXSPIB_DATA00 0x401F81E0U, 0x1U, 0x401F84B8U, 0x0U, 0x401F83D0U +#define IOMUXC_GPIO_SD_B1_03_FLEXPWM2_PWMB03 0x401F81E0U, 0x2U, 0x401F8484U, 0x0U, 0x401F83D0U +#define IOMUXC_GPIO_SD_B1_03_SAI1_MCLK 0x401F81E0U, 0x3U, 0x401F858CU, 0x0U, 0x401F83D0U +#define IOMUXC_GPIO_SD_B1_03_FLEXCAN1_RX 0x401F81E0U, 0x4U, 0x401F844CU, 0x0U, 0x401F83D0U +#define IOMUXC_GPIO_SD_B1_03_GPIO3_IO03 0x401F81E0U, 0x5U, 0, 0, 0x401F83D0U +#define IOMUXC_GPIO_SD_B1_03_CCM_PMIC_READY 0x401F81E0U, 0x6U, 0x401F83FCU, 0x0U, 0x401F83D0U +#define IOMUXC_GPIO_SD_B1_03_SAI3_TX_BCLK 0x401F81E0U, 0x8U, 0x401F8780U, 0x1U, 0x401F83D0U + +#define IOMUXC_GPIO_SD_B1_04_USDHC2_CLK 0x401F81E4U, 0x0U, 0x401F85DCU, 0x0U, 0x401F83D4U +#define IOMUXC_GPIO_SD_B1_04_FLEXSPIB_SCLK 0x401F81E4U, 0x1U, 0, 0, 0x401F83D4U +#define IOMUXC_GPIO_SD_B1_04_LPI2C1_SCL 0x401F81E4U, 0x2U, 0x401F84CCU, 0x0U, 0x401F83D4U +#define IOMUXC_GPIO_SD_B1_04_SAI1_RX_SYNC 0x401F81E4U, 0x3U, 0x401F85A4U, 0x0U, 0x401F83D4U +#define IOMUXC_GPIO_SD_B1_04_FLEXSPIA_SS1_B 0x401F81E4U, 0x4U, 0, 0, 0x401F83D4U +#define IOMUXC_GPIO_SD_B1_04_GPIO3_IO04 0x401F81E4U, 0x5U, 0, 0, 0x401F83D4U +#define IOMUXC_GPIO_SD_B1_04_CCM_STOP 0x401F81E4U, 0x6U, 0, 0, 0x401F83D4U +#define IOMUXC_GPIO_SD_B1_04_SAI3_MCLK 0x401F81E4U, 0x8U, 0x401F8770U, 0x1U, 0x401F83D4U + +#define IOMUXC_GPIO_SD_B1_05_USDHC2_CMD 0x401F81E8U, 0x0U, 0x401F85E4U, 0x0U, 0x401F83D8U +#define IOMUXC_GPIO_SD_B1_05_FLEXSPIA_DQS 0x401F81E8U, 0x1U, 0x401F84A4U, 0x0U, 0x401F83D8U +#define IOMUXC_GPIO_SD_B1_05_LPI2C1_SDA 0x401F81E8U, 0x2U, 0x401F84D0U, 0x0U, 0x401F83D8U +#define IOMUXC_GPIO_SD_B1_05_SAI1_RX_BCLK 0x401F81E8U, 0x3U, 0x401F8590U, 0x0U, 0x401F83D8U +#define IOMUXC_GPIO_SD_B1_05_FLEXSPIB_SS0_B 0x401F81E8U, 0x4U, 0, 0, 0x401F83D8U +#define IOMUXC_GPIO_SD_B1_05_GPIO3_IO05 0x401F81E8U, 0x5U, 0, 0, 0x401F83D8U +#define IOMUXC_GPIO_SD_B1_05_SAI3_RX_SYNC 0x401F81E8U, 0x8U, 0x401F877CU, 0x1U, 0x401F83D8U + +#define IOMUXC_GPIO_SD_B1_06_USDHC2_RESET_B 0x401F81ECU, 0x0U, 0, 0, 0x401F83DCU +#define IOMUXC_GPIO_SD_B1_06_FLEXSPIA_SS0_B 0x401F81ECU, 0x1U, 0, 0, 0x401F83DCU +#define IOMUXC_GPIO_SD_B1_06_LPUART7_CTS_B 0x401F81ECU, 0x2U, 0, 0, 0x401F83DCU +#define IOMUXC_GPIO_SD_B1_06_SAI1_RX_DATA00 0x401F81ECU, 0x3U, 0x401F8594U, 0x0U, 0x401F83DCU +#define IOMUXC_GPIO_SD_B1_06_LPSPI2_PCS0 0x401F81ECU, 0x4U, 0x401F84FCU, 0x0U, 0x401F83DCU +#define IOMUXC_GPIO_SD_B1_06_GPIO3_IO06 0x401F81ECU, 0x5U, 0, 0, 0x401F83DCU +#define IOMUXC_GPIO_SD_B1_06_SAI3_RX_BCLK 0x401F81ECU, 0x8U, 0x401F8774U, 0x1U, 0x401F83DCU + +#define IOMUXC_GPIO_SD_B1_07_SEMC_CSX01 0x401F81F0U, 0x0U, 0, 0, 0x401F83E0U +#define IOMUXC_GPIO_SD_B1_07_FLEXSPIA_SCLK 0x401F81F0U, 0x1U, 0x401F84C8U, 0x0U, 0x401F83E0U +#define IOMUXC_GPIO_SD_B1_07_LPUART7_RTS_B 0x401F81F0U, 0x2U, 0, 0, 0x401F83E0U +#define IOMUXC_GPIO_SD_B1_07_SAI1_TX_DATA00 0x401F81F0U, 0x3U, 0, 0, 0x401F83E0U +#define IOMUXC_GPIO_SD_B1_07_LPSPI2_SCK 0x401F81F0U, 0x4U, 0x401F8500U, 0x0U, 0x401F83E0U +#define IOMUXC_GPIO_SD_B1_07_GPIO3_IO07 0x401F81F0U, 0x5U, 0, 0, 0x401F83E0U + +#define IOMUXC_GPIO_SD_B1_08_USDHC2_DATA4 0x401F81F4U, 0x0U, 0x401F85F8U, 0x0U, 0x401F83E4U +#define IOMUXC_GPIO_SD_B1_08_FLEXSPIA_DATA00 0x401F81F4U, 0x1U, 0x401F84A8U, 0x0U, 0x401F83E4U +#define IOMUXC_GPIO_SD_B1_08_LPUART7_TX 0x401F81F4U, 0x2U, 0x401F855CU, 0x0U, 0x401F83E4U +#define IOMUXC_GPIO_SD_B1_08_SAI1_TX_BCLK 0x401F81F4U, 0x3U, 0x401F85A8U, 0x0U, 0x401F83E4U +#define IOMUXC_GPIO_SD_B1_08_LPSPI2_SD0 0x401F81F4U, 0x4U, 0x401F8508U, 0x0U, 0x401F83E4U +#define IOMUXC_GPIO_SD_B1_08_GPIO3_IO08 0x401F81F4U, 0x5U, 0, 0, 0x401F83E4U +#define IOMUXC_GPIO_SD_B1_08_SEMC_CSX02 0x401F81F4U, 0x6U, 0, 0, 0x401F83E4U + +#define IOMUXC_GPIO_SD_B1_09_USDHC2_DATA5 0x401F81F8U, 0x0U, 0x401F85FCU, 0x0U, 0x401F83E8U +#define IOMUXC_GPIO_SD_B1_09_FLEXSPIA_DATA01 0x401F81F8U, 0x1U, 0x401F84ACU, 0x0U, 0x401F83E8U +#define IOMUXC_GPIO_SD_B1_09_LPUART7_RX 0x401F81F8U, 0x2U, 0x401F8558U, 0x0U, 0x401F83E8U +#define IOMUXC_GPIO_SD_B1_09_SAI1_TX_SYNC 0x401F81F8U, 0x3U, 0x401F85ACU, 0x0U, 0x401F83E8U +#define IOMUXC_GPIO_SD_B1_09_LPSPI2_SDI 0x401F81F8U, 0x4U, 0x401F8504U, 0x0U, 0x401F83E8U +#define IOMUXC_GPIO_SD_B1_09_GPIO3_IO09 0x401F81F8U, 0x5U, 0, 0, 0x401F83E8U + +#define IOMUXC_GPIO_SD_B1_10_USDHC2_DATA6 0x401F81FCU, 0x0U, 0x401F8600U, 0x0U, 0x401F83ECU +#define IOMUXC_GPIO_SD_B1_10_FLEXSPIA_DATA02 0x401F81FCU, 0x1U, 0x401F84B0U, 0x0U, 0x401F83ECU +#define IOMUXC_GPIO_SD_B1_10_LPUART2_RX 0x401F81FCU, 0x2U, 0x401F852CU, 0x0U, 0x401F83ECU +#define IOMUXC_GPIO_SD_B1_10_LPI2C2_SDA 0x401F81FCU, 0x3U, 0x401F84D8U, 0x0U, 0x401F83ECU +#define IOMUXC_GPIO_SD_B1_10_LPSPI2_PCS2 0x401F81FCU, 0x4U, 0, 0, 0x401F83ECU +#define IOMUXC_GPIO_SD_B1_10_GPIO3_IO10 0x401F81FCU, 0x5U, 0, 0, 0x401F83ECU + +#define IOMUXC_GPIO_SD_B1_11_USDHC2_DATA7 0x401F8200U, 0x0U, 0x401F8604U, 0x0U, 0x401F83F0U +#define IOMUXC_GPIO_SD_B1_11_FLEXSPIA_DATA03 0x401F8200U, 0x1U, 0x401F84B4U, 0x0U, 0x401F83F0U +#define IOMUXC_GPIO_SD_B1_11_LPUART2_TX 0x401F8200U, 0x2U, 0x401F8530U, 0x0U, 0x401F83F0U +#define IOMUXC_GPIO_SD_B1_11_LPI2C2_SCL 0x401F8200U, 0x3U, 0x401F84D4U, 0x0U, 0x401F83F0U +#define IOMUXC_GPIO_SD_B1_11_LPSPI2_PCS3 0x401F8200U, 0x4U, 0, 0, 0x401F83F0U +#define IOMUXC_GPIO_SD_B1_11_GPIO3_IO11 0x401F8200U, 0x5U, 0, 0, 0x401F83F0U + +#define IOMUXC_GPIO_SPI_B0_00 0, 0, 0, 0, 0x401F86B4U + +#define IOMUXC_GPIO_SPI_B0_01 0, 0, 0, 0, 0x401F86B8U + +#define IOMUXC_GPIO_SPI_B0_02 0, 0, 0, 0, 0x401F86BCU + +#define IOMUXC_GPIO_SPI_B0_03 0, 0, 0, 0, 0x401F86C0U + +#define IOMUXC_GPIO_SPI_B0_04 0, 0, 0, 0, 0x401F86C4U + +#define IOMUXC_GPIO_SPI_B0_05 0, 0, 0, 0, 0x401F86C8U + +#define IOMUXC_GPIO_SPI_B0_06 0, 0, 0, 0, 0x401F86CCU + +#define IOMUXC_GPIO_SPI_B0_07 0, 0, 0, 0, 0x401F86D0U + +#define IOMUXC_GPIO_SPI_B0_08 0, 0, 0, 0, 0x401F86D4U + +#define IOMUXC_GPIO_SPI_B0_09 0, 0, 0, 0, 0x401F86D8U + +#define IOMUXC_GPIO_SPI_B0_10 0, 0, 0, 0, 0x401F86DCU + +#define IOMUXC_GPIO_SPI_B0_11 0, 0, 0, 0, 0x401F86E0U + +#define IOMUXC_GPIO_SPI_B0_12 0, 0, 0, 0, 0x401F86E4U + +#define IOMUXC_GPIO_SPI_B0_13 0, 0, 0, 0, 0x401F86E8U + +#define IOMUXC_GPIO_SPI_B1_00 0, 0, 0, 0, 0x401F86ECU + +#define IOMUXC_GPIO_SPI_B1_01 0, 0, 0, 0, 0x401F86F0U + +#define IOMUXC_GPIO_SPI_B1_02 0, 0, 0, 0, 0x401F86F4U + +#define IOMUXC_GPIO_SPI_B1_03 0, 0, 0, 0, 0x401F86F8U + +#define IOMUXC_GPIO_SPI_B1_04 0, 0, 0, 0, 0x401F86FCU + +#define IOMUXC_GPIO_SPI_B1_05 0, 0, 0, 0, 0x401F8700U + +#define IOMUXC_GPIO_SPI_B1_06 0, 0, 0, 0, 0x401F8704U + +#define IOMUXC_GPIO_SPI_B1_07 0, 0, 0, 0, 0x401F8708U + +#define IOMUXC_GPR_SAIMCLK_LOWBITMASK (0x7U) +#define IOMUXC_GPR_SAIMCLK_HIGHBITMASK (0x3U) + +typedef enum _iomuxc_gpr_mode +{ + kIOMUXC_GPR_GlobalInterruptRequest = IOMUXC_GPR_GPR1_GINT_MASK, + kIOMUXC_GPR_ENET1RefClkMode = IOMUXC_GPR_GPR1_ENET1_CLK_SEL_MASK, + kIOMUXC_GPR_ENET2RefClkMode = IOMUXC_GPR_GPR1_ENET2_CLK_SEL_MASK, + kIOMUXC_GPR_USBExposureMode = IOMUXC_GPR_GPR1_USB_EXP_MODE_MASK, + kIOMUXC_GPR_ENET1TxClkOutputDir = IOMUXC_GPR_GPR1_ENET1_TX_CLK_DIR_MASK, + kIOMUXC_GPR_ENET2TxClkOutputDir = IOMUXC_GPR_GPR1_ENET2_TX_CLK_DIR_MASK, + kIOMUXC_GPR_SAI1MClkOutputDir = IOMUXC_GPR_GPR1_SAI1_MCLK_DIR_MASK, + kIOMUXC_GPR_SAI2MClkOutputDir = IOMUXC_GPR_GPR1_SAI2_MCLK_DIR_MASK, + kIOMUXC_GPR_SAI3MClkOutputDir = IOMUXC_GPR_GPR1_SAI3_MCLK_DIR_MASK, + kIOMUXC_GPR_ExcMonitorSlavErrResponse = IOMUXC_GPR_GPR1_EXC_MON_MASK, + kIOMUXC_GPR_ENETIpgClkOn = IOMUXC_GPR_GPR1_ENET_IPG_CLK_S_EN_MASK, + kIOMUXC_GPR_AHBClockEnable = IOMUXC_GPR_GPR1_CM7_FORCE_HCLK_EN_MASK, +} iomuxc_gpr_mode_t; + +typedef enum _iomuxc_gpr_saimclk +{ + kIOMUXC_GPR_SAI1MClk1Sel = IOMUXC_GPR_GPR1_SAI1_MCLK1_SEL_SHIFT, + kIOMUXC_GPR_SAI1MClk2Sel = IOMUXC_GPR_GPR1_SAI1_MCLK2_SEL_SHIFT, + kIOMUXC_GPR_SAI1MClk3Sel = IOMUXC_GPR_GPR1_SAI1_MCLK3_SEL_SHIFT, + kIOMUXC_GPR_SAI2MClk3Sel = IOMUXC_GPR_GPR1_SAI2_MCLK3_SEL_SHIFT, + kIOMUXC_GPR_SAI3MClk3Sel = IOMUXC_GPR_GPR1_SAI3_MCLK3_SEL_SHIFT, +} iomuxc_gpr_saimclk_t; + +typedef enum _iomuxc_mqs_pwm_oversample_rate +{ + kIOMUXC_MqsPwmOverSampleRate32 = 0, /* MQS PWM over sampling rate 32. */ + kIOMUXC_MqsPwmOverSampleRate64 = 1 /* MQS PWM over sampling rate 64. */ +} iomuxc_mqs_pwm_oversample_rate_t; + +/*@}*/ + +#if defined(__cplusplus) +extern "C" { +#endif /*_cplusplus */ + +/*! @name Configuration */ +/*@{*/ + +/*! + * @brief Sets the IOMUXC pin mux mode. + * @note The first five parameters can be filled with the pin function ID macros. + * + * This is an example to set the PTA6 as the lpuart0_tx: + * @code + * IOMUXC_SetPinMux(IOMUXC_PTA6_LPUART0_TX, 0); + * @endcode + * + * This is an example to set the PTA0 as GPIOA0: + * @code + * IOMUXC_SetPinMux(IOMUXC_PTA0_GPIOA0, 0); + * @endcode + * + * @param muxRegister The pin mux register. + * @param muxMode The pin mux mode. + * @param inputRegister The select input register. + * @param inputDaisy The input daisy. + * @param configRegister The config register. + * @param inputOnfield Software input on field. + */ +static inline void IOMUXC_SetPinMux(uint32_t muxRegister, + uint32_t muxMode, + uint32_t inputRegister, + uint32_t inputDaisy, + uint32_t configRegister, + uint32_t inputOnfield) +{ + *((volatile uint32_t *)muxRegister) = + IOMUXC_SW_MUX_CTL_PAD_MUX_MODE(muxMode) | IOMUXC_SW_MUX_CTL_PAD_SION(inputOnfield); + + if (inputRegister) + { + *((volatile uint32_t *)inputRegister) = inputDaisy; + } +} + +/*! + * @brief Sets the IOMUXC pin configuration. + * @note The previous five parameters can be filled with the pin function ID macros. + * + * This is an example to set pin configuration for IOMUXC_PTA3_LPI2C0_SCLS: + * @code + * IOMUXC_SetPinConfig(IOMUXC_PTA3_LPI2C0_SCLS,IOMUXC_SW_PAD_CTL_PAD_PUS_MASK|IOMUXC_SW_PAD_CTL_PAD_PUS(2U)) + * @endcode + * + * @param muxRegister The pin mux register. + * @param muxMode The pin mux mode. + * @param inputRegister The select input register. + * @param inputDaisy The input daisy. + * @param configRegister The config register. + * @param configValue The pin config value. + */ +static inline void IOMUXC_SetPinConfig(uint32_t muxRegister, + uint32_t muxMode, + uint32_t inputRegister, + uint32_t inputDaisy, + uint32_t configRegister, + uint32_t configValue) +{ + if (configRegister) + { + *((volatile uint32_t *)configRegister) = configValue; + } +} + +/*! + * @brief Sets IOMUXC general configuration for some mode. + * + * @param base The IOMUXC GPR base address. + * @param mode The mode for setting. the mode is the logical OR of "iomuxc_gpr_mode" + * @param enable True enable false disable. + */ +static inline void IOMUXC_EnableMode(IOMUXC_GPR_Type *base, uint32_t mode, bool enable) +{ + mode &= ~(IOMUXC_GPR_GPR1_SAI1_MCLK1_SEL_MASK + | IOMUXC_GPR_GPR1_SAI1_MCLK2_SEL_MASK + | IOMUXC_GPR_GPR1_SAI1_MCLK3_SEL_MASK + | IOMUXC_GPR_GPR1_SAI2_MCLK3_SEL_MASK + | IOMUXC_GPR_GPR1_SAI3_MCLK3_SEL_MASK); + + if (enable) + { + base->GPR1 |= mode; + } + else + { + base->GPR1 &= ~mode; + } +} + +/*! + * @brief Sets IOMUXC general configuration for SAI MCLK selection. + * + * @param base The IOMUXC GPR base address. + * @param mclk The SAI MCLK. + * @param clkSrc The clock source. Take refer to register setting details for the clock source in RM. + */ +static inline void IOMUXC_SetSaiMClkClockSource(IOMUXC_GPR_Type *base, iomuxc_gpr_saimclk_t mclk, uint8_t clkSrc) +{ + uint32_t gpr; + + if (mclk > kIOMUXC_GPR_SAI1MClk2Sel) + { + gpr = base->GPR1 & ~(IOMUXC_GPR_SAIMCLK_HIGHBITMASK << mclk); + base->GPR1 = ((clkSrc & IOMUXC_GPR_SAIMCLK_HIGHBITMASK) << mclk) | gpr; + } + else + { + gpr = base->GPR1 & ~(IOMUXC_GPR_SAIMCLK_LOWBITMASK << mclk); + base->GPR1 = ((clkSrc & IOMUXC_GPR_SAIMCLK_LOWBITMASK) << mclk) | gpr; + } +} + +/*! + * @brief Enters or exit MQS software reset. + * + * @param base The IOMUXC GPR base address. + * @param enable Enter or exit MQS software reset. + */ +static inline void IOMUXC_MQSEnterSoftwareReset(IOMUXC_GPR_Type *base, bool enable) +{ + if (enable) + { + base->GPR2 |= IOMUXC_GPR_GPR2_MQS_SW_RST_MASK; + } + else + { + base->GPR2 &= ~IOMUXC_GPR_GPR2_MQS_SW_RST_MASK; + } +} + + +/*! + * @brief Enables or disables MQS. + * + * @param base The IOMUXC GPR base address. + * @param enable Enable or disable the MQS. + */ +static inline void IOMUXC_MQSEnable(IOMUXC_GPR_Type *base, bool enable) +{ + if (enable) + { + base->GPR2 |= IOMUXC_GPR_GPR2_MQS_EN_MASK; + } + else + { + base->GPR2 &= ~IOMUXC_GPR_GPR2_MQS_EN_MASK; + } +} + +/*! + * @brief Configure MQS PWM oversampling rate compared with mclk and divider ratio control for mclk from hmclk. + * + * @param base The IOMUXC GPR base address. + * @param rate The MQS PWM oversampling rate, refer to "iomuxc_mqs_pwm_oversample_rate_t". + * @param divider The divider ratio control for mclk from hmclk. mclk freq = 1 /(divider + 1) * hmclk freq. + */ + +static inline void IOMUXC_MQSConfig(IOMUXC_GPR_Type *base, iomuxc_mqs_pwm_oversample_rate_t rate, uint8_t divider) +{ + uint32_t gpr = base->GPR2 & ~(IOMUXC_GPR_GPR2_MQS_OVERSAMPLE_MASK | IOMUXC_GPR_GPR2_MQS_CLK_DIV_MASK); + + base->GPR2 = gpr | IOMUXC_GPR_GPR2_MQS_OVERSAMPLE(rate) | IOMUXC_GPR_GPR2_MQS_CLK_DIV(divider); +} + +/*@}*/ + +#if defined(__cplusplus) +} +#endif /*_cplusplus */ + +/*! @}*/ + +#endif /* _FSL_IOMUXC_H_ */ + diff --git a/ports/nxp/board/evkmimxrt1064/hardware_init.c b/ports/nxp/board/evkmimxrt1064/hardware_init.c new file mode 100644 index 000000000000..e64d177fd55b --- /dev/null +++ b/ports/nxp/board/evkmimxrt1064/hardware_init.c @@ -0,0 +1,36 @@ +/* + * Copyright 2018 NXP + * All rights reserved. + * + * + * SPDX-License-Identifier: BSD-3-Clause + */ +/*${header:start}*/ +#include "pin_mux.h" +#include "board.h" +#include "clock_config.h" +/*${header:end}*/ + +/*${function:start}*/ +static void BOARD_USDHCClockConfiguration(void) +{ + CLOCK_InitSysPll(&sysPllConfig_BOARD_BootClockRUN); + /*configure system pll PFD0 fractional divider to 24, output clock is 528MHZ * 18 / 24 = 396 MHZ*/ + CLOCK_InitSysPfd(kCLOCK_Pfd0, 24U); + /* Configure USDHC clock source and divider */ + CLOCK_SetDiv(kCLOCK_Usdhc1Div, 0U); + CLOCK_SetMux(kCLOCK_Usdhc1Mux, 1U); +} + +void BOARD_InitHardware(void) +{ + BOARD_ConfigMPU(); + BOARD_InitPins(); + BOARD_InitSemcPins(); + BOARD_InitI2C1Pins(); + BOARD_BootClockRUN(); + BOARD_USDHCClockConfiguration(); + BOARD_InitDebugConsole(); + NVIC_SetPriority(BOARD_SD_HOST_IRQ, 5U); +} +/*${function:end}*/ diff --git a/ports/nxp/board/evkmimxrt1064/littlevgl_support.c b/ports/nxp/board/evkmimxrt1064/littlevgl_support.c new file mode 100644 index 000000000000..a6d10963651f --- /dev/null +++ b/ports/nxp/board/evkmimxrt1064/littlevgl_support.c @@ -0,0 +1,305 @@ +/* + * Copyright 2019 NXP + * All rights reserved. + * + * SPDX-License-Identifier: BSD-3-Clause + */ + +#include "littlevgl_support.h" +#include "FreeRTOS.h" +#include "semphr.h" + +#include "fsl_elcdif.h" +#include "fsl_lpi2c.h" +#include "fsl_gpio.h" +#include "fsl_ft5406_rt.h" +#include "fsl_debug_console.h" + +/******************************************************************************* + * Definitions + ******************************************************************************/ + +/* Macros for the touch touch controller. */ +#define TOUCH_I2C LPI2C1 + +/* Select USB1 PLL (480 MHz) as master lpi2c clock source */ +#define TOUCH_LPI2C_CLOCK_SOURCE_SELECT (0U) +/* Clock divider for master lpi2c clock source */ +#define TOUCH_LPI2C_CLOCK_SOURCE_DIVIDER (5U) + +#define TOUCH_I2C_CLOCK_FREQ ((CLOCK_GetFreq(kCLOCK_Usb1PllClk) / 8) / (TOUCH_LPI2C_CLOCK_SOURCE_DIVIDER + 1U)) +#define TOUCH_I2C_BAUDRATE 100000U + +/* Macros for panel. */ +#define LCD_HSW 41 +#define LCD_HFP 4 +#define LCD_HBP 8 +#define LCD_VSW 10 +#define LCD_VFP 4 +#define LCD_VBP 2 +#define LCD_POL_FLAGS \ + (kELCDIF_DataEnableActiveHigh | kELCDIF_VsyncActiveLow | kELCDIF_HsyncActiveLow | kELCDIF_DriveDataOnRisingClkEdge) +#define LCD_LCDIF_DATA_BUS kELCDIF_DataBus16Bit + +/* Back light. */ +#define LCD_BL_GPIO GPIO2 +#define LCD_BL_GPIO_PIN 31 + +/******************************************************************************* + * Prototypes + ******************************************************************************/ +static void DEMO_InitLcdClock(void); + +static void DEMO_InitLcdBackLight(void); + + +/******************************************************************************* + * Variables + ******************************************************************************/ +static volatile bool s_framePending; +static SemaphoreHandle_t s_frameSema; +static ft5406_rt_handle_t touchHandle; +AT_NONCACHEABLE_SECTION_ALIGN(static uint8_t s_frameBuffer[2][LCD_WIDTH * LCD_HEIGHT * LCD_FB_BYTE_PER_PIXEL], 64); + +/******************************************************************************* + * Code + ******************************************************************************/ + +void lv_port_pre_init(void) +{ + /* + * Pass in the frame buffer address to LittlevGL manually, the LV_VDB_ADR + * and LV_VDB2_ADR should be defined to LV_VDB_ADR_INV in lv_conf.h + */ + lv_vdb_set_adr(s_frameBuffer[0], s_frameBuffer[1]); +} + +void lv_port_disp_init(void) +{ + /*------------------------- + * Initialize your display + * -----------------------*/ + DEMO_InitLcd(); + + /*----------------------------------- + * Register the display in LittlevGL + *----------------------------------*/ + + lv_disp_drv_t disp_drv; /*Descriptor of a display driver*/ + lv_disp_drv_init(&disp_drv); /*Basic initialization*/ + + /*Set up the functions to access to your display*/ + + /*Used in buffered mode (LV_VDB_SIZE != 0 in lv_conf.h)*/ +// disp_drv.disp_flush = DEMO_FlushDisplay; + + /*Finally register the driver*/ + lv_disp_drv_register(&disp_drv); +} + +void LCDIF_IRQHandler(void) +{ + BaseType_t taskAwake = pdFALSE; + + uint32_t intStatus = ELCDIF_GetInterruptStatus(LCDIF); + + ELCDIF_ClearInterruptStatus(LCDIF, intStatus); + if (s_framePending) + { + if (intStatus & kELCDIF_CurFrameDone) + { + s_framePending = false; + + xSemaphoreGiveFromISR(s_frameSema, &taskAwake); + portYIELD_FROM_ISR(taskAwake); + } + } + +/* Add for ARM errata 838869, affects Cortex-M4, Cortex-M4F Store immediate overlapping + exception return operation might vector to incorrect interrupt */ +#if defined __CORTEX_M && (__CORTEX_M == 4U) + __DSB(); +#endif +} + +static void DEMO_InitLcdClock(void) +{ + /* + * The desired output frame rate is 60Hz. So the pixel clock frequency is: + * (480 + 41 + 4 + 18) * (272 + 10 + 4 + 2) * 60 = 9.2M. + * Here set the LCDIF pixel clock to 9.3M. + */ + + /* + * Initialize the Video PLL. + * Video PLL output clock is OSC24M * (loopDivider + (denominator / numerator)) / postDivider = 93MHz. + */ + clock_video_pll_config_t config = { + .loopDivider = 31, + .postDivider = 8, + .numerator = 0, + .denominator = 0, + }; + + CLOCK_InitVideoPll(&config); + + /* + * 000 derive clock from PLL2 + * 001 derive clock from PLL3 PFD3 + * 010 derive clock from PLL5 + * 011 derive clock from PLL2 PFD0 + * 100 derive clock from PLL2 PFD1 + * 101 derive clock from PLL3 PFD1 + */ + CLOCK_SetMux(kCLOCK_LcdifPreMux, 2); + + CLOCK_SetDiv(kCLOCK_LcdifPreDiv, 4); + + CLOCK_SetDiv(kCLOCK_LcdifDiv, 1); +} + +static void DEMO_InitLcdBackLight(void) +{ + const gpio_pin_config_t config = { + kGPIO_DigitalOutput, + 1, + }; + + /* Backlight. */ + GPIO_PinInit(LCD_BL_GPIO, LCD_BL_GPIO_PIN, &config); +} + +void DEMO_InitLcd(void) +{ + /* Initialize the display. */ + const elcdif_rgb_mode_config_t config = { + .panelWidth = LCD_WIDTH, + .panelHeight = LCD_HEIGHT, + .hsw = LCD_HSW, + .hfp = LCD_HFP, + .hbp = LCD_HBP, + .vsw = LCD_VSW, + .vfp = LCD_VFP, + .vbp = LCD_VBP, + .polarityFlags = LCD_POL_FLAGS, + /* littlevgl starts render in frame buffer 0, so show frame buffer 1 first. */ + .bufferAddr = (uint32_t)s_frameBuffer[1], + .pixelFormat = kELCDIF_PixelFormatRGB565, + .dataBus = LCD_LCDIF_DATA_BUS, + }; + + /* Clear frame buffer. */ + memset((void *)s_frameBuffer, 0, sizeof(s_frameBuffer)); + + s_frameSema = xSemaphoreCreateBinary(); + if (NULL == s_frameSema) + { + PRINTF("Frame semaphore create failed\r\n"); + assert(0); + } + + /* No frame pending. */ + s_framePending = false; + NVIC_SetPriority(LCDIF_IRQn, 3); + + DEMO_InitLcdClock(); + ELCDIF_RgbModeInit(LCDIF, &config); + + ELCDIF_EnableInterrupts(LCDIF, kELCDIF_CurFrameDoneInterruptEnable); + NVIC_EnableIRQ(LCDIF_IRQn); + ELCDIF_RgbModeStart(LCDIF); + DEMO_InitLcdBackLight(); +} + +void DEMO_FlushDisplay(int32_t x1, int32_t y1, int32_t x2, int32_t y2, const lv_color_t *color_p) +{ + ELCDIF_SetNextBufferAddr(LCDIF, (uint32_t)color_p); + + s_framePending = true; + + xSemaphoreTake(s_frameSema, portMAX_DELAY); + /* IMPORTANT!!! + * Inform the graphics library that you are ready with the flushing*/ + lv_flush_ready(); +} + +void lv_port_indev_init(void) +{ + lv_indev_drv_t indev_drv; + + /*------------------ + * Touchpad + * -----------------*/ + + /*Initialize your touchpad */ + DEMO_InitTouch(); + + /*Register a touchpad input device*/ + lv_indev_drv_init(&indev_drv); + indev_drv.type = LV_INDEV_TYPE_POINTER; + indev_drv.read = DEMO_ReadTouch; + lv_indev_drv_register(&indev_drv); +} + +/*Initialize your touchpad*/ +void DEMO_InitTouch(void) +{ + status_t status; + + lpi2c_master_config_t masterConfig = {0}; + + /*Clock setting for LPI2C*/ + CLOCK_SetMux(kCLOCK_Lpi2cMux, TOUCH_LPI2C_CLOCK_SOURCE_SELECT); + CLOCK_SetDiv(kCLOCK_Lpi2cDiv, TOUCH_LPI2C_CLOCK_SOURCE_DIVIDER); + + /* + * masterConfig.debugEnable = false; + * masterConfig.ignoreAck = false; + * masterConfig.pinConfig = kLPI2C_2PinOpenDrain; + * masterConfig.baudRate_Hz = 100000U; + * masterConfig.busIdleTimeout_ns = 0; + * masterConfig.pinLowTimeout_ns = 0; + * masterConfig.sdaGlitchFilterWidth_ns = 0; + * masterConfig.sclGlitchFilterWidth_ns = 0; + */ + LPI2C_MasterGetDefaultConfig(&masterConfig); + + /* Change the default baudrate configuration */ + masterConfig.baudRate_Hz = TOUCH_I2C_BAUDRATE; + + /* Initialize the LPI2C master peripheral */ + LPI2C_MasterInit(TOUCH_I2C, &masterConfig, TOUCH_I2C_CLOCK_FREQ); + + /* Initialize touch panel controller */ + status = FT5406_RT_Init(&touchHandle, TOUCH_I2C); + if (status != kStatus_Success) + { + PRINTF("Touch panel init failed\n"); + assert(0); + } +} + +/* Will be called by the library to read the touchpad */ +bool DEMO_ReadTouch(lv_indev_data_t *data) +{ + touch_event_t touch_event; + static int touch_x = 0; + static int touch_y = 0; + + data->state = LV_INDEV_STATE_REL; + + if (kStatus_Success == FT5406_RT_GetSingleTouch(&touchHandle, &touch_event, &touch_x, &touch_y)) + { + if ((touch_event == kTouch_Down) || (touch_event == kTouch_Contact)) + { + data->state = LV_INDEV_STATE_PR; + } + } + + /*Set the last pressed coordinates*/ + data->point.x = touch_y; + data->point.y = touch_x; + + /*Return `false` because we are not buffering and no more data to read*/ + return false; +} diff --git a/ports/nxp/board/evkmimxrt1064/littlevgl_support.h b/ports/nxp/board/evkmimxrt1064/littlevgl_support.h new file mode 100644 index 000000000000..d267d03f21f4 --- /dev/null +++ b/ports/nxp/board/evkmimxrt1064/littlevgl_support.h @@ -0,0 +1,41 @@ +/* + * Copyright 2018 NXP + * All rights reserved. + * + * SPDX-License-Identifier: BSD-3-Clause + */ + +#ifndef LITTLEVGL_SUPPORT_H +#define LITTLEVGL_SUPPORT_H + +#include +#include "lvgl.h" +/******************************************************************************* + * Definitions + ******************************************************************************/ + +#define LCD_WIDTH 480 +#define LCD_HEIGHT 272 +#define LCD_FB_BYTE_PER_PIXEL 2 + +/******************************************************************************* + * API + ******************************************************************************/ + +#ifdef __cplusplus +extern "C" { +#endif + +void DEMO_InitLcd(void); +void lv_port_pre_init(void); +void lv_port_disp_init(void); +void lv_port_indev_init(void); +void DEMO_FlushDisplay(int32_t x1, int32_t y1, int32_t x2, int32_t y2, const lv_color_t *color_p); +void DEMO_InitTouch(void); +bool DEMO_ReadTouch(lv_indev_data_t *data); + +#if defined(__cplusplus) +} +#endif + +#endif /*LITTLEVGL_SUPPORT_H */ diff --git a/ports/nxp/board/evkmimxrt1064/lv_conf.h b/ports/nxp/board/evkmimxrt1064/lv_conf.h new file mode 100644 index 000000000000..22d254c4b901 --- /dev/null +++ b/ports/nxp/board/evkmimxrt1064/lv_conf.h @@ -0,0 +1,408 @@ +/* + * The MIT License (MIT) + * + * Copyright (c) 2013-2019 Damien P. George + * + * Permission is hereby granted, free of charge, to any person obtaining a copy + * of this software and associated documentation files (the "Software"), to deal + * in the Software without restriction, including without limitation the rights + * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell + * copies of the Software, and to permit persons to whom the Software is + * furnished to do so, subject to the following conditions: + * + * The above copyright notice and this permission notice shall be included in + * all copies or substantial portions of the Software. + * + * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR + * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, + * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE + * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER + * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, + * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN + * THE SOFTWARE. + */ +/** + * @file lv_conf.h + * + */ + +#if 1 /*Set it to "1" to enable the content*/ + +#ifndef LV_CONF_H +#define LV_CONF_H + +/*=================== + Dynamic memory + *===================*/ + +/* Memory size which will be used by the library + * to store the graphical objects and other data */ +#define LV_MEM_CUSTOM 1 /*1: use custom malloc/free, 0: use the built-in lv_mem_alloc/lv_mem_free*/ +#if LV_MEM_CUSTOM == 0 +#define LV_MEM_SIZE (64U * 1024U) /*Size memory used by `lv_mem_alloc` in bytes (>= 2kB)*/ +#define LV_MEM_ATTR /*Complier prefix for big array declaration*/ +#define LV_MEM_AUTO_DEFRAG 1 /*Automatically defrag on free*/ +#else /*LV_MEM_CUSTOM*/ +#define LV_MEM_CUSTOM_INCLUDE /*Header for the dynamic memory function*/ +#define LV_MEM_CUSTOM_ALLOC m_malloc /*Wrapper to malloc*/ +#define LV_MEM_CUSTOM_FREE m_free /*Wrapper to free*/ +#endif /*LV_MEM_CUSTOM*/ + +/* Enable GC for Micropython */ +#define LV_ENABLE_GC 1 +#if LV_ENABLE_GC == 1 +# define LV_MEM_CUSTOM_REALLOC m_realloc /*Wrapper to realloc*/ +# define LV_MEM_CUSTOM_GET_SIZE gc_nbytes /*Wrapper to lv_mem_get_size*/ +# define LV_GC_INCLUDE "py/mpstate.h" +# define LV_GC_ROOT(x) MP_STATE_PORT(x) +#endif /* LV_ENABLE_GC */ + +/*=================== + Graphical settings + *===================*/ + +/* Horizontal and vertical resolution of the library.*/ +#define LV_HOR_RES (480) +#define LV_VER_RES (272) + +/* Dot Per Inch: used to initialize default sizes. E.g. a button with width = LV_DPI / 2 -> half inch wide + * (Not so important, you can adjust it to modify default sizes and spaces)*/ +#define LV_DPI 100 + +/* Enable anti-aliasing (lines, and radiuses will be smoothed) */ +#define LV_ANTIALIAS 1 /*1: Enable anti-aliasing*/ + +/*Screen refresh period in milliseconds*/ +#define LV_REFR_PERIOD 30 + +/*----------------- + * VDB settings + *----------------*/ + +/* VDB (Virtual Display Buffer) is an internal graphics buffer. + * To images will be drawn into this buffer first and then + * the buffer will be passed to your `disp_drv.disp_flush` function to + * copy it to your frame buffer. + * VDB is required for: buffered drawing, opacity, anti-aliasing and shadows + * Learn more: https://docs.littlevgl.com/#Drawing*/ + +/* Size of the VDB in pixels. Typical size: ~1/10 screen. Must be >= LV_HOR_RES + * Setting it to 0 will disable VDB and `disp_drv.disp_fill` and `disp_drv.disp_map` functions + * will be called to draw to the frame buffer directly*/ +#define LV_VDB_SIZE ((LV_VER_RES * LV_HOR_RES) / 1) + + /* Bit-per-pixel of VDB. Useful for monochrome or non-standard color format displays. + * Special formats are handled with `disp_drv.vdb_wr`)*/ +#define LV_VDB_PX_BPP 16 /*LV_COLOR_SIZE comes from LV_COLOR_DEPTH below to set 8, 16 or 32 bit pixel size automatically */ + + /* Place VDB to a specific address (e.g. in external RAM) + * 0: allocate automatically into RAM + * LV_VDB_ADR_INV: to replace it later with `lv_vdb_set_adr()`*/ +#define LV_VDB_ADR 8 + +/* Use two Virtual Display buffers (VDB) parallelize rendering and flushing (optional) + * The flushing should use DMA to write the frame buffer in the background */ +#define LV_VDB_DOUBLE 1 + +/* Place VDB2 to a specific address (e.g. in external RAM) + * 0: allocate automatically into RAM + * LV_VDB_ADR_INV: to replace it later with `lv_vdb_set_adr()`*/ +#define LV_VDB2_ADR 8 + +/* Using true double buffering in `disp_drv.disp_flush` you will always get the image of the whole screen. + * Your only task is to set the rendered image (`color_p` parameter) as frame buffer address or send it to your display. + * The best if you do in the blank period of you display to avoid tearing effect. + * Requires: + * - LV_VDB_SIZE = LV_HOR_RES * LV_VER_RES + * - LV_VDB_DOUBLE = 1 + */ +#define LV_VDB_TRUE_DOUBLE_BUFFERED 1 + +/*================= + Misc. setting + *=================*/ + +/*Input device settings*/ +#define LV_INDEV_READ_PERIOD 50 /*Input device read period in milliseconds*/ +#define LV_INDEV_POINT_MARKER 0 /*Mark the pressed points (required: USE_LV_REAL_DRAW = 1)*/ +#define LV_INDEV_DRAG_LIMIT 10 /*Drag threshold in pixels */ +#define LV_INDEV_DRAG_THROW 20 /*Drag throw slow-down in [%]. Greater value means faster slow-down */ +#define LV_INDEV_LONG_PRESS_TIME 400 /*Long press time in milliseconds*/ +#define LV_INDEV_LONG_PRESS_REP_TIME 100 /*Repeated trigger period in long press [ms] */ + +/*Color settings*/ +#define LV_COLOR_DEPTH 16 /*Color depth: 1/8/16/32*/ +#define LV_COLOR_16_SWAP 0 /*Swap the 2 bytes of RGB565 color. Useful if the display has a 8 bit interface (e.g. SPI)*/ +#define LV_COLOR_SCREEN_TRANSP 0 /*1: Enable screen transparency. Useful for OSD or other overlapping GUIs. Requires ARGB8888 colors*/ +#define LV_COLOR_TRANSP LV_COLOR_LIME /*Images pixels with this color will not be drawn (with chroma keying)*/ + +/*Text settings*/ +#define LV_TXT_UTF8 1 /*Enable UTF-8 coded Unicode character usage */ +#define LV_TXT_BREAK_CHARS " ,.;:-_" /*Can break texts on these chars*/ +#define LV_TXT_LINE_BREAK_LONG_LEN 12 /* If a character is at least this long, will break wherever "prettiest" */ +#define LV_TXT_LINE_BREAK_LONG_PRE_MIN_LEN 3 /* Minimum number of characters of a word to put on a line before a break */ +#define LV_TXT_LINE_BREAK_LONG_POST_MIN_LEN 1 /* Minimum number of characters of a word to put on a line after a break */ + +/*Feature usage*/ +#define USE_LV_ANIMATION 1 /*1: Enable all animations*/ +#define USE_LV_SHADOW 0 /*1: Enable shadows*/ +#define USE_LV_GROUP 1 /*1: Enable object groups (for keyboards)*/ +#define USE_LV_GPU 0 /*1: Enable GPU interface*/ +#define USE_LV_REAL_DRAW 1 /*1: Enable function which draw directly to the frame buffer instead of VDB (required if LV_VDB_SIZE = 0)*/ +#define USE_LV_FILESYSTEM 0 /*1: Enable file system (might be required for images*/ + +/*Compiler settings*/ +#define LV_ATTRIBUTE_TICK_INC /* Define a custom attribute to `lv_tick_inc` function */ +#define LV_ATTRIBUTE_TASK_HANDLER /* Define a custom attribute to `lv_task_handler` function */ +#define LV_COMPILER_VLA_SUPPORTED 0 /* 1: Variable length array is supported*/ +#define LV_COMPILER_NON_CONST_INIT_SUPPORTED 1 /* 1: Initialization with non constant values are supported */ + +/*HAL settings*/ +#define LV_TICK_CUSTOM 0 /*1: use a custom tick source (removing the need to manually update the tick with `lv_tick_inc`) */ +#if LV_TICK_CUSTOM == 1 +#define LV_TICK_CUSTOM_INCLUDE "sonething.h" /*Header for the sys time function*/ +#define LV_TICK_CUSTOM_SYS_TIME_EXPR (millis()) /*Expression evaluating to current systime in ms*/ +#endif /*LV_TICK_CUSTOM*/ + + +/*Log settings*/ +#define USE_LV_LOG 0 /*Enable/disable the log module*/ +#if USE_LV_LOG +/* How important log should be added: + * LV_LOG_LEVEL_TRACE A lot of logs to give detailed information + * LV_LOG_LEVEL_INFO Log important events + * LV_LOG_LEVEL_WARN Log if something unwanted happened but didn't caused problem + * LV_LOG_LEVEL_ERROR Only critical issue, when the system may fail + */ +#define LV_LOG_LEVEL LV_LOG_LEVEL_WARN +/* 1: Print the log with 'printf'; 0: user need to register a callback*/ + +#define LV_LOG_PRINTF 0 +#endif /*USE_LV_LOG*/ + +/*================ + * THEME USAGE + *================*/ +#define LV_THEME_LIVE_UPDATE 1 /*1: Allow theme switching at run time. Uses 8..10 kB of RAM*/ + +#define USE_LV_THEME_TEMPL 0 /*Just for test*/ +#define USE_LV_THEME_DEFAULT 1 /*Built mainly from the built-in styles. Consumes very few RAM*/ +#define USE_LV_THEME_ALIEN 1 /*Dark futuristic theme*/ +#define USE_LV_THEME_NIGHT 1 /*Dark elegant theme*/ +#define USE_LV_THEME_MONO 1 /*Mono color theme for monochrome displays*/ +#define USE_LV_THEME_MATERIAL 1 /*Flat theme with bold colors and light shadows*/ +#define USE_LV_THEME_ZEN 1 /*Peaceful, mainly light theme */ +#define USE_LV_THEME_NEMO 1 /*Water-like theme based on the movie "Finding Nemo"*/ + +/*================== + * FONT USAGE + *===================*/ + +/* More info about fonts: https://docs.littlevgl.com/#Fonts + * To enable a built-in font use 1,2,4 or 8 values + * which will determine the bit-per-pixel. Higher value means smoother fonts */ +#define USE_LV_FONT_DEJAVU_10 0 +#define USE_LV_FONT_DEJAVU_10_LATIN_SUP 0 +#define USE_LV_FONT_DEJAVU_10_CYRILLIC 0 +#define USE_LV_FONT_SYMBOL_10 0 + +#define USE_LV_FONT_DEJAVU_20 1 +#define USE_LV_FONT_DEJAVU_20_LATIN_SUP 1 +#define USE_LV_FONT_DEJAVU_20_CYRILLIC 1 +#define USE_LV_FONT_SYMBOL_20 1 + +#define USE_LV_FONT_DEJAVU_30 0 +#define USE_LV_FONT_DEJAVU_30_LATIN_SUP 0 +#define USE_LV_FONT_DEJAVU_30_CYRILLIC 0 +#define USE_LV_FONT_SYMBOL_30 0 + +#define USE_LV_FONT_DEJAVU_40 0 +#define USE_LV_FONT_DEJAVU_40_LATIN_SUP 0 +#define USE_LV_FONT_DEJAVU_40_CYRILLIC 0 +#define USE_LV_FONT_SYMBOL_40 0 + +#define USE_LV_FONT_MONOSPACE_8 0 + +/* Optionally declare your custom fonts here. + * You can use these fonts as default font too + * and they will be available globally. E.g. + * #define LV_FONT_CUSTOM_DECLARE LV_FONT_DECLARE(my_font_1) \ + * LV_FONT_DECLARE(my_font_2) \ + */ +#define LV_FONT_CUSTOM_DECLARE + + +#define LV_FONT_DEFAULT &lv_font_dejavu_20 /*Always set a default font from the built-in fonts*/ + +/*=================== + * LV_OBJ SETTINGS + *==================*/ +#define LV_OBJ_FREE_NUM_TYPE uint32_t /*Type of free number attribute (comment out disable free number)*/ +#define LV_OBJ_FREE_PTR 1 /*Enable the free pointer attribute*/ +#define LV_OBJ_REALIGN 1 /*Enable `lv_obj_realaign()` based on `lv_obj_align()` parameters*/ + +/*================== + * LV OBJ X USAGE + *================*/ +/* + * Documentation of the object types: https://docs.littlevgl.com/#Object-types + */ + +/***************** + * Simple object + *****************/ + +/*Label (dependencies: -*/ +#define USE_LV_LABEL 1 +#if USE_LV_LABEL != 0 +#define LV_LABEL_SCROLL_SPEED 25 /*Hor, or ver. scroll speed [px/sec] in 'LV_LABEL_LONG_SCROLL/ROLL' mode*/ +#endif + +/*Image (dependencies: lv_label*/ +#define USE_LV_IMG 1 +#if USE_LV_IMG != 0 +#define LV_IMG_CF_INDEXED 1 /*Enable indexed (palette) images*/ +#define LV_IMG_CF_ALPHA 1 /*Enable alpha indexed images*/ +#endif + +/*Line (dependencies: -*/ +#define USE_LV_LINE 1 + +/*Arc (dependencies: -)*/ +#define USE_LV_ARC 1 + +/******************* + * Container objects + *******************/ + +/*Container (dependencies: -*/ +#define USE_LV_CONT 1 + +/*Page (dependencies: lv_cont)*/ +#define USE_LV_PAGE 1 + +/*Window (dependencies: lv_cont, lv_btn, lv_label, lv_img, lv_page)*/ +#define USE_LV_WIN 1 + +/*Tab (dependencies: lv_page, lv_btnm)*/ +#define USE_LV_TABVIEW 1 +#if USE_LV_TABVIEW != 0 +#define LV_TABVIEW_ANIM_TIME 300 /*Time of slide animation [ms] (0: no animation)*/ +#endif + +/*Tileview (dependencies: lv_page) */ +#define USE_LV_TILEVIEW 1 +#if USE_LV_TILEVIEW +#define LV_TILEVIEW_ANIM_TIME 300 /*Time of slide animation [ms] (0: no animation)*/ +#endif + +/************************* + * Data visualizer objects + *************************/ + +/*Bar (dependencies: -)*/ +#define USE_LV_BAR 1 + +/*Line meter (dependencies: *;)*/ +#define USE_LV_LMETER 1 + +/*Gauge (dependencies:lv_bar, lv_lmeter)*/ +#define USE_LV_GAUGE 1 + +/*Chart (dependencies: -)*/ +#define USE_LV_CHART 1 + +/*Table (dependencies: lv_label)*/ +#define USE_LV_TABLE 1 +#if USE_LV_TABLE +#define LV_TABLE_COL_MAX 12 +#endif + +/*LED (dependencies: -)*/ +#define USE_LV_LED 1 + +/*Message box (dependencies: lv_rect, lv_btnm, lv_label)*/ +#define USE_LV_MBOX 1 + +/*Text area (dependencies: lv_label, lv_page)*/ +#define USE_LV_TA 1 +#if USE_LV_TA != 0 +#define LV_TA_CURSOR_BLINK_TIME 400 /*ms*/ +#define LV_TA_PWD_SHOW_TIME 1500 /*ms*/ +#endif + +/*Spinbox (dependencies: lv_ta)*/ +#define USE_LV_SPINBOX 1 + +/*Calendar (dependencies: -)*/ +#define USE_LV_CALENDAR 1 + +/*Preload (dependencies: lv_arc)*/ +#define USE_LV_PRELOAD 1 +#if USE_LV_PRELOAD != 0 +#define LV_PRELOAD_DEF_ARC_LENGTH 60 /*[deg]*/ +#define LV_PRELOAD_DEF_SPIN_TIME 1000 /*[ms]*/ +#define LV_PRELOAD_DEF_ANIM LV_PRELOAD_TYPE_SPINNING_ARC +#endif + +/*Canvas (dependencies: lv_img)*/ +#define USE_LV_CANVAS 1 +/************************* + * User input objects + *************************/ + +/*Button (dependencies: lv_cont*/ +#define USE_LV_BTN 1 +#if USE_LV_BTN != 0 +#define LV_BTN_INK_EFFECT 1 /*Enable button-state animations - draw a circle on click (dependencies: USE_LV_ANIMATION)*/ +#endif + +/*Image Button (dependencies: lv_btn*/ +#define USE_LV_IMGBTN 1 +#if USE_LV_IMGBTN +#define LV_IMGBTN_TILED 0 /*1: The imgbtn requires left, mid and right parts and the width can be set freely*/ +#endif + +/*Button matrix (dependencies: -)*/ +#define USE_LV_BTNM 1 + +/*Keyboard (dependencies: lv_btnm)*/ +#define USE_LV_KB 1 + +/*Check box (dependencies: lv_btn, lv_label)*/ +#define USE_LV_CB 1 + +/*List (dependencies: lv_page, lv_btn, lv_label, (lv_img optionally for icons ))*/ +#define USE_LV_LIST 1 +#if USE_LV_LIST != 0 +#define LV_LIST_FOCUS_TIME 100 /*Default animation time of focusing to a list element [ms] (0: no animation) */ +#endif + +/*Drop down list (dependencies: lv_page, lv_label, lv_symbol_def.h)*/ +#define USE_LV_DDLIST 1 +#if USE_LV_DDLIST != 0 +#define LV_DDLIST_ANIM_TIME 200 /*Open and close default animation time [ms] (0: no animation)*/ +#endif + +/*Roller (dependencies: lv_ddlist)*/ +#define USE_LV_ROLLER 1 +#if USE_LV_ROLLER != 0 +#define LV_ROLLER_ANIM_TIME 200 /*Focus animation time [ms] (0: no animation)*/ +#endif + +/*Slider (dependencies: lv_bar)*/ +#define USE_LV_SLIDER 1 + +/*Switch (dependencies: lv_slider)*/ +#define USE_LV_SW 1 + +/************************* + * Non-user section + *************************/ +#if defined(_MSC_VER) && !defined(_CRT_SECURE_NO_WARNINGS) /* Disable warnings for Visual Studio*/ +#define _CRT_SECURE_NO_WARNINGS +#endif + +#endif /*LV_CONF_H*/ + +#endif /*End of "Content enable"*/ \ No newline at end of file diff --git a/ports/nxp/board/evkmimxrt1064/lv_mp_mem_custom_include.h b/ports/nxp/board/evkmimxrt1064/lv_mp_mem_custom_include.h new file mode 100644 index 000000000000..9a6003e78aa9 --- /dev/null +++ b/ports/nxp/board/evkmimxrt1064/lv_mp_mem_custom_include.h @@ -0,0 +1,31 @@ +/* + * The MIT License (MIT) + * + * Copyright (c) 2013-2019 Damien P. George + * + * Permission is hereby granted, free of charge, to any person obtaining a copy + * of this software and associated documentation files (the "Software"), to deal + * in the Software without restriction, including without limitation the rights + * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell + * copies of the Software, and to permit persons to whom the Software is + * furnished to do so, subject to the following conditions: + * + * The above copyright notice and this permission notice shall be included in + * all copies or substantial portions of the Software. + * + * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR + * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, + * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE + * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER + * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, + * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN + * THE SOFTWARE. + */ +#ifndef __LV_MP_MEM_CUSTOM_INCLUDE_H +#define __LV_MP_MEM_CUSTOM_INCLUDE_H + +#include +#include +#include + +#endif //__LV_MP_MEM_CUSTOM_INCLUDE_H diff --git a/ports/nxp/board/evkmimxrt1064/mpconfigboard.h b/ports/nxp/board/evkmimxrt1064/mpconfigboard.h new file mode 100644 index 000000000000..cdb36a1a4fbb --- /dev/null +++ b/ports/nxp/board/evkmimxrt1064/mpconfigboard.h @@ -0,0 +1,7 @@ +#define MICROPY_HW_BOARD_NAME "evkmimxrt1064" +#define MICROPY_HW_MCU_NAME "imxrt1064" +#define MICROPY_MIN_USE_IMXRT1064_MCU (1) + +/* Enable LVGL */ +#define MICROPY_PY_LVGL (1) +#define MICROPY_PY_LPI2C (1) \ No newline at end of file diff --git a/ports/nxp/board/evkmimxrt1064/mpconfigboard.mk b/ports/nxp/board/evkmimxrt1064/mpconfigboard.mk new file mode 100644 index 000000000000..c687cbf9e875 --- /dev/null +++ b/ports/nxp/board/evkmimxrt1064/mpconfigboard.mk @@ -0,0 +1,37 @@ +Series := imx +BOARD := evkmimxrt1064 +Device := MIMXRT1064 + +BOARD_DIR = ports/nxp/board/$(BOARD) + +CFLAGS_CORE = -mthumb -mtune=cortex-m7 \ + -mcpu=cortex-m7 \ + -mfpu=fpv5-d16 -mfloat-abi=hard \ + -fsingle-precision-constant -Wdouble-promotion + +CFLAGS_BOARD = -DCPU_MIMXRT1064DVL6A -D__MPU_PRESENT=1 \ + -DXIP_EXTERNAL_FLASH=1 \ + -DXIP_BOOT_HEADER_ENABLE=1 \ + -DXIP_BOOT_HEADER_DCD_ENABLE=1 \ + -DSKIP_SYSCLK_INIT \ + -DFSL_SDK_ENABLE_DRIVER_CACHE_CONTROL=1 \ + +LINK_FILE = MIMXRT1064xxxxx_flexspi_nor_sdram.ld + +SRC_BOARD = $(addprefix $(BOARD_DIR)/, \ + board.c \ + port-pad.c \ + clock_config.c \ + evkmimxrt1064_flexspi_nor_config.c \ + evkmimxrt1064_sdram_ini_dcd.c \ + fsl_clock.c \ + hardware_init.c \ + pin_mux.c \ + littlevgl_support.c \ +) + +# If use little vgl Set this variable +LITTLEVGL_ENABLE = 1 + +BOARD_FSL_DRIVERS = \ + fsl_elcdif.c \ No newline at end of file diff --git a/ports/nxp/board/evkmimxrt1064/pin_mux.c b/ports/nxp/board/evkmimxrt1064/pin_mux.c new file mode 100644 index 000000000000..e80b3a3197db --- /dev/null +++ b/ports/nxp/board/evkmimxrt1064/pin_mux.c @@ -0,0 +1,1064 @@ +/* + * Copyright 2018-2019 NXP + * All rights reserved. + * + * SPDX-License-Identifier: BSD-3-Clause + */ + +/*********************************************************************************************************************** + * This file was generated by the MCUXpresso Config Tools. Any manual edits made to this file + * will be overwritten if the respective MCUXpresso Config Tools is used to update this file. + **********************************************************************************************************************/ + +/* + * TEXT BELOW IS USED AS SETTING FOR TOOLS ************************************* +!!GlobalInfo +product: Pins v5.0 +processor: MIMXRT1064xxxxA +package_id: MIMXRT1064DVL6A +mcu_data: ksdk2_0 +processor_version: 5.0.1 +board: MIMXRT1064-EVK + * BE CAREFUL MODIFYING THIS COMMENT - IT IS YAML SETTINGS FOR TOOLS *********** + */ + +#include "fsl_common.h" +#include "fsl_iomuxc.h" +#include "pin_mux.h" + +/* FUNCTION ************************************************************************************************************ + * + * Function Name : BOARD_InitBootPins + * Description : Calls initialization functions. + * + * END ****************************************************************************************************************/ +void BOARD_InitBootPins(void) { + BOARD_InitPins(); +} + +/* + * TEXT BELOW IS USED AS SETTING FOR TOOLS ************************************* +BOARD_InitPins: +- options: {callFromInitBoot: 'true', coreID: core0, enableClock: 'true'} +- pin_list: + - {pin_num: L14, peripheral: LPUART1, signal: RX, pin_signal: GPIO_AD_B0_13, software_input_on: Disable, hysteresis_enable: Disable, pull_up_down_config: Pull_Down_100K_Ohm, + pull_keeper_select: Keeper, pull_keeper_enable: Enable, open_drain: Disable, speed: MHZ_100, drive_strength: R0_6, slew_rate: Slow} + - {pin_num: K14, peripheral: LPUART1, signal: TX, pin_signal: GPIO_AD_B0_12, software_input_on: Disable, hysteresis_enable: Disable, pull_up_down_config: Pull_Down_100K_Ohm, + pull_keeper_select: Keeper, pull_keeper_enable: Enable, open_drain: Disable, speed: MHZ_100, drive_strength: R0_6, slew_rate: Slow} + * BE CAREFUL MODIFYING THIS COMMENT - IT IS YAML SETTINGS FOR TOOLS *********** + */ + +/* FUNCTION ************************************************************************************************************ + * + * Function Name : BOARD_InitPins + * Description : Configures pin routing and optionally pin electrical features. + * + * END ****************************************************************************************************************/ +void BOARD_InitPins(void) { + CLOCK_EnableClock(kCLOCK_Iomuxc); /* iomuxc clock (iomuxc_clk_enable): 0x03U */ + + IOMUXC_SetPinMux( + IOMUXC_GPIO_AD_B0_12_LPUART1_TX, /* GPIO_AD_B0_12 is configured as LPUART1_TX */ + 0U); /* Software Input On Field: Input Path is determined by functionality */ + IOMUXC_SetPinMux( + IOMUXC_GPIO_AD_B0_13_LPUART1_RX, /* GPIO_AD_B0_13 is configured as LPUART1_RX */ + 0U); /* Software Input On Field: Input Path is determined by functionality */ + IOMUXC_SetPinConfig( + IOMUXC_GPIO_AD_B0_12_LPUART1_TX, /* GPIO_AD_B0_12 PAD functional properties : */ + 0x10B0U); /* Slew Rate Field: Slow Slew Rate + Drive Strength Field: R0/6 + Speed Field: medium(100MHz) + Open Drain Enable Field: Open Drain Disabled + Pull / Keep Enable Field: Pull/Keeper Enabled + Pull / Keep Select Field: Keeper + Pull Up / Down Config. Field: 100K Ohm Pull Down + Hyst. Enable Field: Hysteresis Disabled */ + IOMUXC_SetPinConfig( + IOMUXC_GPIO_AD_B0_13_LPUART1_RX, /* GPIO_AD_B0_13 PAD functional properties : */ + 0x10B0U); /* Slew Rate Field: Slow Slew Rate + Drive Strength Field: R0/6 + Speed Field: medium(100MHz) + Open Drain Enable Field: Open Drain Disabled + Pull / Keep Enable Field: Pull/Keeper Enabled + Pull / Keep Select Field: Keeper + Pull Up / Down Config. Field: 100K Ohm Pull Down + Hyst. Enable Field: Hysteresis Disabled */ + IOMUXC_SetPinMux( + IOMUXC_GPIO_AD_B0_09_GPIO1_IO09, /* GPIO_AD_B0_09 is configured as GPIO1_IO09 */ + 0U); /* Software Input On Field: Input Path is determined by functionality */ + IOMUXC_SetPinConfig( + IOMUXC_GPIO_AD_B0_09_GPIO1_IO09, /* GPIO_AD_B0_09 PAD functional properties : */ + 0x10B0u); /* Slew Rate Field: Slow Slew Rate + Drive Strength Field: R0/6 + Speed Field: medium(100MHz) + Open Drain Enable Field: Open Drain Disabled + Pull / Keep Enable Field: Pull/Keeper Enabled + Pull / Keep Select Field: Keeper + Pull Up / Down Config. Field: 100K Ohm Pull Down + Hyst. Enable Field: Hysteresis Disabled */ + IOMUXC_SetPinMux( + IOMUXC_GPIO_AD_B0_02_GPIO1_IO02, /* GPIO_AD_B0_02 is configured as GPIO1_IO02 */ + 0U); /* Software Input On Field: Input Path is determined by functionality */ + IOMUXC_SetPinMux( + IOMUXC_GPIO_B0_00_LCD_CLK, /* GPIO_B0_00 is configured as LCD_CLK */ + 0U); /* Software Input On Field: Input Path is determined by functionality */ + IOMUXC_SetPinMux( + IOMUXC_GPIO_B0_01_LCD_ENABLE, /* GPIO_B0_01 is configured as LCD_ENABLE */ + 0U); /* Software Input On Field: Input Path is determined by functionality */ + IOMUXC_SetPinMux( + IOMUXC_GPIO_B0_02_LCD_HSYNC, /* GPIO_B0_02 is configured as LCD_HSYNC */ + 0U); /* Software Input On Field: Input Path is determined by functionality */ + IOMUXC_SetPinMux( + IOMUXC_GPIO_B0_03_LCD_VSYNC, /* GPIO_B0_03 is configured as LCD_VSYNC */ + 0U); /* Software Input On Field: Input Path is determined by functionality */ + IOMUXC_SetPinMux( + IOMUXC_GPIO_B0_04_LCD_DATA00, /* GPIO_B0_04 is configured as LCD_DATA00 */ + 0U); /* Software Input On Field: Input Path is determined by functionality */ + IOMUXC_SetPinMux( + IOMUXC_GPIO_B0_05_LCD_DATA01, /* GPIO_B0_05 is configured as LCD_DATA01 */ + 0U); /* Software Input On Field: Input Path is determined by functionality */ + IOMUXC_SetPinMux( + IOMUXC_GPIO_B0_06_LCD_DATA02, /* GPIO_B0_06 is configured as LCD_DATA02 */ + 0U); /* Software Input On Field: Input Path is determined by functionality */ + IOMUXC_SetPinMux( + IOMUXC_GPIO_B0_07_LCD_DATA03, /* GPIO_B0_07 is configured as LCD_DATA03 */ + 0U); /* Software Input On Field: Input Path is determined by functionality */ + IOMUXC_SetPinMux( + IOMUXC_GPIO_B0_08_LCD_DATA04, /* GPIO_B0_08 is configured as LCD_DATA04 */ + 0U); /* Software Input On Field: Input Path is determined by functionality */ + IOMUXC_SetPinMux( + IOMUXC_GPIO_B0_09_LCD_DATA05, /* GPIO_B0_09 is configured as LCD_DATA05 */ + 0U); /* Software Input On Field: Input Path is determined by functionality */ + IOMUXC_SetPinMux( + IOMUXC_GPIO_B0_10_LCD_DATA06, /* GPIO_B0_10 is configured as LCD_DATA06 */ + 0U); /* Software Input On Field: Input Path is determined by functionality */ + IOMUXC_SetPinMux( + IOMUXC_GPIO_B0_11_LCD_DATA07, /* GPIO_B0_11 is configured as LCD_DATA07 */ + 0U); /* Software Input On Field: Input Path is determined by functionality */ + IOMUXC_SetPinMux( + IOMUXC_GPIO_B0_12_LCD_DATA08, /* GPIO_B0_12 is configured as LCD_DATA08 */ + 0U); /* Software Input On Field: Input Path is determined by functionality */ + IOMUXC_SetPinMux( + IOMUXC_GPIO_B0_13_LCD_DATA09, /* GPIO_B0_13 is configured as LCD_DATA09 */ + 0U); /* Software Input On Field: Input Path is determined by functionality */ + IOMUXC_SetPinMux( + IOMUXC_GPIO_B0_14_LCD_DATA10, /* GPIO_B0_14 is configured as LCD_DATA10 */ + 0U); /* Software Input On Field: Input Path is determined by functionality */ + IOMUXC_SetPinMux( + IOMUXC_GPIO_B0_15_LCD_DATA11, /* GPIO_B0_15 is configured as LCD_DATA11 */ + 0U); /* Software Input On Field: Input Path is determined by functionality */ + IOMUXC_SetPinMux( + IOMUXC_GPIO_B1_00_LCD_DATA12, /* GPIO_B1_00 is configured as LCD_DATA12 */ + 0U); /* Software Input On Field: Input Path is determined by functionality */ + IOMUXC_SetPinMux( + IOMUXC_GPIO_B1_01_LCD_DATA13, /* GPIO_B1_01 is configured as LCD_DATA13 */ + 0U); /* Software Input On Field: Input Path is determined by functionality */ + IOMUXC_SetPinMux( + IOMUXC_GPIO_B1_02_LCD_DATA14, /* GPIO_B1_02 is configured as LCD_DATA14 */ + 0U); /* Software Input On Field: Input Path is determined by functionality */ + IOMUXC_SetPinMux( + IOMUXC_GPIO_B1_03_LCD_DATA15, /* GPIO_B1_03 is configured as LCD_DATA15 */ + 0U); /* Software Input On Field: Input Path is determined by functionality */ + IOMUXC_SetPinMux( + IOMUXC_GPIO_B1_15_GPIO2_IO31, /* GPIO_B1_15 is configured as GPIO2_IO31 */ + 0U); /* Software Input On Field: Input Path is determined by functionality */ + + IOMUXC_SetPinMux( + IOMUXC_GPIO_AD_B1_03_GPIO1_IO19, /* GPIO_AD_B1_03 is configured as GPIO1_IO19 */ + 0U); /* Software Input On Field: Input Path is determined by functionality */ + IOMUXC_SetPinMux( + IOMUXC_GPIO_B1_12_GPIO2_IO28, /* GPIO_B1_12 is configured as GPIO2_IO28 */ + 0U); /* Software Input On Field: Input Path is determined by functionality */ + IOMUXC_SetPinMux( + IOMUXC_GPIO_B1_14_USDHC1_VSELECT, /* GPIO_B1_14 is configured as USDHC1_VSELECT */ + 0U); /* Software Input On Field: Input Path is determined by functionality */ + IOMUXC_SetPinMux( + IOMUXC_GPIO_SD_B0_00_USDHC1_CMD, /* GPIO_SD_B0_00 is configured as USDHC1_CMD */ + 0U); /* Software Input On Field: Input Path is determined by functionality */ + IOMUXC_SetPinMux( + IOMUXC_GPIO_SD_B0_01_USDHC1_CLK, /* GPIO_SD_B0_01 is configured as USDHC1_CLK */ + 0U); /* Software Input On Field: Input Path is determined by functionality */ + IOMUXC_SetPinMux( + IOMUXC_GPIO_SD_B0_02_USDHC1_DATA0, /* GPIO_SD_B0_02 is configured as USDHC1_DATA0 */ + 0U); /* Software Input On Field: Input Path is determined by functionality */ + IOMUXC_SetPinMux( + IOMUXC_GPIO_SD_B0_03_USDHC1_DATA1, /* GPIO_SD_B0_03 is configured as USDHC1_DATA1 */ + 0U); /* Software Input On Field: Input Path is determined by functionality */ + IOMUXC_SetPinMux( + IOMUXC_GPIO_SD_B0_04_USDHC1_DATA2, /* GPIO_SD_B0_04 is configured as USDHC1_DATA2 */ + 0U); /* Software Input On Field: Input Path is determined by functionality */ + IOMUXC_SetPinMux( + IOMUXC_GPIO_SD_B0_05_USDHC1_DATA3, /* GPIO_SD_B0_05 is configured as USDHC1_DATA3 */ + 0U); /* Software Input On Field: Input Path is determined by functionality */ + + IOMUXC_SetPinConfig( + IOMUXC_GPIO_AD_B0_02_GPIO1_IO02, /* GPIO_AD_B0_02 PAD functional properties : */ + 0x10B0u); /* Slew Rate Field: Slow Slew Rate + Drive Strength Field: R0/6 + Speed Field: medium(100MHz) + Open Drain Enable Field: Open Drain Disabled + Pull / Keep Enable Field: Pull/Keeper Enabled + Pull / Keep Select Field: Keeper + Pull Up / Down Config. Field: 100K Ohm Pull Down + Hyst. Enable Field: Hysteresis Disabled */ + IOMUXC_SetPinConfig( + IOMUXC_GPIO_B0_00_LCD_CLK, /* GPIO_B0_00 PAD functional properties : */ + 0x01B0B0u); /* Slew Rate Field: Slow Slew Rate + Drive Strength Field: R0/6 + Speed Field: medium(100MHz) + Open Drain Enable Field: Open Drain Disabled + Pull / Keep Enable Field: Pull/Keeper Enabled + Pull / Keep Select Field: Pull + Pull Up / Down Config. Field: 100K Ohm Pull Up + Hyst. Enable Field: Hysteresis Enabled */ + IOMUXC_SetPinConfig( + IOMUXC_GPIO_B0_01_LCD_ENABLE, /* GPIO_B0_01 PAD functional properties : */ + 0x01B0B0u); /* Slew Rate Field: Slow Slew Rate + Drive Strength Field: R0/6 + Speed Field: medium(100MHz) + Open Drain Enable Field: Open Drain Disabled + Pull / Keep Enable Field: Pull/Keeper Enabled + Pull / Keep Select Field: Pull + Pull Up / Down Config. Field: 100K Ohm Pull Up + Hyst. Enable Field: Hysteresis Enabled */ + IOMUXC_SetPinConfig( + IOMUXC_GPIO_B0_02_LCD_HSYNC, /* GPIO_B0_02 PAD functional properties : */ + 0x01B0B0u); /* Slew Rate Field: Slow Slew Rate + Drive Strength Field: R0/6 + Speed Field: medium(100MHz) + Open Drain Enable Field: Open Drain Disabled + Pull / Keep Enable Field: Pull/Keeper Enabled + Pull / Keep Select Field: Pull + Pull Up / Down Config. Field: 100K Ohm Pull Up + Hyst. Enable Field: Hysteresis Enabled */ + IOMUXC_SetPinConfig( + IOMUXC_GPIO_B0_03_LCD_VSYNC, /* GPIO_B0_03 PAD functional properties : */ + 0x01B0B0u); /* Slew Rate Field: Slow Slew Rate + Drive Strength Field: R0/6 + Speed Field: medium(100MHz) + Open Drain Enable Field: Open Drain Disabled + Pull / Keep Enable Field: Pull/Keeper Enabled + Pull / Keep Select Field: Pull + Pull Up / Down Config. Field: 100K Ohm Pull Up + Hyst. Enable Field: Hysteresis Enabled */ + IOMUXC_SetPinConfig( + IOMUXC_GPIO_B0_04_LCD_DATA00, /* GPIO_B0_04 PAD functional properties : */ + 0x01B0B0u); /* Slew Rate Field: Slow Slew Rate + Drive Strength Field: R0/6 + Speed Field: medium(100MHz) + Open Drain Enable Field: Open Drain Disabled + Pull / Keep Enable Field: Pull/Keeper Enabled + Pull / Keep Select Field: Pull + Pull Up / Down Config. Field: 100K Ohm Pull Up + Hyst. Enable Field: Hysteresis Enabled */ + IOMUXC_SetPinConfig( + IOMUXC_GPIO_B0_05_LCD_DATA01, /* GPIO_B0_05 PAD functional properties : */ + 0x01B0B0u); /* Slew Rate Field: Slow Slew Rate + Drive Strength Field: R0/6 + Speed Field: medium(100MHz) + Open Drain Enable Field: Open Drain Disabled + Pull / Keep Enable Field: Pull/Keeper Enabled + Pull / Keep Select Field: Pull + Pull Up / Down Config. Field: 100K Ohm Pull Up + Hyst. Enable Field: Hysteresis Enabled */ + IOMUXC_SetPinConfig( + IOMUXC_GPIO_B0_06_LCD_DATA02, /* GPIO_B0_06 PAD functional properties : */ + 0x01B0B0u); /* Slew Rate Field: Slow Slew Rate + Drive Strength Field: R0/6 + Speed Field: medium(100MHz) + Open Drain Enable Field: Open Drain Disabled + Pull / Keep Enable Field: Pull/Keeper Enabled + Pull / Keep Select Field: Pull + Pull Up / Down Config. Field: 100K Ohm Pull Up + Hyst. Enable Field: Hysteresis Enabled */ + IOMUXC_SetPinConfig( + IOMUXC_GPIO_B0_07_LCD_DATA03, /* GPIO_B0_07 PAD functional properties : */ + 0x01B0B0u); /* Slew Rate Field: Slow Slew Rate + Drive Strength Field: R0/6 + Speed Field: medium(100MHz) + Open Drain Enable Field: Open Drain Disabled + Pull / Keep Enable Field: Pull/Keeper Enabled + Pull / Keep Select Field: Pull + Pull Up / Down Config. Field: 100K Ohm Pull Up + Hyst. Enable Field: Hysteresis Enabled */ + IOMUXC_SetPinConfig( + IOMUXC_GPIO_B0_08_LCD_DATA04, /* GPIO_B0_08 PAD functional properties : */ + 0x01B0B0u); /* Slew Rate Field: Slow Slew Rate + Drive Strength Field: R0/6 + Speed Field: medium(100MHz) + Open Drain Enable Field: Open Drain Disabled + Pull / Keep Enable Field: Pull/Keeper Enabled + Pull / Keep Select Field: Pull + Pull Up / Down Config. Field: 100K Ohm Pull Up + Hyst. Enable Field: Hysteresis Enabled */ + IOMUXC_SetPinConfig( + IOMUXC_GPIO_B0_09_LCD_DATA05, /* GPIO_B0_09 PAD functional properties : */ + 0x01B0B0u); /* Slew Rate Field: Slow Slew Rate + Drive Strength Field: R0/6 + Speed Field: medium(100MHz) + Open Drain Enable Field: Open Drain Disabled + Pull / Keep Enable Field: Pull/Keeper Enabled + Pull / Keep Select Field: Pull + Pull Up / Down Config. Field: 100K Ohm Pull Up + Hyst. Enable Field: Hysteresis Enabled */ + IOMUXC_SetPinConfig( + IOMUXC_GPIO_B0_10_LCD_DATA06, /* GPIO_B0_10 PAD functional properties : */ + 0x01B0B0u); /* Slew Rate Field: Slow Slew Rate + Drive Strength Field: R0/6 + Speed Field: medium(100MHz) + Open Drain Enable Field: Open Drain Disabled + Pull / Keep Enable Field: Pull/Keeper Enabled + Pull / Keep Select Field: Pull + Pull Up / Down Config. Field: 100K Ohm Pull Up + Hyst. Enable Field: Hysteresis Enabled */ + IOMUXC_SetPinConfig( + IOMUXC_GPIO_B0_11_LCD_DATA07, /* GPIO_B0_11 PAD functional properties : */ + 0x01B0B0u); /* Slew Rate Field: Slow Slew Rate + Drive Strength Field: R0/6 + Speed Field: medium(100MHz) + Open Drain Enable Field: Open Drain Disabled + Pull / Keep Enable Field: Pull/Keeper Enabled + Pull / Keep Select Field: Pull + Pull Up / Down Config. Field: 100K Ohm Pull Up + Hyst. Enable Field: Hysteresis Enabled */ + IOMUXC_SetPinConfig( + IOMUXC_GPIO_B0_12_LCD_DATA08, /* GPIO_B0_12 PAD functional properties : */ + 0x01B0B0u); /* Slew Rate Field: Slow Slew Rate + Drive Strength Field: R0/6 + Speed Field: medium(100MHz) + Open Drain Enable Field: Open Drain Disabled + Pull / Keep Enable Field: Pull/Keeper Enabled + Pull / Keep Select Field: Pull + Pull Up / Down Config. Field: 100K Ohm Pull Up + Hyst. Enable Field: Hysteresis Enabled */ + IOMUXC_SetPinConfig( + IOMUXC_GPIO_B0_13_LCD_DATA09, /* GPIO_B0_13 PAD functional properties : */ + 0x01B0B0u); /* Slew Rate Field: Slow Slew Rate + Drive Strength Field: R0/6 + Speed Field: medium(100MHz) + Open Drain Enable Field: Open Drain Disabled + Pull / Keep Enable Field: Pull/Keeper Enabled + Pull / Keep Select Field: Pull + Pull Up / Down Config. Field: 100K Ohm Pull Up + Hyst. Enable Field: Hysteresis Enabled */ + IOMUXC_SetPinConfig( + IOMUXC_GPIO_B0_14_LCD_DATA10, /* GPIO_B0_14 PAD functional properties : */ + 0x01B0B0u); /* Slew Rate Field: Slow Slew Rate + Drive Strength Field: R0/6 + Speed Field: medium(100MHz) + Open Drain Enable Field: Open Drain Disabled + Pull / Keep Enable Field: Pull/Keeper Enabled + Pull / Keep Select Field: Pull + Pull Up / Down Config. Field: 100K Ohm Pull Up + Hyst. Enable Field: Hysteresis Enabled */ + IOMUXC_SetPinConfig( + IOMUXC_GPIO_B0_15_LCD_DATA11, /* GPIO_B0_15 PAD functional properties : */ + 0x01B0B0u); /* Slew Rate Field: Slow Slew Rate + Drive Strength Field: R0/6 + Speed Field: medium(100MHz) + Open Drain Enable Field: Open Drain Disabled + Pull / Keep Enable Field: Pull/Keeper Enabled + Pull / Keep Select Field: Pull + Pull Up / Down Config. Field: 100K Ohm Pull Up + Hyst. Enable Field: Hysteresis Enabled */ + IOMUXC_SetPinConfig( + IOMUXC_GPIO_B1_00_LCD_DATA12, /* GPIO_B1_00 PAD functional properties : */ + 0x01B0B0u); /* Slew Rate Field: Slow Slew Rate + Drive Strength Field: R0/6 + Speed Field: medium(100MHz) + Open Drain Enable Field: Open Drain Disabled + Pull / Keep Enable Field: Pull/Keeper Enabled + Pull / Keep Select Field: Pull + Pull Up / Down Config. Field: 100K Ohm Pull Up + Hyst. Enable Field: Hysteresis Enabled */ + IOMUXC_SetPinConfig( + IOMUXC_GPIO_B1_01_LCD_DATA13, /* GPIO_B1_01 PAD functional properties : */ + 0x01B0B0u); /* Slew Rate Field: Slow Slew Rate + Drive Strength Field: R0/6 + Speed Field: medium(100MHz) + Open Drain Enable Field: Open Drain Disabled + Pull / Keep Enable Field: Pull/Keeper Enabled + Pull / Keep Select Field: Pull + Pull Up / Down Config. Field: 100K Ohm Pull Up + Hyst. Enable Field: Hysteresis Enabled */ + IOMUXC_SetPinConfig( + IOMUXC_GPIO_B1_02_LCD_DATA14, /* GPIO_B1_02 PAD functional properties : */ + 0x01B0B0u); /* Slew Rate Field: Slow Slew Rate + Drive Strength Field: R0/6 + Speed Field: medium(100MHz) + Open Drain Enable Field: Open Drain Disabled + Pull / Keep Enable Field: Pull/Keeper Enabled + Pull / Keep Select Field: Pull + Pull Up / Down Config. Field: 100K Ohm Pull Up + Hyst. Enable Field: Hysteresis Enabled */ + IOMUXC_SetPinConfig( + IOMUXC_GPIO_B1_03_LCD_DATA15, /* GPIO_B1_03 PAD functional properties : */ + 0x01B0B0u); /* Slew Rate Field: Slow Slew Rate + Drive Strength Field: R0/6 + Speed Field: medium(100MHz) + Open Drain Enable Field: Open Drain Disabled + Pull / Keep Enable Field: Pull/Keeper Enabled + Pull / Keep Select Field: Pull + Pull Up / Down Config. Field: 100K Ohm Pull Up + Hyst. Enable Field: Hysteresis Enabled */ + IOMUXC_SetPinConfig( + IOMUXC_GPIO_B1_15_GPIO2_IO31, /* GPIO_B1_15 PAD functional properties : */ + 0x10B0u); /* Slew Rate Field: Slow Slew Rate + Drive Strength Field: R0/6 + Speed Field: medium(100MHz) + Open Drain Enable Field: Open Drain Disabled + Pull / Keep Enable Field: Pull/Keeper Enabled + Pull / Keep Select Field: Keeper + Pull Up / Down Config. Field: 100K Ohm Pull Down + Hyst. Enable Field: Hysteresis Disabled */ + IOMUXC_SetPinConfig( + IOMUXC_GPIO_AD_B1_03_GPIO1_IO19, /* GPIO_AD_B1_03 PAD functional properties : */ + 0x10B0u); /* Slew Rate Field: Slow Slew Rate + Drive Strength Field: R0/6 + Speed Field: medium(100MHz) + Open Drain Enable Field: Open Drain Disabled + Pull / Keep Enable Field: Pull/Keeper Enabled + Pull / Keep Select Field: Keeper + Pull Up / Down Config. Field: 100K Ohm Pull Down + Hyst. Enable Field: Hysteresis Disabled */ + IOMUXC_SetPinConfig( + IOMUXC_GPIO_B1_12_GPIO2_IO28, /* GPIO_B1_12 PAD functional properties : */ + 0x017089u); /* Slew Rate Field: Fast Slew Rate + Drive Strength Field: R0(150 Ohm @ 3.3V, 260 Ohm@1.8V) + Speed Field: medium(100MHz) + Open Drain Enable Field: Open Drain Disabled + Pull / Keep Enable Field: Pull/Keeper Enabled + Pull / Keep Select Field: Pull + Pull Up / Down Config. Field: 47K Ohm Pull Up + Hyst. Enable Field: Hysteresis Enabled */ + IOMUXC_SetPinConfig( + IOMUXC_GPIO_B1_14_USDHC1_VSELECT, /* GPIO_B1_14 PAD functional properties : */ + 0x0170A1u); /* Slew Rate Field: Fast Slew Rate + Drive Strength Field: R0/4 + Speed Field: medium(100MHz) + Open Drain Enable Field: Open Drain Disabled + Pull / Keep Enable Field: Pull/Keeper Enabled + Pull / Keep Select Field: Pull + Pull Up / Down Config. Field: 47K Ohm Pull Up + Hyst. Enable Field: Hysteresis Enabled */ + IOMUXC_SetPinConfig( + IOMUXC_GPIO_SD_B0_00_USDHC1_CMD, /* GPIO_SD_B0_00 PAD functional properties : */ + 0x017089u); /* Slew Rate Field: Fast Slew Rate + Drive Strength Field: R0(150 Ohm @ 3.3V, 260 Ohm@1.8V) + Speed Field: medium(100MHz) + Open Drain Enable Field: Open Drain Disabled + Pull / Keep Enable Field: Pull/Keeper Enabled + Pull / Keep Select Field: Pull + Pull Up / Down Config. Field: 47K Ohm Pull Up + Hyst. Enable Field: Hysteresis Enabled */ + IOMUXC_SetPinConfig( + IOMUXC_GPIO_SD_B0_01_USDHC1_CLK, /* GPIO_SD_B0_01 PAD functional properties : */ + 0x014089u); /* Slew Rate Field: Fast Slew Rate + Drive Strength Field: R0(150 Ohm @ 3.3V, 260 Ohm@1.8V) + Speed Field: medium(100MHz) + Open Drain Enable Field: Open Drain Disabled + Pull / Keep Enable Field: Pull/Keeper Disabled + Pull / Keep Select Field: Keeper + Pull Up / Down Config. Field: 47K Ohm Pull Up + Hyst. Enable Field: Hysteresis Enabled */ + IOMUXC_SetPinConfig( + IOMUXC_GPIO_SD_B0_02_USDHC1_DATA0, /* GPIO_SD_B0_02 PAD functional properties : */ + 0x017089u); /* Slew Rate Field: Fast Slew Rate + Drive Strength Field: R0(150 Ohm @ 3.3V, 260 Ohm@1.8V) + Speed Field: medium(100MHz) + Open Drain Enable Field: Open Drain Disabled + Pull / Keep Enable Field: Pull/Keeper Enabled + Pull / Keep Select Field: Pull + Pull Up / Down Config. Field: 47K Ohm Pull Up + Hyst. Enable Field: Hysteresis Enabled */ + IOMUXC_SetPinConfig( + IOMUXC_GPIO_SD_B0_03_USDHC1_DATA1, /* GPIO_SD_B0_03 PAD functional properties : */ + 0x017089u); /* Slew Rate Field: Fast Slew Rate + Drive Strength Field: R0(150 Ohm @ 3.3V, 260 Ohm@1.8V) + Speed Field: medium(100MHz) + Open Drain Enable Field: Open Drain Disabled + Pull / Keep Enable Field: Pull/Keeper Enabled + Pull / Keep Select Field: Pull + Pull Up / Down Config. Field: 47K Ohm Pull Up + Hyst. Enable Field: Hysteresis Enabled */ + IOMUXC_SetPinConfig( + IOMUXC_GPIO_SD_B0_04_USDHC1_DATA2, /* GPIO_SD_B0_04 PAD functional properties : */ + 0x017089u); /* Slew Rate Field: Fast Slew Rate + Drive Strength Field: R0(150 Ohm @ 3.3V, 260 Ohm@1.8V) + Speed Field: medium(100MHz) + Open Drain Enable Field: Open Drain Disabled + Pull / Keep Enable Field: Pull/Keeper Enabled + Pull / Keep Select Field: Pull + Pull Up / Down Config. Field: 47K Ohm Pull Up + Hyst. Enable Field: Hysteresis Enabled */ + IOMUXC_SetPinConfig( + IOMUXC_GPIO_SD_B0_05_USDHC1_DATA3, /* GPIO_SD_B0_05 PAD functional properties : */ + 0x017089u); /* Slew Rate Field: Fast Slew Rate + Drive Strength Field: R0(150 Ohm @ 3.3V, 260 Ohm@1.8V) + Speed Field: medium(100MHz) + Open Drain Enable Field: Open Drain Disabled + Pull / Keep Enable Field: Pull/Keeper Enabled + Pull / Keep Select Field: Pull + Pull Up / Down Config. Field: 47K Ohm Pull Up + Hyst. Enable Field: Hysteresis Enabled */ +} + +/* FUNCTION ************************************************************************************************************ + * + * Function Name : BOARD_InitSemcPins + * Description : Configures pin routing and optionally pin electrical features. + * + * END ****************************************************************************************************************/ +void BOARD_InitSemcPins(void) { + CLOCK_EnableClock(kCLOCK_Iomuxc); /* iomuxc clock (iomuxc_clk_enable): 0x03u */ + + IOMUXC_SetPinMux( + IOMUXC_GPIO_EMC_00_SEMC_DATA00, /* GPIO_EMC_00 is configured as SEMC_DATA00 */ + 0U); /* Software Input On Field: Input Path is determined by functionality */ + IOMUXC_SetPinMux( + IOMUXC_GPIO_EMC_01_SEMC_DATA01, /* GPIO_EMC_01 is configured as SEMC_DATA01 */ + 0U); /* Software Input On Field: Input Path is determined by functionality */ + IOMUXC_SetPinMux( + IOMUXC_GPIO_EMC_02_SEMC_DATA02, /* GPIO_EMC_02 is configured as SEMC_DATA02 */ + 0U); /* Software Input On Field: Input Path is determined by functionality */ + IOMUXC_SetPinMux( + IOMUXC_GPIO_EMC_03_SEMC_DATA03, /* GPIO_EMC_03 is configured as SEMC_DATA03 */ + 0U); /* Software Input On Field: Input Path is determined by functionality */ + IOMUXC_SetPinMux( + IOMUXC_GPIO_EMC_04_SEMC_DATA04, /* GPIO_EMC_04 is configured as SEMC_DATA04 */ + 0U); /* Software Input On Field: Input Path is determined by functionality */ + IOMUXC_SetPinMux( + IOMUXC_GPIO_EMC_05_SEMC_DATA05, /* GPIO_EMC_05 is configured as SEMC_DATA05 */ + 0U); /* Software Input On Field: Input Path is determined by functionality */ + IOMUXC_SetPinMux( + IOMUXC_GPIO_EMC_06_SEMC_DATA06, /* GPIO_EMC_06 is configured as SEMC_DATA06 */ + 0U); /* Software Input On Field: Input Path is determined by functionality */ + IOMUXC_SetPinMux( + IOMUXC_GPIO_EMC_07_SEMC_DATA07, /* GPIO_EMC_07 is configured as SEMC_DATA07 */ + 0U); /* Software Input On Field: Input Path is determined by functionality */ + IOMUXC_SetPinMux( + IOMUXC_GPIO_EMC_08_SEMC_DM00, /* GPIO_EMC_08 is configured as SEMC_DM00 */ + 0U); /* Software Input On Field: Input Path is determined by functionality */ + IOMUXC_SetPinMux( + IOMUXC_GPIO_EMC_09_SEMC_ADDR00, /* GPIO_EMC_09 is configured as SEMC_ADDR00 */ + 0U); /* Software Input On Field: Input Path is determined by functionality */ + IOMUXC_SetPinMux( + IOMUXC_GPIO_EMC_10_SEMC_ADDR01, /* GPIO_EMC_10 is configured as SEMC_ADDR01 */ + 0U); /* Software Input On Field: Input Path is determined by functionality */ + IOMUXC_SetPinMux( + IOMUXC_GPIO_EMC_11_SEMC_ADDR02, /* GPIO_EMC_11 is configured as SEMC_ADDR02 */ + 0U); /* Software Input On Field: Input Path is determined by functionality */ + IOMUXC_SetPinMux( + IOMUXC_GPIO_EMC_12_SEMC_ADDR03, /* GPIO_EMC_12 is configured as SEMC_ADDR03 */ + 0U); /* Software Input On Field: Input Path is determined by functionality */ + IOMUXC_SetPinMux( + IOMUXC_GPIO_EMC_13_SEMC_ADDR04, /* GPIO_EMC_13 is configured as SEMC_ADDR04 */ + 0U); /* Software Input On Field: Input Path is determined by functionality */ + IOMUXC_SetPinMux( + IOMUXC_GPIO_EMC_14_SEMC_ADDR05, /* GPIO_EMC_14 is configured as SEMC_ADDR05 */ + 0U); /* Software Input On Field: Input Path is determined by functionality */ + IOMUXC_SetPinMux( + IOMUXC_GPIO_EMC_15_SEMC_ADDR06, /* GPIO_EMC_15 is configured as SEMC_ADDR06 */ + 0U); /* Software Input On Field: Input Path is determined by functionality */ + IOMUXC_SetPinMux( + IOMUXC_GPIO_EMC_16_SEMC_ADDR07, /* GPIO_EMC_16 is configured as SEMC_ADDR07 */ + 0U); /* Software Input On Field: Input Path is determined by functionality */ + IOMUXC_SetPinMux( + IOMUXC_GPIO_EMC_17_SEMC_ADDR08, /* GPIO_EMC_17 is configured as SEMC_ADDR08 */ + 0U); /* Software Input On Field: Input Path is determined by functionality */ + IOMUXC_SetPinMux( + IOMUXC_GPIO_EMC_18_SEMC_ADDR09, /* GPIO_EMC_18 is configured as SEMC_ADDR09 */ + 0U); /* Software Input On Field: Input Path is determined by functionality */ + IOMUXC_SetPinMux( + IOMUXC_GPIO_EMC_19_SEMC_ADDR11, /* GPIO_EMC_19 is configured as SEMC_ADDR11 */ + 0U); /* Software Input On Field: Input Path is determined by functionality */ + IOMUXC_SetPinMux( + IOMUXC_GPIO_EMC_20_SEMC_ADDR12, /* GPIO_EMC_20 is configured as SEMC_ADDR12 */ + 0U); /* Software Input On Field: Input Path is determined by functionality */ + IOMUXC_SetPinMux( + IOMUXC_GPIO_EMC_21_SEMC_BA0, /* GPIO_EMC_21 is configured as SEMC_BA0 */ + 0U); /* Software Input On Field: Input Path is determined by functionality */ + IOMUXC_SetPinMux( + IOMUXC_GPIO_EMC_22_SEMC_BA1, /* GPIO_EMC_22 is configured as SEMC_BA1 */ + 0U); /* Software Input On Field: Input Path is determined by functionality */ + IOMUXC_SetPinMux( + IOMUXC_GPIO_EMC_23_SEMC_ADDR10, /* GPIO_EMC_23 is configured as SEMC_ADDR10 */ + 0U); /* Software Input On Field: Input Path is determined by functionality */ + IOMUXC_SetPinMux( + IOMUXC_GPIO_EMC_24_SEMC_CAS, /* GPIO_EMC_24 is configured as SEMC_CAS */ + 0U); /* Software Input On Field: Input Path is determined by functionality */ + IOMUXC_SetPinMux( + IOMUXC_GPIO_EMC_25_SEMC_RAS, /* GPIO_EMC_25 is configured as SEMC_RAS */ + 0U); /* Software Input On Field: Input Path is determined by functionality */ + IOMUXC_SetPinMux( + IOMUXC_GPIO_EMC_26_SEMC_CLK, /* GPIO_EMC_26 is configured as SEMC_CLK */ + 0U); /* Software Input On Field: Input Path is determined by functionality */ + IOMUXC_SetPinMux( + IOMUXC_GPIO_EMC_27_SEMC_CKE, /* GPIO_EMC_27 is configured as SEMC_CKE */ + 0U); /* Software Input On Field: Input Path is determined by functionality */ + IOMUXC_SetPinMux( + IOMUXC_GPIO_EMC_28_SEMC_WE, /* GPIO_EMC_28 is configured as SEMC_WE */ + 0U); /* Software Input On Field: Input Path is determined by functionality */ + IOMUXC_SetPinMux( + IOMUXC_GPIO_EMC_29_SEMC_CS0, /* GPIO_EMC_29 is configured as SEMC_CS0 */ + 0U); /* Software Input On Field: Input Path is determined by functionality */ + IOMUXC_SetPinMux( + IOMUXC_GPIO_EMC_30_SEMC_DATA08, /* GPIO_EMC_30 is configured as SEMC_DATA08 */ + 0U); /* Software Input On Field: Input Path is determined by functionality */ + IOMUXC_SetPinMux( + IOMUXC_GPIO_EMC_31_SEMC_DATA09, /* GPIO_EMC_31 is configured as SEMC_DATA09 */ + 0U); /* Software Input On Field: Input Path is determined by functionality */ + IOMUXC_SetPinMux( + IOMUXC_GPIO_EMC_32_SEMC_DATA10, /* GPIO_EMC_32 is configured as SEMC_DATA10 */ + 0U); /* Software Input On Field: Input Path is determined by functionality */ + IOMUXC_SetPinMux( + IOMUXC_GPIO_EMC_33_SEMC_DATA11, /* GPIO_EMC_33 is configured as SEMC_DATA11 */ + 0U); /* Software Input On Field: Input Path is determined by functionality */ + IOMUXC_SetPinMux( + IOMUXC_GPIO_EMC_34_SEMC_DATA12, /* GPIO_EMC_34 is configured as SEMC_DATA12 */ + 0U); /* Software Input On Field: Input Path is determined by functionality */ + IOMUXC_SetPinMux( + IOMUXC_GPIO_EMC_35_SEMC_DATA13, /* GPIO_EMC_35 is configured as SEMC_DATA13 */ + 0U); /* Software Input On Field: Input Path is determined by functionality */ + IOMUXC_SetPinMux( + IOMUXC_GPIO_EMC_36_SEMC_DATA14, /* GPIO_EMC_36 is configured as SEMC_DATA14 */ + 0U); /* Software Input On Field: Input Path is determined by functionality */ + IOMUXC_SetPinMux( + IOMUXC_GPIO_EMC_37_SEMC_DATA15, /* GPIO_EMC_37 is configured as SEMC_DATA15 */ + 0U); /* Software Input On Field: Input Path is determined by functionality */ + IOMUXC_SetPinMux( + IOMUXC_GPIO_EMC_38_SEMC_DM01, /* GPIO_EMC_38 is configured as SEMC_DM01 */ + 0U); /* Software Input On Field: Input Path is determined by functionality */ + IOMUXC_SetPinConfig( + IOMUXC_GPIO_EMC_00_SEMC_DATA00, /* GPIO_EMC_00 PAD functional properties : */ + 0x10B0u); /* Slew Rate Field: Slow Slew Rate + Drive Strength Field: R0/6 + Speed Field: medium(100MHz) + Open Drain Enable Field: Open Drain Disabled + Pull / Keep Enable Field: Pull/Keeper Enabled + Pull / Keep Select Field: Keeper + Pull Up / Down Config. Field: 100K Ohm Pull Down + Hyst. Enable Field: Hysteresis Disabled */ + IOMUXC_SetPinConfig( + IOMUXC_GPIO_EMC_01_SEMC_DATA01, /* GPIO_EMC_01 PAD functional properties : */ + 0x10B0u); /* Slew Rate Field: Slow Slew Rate + Drive Strength Field: R0/6 + Speed Field: medium(100MHz) + Open Drain Enable Field: Open Drain Disabled + Pull / Keep Enable Field: Pull/Keeper Enabled + Pull / Keep Select Field: Keeper + Pull Up / Down Config. Field: 100K Ohm Pull Down + Hyst. Enable Field: Hysteresis Disabled */ + IOMUXC_SetPinConfig( + IOMUXC_GPIO_EMC_02_SEMC_DATA02, /* GPIO_EMC_02 PAD functional properties : */ + 0x10B0u); /* Slew Rate Field: Slow Slew Rate + Drive Strength Field: R0/6 + Speed Field: medium(100MHz) + Open Drain Enable Field: Open Drain Disabled + Pull / Keep Enable Field: Pull/Keeper Enabled + Pull / Keep Select Field: Keeper + Pull Up / Down Config. Field: 100K Ohm Pull Down + Hyst. Enable Field: Hysteresis Disabled */ + IOMUXC_SetPinConfig( + IOMUXC_GPIO_EMC_03_SEMC_DATA03, /* GPIO_EMC_03 PAD functional properties : */ + 0x10B0u); /* Slew Rate Field: Slow Slew Rate + Drive Strength Field: R0/6 + Speed Field: medium(100MHz) + Open Drain Enable Field: Open Drain Disabled + Pull / Keep Enable Field: Pull/Keeper Enabled + Pull / Keep Select Field: Keeper + Pull Up / Down Config. Field: 100K Ohm Pull Down + Hyst. Enable Field: Hysteresis Disabled */ + IOMUXC_SetPinConfig( + IOMUXC_GPIO_EMC_04_SEMC_DATA04, /* GPIO_EMC_04 PAD functional properties : */ + 0x10B0u); /* Slew Rate Field: Slow Slew Rate + Drive Strength Field: R0/6 + Speed Field: medium(100MHz) + Open Drain Enable Field: Open Drain Disabled + Pull / Keep Enable Field: Pull/Keeper Enabled + Pull / Keep Select Field: Keeper + Pull Up / Down Config. Field: 100K Ohm Pull Down + Hyst. Enable Field: Hysteresis Disabled */ + IOMUXC_SetPinConfig( + IOMUXC_GPIO_EMC_05_SEMC_DATA05, /* GPIO_EMC_05 PAD functional properties : */ + 0x10B0u); /* Slew Rate Field: Slow Slew Rate + Drive Strength Field: R0/6 + Speed Field: medium(100MHz) + Open Drain Enable Field: Open Drain Disabled + Pull / Keep Enable Field: Pull/Keeper Enabled + Pull / Keep Select Field: Keeper + Pull Up / Down Config. Field: 100K Ohm Pull Down + Hyst. Enable Field: Hysteresis Disabled */ + IOMUXC_SetPinConfig( + IOMUXC_GPIO_EMC_06_SEMC_DATA06, /* GPIO_EMC_06 PAD functional properties : */ + 0x10B0u); /* Slew Rate Field: Slow Slew Rate + Drive Strength Field: R0/6 + Speed Field: medium(100MHz) + Open Drain Enable Field: Open Drain Disabled + Pull / Keep Enable Field: Pull/Keeper Enabled + Pull / Keep Select Field: Keeper + Pull Up / Down Config. Field: 100K Ohm Pull Down + Hyst. Enable Field: Hysteresis Disabled */ + IOMUXC_SetPinConfig( + IOMUXC_GPIO_EMC_07_SEMC_DATA07, /* GPIO_EMC_07 PAD functional properties : */ + 0x10B0u); /* Slew Rate Field: Slow Slew Rate + Drive Strength Field: R0/6 + Speed Field: medium(100MHz) + Open Drain Enable Field: Open Drain Disabled + Pull / Keep Enable Field: Pull/Keeper Enabled + Pull / Keep Select Field: Keeper + Pull Up / Down Config. Field: 100K Ohm Pull Down + Hyst. Enable Field: Hysteresis Disabled */ + IOMUXC_SetPinConfig( + IOMUXC_GPIO_EMC_08_SEMC_DM00, /* GPIO_EMC_08 PAD functional properties : */ + 0x10B0u); /* Slew Rate Field: Slow Slew Rate + Drive Strength Field: R0/6 + Speed Field: medium(100MHz) + Open Drain Enable Field: Open Drain Disabled + Pull / Keep Enable Field: Pull/Keeper Enabled + Pull / Keep Select Field: Keeper + Pull Up / Down Config. Field: 100K Ohm Pull Down + Hyst. Enable Field: Hysteresis Disabled */ + IOMUXC_SetPinConfig( + IOMUXC_GPIO_EMC_09_SEMC_ADDR00, /* GPIO_EMC_09 PAD functional properties : */ + 0x10B0u); /* Slew Rate Field: Slow Slew Rate + Drive Strength Field: R0/6 + Speed Field: medium(100MHz) + Open Drain Enable Field: Open Drain Disabled + Pull / Keep Enable Field: Pull/Keeper Enabled + Pull / Keep Select Field: Keeper + Pull Up / Down Config. Field: 100K Ohm Pull Down + Hyst. Enable Field: Hysteresis Disabled */ + IOMUXC_SetPinConfig( + IOMUXC_GPIO_EMC_10_SEMC_ADDR01, /* GPIO_EMC_10 PAD functional properties : */ + 0x10B0u); /* Slew Rate Field: Slow Slew Rate + Drive Strength Field: R0/6 + Speed Field: medium(100MHz) + Open Drain Enable Field: Open Drain Disabled + Pull / Keep Enable Field: Pull/Keeper Enabled + Pull / Keep Select Field: Keeper + Pull Up / Down Config. Field: 100K Ohm Pull Down + Hyst. Enable Field: Hysteresis Disabled */ + IOMUXC_SetPinConfig( + IOMUXC_GPIO_EMC_11_SEMC_ADDR02, /* GPIO_EMC_11 PAD functional properties : */ + 0x10B0u); /* Slew Rate Field: Slow Slew Rate + Drive Strength Field: R0/6 + Speed Field: medium(100MHz) + Open Drain Enable Field: Open Drain Disabled + Pull / Keep Enable Field: Pull/Keeper Enabled + Pull / Keep Select Field: Keeper + Pull Up / Down Config. Field: 100K Ohm Pull Down + Hyst. Enable Field: Hysteresis Disabled */ + IOMUXC_SetPinConfig( + IOMUXC_GPIO_EMC_12_SEMC_ADDR03, /* GPIO_EMC_12 PAD functional properties : */ + 0x10B0u); /* Slew Rate Field: Slow Slew Rate + Drive Strength Field: R0/6 + Speed Field: medium(100MHz) + Open Drain Enable Field: Open Drain Disabled + Pull / Keep Enable Field: Pull/Keeper Enabled + Pull / Keep Select Field: Keeper + Pull Up / Down Config. Field: 100K Ohm Pull Down + Hyst. Enable Field: Hysteresis Disabled */ + IOMUXC_SetPinConfig( + IOMUXC_GPIO_EMC_13_SEMC_ADDR04, /* GPIO_EMC_13 PAD functional properties : */ + 0x10B0u); /* Slew Rate Field: Slow Slew Rate + Drive Strength Field: R0/6 + Speed Field: medium(100MHz) + Open Drain Enable Field: Open Drain Disabled + Pull / Keep Enable Field: Pull/Keeper Enabled + Pull / Keep Select Field: Keeper + Pull Up / Down Config. Field: 100K Ohm Pull Down + Hyst. Enable Field: Hysteresis Disabled */ + IOMUXC_SetPinConfig( + IOMUXC_GPIO_EMC_14_SEMC_ADDR05, /* GPIO_EMC_14 PAD functional properties : */ + 0x10B0u); /* Slew Rate Field: Slow Slew Rate + Drive Strength Field: R0/6 + Speed Field: medium(100MHz) + Open Drain Enable Field: Open Drain Disabled + Pull / Keep Enable Field: Pull/Keeper Enabled + Pull / Keep Select Field: Keeper + Pull Up / Down Config. Field: 100K Ohm Pull Down + Hyst. Enable Field: Hysteresis Disabled */ + IOMUXC_SetPinConfig( + IOMUXC_GPIO_EMC_15_SEMC_ADDR06, /* GPIO_EMC_15 PAD functional properties : */ + 0x10B0u); /* Slew Rate Field: Slow Slew Rate + Drive Strength Field: R0/6 + Speed Field: medium(100MHz) + Open Drain Enable Field: Open Drain Disabled + Pull / Keep Enable Field: Pull/Keeper Enabled + Pull / Keep Select Field: Keeper + Pull Up / Down Config. Field: 100K Ohm Pull Down + Hyst. Enable Field: Hysteresis Disabled */ + IOMUXC_SetPinConfig( + IOMUXC_GPIO_EMC_16_SEMC_ADDR07, /* GPIO_EMC_16 PAD functional properties : */ + 0x10B0u); /* Slew Rate Field: Slow Slew Rate + Drive Strength Field: R0/6 + Speed Field: medium(100MHz) + Open Drain Enable Field: Open Drain Disabled + Pull / Keep Enable Field: Pull/Keeper Enabled + Pull / Keep Select Field: Keeper + Pull Up / Down Config. Field: 100K Ohm Pull Down + Hyst. Enable Field: Hysteresis Disabled */ + IOMUXC_SetPinConfig( + IOMUXC_GPIO_EMC_17_SEMC_ADDR08, /* GPIO_EMC_17 PAD functional properties : */ + 0x10B0u); /* Slew Rate Field: Slow Slew Rate + Drive Strength Field: R0/6 + Speed Field: medium(100MHz) + Open Drain Enable Field: Open Drain Disabled + Pull / Keep Enable Field: Pull/Keeper Enabled + Pull / Keep Select Field: Keeper + Pull Up / Down Config. Field: 100K Ohm Pull Down + Hyst. Enable Field: Hysteresis Disabled */ + IOMUXC_SetPinConfig( + IOMUXC_GPIO_EMC_18_SEMC_ADDR09, /* GPIO_EMC_18 PAD functional properties : */ + 0x10B0u); /* Slew Rate Field: Slow Slew Rate + Drive Strength Field: R0/6 + Speed Field: medium(100MHz) + Open Drain Enable Field: Open Drain Disabled + Pull / Keep Enable Field: Pull/Keeper Enabled + Pull / Keep Select Field: Keeper + Pull Up / Down Config. Field: 100K Ohm Pull Down + Hyst. Enable Field: Hysteresis Disabled */ + IOMUXC_SetPinConfig( + IOMUXC_GPIO_EMC_19_SEMC_ADDR11, /* GPIO_EMC_19 PAD functional properties : */ + 0x10B0u); /* Slew Rate Field: Slow Slew Rate + Drive Strength Field: R0/6 + Speed Field: medium(100MHz) + Open Drain Enable Field: Open Drain Disabled + Pull / Keep Enable Field: Pull/Keeper Enabled + Pull / Keep Select Field: Keeper + Pull Up / Down Config. Field: 100K Ohm Pull Down + Hyst. Enable Field: Hysteresis Disabled */ + IOMUXC_SetPinConfig( + IOMUXC_GPIO_EMC_20_SEMC_ADDR12, /* GPIO_EMC_20 PAD functional properties : */ + 0x10B0u); /* Slew Rate Field: Slow Slew Rate + Drive Strength Field: R0/6 + Speed Field: medium(100MHz) + Open Drain Enable Field: Open Drain Disabled + Pull / Keep Enable Field: Pull/Keeper Enabled + Pull / Keep Select Field: Keeper + Pull Up / Down Config. Field: 100K Ohm Pull Down + Hyst. Enable Field: Hysteresis Disabled */ + IOMUXC_SetPinConfig( + IOMUXC_GPIO_EMC_21_SEMC_BA0, /* GPIO_EMC_21 PAD functional properties : */ + 0x10B0u); /* Slew Rate Field: Slow Slew Rate + Drive Strength Field: R0/6 + Speed Field: medium(100MHz) + Open Drain Enable Field: Open Drain Disabled + Pull / Keep Enable Field: Pull/Keeper Enabled + Pull / Keep Select Field: Keeper + Pull Up / Down Config. Field: 100K Ohm Pull Down + Hyst. Enable Field: Hysteresis Disabled */ + IOMUXC_SetPinConfig( + IOMUXC_GPIO_EMC_22_SEMC_BA1, /* GPIO_EMC_22 PAD functional properties : */ + 0x10B0u); /* Slew Rate Field: Slow Slew Rate + Drive Strength Field: R0/6 + Speed Field: medium(100MHz) + Open Drain Enable Field: Open Drain Disabled + Pull / Keep Enable Field: Pull/Keeper Enabled + Pull / Keep Select Field: Keeper + Pull Up / Down Config. Field: 100K Ohm Pull Down + Hyst. Enable Field: Hysteresis Disabled */ + IOMUXC_SetPinConfig( + IOMUXC_GPIO_EMC_23_SEMC_ADDR10, /* GPIO_EMC_23 PAD functional properties : */ + 0x10B0u); /* Slew Rate Field: Slow Slew Rate + Drive Strength Field: R0/6 + Speed Field: medium(100MHz) + Open Drain Enable Field: Open Drain Disabled + Pull / Keep Enable Field: Pull/Keeper Enabled + Pull / Keep Select Field: Keeper + Pull Up / Down Config. Field: 100K Ohm Pull Down + Hyst. Enable Field: Hysteresis Disabled */ + IOMUXC_SetPinConfig( + IOMUXC_GPIO_EMC_24_SEMC_CAS, /* GPIO_EMC_24 PAD functional properties : */ + 0x10B0u); /* Slew Rate Field: Slow Slew Rate + Drive Strength Field: R0/6 + Speed Field: medium(100MHz) + Open Drain Enable Field: Open Drain Disabled + Pull / Keep Enable Field: Pull/Keeper Enabled + Pull / Keep Select Field: Keeper + Pull Up / Down Config. Field: 100K Ohm Pull Down + Hyst. Enable Field: Hysteresis Disabled */ + IOMUXC_SetPinConfig( + IOMUXC_GPIO_EMC_25_SEMC_RAS, /* GPIO_EMC_25 PAD functional properties : */ + 0x10B0u); /* Slew Rate Field: Slow Slew Rate + Drive Strength Field: R0/6 + Speed Field: medium(100MHz) + Open Drain Enable Field: Open Drain Disabled + Pull / Keep Enable Field: Pull/Keeper Enabled + Pull / Keep Select Field: Keeper + Pull Up / Down Config. Field: 100K Ohm Pull Down + Hyst. Enable Field: Hysteresis Disabled */ + IOMUXC_SetPinConfig( + IOMUXC_GPIO_EMC_26_SEMC_CLK, /* GPIO_EMC_26 PAD functional properties : */ + 0x10B0u); /* Slew Rate Field: Slow Slew Rate + Drive Strength Field: R0/6 + Speed Field: medium(100MHz) + Open Drain Enable Field: Open Drain Disabled + Pull / Keep Enable Field: Pull/Keeper Enabled + Pull / Keep Select Field: Keeper + Pull Up / Down Config. Field: 100K Ohm Pull Down + Hyst. Enable Field: Hysteresis Disabled */ + IOMUXC_SetPinConfig( + IOMUXC_GPIO_EMC_27_SEMC_CKE, /* GPIO_EMC_27 PAD functional properties : */ + 0x10B0u); /* Slew Rate Field: Slow Slew Rate + Drive Strength Field: R0/6 + Speed Field: medium(100MHz) + Open Drain Enable Field: Open Drain Disabled + Pull / Keep Enable Field: Pull/Keeper Enabled + Pull / Keep Select Field: Keeper + Pull Up / Down Config. Field: 100K Ohm Pull Down + Hyst. Enable Field: Hysteresis Disabled */ + IOMUXC_SetPinConfig( + IOMUXC_GPIO_EMC_28_SEMC_WE, /* GPIO_EMC_28 PAD functional properties : */ + 0x10B0u); /* Slew Rate Field: Slow Slew Rate + Drive Strength Field: R0/6 + Speed Field: medium(100MHz) + Open Drain Enable Field: Open Drain Disabled + Pull / Keep Enable Field: Pull/Keeper Enabled + Pull / Keep Select Field: Keeper + Pull Up / Down Config. Field: 100K Ohm Pull Down + Hyst. Enable Field: Hysteresis Disabled */ + IOMUXC_SetPinConfig( + IOMUXC_GPIO_EMC_29_SEMC_CS0, /* GPIO_EMC_29 PAD functional properties : */ + 0x10B0u); /* Slew Rate Field: Slow Slew Rate + Drive Strength Field: R0/6 + Speed Field: medium(100MHz) + Open Drain Enable Field: Open Drain Disabled + Pull / Keep Enable Field: Pull/Keeper Enabled + Pull / Keep Select Field: Keeper + Pull Up / Down Config. Field: 100K Ohm Pull Down + Hyst. Enable Field: Hysteresis Disabled */ + IOMUXC_SetPinConfig( + IOMUXC_GPIO_EMC_30_SEMC_DATA08, /* GPIO_EMC_30 PAD functional properties : */ + 0x10B0u); /* Slew Rate Field: Slow Slew Rate + Drive Strength Field: R0/6 + Speed Field: medium(100MHz) + Open Drain Enable Field: Open Drain Disabled + Pull / Keep Enable Field: Pull/Keeper Enabled + Pull / Keep Select Field: Keeper + Pull Up / Down Config. Field: 100K Ohm Pull Down + Hyst. Enable Field: Hysteresis Disabled */ + IOMUXC_SetPinConfig( + IOMUXC_GPIO_EMC_31_SEMC_DATA09, /* GPIO_EMC_31 PAD functional properties : */ + 0x10B0u); /* Slew Rate Field: Slow Slew Rate + Drive Strength Field: R0/6 + Speed Field: medium(100MHz) + Open Drain Enable Field: Open Drain Disabled + Pull / Keep Enable Field: Pull/Keeper Enabled + Pull / Keep Select Field: Keeper + Pull Up / Down Config. Field: 100K Ohm Pull Down + Hyst. Enable Field: Hysteresis Disabled */ + IOMUXC_SetPinConfig( + IOMUXC_GPIO_EMC_32_SEMC_DATA10, /* GPIO_EMC_32 PAD functional properties : */ + 0x10B0u); /* Slew Rate Field: Slow Slew Rate + Drive Strength Field: R0/6 + Speed Field: medium(100MHz) + Open Drain Enable Field: Open Drain Disabled + Pull / Keep Enable Field: Pull/Keeper Enabled + Pull / Keep Select Field: Keeper + Pull Up / Down Config. Field: 100K Ohm Pull Down + Hyst. Enable Field: Hysteresis Disabled */ + IOMUXC_SetPinConfig( + IOMUXC_GPIO_EMC_33_SEMC_DATA11, /* GPIO_EMC_33 PAD functional properties : */ + 0x10B0u); /* Slew Rate Field: Slow Slew Rate + Drive Strength Field: R0/6 + Speed Field: medium(100MHz) + Open Drain Enable Field: Open Drain Disabled + Pull / Keep Enable Field: Pull/Keeper Enabled + Pull / Keep Select Field: Keeper + Pull Up / Down Config. Field: 100K Ohm Pull Down + Hyst. Enable Field: Hysteresis Disabled */ + IOMUXC_SetPinConfig( + IOMUXC_GPIO_EMC_34_SEMC_DATA12, /* GPIO_EMC_34 PAD functional properties : */ + 0x10B0u); /* Slew Rate Field: Slow Slew Rate + Drive Strength Field: R0/6 + Speed Field: medium(100MHz) + Open Drain Enable Field: Open Drain Disabled + Pull / Keep Enable Field: Pull/Keeper Enabled + Pull / Keep Select Field: Keeper + Pull Up / Down Config. Field: 100K Ohm Pull Down + Hyst. Enable Field: Hysteresis Disabled */ + IOMUXC_SetPinConfig( + IOMUXC_GPIO_EMC_35_SEMC_DATA13, /* GPIO_EMC_35 PAD functional properties : */ + 0x10B0u); /* Slew Rate Field: Slow Slew Rate + Drive Strength Field: R0/6 + Speed Field: medium(100MHz) + Open Drain Enable Field: Open Drain Disabled + Pull / Keep Enable Field: Pull/Keeper Enabled + Pull / Keep Select Field: Keeper + Pull Up / Down Config. Field: 100K Ohm Pull Down + Hyst. Enable Field: Hysteresis Disabled */ + IOMUXC_SetPinConfig( + IOMUXC_GPIO_EMC_36_SEMC_DATA14, /* GPIO_EMC_36 PAD functional properties : */ + 0x10B0u); /* Slew Rate Field: Slow Slew Rate + Drive Strength Field: R0/6 + Speed Field: medium(100MHz) + Open Drain Enable Field: Open Drain Disabled + Pull / Keep Enable Field: Pull/Keeper Enabled + Pull / Keep Select Field: Keeper + Pull Up / Down Config. Field: 100K Ohm Pull Down + Hyst. Enable Field: Hysteresis Disabled */ + IOMUXC_SetPinConfig( + IOMUXC_GPIO_EMC_37_SEMC_DATA15, /* GPIO_EMC_37 PAD functional properties : */ + 0x10B0u); /* Slew Rate Field: Slow Slew Rate + Drive Strength Field: R0/6 + Speed Field: medium(100MHz) + Open Drain Enable Field: Open Drain Disabled + Pull / Keep Enable Field: Pull/Keeper Enabled + Pull / Keep Select Field: Keeper + Pull Up / Down Config. Field: 100K Ohm Pull Down + Hyst. Enable Field: Hysteresis Disabled */ + IOMUXC_SetPinConfig( + IOMUXC_GPIO_EMC_38_SEMC_DM01, /* GPIO_EMC_38 PAD functional properties : */ + 0x10B0u); /* Slew Rate Field: Slow Slew Rate + Drive Strength Field: R0/6 + Speed Field: medium(100MHz) + Open Drain Enable Field: Open Drain Disabled + Pull / Keep Enable Field: Pull/Keeper Enabled + Pull / Keep Select Field: Keeper + Pull Up / Down Config. Field: 100K Ohm Pull Down + Hyst. Enable Field: Hysteresis Disabled */ +} + +/* FUNCTION ************************************************************************************************************ + * + * Function Name : BOARD_InitI2C1Pins + * Description : Configures pin routing and optionally pin electrical features. + * + * END ****************************************************************************************************************/ +void BOARD_InitI2C1Pins(void) { + CLOCK_EnableClock(kCLOCK_Iomuxc); /* iomuxc clock (iomuxc_clk_enable): 0x03u */ + + IOMUXC_SetPinMux( + IOMUXC_GPIO_AD_B1_00_LPI2C1_SCL, /* GPIO_AD_B1_00 is configured as LPI2C1_SCL */ + 1U); /* Software Input On Field: Force input path of pad GPIO_AD_B1_00 */ + IOMUXC_SetPinMux( + IOMUXC_GPIO_AD_B1_01_LPI2C1_SDA, /* GPIO_AD_B1_01 is configured as LPI2C1_SDA */ + 1U); /* Software Input On Field: Force input path of pad GPIO_AD_B1_01 */ + IOMUXC_SetPinConfig( + IOMUXC_GPIO_AD_B1_00_LPI2C1_SCL, /* GPIO_AD_B1_00 PAD functional properties : */ + 0xD8B0u); /* Slew Rate Field: Slow Slew Rate + Drive Strength Field: R0/6 + Speed Field: medium(100MHz) + Open Drain Enable Field: Open Drain Enabled + Pull / Keep Enable Field: Pull/Keeper Enabled + Pull / Keep Select Field: Keeper + Pull Up / Down Config. Field: 22K Ohm Pull Up + Hyst. Enable Field: Hysteresis Disabled */ + IOMUXC_SetPinConfig( + IOMUXC_GPIO_AD_B1_01_LPI2C1_SDA, /* GPIO_AD_B1_01 PAD functional properties : */ + 0xD8B0u); /* Slew Rate Field: Slow Slew Rate + Drive Strength Field: R0/6 + Speed Field: medium(100MHz) + Open Drain Enable Field: Open Drain Enabled + Pull / Keep Enable Field: Pull/Keeper Enabled + Pull / Keep Select Field: Keeper + Pull Up / Down Config. Field: 22K Ohm Pull Up + Hyst. Enable Field: Hysteresis Disabled */ +} + + +/*********************************************************************************************************************** + * EOF + **********************************************************************************************************************/ diff --git a/ports/nxp/board/evkmimxrt1064/pin_mux.h b/ports/nxp/board/evkmimxrt1064/pin_mux.h new file mode 100644 index 000000000000..76b673ec802b --- /dev/null +++ b/ports/nxp/board/evkmimxrt1064/pin_mux.h @@ -0,0 +1,81 @@ +/* + * Copyright 2018-2019 NXP + * All rights reserved. + * + * SPDX-License-Identifier: BSD-3-Clause + */ + +/*********************************************************************************************************************** + * This file was generated by the MCUXpresso Config Tools. Any manual edits made to this file + * will be overwritten if the respective MCUXpresso Config Tools is used to update this file. + **********************************************************************************************************************/ + +#ifndef _PIN_MUX_H_ +#define _PIN_MUX_H_ + +/*********************************************************************************************************************** + * Definitions + **********************************************************************************************************************/ + +/*! @brief Direction type */ +typedef enum _pin_mux_direction +{ + kPIN_MUX_DirectionInput = 0U, /* Input direction */ + kPIN_MUX_DirectionOutput = 1U, /* Output direction */ + kPIN_MUX_DirectionInputOrOutput = 2U /* Input or output direction */ +} pin_mux_direction_t; + +/*! + * @addtogroup pin_mux + * @{ + */ + +/*********************************************************************************************************************** + * API + **********************************************************************************************************************/ + +#if defined(__cplusplus) +extern "C" { +#endif + +/*! + * @brief Calls initialization functions. + * + */ +void BOARD_InitBootPins(void); + +/*! + * @brief Configures pin routing and optionally pin electrical features. + * + */ +void BOARD_InitSemcPins(void); + +void BOARD_InitI2C1Pins(void); + +/* GPIO_AD_B0_13 (coord L14), UART1_RXD */ +#define BOARD_INITPINS_UART1_RXD_PERIPHERAL LPUART1 /*!< Device name: LPUART1 */ +#define BOARD_INITPINS_UART1_RXD_SIGNAL RX /*!< LPUART1 signal: RX */ + +/* GPIO_AD_B0_12 (coord K14), UART1_TXD */ +#define BOARD_INITPINS_UART1_TXD_PERIPHERAL LPUART1 /*!< Device name: LPUART1 */ +#define BOARD_INITPINS_UART1_TXD_SIGNAL TX /*!< LPUART1 signal: TX */ + + +/*! + * @brief Configures pin routing and optionally pin electrical features. + * + */ +void BOARD_InitPins(void); + +#if defined(__cplusplus) +} +#endif + +/*! + * @} + */ +#endif /* _PIN_MUX_H_ */ + +/*********************************************************************************************************************** + * EOF + **********************************************************************************************************************/ diff --git a/ports/nxp/board/evkmimxrt1064/port-pad.c b/ports/nxp/board/evkmimxrt1064/port-pad.c new file mode 100644 index 000000000000..20febf9de39b --- /dev/null +++ b/ports/nxp/board/evkmimxrt1064/port-pad.c @@ -0,0 +1,75 @@ +/* + * The MIT License (MIT) + * + * Copyright (c) 2013-2019 Damien P. George + * + * Permission is hereby granted, free of charge, to any person obtaining a copy + * of this software and associated documentation files (the "Software"), to deal + * in the Software without restriction, including without limitation the rights + * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell + * copies of the Software, and to permit persons to whom the Software is + * furnished to do so, subject to the following conditions: + * + * The above copyright notice and this permission notice shall be included in + * all copies or substantial portions of the Software. + * + * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR + * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, + * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE + * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER + * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, + * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN + * THE SOFTWARE. + */ +#include + +#include "py/obj.h" + +#include "fsl_iomuxc.h" +#include "pybpinmux.h" + +#define IOMUX(pad, port, muxRegisterWord, muxModeWord, inputRegisterWord, inputDaisyWord, configRegisterWord) \ +{ \ + {&pinmux_type}, \ + .pinmux_name = MP_QSTR_IOMUXC_## pad ## _ ## port, \ + .muxRegister = muxRegisterWord,\ + .muxMode = muxModeWord, \ + .inputRegister = inputRegisterWord, \ + .inputDaisy = inputDaisyWord, \ + .configRegister = configRegisterWord \ +} + +#define PORT(port, pinmuxArray) \ +{ \ + {&port_type}, \ + .port_name = MP_QSTR_## port, \ + .pinmux_num = sizeof(pinmuxArray)/sizeof(pinmux_obj_t), \ + .pinmux = pinmuxArray, \ +} + +const pinmux_obj_t LPI2C1_SCL_pinmux [] = { + IOMUX(GPIO_AD_B1_00, LPI2C1_SCL, 0x401F80FCU, 0x3U, 0x401F84CCU, 0x1U, 0x401F82ECU), + IOMUX(GPIO_SD_B1_04, LPI2C1_SCL, 0x401F81E4U, 0x2U, 0x401F84CCU, 0x0U, 0x401F83D4U), +}; + +const port_obj_t LPI2C1_SCL_obj = PORT(LPI2C1_SCL, LPI2C1_SCL_pinmux); + +const pinmux_obj_t LPI2C1_SDA_pinmux [] = { + IOMUX(GPIO_AD_B1_01, LPI2C1_SDA, 0x401F8100U, 0x3U, 0x401F84D0U, 0x1U, 0x401F82F0U), + IOMUX(GPIO_SD_B1_05, LPI2C1_SDA, 0x401F81E8U, 0x2U, 0x401F84D0U, 0x0U, 0x401F83D8U), +}; + +const port_obj_t LPI2C1_SDA_obj = PORT(LPI2C1_SDA, LPI2C1_SDA_pinmux); + +const port_obj_t * const Module_LPI2C1[] = +{ + &LPI2C1_SCL_obj, + &LPI2C1_SDA_obj, +}; + + +STATIC const mp_rom_map_elem_t port_board_pinmux_locals_dict_table[] = { + { MP_ROM_QSTR(MP_QSTR_LPI2C1_SCL), MP_ROM_PTR(&LPI2C1_SCL_obj) }, + { MP_ROM_QSTR(MP_QSTR_LPI2C1_SDA), MP_ROM_PTR(&LPI2C1_SDA_obj) }, +}; +MP_DEFINE_CONST_DICT(port_board_pinmux_locals_dict, port_board_pinmux_locals_dict_table); \ No newline at end of file diff --git a/ports/nxp/board/evkmimxrt1064/port-pad.h b/ports/nxp/board/evkmimxrt1064/port-pad.h new file mode 100644 index 000000000000..04f3b89eea09 --- /dev/null +++ b/ports/nxp/board/evkmimxrt1064/port-pad.h @@ -0,0 +1,28 @@ +/* + * The MIT License (MIT) + * + * Copyright (c) 2013-2019 Damien P. George + * + * Permission is hereby granted, free of charge, to any person obtaining a copy + * of this software and associated documentation files (the "Software"), to deal + * in the Software without restriction, including without limitation the rights + * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell + * copies of the Software, and to permit persons to whom the Software is + * furnished to do so, subject to the following conditions: + * + * The above copyright notice and this permission notice shall be included in + * all copies or substantial portions of the Software. + * + * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR + * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, + * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE + * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER + * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, + * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN + * THE SOFTWARE. + */ + +extern const pinmux_obj_t LPI2C1_SCL_pinmux []; +extern const port_obj_t LPI2C_SCL_obj; +extern const pinmux_obj_t LPI2C1_SDA_pinmux []; +extern const port_obj_t LPI2C1_SDA_obj; \ No newline at end of file diff --git a/ports/nxp/ffconf.h b/ports/nxp/ffconf.h new file mode 100644 index 000000000000..c5310397e7c5 --- /dev/null +++ b/ports/nxp/ffconf.h @@ -0,0 +1,65 @@ +/* + * This file is part of the MicroPython project, http://micropython.org/ + * + * The MIT License (MIT) + * + * Copyright (c) 2019 Damien P. George + * + * Permission is hereby granted, free of charge, to any person obtaining a copy + * of this software and associated documentation files (the "Software"), to deal + * in the Software without restriction, including without limitation the rights + * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell + * copies of the Software, and to permit persons to whom the Software is + * furnished to do so, subject to the following conditions: + * + * The above copyright notice and this permission notice shall be included in + * all copies or substantial portions of the Software. + * + * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR + * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, + * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE + * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER + * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, + * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN + * THE SOFTWARE. + */ + +#define FFCONF_DEF 86604 + +#define FF_FS_READONLY 0 +#define FF_FS_MINIMIZE 0 +#define FF_USE_STRFUNC 1 + +#define FF_USE_FIND 0 +#define FF_USE_MKFS 1 +#define FF_USE_FASTSEEK 0 +#define FF_USE_EXPAND 0 +#define FF_USE_CHMOD 0 +#define FF_USE_LABEL 0 +#define FF_USE_FORWARD 0 + +#define FF_CODE_PAGE 932 +#define FF_USE_LFN 0 +#define FF_MAX_LFN 255 +#define FF_LFN_UNICODE 0 +#define FF_LFN_BUF 255 +#define FF_SFN_BUF 12 +#define FF_STRF_ENCODE 3 +#define FF_FS_RPATH 2 + +#define FF_VOLUMES 1 +#define FF_STR_VOLUME_ID 0 +#define FF_MULTI_PARTITION 1 +#define FF_MIN_SS 512 +#define FF_MAX_SS 512 +#define FF_USE_TRIM 0 +#define FF_FS_NOFSINFO 0 + +#define FF_FS_TINY 0 +#define FF_FS_EXFAT 0 +#define FF_FS_NORTC 1 +#define FF_NORTC_MON 1 +#define FF_NORTC_MDAY 1 +#define FF_NORTC_YEAR 2019 +#define FF_FS_LOCK 0 +#define FF_FS_REENTRANT 0 diff --git a/ports/nxp/gccollect.c b/ports/nxp/gccollect.c new file mode 100644 index 000000000000..16e737d723e9 --- /dev/null +++ b/ports/nxp/gccollect.c @@ -0,0 +1,50 @@ +/* + * The MIT License (MIT) + * + * Copyright (c) 2013-2019 Damien P. George + * + * Permission is hereby granted, free of charge, to any person obtaining a copy + * of this software and associated documentation files (the "Software"), to deal + * in the Software without restriction, including without limitation the rights + * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell + * copies of the Software, and to permit persons to whom the Software is + * furnished to do so, subject to the following conditions: + * + * The above copyright notice and this permission notice shall be included in + * all copies or substantial portions of the Software. + * + * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR + * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, + * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE + * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER + * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, + * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN + * THE SOFTWARE. + */ + +#include +#include + +#include "py/mpstate.h" +#include "py/gc.h" +#include "py/mpthread.h" +#include "lib/utils/gchelper.h" +#include "gccollect.h" + +uintptr_t gc_helper_get_regs_and_sp(uintptr_t *regs); + +void gc_collect(void){ + gc_collect_start(); + + uintptr_t regs[10]; + // invoke from gchelper_m3.s or gchelper_m0.s + uintptr_t sp; + sp = gc_helper_get_regs_and_sp(regs); + + gc_collect_root((void**)sp, (((uint32_t)&__StackTop) - sp) / sizeof(uint32_t)); + + gc_collect_end(); +// gc_dump_info(); +} + + diff --git a/ports/nxp/gccollect.h b/ports/nxp/gccollect.h new file mode 100644 index 000000000000..d354ea79e72c --- /dev/null +++ b/ports/nxp/gccollect.h @@ -0,0 +1,38 @@ +/* + * The MIT License (MIT) + * + * Copyright (c) 2013-2019 Damien P. George + * + * Permission is hereby granted, free of charge, to any person obtaining a copy + * of this software and associated documentation files (the "Software"), to deal + * in the Software without restriction, including without limitation the rights + * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell + * copies of the Software, and to permit persons to whom the Software is + * furnished to do so, subject to the following conditions: + * + * The above copyright notice and this permission notice shall be included in + * all copies or substantial portions of the Software. + * + * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR + * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, + * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE + * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER + * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, + * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN + * THE SOFTWARE. + */ + +#ifndef _GCCOLLECT_H_ +#define _GCCOLLECT_H_ + + +extern uint32_t m_text; +extern uint32_t m_data; +extern uint32_t m_data2; +extern uint32_t __HeapBase; +extern uint32_t __HeapLimit; +extern uint32_t __StackTop; +extern uint32_t __StackLimit; +extern uint32_t STACK_SIZE; + +#endif \ No newline at end of file diff --git a/ports/nxp/led.c b/ports/nxp/led.c new file mode 100644 index 000000000000..369de2d73453 --- /dev/null +++ b/ports/nxp/led.c @@ -0,0 +1,155 @@ +/* + * The MIT License (MIT) + * + * Copyright (c) 2013-2019 Damien P. George + * + * Permission is hereby granted, free of charge, to any person obtaining a copy + * of this software and associated documentation files (the "Software"), to deal + * in the Software without restriction, including without limitation the rights + * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell + * copies of the Software, and to permit persons to whom the Software is + * furnished to do so, subject to the following conditions: + * + * The above copyright notice and this permission notice shall be included in + * all copies or substantial portions of the Software. + * + * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR + * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, + * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE + * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER + * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, + * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN + * THE SOFTWARE. + */ + +#include + +#include "py/runtime.h" +#include "py/mphal.h" + +#include "led.h" +#include "pin.h" + +#include "fsl_gpio.h" + +typedef struct _pyb_led_obj_t +{ + mp_obj_base_t base; + mp_uint_t led_id; + const pin_obj_t *led_pin; +}pyb_led_obj_t; + +const pin_obj_t pin_led_obj = PIN(1, 9, GPIO1); + +STATIC const pyb_led_obj_t pyb_led_obj[] = { + {{&pyb_led_type}, 1, &pin_led_obj}, +}; + +#define NUM_LEDS MP_ARRAY_SIZE(pyb_led_obj) + +void led_init(void) +{ + for(int led=0; ledgpio, led_pin->pin, &led_config); + } +} + +void led_state(pyb_led_t led, int state) +{ + if (led < 1 || led >NUM_LEDS ) + return ; + + const pin_obj_t* led_pin = pyb_led_obj[led-1].led_pin; + + if (state == 0) + { + mp_hal_pin_low(led_pin); + } + else + { + mp_hal_pin_high(led_pin); + } +} + +/* + * class method print + */ +void led_obj_print(const mp_print_t *print, mp_obj_t self_in, mp_print_kind_t kind) { + pyb_led_obj_t *self = MP_OBJ_TO_PTR(self_in); + mp_printf(print, "LED(%u)", self->led_id); +} + +/* + * class method make new + */ +STATIC mp_obj_t led_obj_make_new(const mp_obj_type_t *type, size_t n_args, size_t n_kw, const mp_obj_t *args) +{ + mp_arg_check_num(n_args, n_kw, 1, 1, false); + + mp_int_t led_id = mp_obj_get_int(args[0]); + // check led number + if (!(1 <= led_id && led_id <= NUM_LEDS)) { + nlr_raise(mp_obj_new_exception_msg_varg(&mp_type_ValueError, "LED(%d) doesn't exist", led_id)); + } + + // return static led object + return MP_OBJ_FROM_PTR(&pyb_led_obj[led_id - 1]); +} + +/* + * instance method on() + * open related led + */ +mp_obj_t led_obj_on(mp_obj_t self_in) +{ + pyb_led_obj_t *self = MP_OBJ_TO_PTR(self_in); + led_state(self->led_id,0); + return mp_const_none; +} +STATIC MP_DEFINE_CONST_FUN_OBJ_1(led_obj_on_obj, led_obj_on); + +/* + * instance method off() + * open related led + */ +mp_obj_t led_obj_off(mp_obj_t self_in) +{ + pyb_led_obj_t *self = MP_OBJ_TO_PTR(self_in); + led_state(self->led_id,1); + return mp_const_none; +} +STATIC MP_DEFINE_CONST_FUN_OBJ_1(led_obj_off_obj, led_obj_off); + +/* + * instance method toggle() + * toggle related led + */ +mp_obj_t led_obj_toggle(mp_obj_t self_in) +{ + pyb_led_obj_t *self = MP_OBJ_TO_PTR(self_in); + mp_hal_pin_toggle(self->led_pin); + return mp_const_none; +} +STATIC MP_DEFINE_CONST_FUN_OBJ_1(led_obj_toggle_obj, led_obj_toggle); + + +STATIC const mp_rom_map_elem_t led_locals_dict_table[] = { + { MP_ROM_QSTR(MP_QSTR_on), MP_ROM_PTR(&led_obj_on_obj) }, + { MP_ROM_QSTR(MP_QSTR_off), MP_ROM_PTR(&led_obj_off_obj) }, + { MP_ROM_QSTR(MP_QSTR_toggle), MP_ROM_PTR(&led_obj_toggle_obj) }, + +}; + +STATIC MP_DEFINE_CONST_DICT(led_locals_dict, led_locals_dict_table); + + +const mp_obj_type_t pyb_led_type = { + {&mp_type_type}, + .name = MP_QSTR_LED, + .print = led_obj_print, + .make_new = led_obj_make_new, + .locals_dict = (mp_obj_dict_t*)&led_locals_dict, +}; diff --git a/ports/nxp/led.h b/ports/nxp/led.h new file mode 100644 index 000000000000..21265da14dec --- /dev/null +++ b/ports/nxp/led.h @@ -0,0 +1,39 @@ +/* + * The MIT License (MIT) + * + * Copyright (c) 2013-2019 Damien P. George + * + * Permission is hereby granted, free of charge, to any person obtaining a copy + * of this software and associated documentation files (the "Software"), to deal + * in the Software without restriction, including without limitation the rights + * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell + * copies of the Software, and to permit persons to whom the Software is + * furnished to do so, subject to the following conditions: + * + * The above copyright notice and this permission notice shall be included in + * all copies or substantial portions of the Software. + * + * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR + * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, + * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE + * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER + * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, + * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN + * THE SOFTWARE. + */ + +#ifndef _LED_H_ +#define _LED_H_ + +typedef enum { + LED_YELLOW = 1, +}pyb_led_t; + + +void led_state(pyb_led_t led, int state); +void led_init(void); + + +extern const mp_obj_type_t pyb_led_type; + +#endif \ No newline at end of file diff --git a/ports/nxp/main.c b/ports/nxp/main.c new file mode 100644 index 000000000000..72575b7233e6 --- /dev/null +++ b/ports/nxp/main.c @@ -0,0 +1,419 @@ +/* + * The MIT License (MIT) + * + * Copyright (c) 2013-2019 Damien P. George + * + * Permission is hereby granted, free of charge, to any person obtaining a copy + * of this software and associated documentation files (the "Software"), to deal + * in the Software without restriction, including without limitation the rights + * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell + * copies of the Software, and to permit persons to whom the Software is + * furnished to do so, subject to the following conditions: + * + * The above copyright notice and this permission notice shall be included in + * all copies or substantial portions of the Software. + * + * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR + * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, + * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE + * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER + * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, + * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN + * THE SOFTWARE. + */ + +#include +#include +#include + +#include "py/compile.h" +#include "py/runtime.h" +#include "py/repl.h" +#include "py/gc.h" +#include "py/mperrno.h" +#include "py/stackctrl.h" +#include "lib/utils/pyexec.h" + +#include "lib/oofatfs/ff.h" +#include "extmod/vfs.h" +#include "extmod/vfs_fat.h" + +#include "fsl_debug_console.h" +#include "app.h" +#include "gccollect.h" + +#if defined(MICROPY_PY_LVGL) && MICROPY_PY_LVGL +#include "littlevgl_support.h" +#endif + +#include "led.h" +#include "pin.h" +#include "sdcard.h" + +#include "FreeRTOSConfig.h" +#include "FreeRTOS.h" +#include "task.h" +#include "semphr.h" + +void REPLTask(void *param); +void CardDetectTask(void *param); +void SdcardInitTask(void *param); + +static void SDCARD_DetectCallBack(bool isInserted, void *userData); + +static volatile bool s_cardInserted = false; +static volatile bool s_cardInsertStatus = false; + +static TaskHandle_t CardDetectTaskHandle; +static TaskHandle_t SdcardInitTaskHandle; +static SemaphoreHandle_t s_fileAccessSemaphore = NULL; +static SemaphoreHandle_t s_CardDetectSemaphore = NULL; +extern sd_card_t g_sd; + +static const sdmmchost_detect_card_t s_sdCardDetect = { +#ifndef BOARD_SD_DETECT_TYPE + .cdType = kSDMMCHOST_DetectCardByGpioCD, +#else + .cdType = BOARD_SD_DETECT_TYPE, +#endif + .cdTimeOut_ms = (~0U), + .cardInserted = SDCARD_DetectCallBack, + .cardRemoved = SDCARD_DetectCallBack, +}; + +static void mp_reset(void) +{ + //Set Stack top + mp_stack_set_top(&__StackTop); + //Set Stack limit + mp_stack_set_limit(STACK_SIZE); + + #if MICROPY_ENABLE_GC + gc_init((void *)&__HeapBase, (void *)&__HeapLimit); + #endif + + #if MICROPY_ENABLE_PYSTACK + static mp_obj_t pystack[384]; + mp_pystack_init(pystack, &pystack[384]); + #endif + // MicroPython init + mp_init(); + mp_obj_list_init(MP_OBJ_TO_PTR(mp_sys_path), 0); + mp_obj_list_append(mp_sys_path, MP_OBJ_NEW_QSTR(MP_QSTR_)); + mp_obj_list_init(MP_OBJ_TO_PTR(mp_sys_argv), 0); +} + +static void SDCARD_DetectCallBack(bool isInserted, void *userData) +{ + s_cardInsertStatus = isInserted; + xSemaphoreGiveFromISR(s_CardDetectSemaphore, NULL); +} + +#if MICROPY_ENABLE_COMPILER +void do_str(const char *src, mp_parse_input_kind_t input_kind) { + nlr_buf_t nlr; + if (nlr_push(&nlr) == 0) { + mp_lexer_t *lex = mp_lexer_new_from_str_len(MP_QSTR__lt_stdin_gt_, src, strlen(src), 0); + qstr source_name = lex->source_name; + mp_parse_tree_t parse_tree = mp_parse(lex, input_kind); + mp_obj_t module_fun = mp_compile(&parse_tree, source_name, MP_EMIT_OPT_NONE, true); + mp_call_function_0(module_fun); + nlr_pop(); + } else { + // uncaught exception + mp_obj_print_exception(&mp_plat_print, (mp_obj_t)nlr.ret_val); + } +} +#endif + +STATIC bool init_sdcard_fs(void) +{ + bool first_part = true; + fs_user_mount_t *vfs_fat; + mp_vfs_mount_t *vfs; + for (int part_num = 1; part_num <= 4; ++part_num) + { + vfs_fat = m_new_obj_maybe(fs_user_mount_t); + vfs = m_new_obj_maybe(mp_vfs_mount_t); + if(vfs == NULL || vfs_fat == NULL) + { + break; + } + vfs_fat->flags = FSUSER_FREE_OBJ; + + /* set vfs_fat */ + sdcard_init_vfs(vfs_fat, part_num); + /* mount the partition */ + FRESULT res = f_mount(&(vfs_fat->fatfs)); + if(res != FR_OK) + { + m_del_obj(fs_user_mount_t, vfs_fat); + m_del_obj(mp_vfs_mount_t, vfs); + } + else + { + if(first_part) + { + vfs->str = "/sd"; + vfs->len = 3; + } + else + { + if(part_num == 2) + { + vfs->str = "/sd2"; + } + else if (part_num == 3) + { + vfs->str = "/sd3"; + } + else + vfs->str = "/sd4"; + vfs->len = 4; + } + vfs->obj = MP_OBJ_FROM_PTR(vfs_fat); + vfs->next = NULL; + for(mp_vfs_mount_t **m = &MP_STATE_VM(vfs_mount_table);;m= &(*m)->next) + { + if(*m == NULL) + { + *m = vfs; + break; + } + } + if(first_part) + { + MP_STATE_PORT(vfs_cur) = vfs; + } + first_part = false; + } + } + if(first_part) + { + printf("MPY: can't mount SD card\r\n"); + return false; + } + else + { + return true; + } +} + + +void CardDetectTask(void *param) +{ + bool mounted_sdcard = false; + s_fileAccessSemaphore = xSemaphoreCreateBinary(); + s_CardDetectSemaphore = xSemaphoreCreateBinary(); + + g_sd.host.base = SD_HOST_BASEADDR; + g_sd.host.sourceClock_Hz = SD_HOST_CLK_FREQ; + g_sd.usrParam.cd = &s_sdCardDetect; + /* SD host init function */ + if (SD_HostInit(&g_sd) == kStatus_Success) + { + while (true) + { + /* take card detect semaphore */ + if (xSemaphoreTake(s_CardDetectSemaphore, portMAX_DELAY) == pdTRUE) + { + if (s_cardInserted != s_cardInsertStatus) + { + s_cardInserted = s_cardInsertStatus; + if (!s_cardInserted) + { + /* power off card */ + SD_PowerOffCard(g_sd.host.base, g_sd.usrParam.pwr); + } + + if (s_cardInserted) + { + /* power on the card */ + SD_PowerOnCard(g_sd.host.base, g_sd.usrParam.pwr); + mounted_sdcard = init_sdcard_fs(); + if(mounted_sdcard) + { + mp_obj_list_append(mp_sys_path, MP_OBJ_NEW_QSTR(MP_QSTR__slash_sd)); + mp_obj_list_append(mp_sys_path, MP_OBJ_NEW_QSTR(MP_QSTR__slash_sd_slash_lib)); + } + /* make file system */ + xSemaphoreGive(s_fileAccessSemaphore); + } + } + + if (!s_cardInserted) + { + printf("\r\nPlease insert a card into board.\r\n"); + } + } + } + } + else + { + printf("\r\nSD host init fail\r\n"); + } + vTaskSuspend(NULL); +} + +void SdcardInitTask(void *param) +{ + while(1) + { + /* mount the sdcard */ + if(xSemaphoreTake(s_fileAccessSemaphore, portMAX_DELAY) == pdTRUE) + { + + /* reset config variables; they should be set by boot.py */ + MP_STATE_PORT(pyb_config_main) = MP_OBJ_NULL; + mp_import_stat_t stat = mp_import_stat("boot.py"); + if(stat == MP_IMPORT_STAT_FILE) + { + vstr_t *vstr = vstr_new(16); + vstr_add_str(vstr, "boot.py"); + if(!pyexec_file(vstr_null_terminated_str(vstr))) + printf("boot.py exec failed\r\n"); + } + + /* Run the main script from the current directory. */ + const char *main_py; + main_py = "main.py"; + stat = mp_import_stat(main_py); + if(stat == MP_IMPORT_STAT_FILE) + { + int main_ret = pyexec_file(main_py); + if(!main_ret) + { + printf("main.py exec error\r\n"); + } + } + BaseType_t task_status; + task_status = xTaskCreate(REPLTask, "REPL", configMINIMAL_STACK_SIZE+400, NULL, 4, NULL); + if(pdPASS != task_status) + { + printf("Failed to creat REPL task\r\n"); + } + } + } +} + +int main(void) { + // BOARD init + BOARD_InitHardware(); + + pin_init0(); + led_init(); +#if defined(MICROPY_PY_LVGL) && MICROPY_PY_LVGL + lv_port_pre_init(); +#endif + /* initialize */ + mp_reset(); + + BaseType_t status; + status = xTaskCreate(CardDetectTask, "CardDetect", configMINIMAL_STACK_SIZE+400, NULL, 3, &CardDetectTaskHandle); + if(pdPASS != status) + { + printf("Failed to creat CardDetect task\r\n"); + } + status = xTaskCreate(SdcardInitTask, "SdcardInit", configMINIMAL_STACK_SIZE+400, NULL, 2, &SdcardInitTaskHandle); + if(pdPASS != status) + { + printf("Failed to creat SdcardInit task\r\n"); + } + vTaskStartScheduler(); + mp_deinit(); + return 0; +} + +void REPLTask(void *param) +{ + /* Delete useless Task */ + vTaskDelete(CardDetectTaskHandle); + vTaskDelete(SdcardInitTaskHandle); + + #if MICROPY_ENABLE_COMPILER + #if MICROPY_REPL_EVENT_DRIVEN + pyexec_event_repl_init(); + for (;;) { + int c = mp_hal_stdin_rx_chr(); + if (pyexec_event_repl_process_char(c)) { + break; + } + } + #else +soft_reset: + for(;;) + { + if(pyexec_mode_kind == PYEXEC_MODE_FRIENDLY_REPL) + { + if(pyexec_friendly_repl() !=0) + break; + } + else if (pyexec_mode_kind == PYEXEC_MODE_RAW_REPL) + { + if(pyexec_raw_repl() != 0) + break; + } + } + goto soft_reset_exit; + #endif + #else + pyexec_frozen_module("frozentest.py"); + #endif + +soft_reset_exit: + printf("MPY: soft reboot\n"); + gc_sweep_all(); + mp_deinit(); + mp_reset(); + goto soft_reset; +} + + +mp_obj_t mp_builtin_open(size_t n_args, const mp_obj_t *args, mp_map_t *kwargs) { + return mp_const_none; +} +MP_DEFINE_CONST_FUN_OBJ_KW(mp_builtin_open_obj, 1, mp_builtin_open); + +void NORETURN __fatal_error(const char *msg) { + PRINTF("FATAL ERROR HAPPENED\r\n"); + while (1); +} + +#ifndef NDEBUG +void MP_WEAK __assert_func(const char *file, int line, const char *func, const char *expr) { + (void)func; + printf("Assertion '%s' failed, at file %s:%d\n", expr, file, line); + __fatal_error("Assertion failed"); +} +#endif + +void nlr_jump_fail(void *val) { + PRINTF("FATAL: uncaught exception %p\n", val); + mp_obj_print_exception(&mp_plat_print, MP_OBJ_FROM_PTR(val)); + __fatal_error(""); + while (1); +} + +void vApplicationMallocFailedHook(void) +{ + for (;;) + { + printf("Malloc Failed \r\n"); + break; + } +} + +/*! + * @brief Stack overflow hook. + */ +void vApplicationStackOverflowHook(TaskHandle_t xTask, signed char *pcTaskName) +{ + (void)pcTaskName; + (void)xTask; + + for (;;) + { + printf("Stack OVerflow \r\n"); + break; + } +} diff --git a/ports/nxp/modSDL.c b/ports/nxp/modSDL.c new file mode 100644 index 000000000000..e6b33167cb49 --- /dev/null +++ b/ports/nxp/modSDL.c @@ -0,0 +1,141 @@ +/* + * The MIT License (MIT) + * + * Copyright (c) 2013-2019 Damien P. George + * + * Permission is hereby granted, free of charge, to any person obtaining a copy + * of this software and associated documentation files (the "Software"), to deal + * in the Software without restriction, including without limitation the rights + * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell + * copies of the Software, and to permit persons to whom the Software is + * furnished to do so, subject to the following conditions: + * + * The above copyright notice and this permission notice shall be included in + * all copies or substantial portions of the Software. + * + * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR + * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, + * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE + * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER + * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, + * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN + * THE SOFTWARE. + */ + +#include +#include + +#include "py/runtime.h" +#include "py/mphal.h" +#include "py/obj.h" +#include "py/binary.h" + +#include "lib/utils/pyexec.h" +#include "common.h" + +#include "littlevgl_support.h" + +#include "FreeRTOSConfig.h" +#include "FreeRTOS.h" +#include "timers.h" +#include "task.h" + +#if LV_HOR_RES != 480 +#error "LV_HOR_RES must be set to 480!" +#endif + +#if LV_VER_RES != 272 +#error "LV_VER_RES must be set to 272!" +#endif + +#if LV_COLOR_DEPTH != 16 +#error "LV_COLOR_DEPTH must be set to 16!" +#endif + +TimerHandle_t xTimer; + +void InitLcd(void); +void FlushDisplay(int32_t x1, int32_t y1, int32_t x2, int32_t y2, const lv_color_t *color_p); +void DispTask(void *param); + + +void vTimerCallback(TimerHandle_t pxTimer) +{ + lv_tick_inc(2); + lv_task_handler(); +} + +void InitLcd(void) +{ + DEMO_InitLcd(); +} + +STATIC mp_obj_t mp_init_SDL(void) +{ + BaseType_t stat; + stat = xTaskCreate(DispTask, "Display", configMINIMAL_STACK_SIZE+400, NULL, 4, NULL); + if (pdPASS != stat) + { + printf("Failed to create display task\r\n"); + } + vTaskDelay(5); + return mp_const_none; +} +STATIC MP_DEFINE_CONST_FUN_OBJ_0(mp_init_SDL_obj, mp_init_SDL); + +void DispTask(void *param) +{ + InitLcd(); + DEMO_InitTouch(); + xTimer = xTimerCreate("lvgl_timer",5,pdTRUE,NULL,vTimerCallback); + if(xTimer == NULL || xTimerStart(xTimer,0) != pdPASS) + { + printf("Failed creating or starting LVGL timer!\r\n"); + } + vTaskSuspend(NULL); +} + +/* + * Flush a buffer to the display. + */ +void display_flush(int32_t x1, int32_t y1, int32_t x2, int32_t y2, const lv_color_t *color_p) +{ + DEMO_FlushDisplay(x1, y1, x2, y2, color_p); +} +DEFINE_PTR_OBJ(display_flush); + +void display_fill(int32_t x1, int32_t y1, int32_t x2, int32_t y2, lv_color_t *color_p) +{ + printf("fill display \r\n"); +} +DEFINE_PTR_OBJ(display_fill); + +void display_map(int32_t x1, int32_t y1, int32_t x2, int32_t y2, const lv_color_t *color_p) +{ + printf("map display\r\n"); +} +DEFINE_PTR_OBJ(display_map); + + +void touch_read(lv_indev_data_t * data) +{ + DEMO_ReadTouch(data); +} +DEFINE_PTR_OBJ(touch_read); + +STATIC const mp_rom_map_elem_t SDL_globals_table[] = { + { MP_ROM_QSTR(MP_QSTR___name__), MP_ROM_QSTR(MP_QSTR_SDL) }, + { MP_ROM_QSTR(MP_QSTR_init), MP_ROM_PTR(&mp_init_SDL_obj) }, + { MP_ROM_QSTR(MP_QSTR_display_flush), MP_ROM_PTR(&PTR_OBJ(display_flush)) }, + { MP_ROM_QSTR(MP_QSTR_display_fill), MP_ROM_PTR(&PTR_OBJ(display_fill)) }, + { MP_ROM_QSTR(MP_QSTR_display_map), MP_ROM_PTR(&PTR_OBJ(display_map)) }, + { MP_ROM_QSTR(MP_QSTR_touch_read), MP_ROM_PTR(&PTR_OBJ(touch_read)) }, +}; + +STATIC MP_DEFINE_CONST_DICT(mp_module_SDL_globals, SDL_globals_table); + + +const mp_obj_module_t mp_module_SDL = { + .base = { &mp_type_module }, + .globals = (mp_obj_dict_t*)&mp_module_SDL_globals, +}; \ No newline at end of file diff --git a/ports/nxp/modlvgl.c b/ports/nxp/modlvgl.c new file mode 100644 index 000000000000..159488679c53 --- /dev/null +++ b/ports/nxp/modlvgl.c @@ -0,0 +1,24200 @@ + +/* + * Auto-Generated file, DO NOT EDIT! + * + * Command line: + * ../../lib/lv_binding_micropython/gen/gen_mpy.py -X anim -X group -X task -I../../lib/lv_binding_micropython/lvgl -I ../../lib/lv_binding_micropython/pycparser/utils/fake_libc_include ../../lib/lv_binding_micropython/lvgl/lvgl.h + * + * Preprocessing command: + * gcc -E -std=c99 -DPYCPARSER -I ../../lib/lv_binding_micropython/lvgl -I ../../lib/lv_binding_micropython/pycparser/utils/fake_libc_include -include ../../lib/lv_binding_micropython/lvgl/lvgl.h ../../lib/lv_binding_micropython/lvgl/lvgl.h + * + * Generating Objects: obj(None), cont(obj), btn(obj), imgbtn(obj), label(obj), img(obj), line(obj), page(obj), list(obj), chart(obj), table(obj), cb(obj), bar(obj), slider(obj), led(obj), btnm(obj), kb(obj), ddlist(obj), roller(obj), ta(obj), canvas(obj), win(obj), tabview(obj), tileview(obj), mbox(obj), lmeter(obj), gauge(obj), sw(obj), arc(obj), preload(obj), calendar(obj), spinbox(obj) + */ + +/* + * Mpy includes + */ + +#include +#include +#include "py/obj.h" +#include "py/objstr.h" +#include "py/runtime.h" +#include "py/binary.h" + +/* + * lvgl includes + */ + +#include "lib/nxplib/middleware/littlevgl/lvgl.h" + + +/* + * Helper functions + */ + +typedef lv_obj_t* (*lv_create)(lv_obj_t * par, const lv_obj_t * copy); + +typedef struct mp_lv_obj_t { + mp_obj_base_t base; + lv_obj_t *lv_obj; + mp_obj_t *action; +} mp_lv_obj_t; + +STATIC mp_obj_t get_native_obj(mp_obj_t *mp_obj) +{ + const mp_obj_type_t *native_type = ((mp_obj_base_t*)mp_obj)->type; + if (native_type->parent == NULL) return mp_obj; + while (native_type->parent) native_type = native_type->parent; + return mp_instance_cast_to_native_base(mp_obj, MP_OBJ_FROM_PTR(native_type)); +} + +STATIC mp_obj_t dict_to_struct(mp_obj_t dict, const mp_obj_type_t *type); + +STATIC mp_obj_t *cast(mp_obj_t *mp_obj, const mp_obj_type_t *mp_type) +{ + mp_obj_t *res = NULL; + if (MP_OBJ_IS_OBJ(mp_obj)){ + res = get_native_obj(mp_obj); + if (res){ + const mp_obj_type_t *res_type = ((mp_obj_base_t*)res)->type; + if (res_type != mp_type){ + if (res_type == &mp_type_dict) res = dict_to_struct(res, mp_type); + else res = NULL; + } + } + } + if (res == NULL) nlr_raise( + mp_obj_new_exception_msg_varg( + &mp_type_SyntaxError, "Can't convert %s to %s!", mp_obj_get_type_str(mp_obj), qstr_str(mp_type->name))); + return res; +} + +STATIC inline lv_obj_t *mp_to_lv(mp_obj_t *mp_obj) +{ + if (mp_obj == NULL || mp_obj == mp_const_none) return NULL; + mp_lv_obj_t *mp_lv_obj = MP_OBJ_TO_PTR(get_native_obj(mp_obj)); + return mp_lv_obj->lv_obj; +} + +STATIC inline mp_obj_t *mp_to_lv_action(mp_obj_t *mp_obj) +{ + if (mp_obj == NULL || mp_obj == mp_const_none) return NULL; + mp_lv_obj_t *mp_lv_obj = MP_OBJ_TO_PTR(mp_obj); + return mp_lv_obj->action; +} + +STATIC inline void set_action(mp_obj_t *mp_obj, mp_obj_t *action) +{ + if (mp_obj == NULL || mp_obj == mp_const_none) return; + mp_lv_obj_t *mp_lv_obj = MP_OBJ_TO_PTR(mp_obj); + mp_lv_obj->action = action; +} + +STATIC inline const mp_obj_type_t *get_BaseObj_type(); + +STATIC inline mp_obj_t *lv_to_mp(lv_obj_t *lv_obj) +{ + mp_lv_obj_t *self = lv_obj_get_free_ptr(lv_obj); + if (!self) + { + self = m_new_obj(mp_lv_obj_t); + *self = (mp_lv_obj_t){ + .base = {get_BaseObj_type()}, + .lv_obj = lv_obj, + .action = NULL + }; + } + return MP_OBJ_FROM_PTR(self); +} + +STATIC mp_obj_t make_new( + lv_create create, + const mp_obj_type_t *type, + size_t n_args, + size_t n_kw, + const mp_obj_t *args) +{ + mp_arg_check_num(n_args, n_kw, 0, 2, false); + mp_lv_obj_t *self = m_new_obj(mp_lv_obj_t); + lv_obj_t *parent = n_args > 0? mp_to_lv(args[0]): NULL; + lv_obj_t *copy = n_args > 1? mp_to_lv(args[1]): NULL; + *self = (mp_lv_obj_t){ + .base = {type}, + .lv_obj = create(parent, copy), + .action = NULL + }; + lv_obj_set_free_ptr(self->lv_obj, self); + return MP_OBJ_FROM_PTR(self); +} + +STATIC inline mp_obj_t convert_to_bool(bool b) +{ + return b? mp_const_true: mp_const_false; +} + +STATIC inline mp_obj_t convert_to_str(const char *str) +{ + return mp_obj_new_str(str, strlen(str)); +} + +STATIC void field_not_found(qstr struct_name, qstr field_name) +{ + nlr_raise( + mp_obj_new_exception_msg_varg( + &mp_type_SyntaxError, + "Cannot access field %s. Field does not exist in struct %s!", + qstr_str(field_name), + qstr_str(struct_name))); +} + +typedef struct mp_lv_struct_t +{ + mp_obj_base_t base; + void *data; +} mp_lv_struct_t; + +STATIC inline mp_lv_struct_t *mp_to_lv_struct(mp_obj_t *mp_obj) +{ + if (mp_obj == NULL || mp_obj == mp_const_none) return NULL; + if (!MP_OBJ_IS_OBJ(mp_obj)) nlr_raise( + mp_obj_new_exception_msg( + &mp_type_SyntaxError, "Struct argument is not an object!")); + mp_lv_struct_t *mp_lv_struct = MP_OBJ_TO_PTR(get_native_obj(mp_obj)); + return mp_lv_struct; +} + +STATIC inline size_t get_lv_struct_size(const mp_obj_type_t *type) +{ + mp_obj_t size_obj = mp_obj_dict_get(type->locals_dict, MP_OBJ_NEW_QSTR(MP_QSTR_SIZE)); + return (size_t)mp_obj_get_int(size_obj); +} + +STATIC mp_obj_t make_new_lv_struct( + const mp_obj_type_t *type, + size_t n_args, + size_t n_kw, + const mp_obj_t *args) +{ + size_t size = get_lv_struct_size(type); + mp_arg_check_num(n_args, n_kw, 0, 1, false); + mp_lv_struct_t *self = m_new_obj(mp_lv_struct_t); + *self = (mp_lv_struct_t){ + .base = {type}, + .data = m_malloc(size) + }; + mp_lv_struct_t *other = n_args > 0? mp_to_lv_struct(cast(args[0], type)): NULL; + if (other) { + memcpy(self->data, other->data, size); + } + return MP_OBJ_FROM_PTR(self); +} + +STATIC void *copy_buffer(const void *buffer, size_t size) +{ + void *new_buffer = m_malloc(size); + memcpy(new_buffer, buffer, size); + return new_buffer; +} + +// Reference an existing lv struct (or part of it) + +STATIC mp_obj_t lv_to_mp_struct(const mp_obj_type_t *type, void *lv_struct) +{ + mp_lv_struct_t *self = m_new_obj(mp_lv_struct_t); + *self = (mp_lv_struct_t){ + .base = {type}, + .data = lv_struct + }; + return MP_OBJ_FROM_PTR(self); +} + +// Convert dict to struct + +STATIC mp_obj_t dict_to_struct(mp_obj_t dict, const mp_obj_type_t *type) +{ + mp_obj_t mp_struct = make_new_lv_struct(type, 0, 0, NULL); + mp_obj_t *native_dict = cast(dict, &mp_type_dict); + mp_map_t *map = mp_obj_dict_get_map(native_dict); + if (map == NULL) return mp_const_none; + for (uint i = 0; i < map->alloc; i++) { + mp_obj_t key = map->table[i].key; + mp_obj_t value = map->table[i].value; + if (key != MP_OBJ_NULL) { + type->attr(mp_struct, mp_obj_str_get_qstr(key), (mp_obj_t[]){MP_OBJ_SENTINEL, value}); + } + } + return mp_struct; +} + + +// Blob is a wrapper for void* + +STATIC void mp_blob_print(const mp_print_t *print, + mp_obj_t self_in, + mp_print_kind_t kind) +{ + mp_printf(print, "lvgl Blob"); +} + +STATIC mp_int_t mp_blob_get_buffer(mp_obj_t self_in, mp_buffer_info_t *bufinfo, mp_uint_t flags) { + (void)flags; + mp_lv_struct_t *self = MP_OBJ_TO_PTR(self_in); + + bufinfo->buf = &self->data; + bufinfo->len = sizeof(self->data); + bufinfo->typecode = BYTEARRAY_TYPECODE; + return 0; +} + +STATIC const mp_obj_type_t mp_blob_type = { + { &mp_type_type }, + .name = MP_QSTR_Blob, + .print = mp_blob_print, + //.make_new = make_new_blob, + //.attr = mp_blob_attr, + //.locals_dict = (mp_obj_dict_t*)&mp_blob_locals_dict, + .buffer_p = { .get_buffer = mp_blob_get_buffer } +}; + +STATIC void* mp_to_ptr(mp_obj_t self_in) +{ + void *result; + mp_buffer_info_t buffer_info; + if (self_in == mp_const_none) return NULL; + mp_get_buffer_raise(self_in, &buffer_info, MP_BUFFER_READ); + if (buffer_info.len != sizeof(result) || buffer_info.typecode != BYTEARRAY_TYPECODE){ + nlr_raise( + mp_obj_new_exception_msg_varg( + &mp_type_SyntaxError, "Cannot convert %s to pointer!", mp_obj_get_type_str(self_in))); + } + memcpy(&result, buffer_info.buf, sizeof(result)); + return result; +} + +STATIC inline mp_obj_t ptr_to_mp(void *data) +{ + return lv_to_mp_struct(&mp_blob_type, data); +} + +// Cast pointer to struct + +STATIC mp_obj_t mp_lv_cast(mp_obj_t type_obj, mp_obj_t ptr_obj) +{ + mp_lv_struct_t *self = m_new_obj(mp_lv_struct_t); + *self = (mp_lv_struct_t){ + .base = {(const mp_obj_type_t*)type_obj}, + .data = mp_to_ptr(ptr_obj) + }; + return self; +} + +STATIC MP_DEFINE_CONST_FUN_OBJ_2(mp_lv_cast_obj, mp_lv_cast); +STATIC MP_DEFINE_CONST_CLASSMETHOD_OBJ(mp_lv_cast_class_method, MP_ROM_PTR(&mp_lv_cast_obj)); + + + +/* + * lvgl LV_TASK_PRIO object definitions + */ + + +STATIC const mp_rom_map_elem_t LV_TASK_PRIO_locals_dict_table[] = { + { MP_ROM_QSTR(MP_QSTR_OFF), MP_ROM_PTR(MP_ROM_INT(LV_TASK_PRIO_OFF)) }, + { MP_ROM_QSTR(MP_QSTR_LOWEST), MP_ROM_PTR(MP_ROM_INT(LV_TASK_PRIO_LOWEST)) }, + { MP_ROM_QSTR(MP_QSTR_LOW), MP_ROM_PTR(MP_ROM_INT(LV_TASK_PRIO_LOW)) }, + { MP_ROM_QSTR(MP_QSTR_MID), MP_ROM_PTR(MP_ROM_INT(LV_TASK_PRIO_MID)) }, + { MP_ROM_QSTR(MP_QSTR_HIGH), MP_ROM_PTR(MP_ROM_INT(LV_TASK_PRIO_HIGH)) }, + { MP_ROM_QSTR(MP_QSTR_HIGHEST), MP_ROM_PTR(MP_ROM_INT(LV_TASK_PRIO_HIGHEST)) }, + { MP_ROM_QSTR(MP_QSTR_NUM), MP_ROM_PTR(MP_ROM_INT(LV_TASK_PRIO_NUM)) } +}; + +STATIC MP_DEFINE_CONST_DICT(LV_TASK_PRIO_locals_dict, LV_TASK_PRIO_locals_dict_table); + +STATIC void LV_TASK_PRIO_print(const mp_print_t *print, + mp_obj_t self_in, + mp_print_kind_t kind) +{ + mp_printf(print, "lvgl LV_TASK_PRIO"); +} + + + +STATIC const mp_obj_type_t mp_LV_TASK_PRIO_type = { + { &mp_type_type }, + .name = MP_QSTR_LV_TASK_PRIO, + .print = LV_TASK_PRIO_print, + + .locals_dict = (mp_obj_dict_t*)&LV_TASK_PRIO_locals_dict, +}; + + +/* + * lvgl LV_OPA object definitions + */ + + +STATIC const mp_rom_map_elem_t LV_OPA_locals_dict_table[] = { + { MP_ROM_QSTR(MP_QSTR_TRANSP), MP_ROM_PTR(MP_ROM_INT(LV_OPA_TRANSP)) }, + { MP_ROM_QSTR(MP_QSTR__0), MP_ROM_PTR(MP_ROM_INT(LV_OPA_0)) }, + { MP_ROM_QSTR(MP_QSTR__10), MP_ROM_PTR(MP_ROM_INT(LV_OPA_10)) }, + { MP_ROM_QSTR(MP_QSTR__20), MP_ROM_PTR(MP_ROM_INT(LV_OPA_20)) }, + { MP_ROM_QSTR(MP_QSTR__30), MP_ROM_PTR(MP_ROM_INT(LV_OPA_30)) }, + { MP_ROM_QSTR(MP_QSTR__40), MP_ROM_PTR(MP_ROM_INT(LV_OPA_40)) }, + { MP_ROM_QSTR(MP_QSTR__50), MP_ROM_PTR(MP_ROM_INT(LV_OPA_50)) }, + { MP_ROM_QSTR(MP_QSTR__60), MP_ROM_PTR(MP_ROM_INT(LV_OPA_60)) }, + { MP_ROM_QSTR(MP_QSTR__70), MP_ROM_PTR(MP_ROM_INT(LV_OPA_70)) }, + { MP_ROM_QSTR(MP_QSTR__80), MP_ROM_PTR(MP_ROM_INT(LV_OPA_80)) }, + { MP_ROM_QSTR(MP_QSTR__90), MP_ROM_PTR(MP_ROM_INT(LV_OPA_90)) }, + { MP_ROM_QSTR(MP_QSTR__100), MP_ROM_PTR(MP_ROM_INT(LV_OPA_100)) }, + { MP_ROM_QSTR(MP_QSTR_COVER), MP_ROM_PTR(MP_ROM_INT(LV_OPA_COVER)) } +}; + +STATIC MP_DEFINE_CONST_DICT(LV_OPA_locals_dict, LV_OPA_locals_dict_table); + +STATIC void LV_OPA_print(const mp_print_t *print, + mp_obj_t self_in, + mp_print_kind_t kind) +{ + mp_printf(print, "lvgl LV_OPA"); +} + + + +STATIC const mp_obj_type_t mp_LV_OPA_type = { + { &mp_type_type }, + .name = MP_QSTR_LV_OPA, + .print = LV_OPA_print, + + .locals_dict = (mp_obj_dict_t*)&LV_OPA_locals_dict, +}; + + +/* + * lvgl LV_SYMBOL object definitions + */ + +MP_DEFINE_STR_OBJ(mp_LV_SYMBOL_AUDIO_NUMSTR, "\xef\xa0\x80\x00"); +MP_DEFINE_STR_OBJ(mp_LV_SYMBOL_VIDEO_NUMSTR, "\xef\xa0\x81\x00"); +MP_DEFINE_STR_OBJ(mp_LV_SYMBOL_LIST_NUMSTR, "\xef\xa0\x82\x00"); +MP_DEFINE_STR_OBJ(mp_LV_SYMBOL_OK_NUMSTR, "\xef\xa0\x83\x00"); +MP_DEFINE_STR_OBJ(mp_LV_SYMBOL_CLOSE_NUMSTR, "\xef\xa0\x84\x00"); +MP_DEFINE_STR_OBJ(mp_LV_SYMBOL_POWER_NUMSTR, "\xef\xa0\x85\x00"); +MP_DEFINE_STR_OBJ(mp_LV_SYMBOL_SETTINGS_NUMSTR, "\xef\xa0\x86\x00"); +MP_DEFINE_STR_OBJ(mp_LV_SYMBOL_TRASH_NUMSTR, "\xef\xa0\x87\x00"); +MP_DEFINE_STR_OBJ(mp_LV_SYMBOL_HOME_NUMSTR, "\xef\xa0\x88\x00"); +MP_DEFINE_STR_OBJ(mp_LV_SYMBOL_DOWNLOAD_NUMSTR, "\xef\xa0\x89\x00"); +MP_DEFINE_STR_OBJ(mp_LV_SYMBOL_DRIVE_NUMSTR, "\xef\xa0\x8a\x00"); +MP_DEFINE_STR_OBJ(mp_LV_SYMBOL_REFRESH_NUMSTR, "\xef\xa0\x8b\x00"); +MP_DEFINE_STR_OBJ(mp_LV_SYMBOL_MUTE_NUMSTR, "\xef\xa0\x8c\x00"); +MP_DEFINE_STR_OBJ(mp_LV_SYMBOL_VOLUME_MID_NUMSTR, "\xef\xa0\x8d\x00"); +MP_DEFINE_STR_OBJ(mp_LV_SYMBOL_VOLUME_MAX_NUMSTR, "\xef\xa0\x8e\x00"); +MP_DEFINE_STR_OBJ(mp_LV_SYMBOL_IMAGE_NUMSTR, "\xef\xa0\x8f\x00"); +MP_DEFINE_STR_OBJ(mp_LV_SYMBOL_EDIT_NUMSTR, "\xef\xa0\x90\x00"); +MP_DEFINE_STR_OBJ(mp_LV_SYMBOL_PREV_NUMSTR, "\xef\xa0\x91\x00"); +MP_DEFINE_STR_OBJ(mp_LV_SYMBOL_PLAY_NUMSTR, "\xef\xa0\x92\x00"); +MP_DEFINE_STR_OBJ(mp_LV_SYMBOL_PAUSE_NUMSTR, "\xef\xa0\x93\x00"); +MP_DEFINE_STR_OBJ(mp_LV_SYMBOL_STOP_NUMSTR, "\xef\xa0\x94\x00"); +MP_DEFINE_STR_OBJ(mp_LV_SYMBOL_NEXT_NUMSTR, "\xef\xa0\x95\x00"); +MP_DEFINE_STR_OBJ(mp_LV_SYMBOL_EJECT_NUMSTR, "\xef\xa0\x96\x00"); +MP_DEFINE_STR_OBJ(mp_LV_SYMBOL_LEFT_NUMSTR, "\xef\xa0\x97\x00"); +MP_DEFINE_STR_OBJ(mp_LV_SYMBOL_RIGHT_NUMSTR, "\xef\xa0\x98\x00"); +MP_DEFINE_STR_OBJ(mp_LV_SYMBOL_PLUS_NUMSTR, "\xef\xa0\x99\x00"); +MP_DEFINE_STR_OBJ(mp_LV_SYMBOL_MINUS_NUMSTR, "\xef\xa0\x9a\x00"); +MP_DEFINE_STR_OBJ(mp_LV_SYMBOL_WARNING_NUMSTR, "\xef\xa0\x9b\x00"); +MP_DEFINE_STR_OBJ(mp_LV_SYMBOL_SHUFFLE_NUMSTR, "\xef\xa0\x9c\x00"); +MP_DEFINE_STR_OBJ(mp_LV_SYMBOL_UP_NUMSTR, "\xef\xa0\x9d\x00"); +MP_DEFINE_STR_OBJ(mp_LV_SYMBOL_DOWN_NUMSTR, "\xef\xa0\x9e\x00"); +MP_DEFINE_STR_OBJ(mp_LV_SYMBOL_LOOP_NUMSTR, "\xef\xa0\x9f\x00"); +MP_DEFINE_STR_OBJ(mp_LV_SYMBOL_DIRECTORY_NUMSTR, "\xef\xa0\xa0\x00"); +MP_DEFINE_STR_OBJ(mp_LV_SYMBOL_UPLOAD_NUMSTR, "\xef\xa0\xa1\x00"); +MP_DEFINE_STR_OBJ(mp_LV_SYMBOL_CALL_NUMSTR, "\xef\xa0\xa2\x00"); +MP_DEFINE_STR_OBJ(mp_LV_SYMBOL_CUT_NUMSTR, "\xef\xa0\xa3\x00"); +MP_DEFINE_STR_OBJ(mp_LV_SYMBOL_COPY_NUMSTR, "\xef\xa0\xa4\x00"); +MP_DEFINE_STR_OBJ(mp_LV_SYMBOL_SAVE_NUMSTR, "\xef\xa0\xa5\x00"); +MP_DEFINE_STR_OBJ(mp_LV_SYMBOL_CHARGE_NUMSTR, "\xef\xa0\xa6\x00"); +MP_DEFINE_STR_OBJ(mp_LV_SYMBOL_BELL_NUMSTR, "\xef\xa0\xa7\x00"); +MP_DEFINE_STR_OBJ(mp_LV_SYMBOL_KEYBOARD_NUMSTR, "\xef\xa0\xa8\x00"); +MP_DEFINE_STR_OBJ(mp_LV_SYMBOL_GPS_NUMSTR, "\xef\xa0\xa9\x00"); +MP_DEFINE_STR_OBJ(mp_LV_SYMBOL_FILE_NUMSTR, "\xef\xa0\xaa\x00"); +MP_DEFINE_STR_OBJ(mp_LV_SYMBOL_WIFI_NUMSTR, "\xef\xa0\xab\x00"); +MP_DEFINE_STR_OBJ(mp_LV_SYMBOL_BATTERY_FULL_NUMSTR, "\xef\xa0\xac\x00"); +MP_DEFINE_STR_OBJ(mp_LV_SYMBOL_BATTERY_3_NUMSTR, "\xef\xa0\xad\x00"); +MP_DEFINE_STR_OBJ(mp_LV_SYMBOL_BATTERY_2_NUMSTR, "\xef\xa0\xae\x00"); +MP_DEFINE_STR_OBJ(mp_LV_SYMBOL_BATTERY_1_NUMSTR, "\xef\xa0\xaf\x00"); +MP_DEFINE_STR_OBJ(mp_LV_SYMBOL_BATTERY_EMPTY_NUMSTR, "\xef\xa0\xb0\x00"); +MP_DEFINE_STR_OBJ(mp_LV_SYMBOL_BLUETOOTH_NUMSTR, "\xef\xa0\xb1\x00"); +MP_DEFINE_STR_OBJ(mp_LV_SYMBOL_DUMMY_NUMSTR, "\xef\xa3\xbf\x00"); + +STATIC const mp_rom_map_elem_t LV_SYMBOL_locals_dict_table[] = { + { MP_ROM_QSTR(MP_QSTR_AUDIO), MP_ROM_PTR(&mp_LV_SYMBOL_AUDIO_NUMSTR) }, + { MP_ROM_QSTR(MP_QSTR_VIDEO), MP_ROM_PTR(&mp_LV_SYMBOL_VIDEO_NUMSTR) }, + { MP_ROM_QSTR(MP_QSTR_LIST), MP_ROM_PTR(&mp_LV_SYMBOL_LIST_NUMSTR) }, + { MP_ROM_QSTR(MP_QSTR_OK), MP_ROM_PTR(&mp_LV_SYMBOL_OK_NUMSTR) }, + { MP_ROM_QSTR(MP_QSTR_CLOSE), MP_ROM_PTR(&mp_LV_SYMBOL_CLOSE_NUMSTR) }, + { MP_ROM_QSTR(MP_QSTR_POWER), MP_ROM_PTR(&mp_LV_SYMBOL_POWER_NUMSTR) }, + { MP_ROM_QSTR(MP_QSTR_SETTINGS), MP_ROM_PTR(&mp_LV_SYMBOL_SETTINGS_NUMSTR) }, + { MP_ROM_QSTR(MP_QSTR_TRASH), MP_ROM_PTR(&mp_LV_SYMBOL_TRASH_NUMSTR) }, + { MP_ROM_QSTR(MP_QSTR_HOME), MP_ROM_PTR(&mp_LV_SYMBOL_HOME_NUMSTR) }, + { MP_ROM_QSTR(MP_QSTR_DOWNLOAD), MP_ROM_PTR(&mp_LV_SYMBOL_DOWNLOAD_NUMSTR) }, + { MP_ROM_QSTR(MP_QSTR_DRIVE), MP_ROM_PTR(&mp_LV_SYMBOL_DRIVE_NUMSTR) }, + { MP_ROM_QSTR(MP_QSTR_REFRESH), MP_ROM_PTR(&mp_LV_SYMBOL_REFRESH_NUMSTR) }, + { MP_ROM_QSTR(MP_QSTR_MUTE), MP_ROM_PTR(&mp_LV_SYMBOL_MUTE_NUMSTR) }, + { MP_ROM_QSTR(MP_QSTR_VOLUME_MID), MP_ROM_PTR(&mp_LV_SYMBOL_VOLUME_MID_NUMSTR) }, + { MP_ROM_QSTR(MP_QSTR_VOLUME_MAX), MP_ROM_PTR(&mp_LV_SYMBOL_VOLUME_MAX_NUMSTR) }, + { MP_ROM_QSTR(MP_QSTR_IMAGE), MP_ROM_PTR(&mp_LV_SYMBOL_IMAGE_NUMSTR) }, + { MP_ROM_QSTR(MP_QSTR_EDIT), MP_ROM_PTR(&mp_LV_SYMBOL_EDIT_NUMSTR) }, + { MP_ROM_QSTR(MP_QSTR_PREV), MP_ROM_PTR(&mp_LV_SYMBOL_PREV_NUMSTR) }, + { MP_ROM_QSTR(MP_QSTR_PLAY), MP_ROM_PTR(&mp_LV_SYMBOL_PLAY_NUMSTR) }, + { MP_ROM_QSTR(MP_QSTR_PAUSE), MP_ROM_PTR(&mp_LV_SYMBOL_PAUSE_NUMSTR) }, + { MP_ROM_QSTR(MP_QSTR_STOP), MP_ROM_PTR(&mp_LV_SYMBOL_STOP_NUMSTR) }, + { MP_ROM_QSTR(MP_QSTR_NEXT), MP_ROM_PTR(&mp_LV_SYMBOL_NEXT_NUMSTR) }, + { MP_ROM_QSTR(MP_QSTR_EJECT), MP_ROM_PTR(&mp_LV_SYMBOL_EJECT_NUMSTR) }, + { MP_ROM_QSTR(MP_QSTR_LEFT), MP_ROM_PTR(&mp_LV_SYMBOL_LEFT_NUMSTR) }, + { MP_ROM_QSTR(MP_QSTR_RIGHT), MP_ROM_PTR(&mp_LV_SYMBOL_RIGHT_NUMSTR) }, + { MP_ROM_QSTR(MP_QSTR_PLUS), MP_ROM_PTR(&mp_LV_SYMBOL_PLUS_NUMSTR) }, + { MP_ROM_QSTR(MP_QSTR_MINUS), MP_ROM_PTR(&mp_LV_SYMBOL_MINUS_NUMSTR) }, + { MP_ROM_QSTR(MP_QSTR_WARNING), MP_ROM_PTR(&mp_LV_SYMBOL_WARNING_NUMSTR) }, + { MP_ROM_QSTR(MP_QSTR_SHUFFLE), MP_ROM_PTR(&mp_LV_SYMBOL_SHUFFLE_NUMSTR) }, + { MP_ROM_QSTR(MP_QSTR_UP), MP_ROM_PTR(&mp_LV_SYMBOL_UP_NUMSTR) }, + { MP_ROM_QSTR(MP_QSTR_DOWN), MP_ROM_PTR(&mp_LV_SYMBOL_DOWN_NUMSTR) }, + { MP_ROM_QSTR(MP_QSTR_LOOP), MP_ROM_PTR(&mp_LV_SYMBOL_LOOP_NUMSTR) }, + { MP_ROM_QSTR(MP_QSTR_DIRECTORY), MP_ROM_PTR(&mp_LV_SYMBOL_DIRECTORY_NUMSTR) }, + { MP_ROM_QSTR(MP_QSTR_UPLOAD), MP_ROM_PTR(&mp_LV_SYMBOL_UPLOAD_NUMSTR) }, + { MP_ROM_QSTR(MP_QSTR_CALL), MP_ROM_PTR(&mp_LV_SYMBOL_CALL_NUMSTR) }, + { MP_ROM_QSTR(MP_QSTR_CUT), MP_ROM_PTR(&mp_LV_SYMBOL_CUT_NUMSTR) }, + { MP_ROM_QSTR(MP_QSTR_COPY), MP_ROM_PTR(&mp_LV_SYMBOL_COPY_NUMSTR) }, + { MP_ROM_QSTR(MP_QSTR_SAVE), MP_ROM_PTR(&mp_LV_SYMBOL_SAVE_NUMSTR) }, + { MP_ROM_QSTR(MP_QSTR_CHARGE), MP_ROM_PTR(&mp_LV_SYMBOL_CHARGE_NUMSTR) }, + { MP_ROM_QSTR(MP_QSTR_BELL), MP_ROM_PTR(&mp_LV_SYMBOL_BELL_NUMSTR) }, + { MP_ROM_QSTR(MP_QSTR_KEYBOARD), MP_ROM_PTR(&mp_LV_SYMBOL_KEYBOARD_NUMSTR) }, + { MP_ROM_QSTR(MP_QSTR_GPS), MP_ROM_PTR(&mp_LV_SYMBOL_GPS_NUMSTR) }, + { MP_ROM_QSTR(MP_QSTR_FILE), MP_ROM_PTR(&mp_LV_SYMBOL_FILE_NUMSTR) }, + { MP_ROM_QSTR(MP_QSTR_WIFI), MP_ROM_PTR(&mp_LV_SYMBOL_WIFI_NUMSTR) }, + { MP_ROM_QSTR(MP_QSTR_BATTERY_FULL), MP_ROM_PTR(&mp_LV_SYMBOL_BATTERY_FULL_NUMSTR) }, + { MP_ROM_QSTR(MP_QSTR_BATTERY_3), MP_ROM_PTR(&mp_LV_SYMBOL_BATTERY_3_NUMSTR) }, + { MP_ROM_QSTR(MP_QSTR_BATTERY_2), MP_ROM_PTR(&mp_LV_SYMBOL_BATTERY_2_NUMSTR) }, + { MP_ROM_QSTR(MP_QSTR_BATTERY_1), MP_ROM_PTR(&mp_LV_SYMBOL_BATTERY_1_NUMSTR) }, + { MP_ROM_QSTR(MP_QSTR_BATTERY_EMPTY), MP_ROM_PTR(&mp_LV_SYMBOL_BATTERY_EMPTY_NUMSTR) }, + { MP_ROM_QSTR(MP_QSTR_BLUETOOTH), MP_ROM_PTR(&mp_LV_SYMBOL_BLUETOOTH_NUMSTR) }, + { MP_ROM_QSTR(MP_QSTR_DUMMY), MP_ROM_PTR(&mp_LV_SYMBOL_DUMMY_NUMSTR) } +}; + +STATIC MP_DEFINE_CONST_DICT(LV_SYMBOL_locals_dict, LV_SYMBOL_locals_dict_table); + +STATIC void LV_SYMBOL_print(const mp_print_t *print, + mp_obj_t self_in, + mp_print_kind_t kind) +{ + mp_printf(print, "lvgl LV_SYMBOL"); +} + + + +STATIC const mp_obj_type_t mp_LV_SYMBOL_type = { + { &mp_type_type }, + .name = MP_QSTR_LV_SYMBOL, + .print = LV_SYMBOL_print, + + .locals_dict = (mp_obj_dict_t*)&LV_SYMBOL_locals_dict, +}; + + +/* + * lvgl LV_BORDER object definitions + */ + + +STATIC const mp_rom_map_elem_t LV_BORDER_locals_dict_table[] = { + { MP_ROM_QSTR(MP_QSTR_NONE), MP_ROM_PTR(MP_ROM_INT(LV_BORDER_NONE)) }, + { MP_ROM_QSTR(MP_QSTR_BOTTOM), MP_ROM_PTR(MP_ROM_INT(LV_BORDER_BOTTOM)) }, + { MP_ROM_QSTR(MP_QSTR_TOP), MP_ROM_PTR(MP_ROM_INT(LV_BORDER_TOP)) }, + { MP_ROM_QSTR(MP_QSTR_LEFT), MP_ROM_PTR(MP_ROM_INT(LV_BORDER_LEFT)) }, + { MP_ROM_QSTR(MP_QSTR_RIGHT), MP_ROM_PTR(MP_ROM_INT(LV_BORDER_RIGHT)) }, + { MP_ROM_QSTR(MP_QSTR_FULL), MP_ROM_PTR(MP_ROM_INT(LV_BORDER_FULL)) }, + { MP_ROM_QSTR(MP_QSTR_INTERNAL), MP_ROM_PTR(MP_ROM_INT(LV_BORDER_INTERNAL)) } +}; + +STATIC MP_DEFINE_CONST_DICT(LV_BORDER_locals_dict, LV_BORDER_locals_dict_table); + +STATIC void LV_BORDER_print(const mp_print_t *print, + mp_obj_t self_in, + mp_print_kind_t kind) +{ + mp_printf(print, "lvgl LV_BORDER"); +} + + + +STATIC const mp_obj_type_t mp_LV_BORDER_type = { + { &mp_type_type }, + .name = MP_QSTR_LV_BORDER, + .print = LV_BORDER_print, + + .locals_dict = (mp_obj_dict_t*)&LV_BORDER_locals_dict, +}; + + +/* + * lvgl LV_SHADOW object definitions + */ + + +STATIC const mp_rom_map_elem_t LV_SHADOW_locals_dict_table[] = { + { MP_ROM_QSTR(MP_QSTR_BOTTOM), MP_ROM_PTR(MP_ROM_INT(LV_SHADOW_BOTTOM)) }, + { MP_ROM_QSTR(MP_QSTR_FULL), MP_ROM_PTR(MP_ROM_INT(LV_SHADOW_FULL)) } +}; + +STATIC MP_DEFINE_CONST_DICT(LV_SHADOW_locals_dict, LV_SHADOW_locals_dict_table); + +STATIC void LV_SHADOW_print(const mp_print_t *print, + mp_obj_t self_in, + mp_print_kind_t kind) +{ + mp_printf(print, "lvgl LV_SHADOW"); +} + + + +STATIC const mp_obj_type_t mp_LV_SHADOW_type = { + { &mp_type_type }, + .name = MP_QSTR_LV_SHADOW, + .print = LV_SHADOW_print, + + .locals_dict = (mp_obj_dict_t*)&LV_SHADOW_locals_dict, +}; + + +/* + * lvgl LV_DESIGN object definitions + */ + + +STATIC const mp_rom_map_elem_t LV_DESIGN_locals_dict_table[] = { + { MP_ROM_QSTR(MP_QSTR_DRAW_MAIN), MP_ROM_PTR(MP_ROM_INT(LV_DESIGN_DRAW_MAIN)) }, + { MP_ROM_QSTR(MP_QSTR_DRAW_POST), MP_ROM_PTR(MP_ROM_INT(LV_DESIGN_DRAW_POST)) }, + { MP_ROM_QSTR(MP_QSTR_COVER_CHK), MP_ROM_PTR(MP_ROM_INT(LV_DESIGN_COVER_CHK)) } +}; + +STATIC MP_DEFINE_CONST_DICT(LV_DESIGN_locals_dict, LV_DESIGN_locals_dict_table); + +STATIC void LV_DESIGN_print(const mp_print_t *print, + mp_obj_t self_in, + mp_print_kind_t kind) +{ + mp_printf(print, "lvgl LV_DESIGN"); +} + + + +STATIC const mp_obj_type_t mp_LV_DESIGN_type = { + { &mp_type_type }, + .name = MP_QSTR_LV_DESIGN, + .print = LV_DESIGN_print, + + .locals_dict = (mp_obj_dict_t*)&LV_DESIGN_locals_dict, +}; + + +/* + * lvgl LV_RES object definitions + */ + + +STATIC const mp_rom_map_elem_t LV_RES_locals_dict_table[] = { + { MP_ROM_QSTR(MP_QSTR_INV), MP_ROM_PTR(MP_ROM_INT(LV_RES_INV)) }, + { MP_ROM_QSTR(MP_QSTR_OK), MP_ROM_PTR(MP_ROM_INT(LV_RES_OK)) } +}; + +STATIC MP_DEFINE_CONST_DICT(LV_RES_locals_dict, LV_RES_locals_dict_table); + +STATIC void LV_RES_print(const mp_print_t *print, + mp_obj_t self_in, + mp_print_kind_t kind) +{ + mp_printf(print, "lvgl LV_RES"); +} + + + +STATIC const mp_obj_type_t mp_LV_RES_type = { + { &mp_type_type }, + .name = MP_QSTR_LV_RES, + .print = LV_RES_print, + + .locals_dict = (mp_obj_dict_t*)&LV_RES_locals_dict, +}; + + +/* + * lvgl LV_SIGNAL object definitions + */ + + +STATIC const mp_rom_map_elem_t LV_SIGNAL_locals_dict_table[] = { + { MP_ROM_QSTR(MP_QSTR_CLEANUP), MP_ROM_PTR(MP_ROM_INT(LV_SIGNAL_CLEANUP)) }, + { MP_ROM_QSTR(MP_QSTR_CHILD_CHG), MP_ROM_PTR(MP_ROM_INT(LV_SIGNAL_CHILD_CHG)) }, + { MP_ROM_QSTR(MP_QSTR_CORD_CHG), MP_ROM_PTR(MP_ROM_INT(LV_SIGNAL_CORD_CHG)) }, + { MP_ROM_QSTR(MP_QSTR_STYLE_CHG), MP_ROM_PTR(MP_ROM_INT(LV_SIGNAL_STYLE_CHG)) }, + { MP_ROM_QSTR(MP_QSTR_REFR_EXT_SIZE), MP_ROM_PTR(MP_ROM_INT(LV_SIGNAL_REFR_EXT_SIZE)) }, + { MP_ROM_QSTR(MP_QSTR_LANG_CHG), MP_ROM_PTR(MP_ROM_INT(LV_SIGNAL_LANG_CHG)) }, + { MP_ROM_QSTR(MP_QSTR_GET_TYPE), MP_ROM_PTR(MP_ROM_INT(LV_SIGNAL_GET_TYPE)) }, + { MP_ROM_QSTR(MP_QSTR_PRESSED), MP_ROM_PTR(MP_ROM_INT(LV_SIGNAL_PRESSED)) }, + { MP_ROM_QSTR(MP_QSTR_PRESSING), MP_ROM_PTR(MP_ROM_INT(LV_SIGNAL_PRESSING)) }, + { MP_ROM_QSTR(MP_QSTR_PRESS_LOST), MP_ROM_PTR(MP_ROM_INT(LV_SIGNAL_PRESS_LOST)) }, + { MP_ROM_QSTR(MP_QSTR_RELEASED), MP_ROM_PTR(MP_ROM_INT(LV_SIGNAL_RELEASED)) }, + { MP_ROM_QSTR(MP_QSTR_LONG_PRESS), MP_ROM_PTR(MP_ROM_INT(LV_SIGNAL_LONG_PRESS)) }, + { MP_ROM_QSTR(MP_QSTR_LONG_PRESS_REP), MP_ROM_PTR(MP_ROM_INT(LV_SIGNAL_LONG_PRESS_REP)) }, + { MP_ROM_QSTR(MP_QSTR_DRAG_BEGIN), MP_ROM_PTR(MP_ROM_INT(LV_SIGNAL_DRAG_BEGIN)) }, + { MP_ROM_QSTR(MP_QSTR_DRAG_END), MP_ROM_PTR(MP_ROM_INT(LV_SIGNAL_DRAG_END)) }, + { MP_ROM_QSTR(MP_QSTR_FOCUS), MP_ROM_PTR(MP_ROM_INT(LV_SIGNAL_FOCUS)) }, + { MP_ROM_QSTR(MP_QSTR_DEFOCUS), MP_ROM_PTR(MP_ROM_INT(LV_SIGNAL_DEFOCUS)) }, + { MP_ROM_QSTR(MP_QSTR_CONTROLL), MP_ROM_PTR(MP_ROM_INT(LV_SIGNAL_CONTROLL)) }, + { MP_ROM_QSTR(MP_QSTR_GET_EDITABLE), MP_ROM_PTR(MP_ROM_INT(LV_SIGNAL_GET_EDITABLE)) } +}; + +STATIC MP_DEFINE_CONST_DICT(LV_SIGNAL_locals_dict, LV_SIGNAL_locals_dict_table); + +STATIC void LV_SIGNAL_print(const mp_print_t *print, + mp_obj_t self_in, + mp_print_kind_t kind) +{ + mp_printf(print, "lvgl LV_SIGNAL"); +} + + + +STATIC const mp_obj_type_t mp_LV_SIGNAL_type = { + { &mp_type_type }, + .name = MP_QSTR_LV_SIGNAL, + .print = LV_SIGNAL_print, + + .locals_dict = (mp_obj_dict_t*)&LV_SIGNAL_locals_dict, +}; + + +/* + * lvgl LV_ALIGN object definitions + */ + + +STATIC const mp_rom_map_elem_t LV_ALIGN_locals_dict_table[] = { + { MP_ROM_QSTR(MP_QSTR_CENTER), MP_ROM_PTR(MP_ROM_INT(LV_ALIGN_CENTER)) }, + { MP_ROM_QSTR(MP_QSTR_IN_TOP_LEFT), MP_ROM_PTR(MP_ROM_INT(LV_ALIGN_IN_TOP_LEFT)) }, + { MP_ROM_QSTR(MP_QSTR_IN_TOP_MID), MP_ROM_PTR(MP_ROM_INT(LV_ALIGN_IN_TOP_MID)) }, + { MP_ROM_QSTR(MP_QSTR_IN_TOP_RIGHT), MP_ROM_PTR(MP_ROM_INT(LV_ALIGN_IN_TOP_RIGHT)) }, + { MP_ROM_QSTR(MP_QSTR_IN_BOTTOM_LEFT), MP_ROM_PTR(MP_ROM_INT(LV_ALIGN_IN_BOTTOM_LEFT)) }, + { MP_ROM_QSTR(MP_QSTR_IN_BOTTOM_MID), MP_ROM_PTR(MP_ROM_INT(LV_ALIGN_IN_BOTTOM_MID)) }, + { MP_ROM_QSTR(MP_QSTR_IN_BOTTOM_RIGHT), MP_ROM_PTR(MP_ROM_INT(LV_ALIGN_IN_BOTTOM_RIGHT)) }, + { MP_ROM_QSTR(MP_QSTR_IN_LEFT_MID), MP_ROM_PTR(MP_ROM_INT(LV_ALIGN_IN_LEFT_MID)) }, + { MP_ROM_QSTR(MP_QSTR_IN_RIGHT_MID), MP_ROM_PTR(MP_ROM_INT(LV_ALIGN_IN_RIGHT_MID)) }, + { MP_ROM_QSTR(MP_QSTR_OUT_TOP_LEFT), MP_ROM_PTR(MP_ROM_INT(LV_ALIGN_OUT_TOP_LEFT)) }, + { MP_ROM_QSTR(MP_QSTR_OUT_TOP_MID), MP_ROM_PTR(MP_ROM_INT(LV_ALIGN_OUT_TOP_MID)) }, + { MP_ROM_QSTR(MP_QSTR_OUT_TOP_RIGHT), MP_ROM_PTR(MP_ROM_INT(LV_ALIGN_OUT_TOP_RIGHT)) }, + { MP_ROM_QSTR(MP_QSTR_OUT_BOTTOM_LEFT), MP_ROM_PTR(MP_ROM_INT(LV_ALIGN_OUT_BOTTOM_LEFT)) }, + { MP_ROM_QSTR(MP_QSTR_OUT_BOTTOM_MID), MP_ROM_PTR(MP_ROM_INT(LV_ALIGN_OUT_BOTTOM_MID)) }, + { MP_ROM_QSTR(MP_QSTR_OUT_BOTTOM_RIGHT), MP_ROM_PTR(MP_ROM_INT(LV_ALIGN_OUT_BOTTOM_RIGHT)) }, + { MP_ROM_QSTR(MP_QSTR_OUT_LEFT_TOP), MP_ROM_PTR(MP_ROM_INT(LV_ALIGN_OUT_LEFT_TOP)) }, + { MP_ROM_QSTR(MP_QSTR_OUT_LEFT_MID), MP_ROM_PTR(MP_ROM_INT(LV_ALIGN_OUT_LEFT_MID)) }, + { MP_ROM_QSTR(MP_QSTR_OUT_LEFT_BOTTOM), MP_ROM_PTR(MP_ROM_INT(LV_ALIGN_OUT_LEFT_BOTTOM)) }, + { MP_ROM_QSTR(MP_QSTR_OUT_RIGHT_TOP), MP_ROM_PTR(MP_ROM_INT(LV_ALIGN_OUT_RIGHT_TOP)) }, + { MP_ROM_QSTR(MP_QSTR_OUT_RIGHT_MID), MP_ROM_PTR(MP_ROM_INT(LV_ALIGN_OUT_RIGHT_MID)) }, + { MP_ROM_QSTR(MP_QSTR_OUT_RIGHT_BOTTOM), MP_ROM_PTR(MP_ROM_INT(LV_ALIGN_OUT_RIGHT_BOTTOM)) } +}; + +STATIC MP_DEFINE_CONST_DICT(LV_ALIGN_locals_dict, LV_ALIGN_locals_dict_table); + +STATIC void LV_ALIGN_print(const mp_print_t *print, + mp_obj_t self_in, + mp_print_kind_t kind) +{ + mp_printf(print, "lvgl LV_ALIGN"); +} + + + +STATIC const mp_obj_type_t mp_LV_ALIGN_type = { + { &mp_type_type }, + .name = MP_QSTR_LV_ALIGN, + .print = LV_ALIGN_print, + + .locals_dict = (mp_obj_dict_t*)&LV_ALIGN_locals_dict, +}; + + +/* + * lvgl LV_PROTECT object definitions + */ + + +STATIC const mp_rom_map_elem_t LV_PROTECT_locals_dict_table[] = { + { MP_ROM_QSTR(MP_QSTR_NONE), MP_ROM_PTR(MP_ROM_INT(LV_PROTECT_NONE)) }, + { MP_ROM_QSTR(MP_QSTR_CHILD_CHG), MP_ROM_PTR(MP_ROM_INT(LV_PROTECT_CHILD_CHG)) }, + { MP_ROM_QSTR(MP_QSTR_PARENT), MP_ROM_PTR(MP_ROM_INT(LV_PROTECT_PARENT)) }, + { MP_ROM_QSTR(MP_QSTR_POS), MP_ROM_PTR(MP_ROM_INT(LV_PROTECT_POS)) }, + { MP_ROM_QSTR(MP_QSTR_FOLLOW), MP_ROM_PTR(MP_ROM_INT(LV_PROTECT_FOLLOW)) }, + { MP_ROM_QSTR(MP_QSTR_PRESS_LOST), MP_ROM_PTR(MP_ROM_INT(LV_PROTECT_PRESS_LOST)) }, + { MP_ROM_QSTR(MP_QSTR_CLICK_FOCUS), MP_ROM_PTR(MP_ROM_INT(LV_PROTECT_CLICK_FOCUS)) } +}; + +STATIC MP_DEFINE_CONST_DICT(LV_PROTECT_locals_dict, LV_PROTECT_locals_dict_table); + +STATIC void LV_PROTECT_print(const mp_print_t *print, + mp_obj_t self_in, + mp_print_kind_t kind) +{ + mp_printf(print, "lvgl LV_PROTECT"); +} + + + +STATIC const mp_obj_type_t mp_LV_PROTECT_type = { + { &mp_type_type }, + .name = MP_QSTR_LV_PROTECT, + .print = LV_PROTECT_print, + + .locals_dict = (mp_obj_dict_t*)&LV_PROTECT_locals_dict, +}; + + +/* + * lvgl LV_ANIM object definitions + */ + + +STATIC const mp_rom_map_elem_t LV_ANIM_locals_dict_table[] = { + { MP_ROM_QSTR(MP_QSTR_NONE), MP_ROM_PTR(MP_ROM_INT(LV_ANIM_NONE)) }, + { MP_ROM_QSTR(MP_QSTR_FLOAT_TOP), MP_ROM_PTR(MP_ROM_INT(LV_ANIM_FLOAT_TOP)) }, + { MP_ROM_QSTR(MP_QSTR_FLOAT_LEFT), MP_ROM_PTR(MP_ROM_INT(LV_ANIM_FLOAT_LEFT)) }, + { MP_ROM_QSTR(MP_QSTR_FLOAT_BOTTOM), MP_ROM_PTR(MP_ROM_INT(LV_ANIM_FLOAT_BOTTOM)) }, + { MP_ROM_QSTR(MP_QSTR_FLOAT_RIGHT), MP_ROM_PTR(MP_ROM_INT(LV_ANIM_FLOAT_RIGHT)) }, + { MP_ROM_QSTR(MP_QSTR_GROW_H), MP_ROM_PTR(MP_ROM_INT(LV_ANIM_GROW_H)) }, + { MP_ROM_QSTR(MP_QSTR_GROW_V), MP_ROM_PTR(MP_ROM_INT(LV_ANIM_GROW_V)) } +}; + +STATIC MP_DEFINE_CONST_DICT(LV_ANIM_locals_dict, LV_ANIM_locals_dict_table); + +STATIC void LV_ANIM_print(const mp_print_t *print, + mp_obj_t self_in, + mp_print_kind_t kind) +{ + mp_printf(print, "lvgl LV_ANIM"); +} + + + +STATIC const mp_obj_type_t mp_LV_ANIM_type = { + { &mp_type_type }, + .name = MP_QSTR_LV_ANIM, + .print = LV_ANIM_print, + + .locals_dict = (mp_obj_dict_t*)&LV_ANIM_locals_dict, +}; + + +/* + * lvgl LV_INDEV_TYPE object definitions + */ + + +STATIC const mp_rom_map_elem_t LV_INDEV_TYPE_locals_dict_table[] = { + { MP_ROM_QSTR(MP_QSTR_NONE), MP_ROM_PTR(MP_ROM_INT(LV_INDEV_TYPE_NONE)) }, + { MP_ROM_QSTR(MP_QSTR_POINTER), MP_ROM_PTR(MP_ROM_INT(LV_INDEV_TYPE_POINTER)) }, + { MP_ROM_QSTR(MP_QSTR_KEYPAD), MP_ROM_PTR(MP_ROM_INT(LV_INDEV_TYPE_KEYPAD)) }, + { MP_ROM_QSTR(MP_QSTR_BUTTON), MP_ROM_PTR(MP_ROM_INT(LV_INDEV_TYPE_BUTTON)) }, + { MP_ROM_QSTR(MP_QSTR_ENCODER), MP_ROM_PTR(MP_ROM_INT(LV_INDEV_TYPE_ENCODER)) } +}; + +STATIC MP_DEFINE_CONST_DICT(LV_INDEV_TYPE_locals_dict, LV_INDEV_TYPE_locals_dict_table); + +STATIC void LV_INDEV_TYPE_print(const mp_print_t *print, + mp_obj_t self_in, + mp_print_kind_t kind) +{ + mp_printf(print, "lvgl LV_INDEV_TYPE"); +} + + + +STATIC const mp_obj_type_t mp_LV_INDEV_TYPE_type = { + { &mp_type_type }, + .name = MP_QSTR_LV_INDEV_TYPE, + .print = LV_INDEV_TYPE_print, + + .locals_dict = (mp_obj_dict_t*)&LV_INDEV_TYPE_locals_dict, +}; + + +/* + * lvgl LV_INDEV_STATE object definitions + */ + + +STATIC const mp_rom_map_elem_t LV_INDEV_STATE_locals_dict_table[] = { + { MP_ROM_QSTR(MP_QSTR_REL), MP_ROM_PTR(MP_ROM_INT(LV_INDEV_STATE_REL)) }, + { MP_ROM_QSTR(MP_QSTR_PR), MP_ROM_PTR(MP_ROM_INT(LV_INDEV_STATE_PR)) } +}; + +STATIC MP_DEFINE_CONST_DICT(LV_INDEV_STATE_locals_dict, LV_INDEV_STATE_locals_dict_table); + +STATIC void LV_INDEV_STATE_print(const mp_print_t *print, + mp_obj_t self_in, + mp_print_kind_t kind) +{ + mp_printf(print, "lvgl LV_INDEV_STATE"); +} + + + +STATIC const mp_obj_type_t mp_LV_INDEV_STATE_type = { + { &mp_type_type }, + .name = MP_QSTR_LV_INDEV_STATE, + .print = LV_INDEV_STATE_print, + + .locals_dict = (mp_obj_dict_t*)&LV_INDEV_STATE_locals_dict, +}; + + +/* + * lvgl LV_LAYOUT object definitions + */ + + +STATIC const mp_rom_map_elem_t LV_LAYOUT_locals_dict_table[] = { + { MP_ROM_QSTR(MP_QSTR_OFF), MP_ROM_PTR(MP_ROM_INT(LV_LAYOUT_OFF)) }, + { MP_ROM_QSTR(MP_QSTR_CENTER), MP_ROM_PTR(MP_ROM_INT(LV_LAYOUT_CENTER)) }, + { MP_ROM_QSTR(MP_QSTR_COL_L), MP_ROM_PTR(MP_ROM_INT(LV_LAYOUT_COL_L)) }, + { MP_ROM_QSTR(MP_QSTR_COL_M), MP_ROM_PTR(MP_ROM_INT(LV_LAYOUT_COL_M)) }, + { MP_ROM_QSTR(MP_QSTR_COL_R), MP_ROM_PTR(MP_ROM_INT(LV_LAYOUT_COL_R)) }, + { MP_ROM_QSTR(MP_QSTR_ROW_T), MP_ROM_PTR(MP_ROM_INT(LV_LAYOUT_ROW_T)) }, + { MP_ROM_QSTR(MP_QSTR_ROW_M), MP_ROM_PTR(MP_ROM_INT(LV_LAYOUT_ROW_M)) }, + { MP_ROM_QSTR(MP_QSTR_ROW_B), MP_ROM_PTR(MP_ROM_INT(LV_LAYOUT_ROW_B)) }, + { MP_ROM_QSTR(MP_QSTR_PRETTY), MP_ROM_PTR(MP_ROM_INT(LV_LAYOUT_PRETTY)) }, + { MP_ROM_QSTR(MP_QSTR_GRID), MP_ROM_PTR(MP_ROM_INT(LV_LAYOUT_GRID)) } +}; + +STATIC MP_DEFINE_CONST_DICT(LV_LAYOUT_locals_dict, LV_LAYOUT_locals_dict_table); + +STATIC void LV_LAYOUT_print(const mp_print_t *print, + mp_obj_t self_in, + mp_print_kind_t kind) +{ + mp_printf(print, "lvgl LV_LAYOUT"); +} + + + +STATIC const mp_obj_type_t mp_LV_LAYOUT_type = { + { &mp_type_type }, + .name = MP_QSTR_LV_LAYOUT, + .print = LV_LAYOUT_print, + + .locals_dict = (mp_obj_dict_t*)&LV_LAYOUT_locals_dict, +}; + + +/* + * lvgl LV_BTN_STATE object definitions + */ + + +STATIC const mp_rom_map_elem_t LV_BTN_STATE_locals_dict_table[] = { + { MP_ROM_QSTR(MP_QSTR_REL), MP_ROM_PTR(MP_ROM_INT(LV_BTN_STATE_REL)) }, + { MP_ROM_QSTR(MP_QSTR_PR), MP_ROM_PTR(MP_ROM_INT(LV_BTN_STATE_PR)) }, + { MP_ROM_QSTR(MP_QSTR_TGL_REL), MP_ROM_PTR(MP_ROM_INT(LV_BTN_STATE_TGL_REL)) }, + { MP_ROM_QSTR(MP_QSTR_TGL_PR), MP_ROM_PTR(MP_ROM_INT(LV_BTN_STATE_TGL_PR)) }, + { MP_ROM_QSTR(MP_QSTR_INA), MP_ROM_PTR(MP_ROM_INT(LV_BTN_STATE_INA)) }, + { MP_ROM_QSTR(MP_QSTR_NUM), MP_ROM_PTR(MP_ROM_INT(LV_BTN_STATE_NUM)) } +}; + +STATIC MP_DEFINE_CONST_DICT(LV_BTN_STATE_locals_dict, LV_BTN_STATE_locals_dict_table); + +STATIC void LV_BTN_STATE_print(const mp_print_t *print, + mp_obj_t self_in, + mp_print_kind_t kind) +{ + mp_printf(print, "lvgl LV_BTN_STATE"); +} + + + +STATIC const mp_obj_type_t mp_LV_BTN_STATE_type = { + { &mp_type_type }, + .name = MP_QSTR_LV_BTN_STATE, + .print = LV_BTN_STATE_print, + + .locals_dict = (mp_obj_dict_t*)&LV_BTN_STATE_locals_dict, +}; + + +/* + * lvgl LV_BTN_ACTION object definitions + */ + + +STATIC const mp_rom_map_elem_t LV_BTN_ACTION_locals_dict_table[] = { + { MP_ROM_QSTR(MP_QSTR_CLICK), MP_ROM_PTR(MP_ROM_INT(LV_BTN_ACTION_CLICK)) }, + { MP_ROM_QSTR(MP_QSTR_PR), MP_ROM_PTR(MP_ROM_INT(LV_BTN_ACTION_PR)) }, + { MP_ROM_QSTR(MP_QSTR_LONG_PR), MP_ROM_PTR(MP_ROM_INT(LV_BTN_ACTION_LONG_PR)) }, + { MP_ROM_QSTR(MP_QSTR_LONG_PR_REPEAT), MP_ROM_PTR(MP_ROM_INT(LV_BTN_ACTION_LONG_PR_REPEAT)) }, + { MP_ROM_QSTR(MP_QSTR_NUM), MP_ROM_PTR(MP_ROM_INT(LV_BTN_ACTION_NUM)) } +}; + +STATIC MP_DEFINE_CONST_DICT(LV_BTN_ACTION_locals_dict, LV_BTN_ACTION_locals_dict_table); + +STATIC void LV_BTN_ACTION_print(const mp_print_t *print, + mp_obj_t self_in, + mp_print_kind_t kind) +{ + mp_printf(print, "lvgl LV_BTN_ACTION"); +} + + + +STATIC const mp_obj_type_t mp_LV_BTN_ACTION_type = { + { &mp_type_type }, + .name = MP_QSTR_LV_BTN_ACTION, + .print = LV_BTN_ACTION_print, + + .locals_dict = (mp_obj_dict_t*)&LV_BTN_ACTION_locals_dict, +}; + + +/* + * lvgl LV_BTN_STYLE object definitions + */ + + +STATIC const mp_rom_map_elem_t LV_BTN_STYLE_locals_dict_table[] = { + { MP_ROM_QSTR(MP_QSTR_REL), MP_ROM_PTR(MP_ROM_INT(LV_BTN_STYLE_REL)) }, + { MP_ROM_QSTR(MP_QSTR_PR), MP_ROM_PTR(MP_ROM_INT(LV_BTN_STYLE_PR)) }, + { MP_ROM_QSTR(MP_QSTR_TGL_REL), MP_ROM_PTR(MP_ROM_INT(LV_BTN_STYLE_TGL_REL)) }, + { MP_ROM_QSTR(MP_QSTR_TGL_PR), MP_ROM_PTR(MP_ROM_INT(LV_BTN_STYLE_TGL_PR)) }, + { MP_ROM_QSTR(MP_QSTR_INA), MP_ROM_PTR(MP_ROM_INT(LV_BTN_STYLE_INA)) } +}; + +STATIC MP_DEFINE_CONST_DICT(LV_BTN_STYLE_locals_dict, LV_BTN_STYLE_locals_dict_table); + +STATIC void LV_BTN_STYLE_print(const mp_print_t *print, + mp_obj_t self_in, + mp_print_kind_t kind) +{ + mp_printf(print, "lvgl LV_BTN_STYLE"); +} + + + +STATIC const mp_obj_type_t mp_LV_BTN_STYLE_type = { + { &mp_type_type }, + .name = MP_QSTR_LV_BTN_STYLE, + .print = LV_BTN_STYLE_print, + + .locals_dict = (mp_obj_dict_t*)&LV_BTN_STYLE_locals_dict, +}; + + +/* + * lvgl LV_TXT_FLAG object definitions + */ + + +STATIC const mp_rom_map_elem_t LV_TXT_FLAG_locals_dict_table[] = { + { MP_ROM_QSTR(MP_QSTR_NONE), MP_ROM_PTR(MP_ROM_INT(LV_TXT_FLAG_NONE)) }, + { MP_ROM_QSTR(MP_QSTR_RECOLOR), MP_ROM_PTR(MP_ROM_INT(LV_TXT_FLAG_RECOLOR)) }, + { MP_ROM_QSTR(MP_QSTR_EXPAND), MP_ROM_PTR(MP_ROM_INT(LV_TXT_FLAG_EXPAND)) }, + { MP_ROM_QSTR(MP_QSTR_CENTER), MP_ROM_PTR(MP_ROM_INT(LV_TXT_FLAG_CENTER)) }, + { MP_ROM_QSTR(MP_QSTR_RIGHT), MP_ROM_PTR(MP_ROM_INT(LV_TXT_FLAG_RIGHT)) } +}; + +STATIC MP_DEFINE_CONST_DICT(LV_TXT_FLAG_locals_dict, LV_TXT_FLAG_locals_dict_table); + +STATIC void LV_TXT_FLAG_print(const mp_print_t *print, + mp_obj_t self_in, + mp_print_kind_t kind) +{ + mp_printf(print, "lvgl LV_TXT_FLAG"); +} + + + +STATIC const mp_obj_type_t mp_LV_TXT_FLAG_type = { + { &mp_type_type }, + .name = MP_QSTR_LV_TXT_FLAG, + .print = LV_TXT_FLAG_print, + + .locals_dict = (mp_obj_dict_t*)&LV_TXT_FLAG_locals_dict, +}; + + +/* + * lvgl LV_TXT_CMD_STATE object definitions + */ + + +STATIC const mp_rom_map_elem_t LV_TXT_CMD_STATE_locals_dict_table[] = { + { MP_ROM_QSTR(MP_QSTR_WAIT), MP_ROM_PTR(MP_ROM_INT(LV_TXT_CMD_STATE_WAIT)) }, + { MP_ROM_QSTR(MP_QSTR_PAR), MP_ROM_PTR(MP_ROM_INT(LV_TXT_CMD_STATE_PAR)) }, + { MP_ROM_QSTR(MP_QSTR_IN), MP_ROM_PTR(MP_ROM_INT(LV_TXT_CMD_STATE_IN)) } +}; + +STATIC MP_DEFINE_CONST_DICT(LV_TXT_CMD_STATE_locals_dict, LV_TXT_CMD_STATE_locals_dict_table); + +STATIC void LV_TXT_CMD_STATE_print(const mp_print_t *print, + mp_obj_t self_in, + mp_print_kind_t kind) +{ + mp_printf(print, "lvgl LV_TXT_CMD_STATE"); +} + + + +STATIC const mp_obj_type_t mp_LV_TXT_CMD_STATE_type = { + { &mp_type_type }, + .name = MP_QSTR_LV_TXT_CMD_STATE, + .print = LV_TXT_CMD_STATE_print, + + .locals_dict = (mp_obj_dict_t*)&LV_TXT_CMD_STATE_locals_dict, +}; + + +/* + * lvgl LV_IMG_SRC object definitions + */ + + +STATIC const mp_rom_map_elem_t LV_IMG_SRC_locals_dict_table[] = { + { MP_ROM_QSTR(MP_QSTR_VARIABLE), MP_ROM_PTR(MP_ROM_INT(LV_IMG_SRC_VARIABLE)) }, + { MP_ROM_QSTR(MP_QSTR_FILE), MP_ROM_PTR(MP_ROM_INT(LV_IMG_SRC_FILE)) }, + { MP_ROM_QSTR(MP_QSTR_SYMBOL), MP_ROM_PTR(MP_ROM_INT(LV_IMG_SRC_SYMBOL)) }, + { MP_ROM_QSTR(MP_QSTR_UNKNOWN), MP_ROM_PTR(MP_ROM_INT(LV_IMG_SRC_UNKNOWN)) } +}; + +STATIC MP_DEFINE_CONST_DICT(LV_IMG_SRC_locals_dict, LV_IMG_SRC_locals_dict_table); + +STATIC void LV_IMG_SRC_print(const mp_print_t *print, + mp_obj_t self_in, + mp_print_kind_t kind) +{ + mp_printf(print, "lvgl LV_IMG_SRC"); +} + + + +STATIC const mp_obj_type_t mp_LV_IMG_SRC_type = { + { &mp_type_type }, + .name = MP_QSTR_LV_IMG_SRC, + .print = LV_IMG_SRC_print, + + .locals_dict = (mp_obj_dict_t*)&LV_IMG_SRC_locals_dict, +}; + + +/* + * lvgl LV_IMG_CF object definitions + */ + + +STATIC const mp_rom_map_elem_t LV_IMG_CF_locals_dict_table[] = { + { MP_ROM_QSTR(MP_QSTR_UNKOWN), MP_ROM_PTR(MP_ROM_INT(LV_IMG_CF_UNKOWN)) }, + { MP_ROM_QSTR(MP_QSTR_RAW), MP_ROM_PTR(MP_ROM_INT(LV_IMG_CF_RAW)) }, + { MP_ROM_QSTR(MP_QSTR_RAW_ALPHA), MP_ROM_PTR(MP_ROM_INT(LV_IMG_CF_RAW_ALPHA)) }, + { MP_ROM_QSTR(MP_QSTR_RAW_CHROMA_KEYED), MP_ROM_PTR(MP_ROM_INT(LV_IMG_CF_RAW_CHROMA_KEYED)) }, + { MP_ROM_QSTR(MP_QSTR_TRUE_COLOR), MP_ROM_PTR(MP_ROM_INT(LV_IMG_CF_TRUE_COLOR)) }, + { MP_ROM_QSTR(MP_QSTR_TRUE_COLOR_ALPHA), MP_ROM_PTR(MP_ROM_INT(LV_IMG_CF_TRUE_COLOR_ALPHA)) }, + { MP_ROM_QSTR(MP_QSTR_TRUE_COLOR_CHROMA_KEYED), MP_ROM_PTR(MP_ROM_INT(LV_IMG_CF_TRUE_COLOR_CHROMA_KEYED)) }, + { MP_ROM_QSTR(MP_QSTR_INDEXED_1BIT), MP_ROM_PTR(MP_ROM_INT(LV_IMG_CF_INDEXED_1BIT)) }, + { MP_ROM_QSTR(MP_QSTR_INDEXED_2BIT), MP_ROM_PTR(MP_ROM_INT(LV_IMG_CF_INDEXED_2BIT)) }, + { MP_ROM_QSTR(MP_QSTR_INDEXED_4BIT), MP_ROM_PTR(MP_ROM_INT(LV_IMG_CF_INDEXED_4BIT)) }, + { MP_ROM_QSTR(MP_QSTR_INDEXED_8BIT), MP_ROM_PTR(MP_ROM_INT(LV_IMG_CF_INDEXED_8BIT)) }, + { MP_ROM_QSTR(MP_QSTR_ALPHA_1BIT), MP_ROM_PTR(MP_ROM_INT(LV_IMG_CF_ALPHA_1BIT)) }, + { MP_ROM_QSTR(MP_QSTR_ALPHA_2BIT), MP_ROM_PTR(MP_ROM_INT(LV_IMG_CF_ALPHA_2BIT)) }, + { MP_ROM_QSTR(MP_QSTR_ALPHA_4BIT), MP_ROM_PTR(MP_ROM_INT(LV_IMG_CF_ALPHA_4BIT)) }, + { MP_ROM_QSTR(MP_QSTR_ALPHA_8BIT), MP_ROM_PTR(MP_ROM_INT(LV_IMG_CF_ALPHA_8BIT)) } +}; + +STATIC MP_DEFINE_CONST_DICT(LV_IMG_CF_locals_dict, LV_IMG_CF_locals_dict_table); + +STATIC void LV_IMG_CF_print(const mp_print_t *print, + mp_obj_t self_in, + mp_print_kind_t kind) +{ + mp_printf(print, "lvgl LV_IMG_CF"); +} + + + +STATIC const mp_obj_type_t mp_LV_IMG_CF_type = { + { &mp_type_type }, + .name = MP_QSTR_LV_IMG_CF, + .print = LV_IMG_CF_print, + + .locals_dict = (mp_obj_dict_t*)&LV_IMG_CF_locals_dict, +}; + + +/* + * lvgl LV_IMGBTN_STYLE object definitions + */ + + +STATIC const mp_rom_map_elem_t LV_IMGBTN_STYLE_locals_dict_table[] = { + { MP_ROM_QSTR(MP_QSTR_REL), MP_ROM_PTR(MP_ROM_INT(LV_IMGBTN_STYLE_REL)) }, + { MP_ROM_QSTR(MP_QSTR_PR), MP_ROM_PTR(MP_ROM_INT(LV_IMGBTN_STYLE_PR)) }, + { MP_ROM_QSTR(MP_QSTR_TGL_REL), MP_ROM_PTR(MP_ROM_INT(LV_IMGBTN_STYLE_TGL_REL)) }, + { MP_ROM_QSTR(MP_QSTR_TGL_PR), MP_ROM_PTR(MP_ROM_INT(LV_IMGBTN_STYLE_TGL_PR)) }, + { MP_ROM_QSTR(MP_QSTR_INA), MP_ROM_PTR(MP_ROM_INT(LV_IMGBTN_STYLE_INA)) } +}; + +STATIC MP_DEFINE_CONST_DICT(LV_IMGBTN_STYLE_locals_dict, LV_IMGBTN_STYLE_locals_dict_table); + +STATIC void LV_IMGBTN_STYLE_print(const mp_print_t *print, + mp_obj_t self_in, + mp_print_kind_t kind) +{ + mp_printf(print, "lvgl LV_IMGBTN_STYLE"); +} + + + +STATIC const mp_obj_type_t mp_LV_IMGBTN_STYLE_type = { + { &mp_type_type }, + .name = MP_QSTR_LV_IMGBTN_STYLE, + .print = LV_IMGBTN_STYLE_print, + + .locals_dict = (mp_obj_dict_t*)&LV_IMGBTN_STYLE_locals_dict, +}; + + +/* + * lvgl LV_LABEL_LONG object definitions + */ + + +STATIC const mp_rom_map_elem_t LV_LABEL_LONG_locals_dict_table[] = { + { MP_ROM_QSTR(MP_QSTR_EXPAND), MP_ROM_PTR(MP_ROM_INT(LV_LABEL_LONG_EXPAND)) }, + { MP_ROM_QSTR(MP_QSTR_BREAK), MP_ROM_PTR(MP_ROM_INT(LV_LABEL_LONG_BREAK)) }, + { MP_ROM_QSTR(MP_QSTR_SCROLL), MP_ROM_PTR(MP_ROM_INT(LV_LABEL_LONG_SCROLL)) }, + { MP_ROM_QSTR(MP_QSTR_DOT), MP_ROM_PTR(MP_ROM_INT(LV_LABEL_LONG_DOT)) }, + { MP_ROM_QSTR(MP_QSTR_ROLL), MP_ROM_PTR(MP_ROM_INT(LV_LABEL_LONG_ROLL)) }, + { MP_ROM_QSTR(MP_QSTR_CROP), MP_ROM_PTR(MP_ROM_INT(LV_LABEL_LONG_CROP)) } +}; + +STATIC MP_DEFINE_CONST_DICT(LV_LABEL_LONG_locals_dict, LV_LABEL_LONG_locals_dict_table); + +STATIC void LV_LABEL_LONG_print(const mp_print_t *print, + mp_obj_t self_in, + mp_print_kind_t kind) +{ + mp_printf(print, "lvgl LV_LABEL_LONG"); +} + + + +STATIC const mp_obj_type_t mp_LV_LABEL_LONG_type = { + { &mp_type_type }, + .name = MP_QSTR_LV_LABEL_LONG, + .print = LV_LABEL_LONG_print, + + .locals_dict = (mp_obj_dict_t*)&LV_LABEL_LONG_locals_dict, +}; + + +/* + * lvgl LV_LABEL_ALIGN object definitions + */ + + +STATIC const mp_rom_map_elem_t LV_LABEL_ALIGN_locals_dict_table[] = { + { MP_ROM_QSTR(MP_QSTR_LEFT), MP_ROM_PTR(MP_ROM_INT(LV_LABEL_ALIGN_LEFT)) }, + { MP_ROM_QSTR(MP_QSTR_CENTER), MP_ROM_PTR(MP_ROM_INT(LV_LABEL_ALIGN_CENTER)) }, + { MP_ROM_QSTR(MP_QSTR_RIGHT), MP_ROM_PTR(MP_ROM_INT(LV_LABEL_ALIGN_RIGHT)) } +}; + +STATIC MP_DEFINE_CONST_DICT(LV_LABEL_ALIGN_locals_dict, LV_LABEL_ALIGN_locals_dict_table); + +STATIC void LV_LABEL_ALIGN_print(const mp_print_t *print, + mp_obj_t self_in, + mp_print_kind_t kind) +{ + mp_printf(print, "lvgl LV_LABEL_ALIGN"); +} + + + +STATIC const mp_obj_type_t mp_LV_LABEL_ALIGN_type = { + { &mp_type_type }, + .name = MP_QSTR_LV_LABEL_ALIGN, + .print = LV_LABEL_ALIGN_print, + + .locals_dict = (mp_obj_dict_t*)&LV_LABEL_ALIGN_locals_dict, +}; + + +/* + * lvgl LV_SB_MODE object definitions + */ + + +STATIC const mp_rom_map_elem_t LV_SB_MODE_locals_dict_table[] = { + { MP_ROM_QSTR(MP_QSTR_OFF), MP_ROM_PTR(MP_ROM_INT(LV_SB_MODE_OFF)) }, + { MP_ROM_QSTR(MP_QSTR_ON), MP_ROM_PTR(MP_ROM_INT(LV_SB_MODE_ON)) }, + { MP_ROM_QSTR(MP_QSTR_DRAG), MP_ROM_PTR(MP_ROM_INT(LV_SB_MODE_DRAG)) }, + { MP_ROM_QSTR(MP_QSTR_AUTO), MP_ROM_PTR(MP_ROM_INT(LV_SB_MODE_AUTO)) }, + { MP_ROM_QSTR(MP_QSTR_HIDE), MP_ROM_PTR(MP_ROM_INT(LV_SB_MODE_HIDE)) }, + { MP_ROM_QSTR(MP_QSTR_UNHIDE), MP_ROM_PTR(MP_ROM_INT(LV_SB_MODE_UNHIDE)) } +}; + +STATIC MP_DEFINE_CONST_DICT(LV_SB_MODE_locals_dict, LV_SB_MODE_locals_dict_table); + +STATIC void LV_SB_MODE_print(const mp_print_t *print, + mp_obj_t self_in, + mp_print_kind_t kind) +{ + mp_printf(print, "lvgl LV_SB_MODE"); +} + + + +STATIC const mp_obj_type_t mp_LV_SB_MODE_type = { + { &mp_type_type }, + .name = MP_QSTR_LV_SB_MODE, + .print = LV_SB_MODE_print, + + .locals_dict = (mp_obj_dict_t*)&LV_SB_MODE_locals_dict, +}; + + +/* + * lvgl LV_PAGE_STYLE object definitions + */ + + +STATIC const mp_rom_map_elem_t LV_PAGE_STYLE_locals_dict_table[] = { + { MP_ROM_QSTR(MP_QSTR_BG), MP_ROM_PTR(MP_ROM_INT(LV_PAGE_STYLE_BG)) }, + { MP_ROM_QSTR(MP_QSTR_SCRL), MP_ROM_PTR(MP_ROM_INT(LV_PAGE_STYLE_SCRL)) }, + { MP_ROM_QSTR(MP_QSTR_SB), MP_ROM_PTR(MP_ROM_INT(LV_PAGE_STYLE_SB)) }, + { MP_ROM_QSTR(MP_QSTR_EDGE_FLASH), MP_ROM_PTR(MP_ROM_INT(LV_PAGE_STYLE_EDGE_FLASH)) } +}; + +STATIC MP_DEFINE_CONST_DICT(LV_PAGE_STYLE_locals_dict, LV_PAGE_STYLE_locals_dict_table); + +STATIC void LV_PAGE_STYLE_print(const mp_print_t *print, + mp_obj_t self_in, + mp_print_kind_t kind) +{ + mp_printf(print, "lvgl LV_PAGE_STYLE"); +} + + + +STATIC const mp_obj_type_t mp_LV_PAGE_STYLE_type = { + { &mp_type_type }, + .name = MP_QSTR_LV_PAGE_STYLE, + .print = LV_PAGE_STYLE_print, + + .locals_dict = (mp_obj_dict_t*)&LV_PAGE_STYLE_locals_dict, +}; + + +/* + * lvgl LV_LIST_STYLE object definitions + */ + + +STATIC const mp_rom_map_elem_t LV_LIST_STYLE_locals_dict_table[] = { + { MP_ROM_QSTR(MP_QSTR_BG), MP_ROM_PTR(MP_ROM_INT(LV_LIST_STYLE_BG)) }, + { MP_ROM_QSTR(MP_QSTR_SCRL), MP_ROM_PTR(MP_ROM_INT(LV_LIST_STYLE_SCRL)) }, + { MP_ROM_QSTR(MP_QSTR_SB), MP_ROM_PTR(MP_ROM_INT(LV_LIST_STYLE_SB)) }, + { MP_ROM_QSTR(MP_QSTR_EDGE_FLASH), MP_ROM_PTR(MP_ROM_INT(LV_LIST_STYLE_EDGE_FLASH)) }, + { MP_ROM_QSTR(MP_QSTR_BTN_REL), MP_ROM_PTR(MP_ROM_INT(LV_LIST_STYLE_BTN_REL)) }, + { MP_ROM_QSTR(MP_QSTR_BTN_PR), MP_ROM_PTR(MP_ROM_INT(LV_LIST_STYLE_BTN_PR)) }, + { MP_ROM_QSTR(MP_QSTR_BTN_TGL_REL), MP_ROM_PTR(MP_ROM_INT(LV_LIST_STYLE_BTN_TGL_REL)) }, + { MP_ROM_QSTR(MP_QSTR_BTN_TGL_PR), MP_ROM_PTR(MP_ROM_INT(LV_LIST_STYLE_BTN_TGL_PR)) }, + { MP_ROM_QSTR(MP_QSTR_BTN_INA), MP_ROM_PTR(MP_ROM_INT(LV_LIST_STYLE_BTN_INA)) } +}; + +STATIC MP_DEFINE_CONST_DICT(LV_LIST_STYLE_locals_dict, LV_LIST_STYLE_locals_dict_table); + +STATIC void LV_LIST_STYLE_print(const mp_print_t *print, + mp_obj_t self_in, + mp_print_kind_t kind) +{ + mp_printf(print, "lvgl LV_LIST_STYLE"); +} + + + +STATIC const mp_obj_type_t mp_LV_LIST_STYLE_type = { + { &mp_type_type }, + .name = MP_QSTR_LV_LIST_STYLE, + .print = LV_LIST_STYLE_print, + + .locals_dict = (mp_obj_dict_t*)&LV_LIST_STYLE_locals_dict, +}; + + +/* + * lvgl LV_CHART_TYPE object definitions + */ + + +STATIC const mp_rom_map_elem_t LV_CHART_TYPE_locals_dict_table[] = { + { MP_ROM_QSTR(MP_QSTR_LINE), MP_ROM_PTR(MP_ROM_INT(LV_CHART_TYPE_LINE)) }, + { MP_ROM_QSTR(MP_QSTR_COLUMN), MP_ROM_PTR(MP_ROM_INT(LV_CHART_TYPE_COLUMN)) }, + { MP_ROM_QSTR(MP_QSTR_POINT), MP_ROM_PTR(MP_ROM_INT(LV_CHART_TYPE_POINT)) }, + { MP_ROM_QSTR(MP_QSTR_VERTICAL_LINE), MP_ROM_PTR(MP_ROM_INT(LV_CHART_TYPE_VERTICAL_LINE)) } +}; + +STATIC MP_DEFINE_CONST_DICT(LV_CHART_TYPE_locals_dict, LV_CHART_TYPE_locals_dict_table); + +STATIC void LV_CHART_TYPE_print(const mp_print_t *print, + mp_obj_t self_in, + mp_print_kind_t kind) +{ + mp_printf(print, "lvgl LV_CHART_TYPE"); +} + + + +STATIC const mp_obj_type_t mp_LV_CHART_TYPE_type = { + { &mp_type_type }, + .name = MP_QSTR_LV_CHART_TYPE, + .print = LV_CHART_TYPE_print, + + .locals_dict = (mp_obj_dict_t*)&LV_CHART_TYPE_locals_dict, +}; + + +/* + * lvgl LV_TABLE_STYLE object definitions + */ + + +STATIC const mp_rom_map_elem_t LV_TABLE_STYLE_locals_dict_table[] = { + { MP_ROM_QSTR(MP_QSTR_BG), MP_ROM_PTR(MP_ROM_INT(LV_TABLE_STYLE_BG)) }, + { MP_ROM_QSTR(MP_QSTR_CELL1), MP_ROM_PTR(MP_ROM_INT(LV_TABLE_STYLE_CELL1)) }, + { MP_ROM_QSTR(MP_QSTR_CELL2), MP_ROM_PTR(MP_ROM_INT(LV_TABLE_STYLE_CELL2)) }, + { MP_ROM_QSTR(MP_QSTR_CELL3), MP_ROM_PTR(MP_ROM_INT(LV_TABLE_STYLE_CELL3)) }, + { MP_ROM_QSTR(MP_QSTR_CELL4), MP_ROM_PTR(MP_ROM_INT(LV_TABLE_STYLE_CELL4)) } +}; + +STATIC MP_DEFINE_CONST_DICT(LV_TABLE_STYLE_locals_dict, LV_TABLE_STYLE_locals_dict_table); + +STATIC void LV_TABLE_STYLE_print(const mp_print_t *print, + mp_obj_t self_in, + mp_print_kind_t kind) +{ + mp_printf(print, "lvgl LV_TABLE_STYLE"); +} + + + +STATIC const mp_obj_type_t mp_LV_TABLE_STYLE_type = { + { &mp_type_type }, + .name = MP_QSTR_LV_TABLE_STYLE, + .print = LV_TABLE_STYLE_print, + + .locals_dict = (mp_obj_dict_t*)&LV_TABLE_STYLE_locals_dict, +}; + + +/* + * lvgl LV_CB_STYLE object definitions + */ + + +STATIC const mp_rom_map_elem_t LV_CB_STYLE_locals_dict_table[] = { + { MP_ROM_QSTR(MP_QSTR_BG), MP_ROM_PTR(MP_ROM_INT(LV_CB_STYLE_BG)) }, + { MP_ROM_QSTR(MP_QSTR_BOX_REL), MP_ROM_PTR(MP_ROM_INT(LV_CB_STYLE_BOX_REL)) }, + { MP_ROM_QSTR(MP_QSTR_BOX_PR), MP_ROM_PTR(MP_ROM_INT(LV_CB_STYLE_BOX_PR)) }, + { MP_ROM_QSTR(MP_QSTR_BOX_TGL_REL), MP_ROM_PTR(MP_ROM_INT(LV_CB_STYLE_BOX_TGL_REL)) }, + { MP_ROM_QSTR(MP_QSTR_BOX_TGL_PR), MP_ROM_PTR(MP_ROM_INT(LV_CB_STYLE_BOX_TGL_PR)) }, + { MP_ROM_QSTR(MP_QSTR_BOX_INA), MP_ROM_PTR(MP_ROM_INT(LV_CB_STYLE_BOX_INA)) } +}; + +STATIC MP_DEFINE_CONST_DICT(LV_CB_STYLE_locals_dict, LV_CB_STYLE_locals_dict_table); + +STATIC void LV_CB_STYLE_print(const mp_print_t *print, + mp_obj_t self_in, + mp_print_kind_t kind) +{ + mp_printf(print, "lvgl LV_CB_STYLE"); +} + + + +STATIC const mp_obj_type_t mp_LV_CB_STYLE_type = { + { &mp_type_type }, + .name = MP_QSTR_LV_CB_STYLE, + .print = LV_CB_STYLE_print, + + .locals_dict = (mp_obj_dict_t*)&LV_CB_STYLE_locals_dict, +}; + + +/* + * lvgl LV_BAR_STYLE object definitions + */ + + +STATIC const mp_rom_map_elem_t LV_BAR_STYLE_locals_dict_table[] = { + { MP_ROM_QSTR(MP_QSTR_BG), MP_ROM_PTR(MP_ROM_INT(LV_BAR_STYLE_BG)) }, + { MP_ROM_QSTR(MP_QSTR_INDIC), MP_ROM_PTR(MP_ROM_INT(LV_BAR_STYLE_INDIC)) } +}; + +STATIC MP_DEFINE_CONST_DICT(LV_BAR_STYLE_locals_dict, LV_BAR_STYLE_locals_dict_table); + +STATIC void LV_BAR_STYLE_print(const mp_print_t *print, + mp_obj_t self_in, + mp_print_kind_t kind) +{ + mp_printf(print, "lvgl LV_BAR_STYLE"); +} + + + +STATIC const mp_obj_type_t mp_LV_BAR_STYLE_type = { + { &mp_type_type }, + .name = MP_QSTR_LV_BAR_STYLE, + .print = LV_BAR_STYLE_print, + + .locals_dict = (mp_obj_dict_t*)&LV_BAR_STYLE_locals_dict, +}; + + +/* + * lvgl LV_SLIDER_STYLE object definitions + */ + + +STATIC const mp_rom_map_elem_t LV_SLIDER_STYLE_locals_dict_table[] = { + { MP_ROM_QSTR(MP_QSTR_BG), MP_ROM_PTR(MP_ROM_INT(LV_SLIDER_STYLE_BG)) }, + { MP_ROM_QSTR(MP_QSTR_INDIC), MP_ROM_PTR(MP_ROM_INT(LV_SLIDER_STYLE_INDIC)) }, + { MP_ROM_QSTR(MP_QSTR_KNOB), MP_ROM_PTR(MP_ROM_INT(LV_SLIDER_STYLE_KNOB)) } +}; + +STATIC MP_DEFINE_CONST_DICT(LV_SLIDER_STYLE_locals_dict, LV_SLIDER_STYLE_locals_dict_table); + +STATIC void LV_SLIDER_STYLE_print(const mp_print_t *print, + mp_obj_t self_in, + mp_print_kind_t kind) +{ + mp_printf(print, "lvgl LV_SLIDER_STYLE"); +} + + + +STATIC const mp_obj_type_t mp_LV_SLIDER_STYLE_type = { + { &mp_type_type }, + .name = MP_QSTR_LV_SLIDER_STYLE, + .print = LV_SLIDER_STYLE_print, + + .locals_dict = (mp_obj_dict_t*)&LV_SLIDER_STYLE_locals_dict, +}; + + +/* + * lvgl LV_BTNM_STYLE object definitions + */ + + +STATIC const mp_rom_map_elem_t LV_BTNM_STYLE_locals_dict_table[] = { + { MP_ROM_QSTR(MP_QSTR_BG), MP_ROM_PTR(MP_ROM_INT(LV_BTNM_STYLE_BG)) }, + { MP_ROM_QSTR(MP_QSTR_BTN_REL), MP_ROM_PTR(MP_ROM_INT(LV_BTNM_STYLE_BTN_REL)) }, + { MP_ROM_QSTR(MP_QSTR_BTN_PR), MP_ROM_PTR(MP_ROM_INT(LV_BTNM_STYLE_BTN_PR)) }, + { MP_ROM_QSTR(MP_QSTR_BTN_TGL_REL), MP_ROM_PTR(MP_ROM_INT(LV_BTNM_STYLE_BTN_TGL_REL)) }, + { MP_ROM_QSTR(MP_QSTR_BTN_TGL_PR), MP_ROM_PTR(MP_ROM_INT(LV_BTNM_STYLE_BTN_TGL_PR)) }, + { MP_ROM_QSTR(MP_QSTR_BTN_INA), MP_ROM_PTR(MP_ROM_INT(LV_BTNM_STYLE_BTN_INA)) } +}; + +STATIC MP_DEFINE_CONST_DICT(LV_BTNM_STYLE_locals_dict, LV_BTNM_STYLE_locals_dict_table); + +STATIC void LV_BTNM_STYLE_print(const mp_print_t *print, + mp_obj_t self_in, + mp_print_kind_t kind) +{ + mp_printf(print, "lvgl LV_BTNM_STYLE"); +} + + + +STATIC const mp_obj_type_t mp_LV_BTNM_STYLE_type = { + { &mp_type_type }, + .name = MP_QSTR_LV_BTNM_STYLE, + .print = LV_BTNM_STYLE_print, + + .locals_dict = (mp_obj_dict_t*)&LV_BTNM_STYLE_locals_dict, +}; + + +/* + * lvgl LV_KB_MODE object definitions + */ + + +STATIC const mp_rom_map_elem_t LV_KB_MODE_locals_dict_table[] = { + { MP_ROM_QSTR(MP_QSTR_TEXT), MP_ROM_PTR(MP_ROM_INT(LV_KB_MODE_TEXT)) }, + { MP_ROM_QSTR(MP_QSTR_NUM), MP_ROM_PTR(MP_ROM_INT(LV_KB_MODE_NUM)) } +}; + +STATIC MP_DEFINE_CONST_DICT(LV_KB_MODE_locals_dict, LV_KB_MODE_locals_dict_table); + +STATIC void LV_KB_MODE_print(const mp_print_t *print, + mp_obj_t self_in, + mp_print_kind_t kind) +{ + mp_printf(print, "lvgl LV_KB_MODE"); +} + + + +STATIC const mp_obj_type_t mp_LV_KB_MODE_type = { + { &mp_type_type }, + .name = MP_QSTR_LV_KB_MODE, + .print = LV_KB_MODE_print, + + .locals_dict = (mp_obj_dict_t*)&LV_KB_MODE_locals_dict, +}; + + +/* + * lvgl LV_KB_STYLE object definitions + */ + + +STATIC const mp_rom_map_elem_t LV_KB_STYLE_locals_dict_table[] = { + { MP_ROM_QSTR(MP_QSTR_BG), MP_ROM_PTR(MP_ROM_INT(LV_KB_STYLE_BG)) }, + { MP_ROM_QSTR(MP_QSTR_BTN_REL), MP_ROM_PTR(MP_ROM_INT(LV_KB_STYLE_BTN_REL)) }, + { MP_ROM_QSTR(MP_QSTR_BTN_PR), MP_ROM_PTR(MP_ROM_INT(LV_KB_STYLE_BTN_PR)) }, + { MP_ROM_QSTR(MP_QSTR_BTN_TGL_REL), MP_ROM_PTR(MP_ROM_INT(LV_KB_STYLE_BTN_TGL_REL)) }, + { MP_ROM_QSTR(MP_QSTR_BTN_TGL_PR), MP_ROM_PTR(MP_ROM_INT(LV_KB_STYLE_BTN_TGL_PR)) }, + { MP_ROM_QSTR(MP_QSTR_BTN_INA), MP_ROM_PTR(MP_ROM_INT(LV_KB_STYLE_BTN_INA)) } +}; + +STATIC MP_DEFINE_CONST_DICT(LV_KB_STYLE_locals_dict, LV_KB_STYLE_locals_dict_table); + +STATIC void LV_KB_STYLE_print(const mp_print_t *print, + mp_obj_t self_in, + mp_print_kind_t kind) +{ + mp_printf(print, "lvgl LV_KB_STYLE"); +} + + + +STATIC const mp_obj_type_t mp_LV_KB_STYLE_type = { + { &mp_type_type }, + .name = MP_QSTR_LV_KB_STYLE, + .print = LV_KB_STYLE_print, + + .locals_dict = (mp_obj_dict_t*)&LV_KB_STYLE_locals_dict, +}; + + +/* + * lvgl LV_DDLIST_STYLE object definitions + */ + + +STATIC const mp_rom_map_elem_t LV_DDLIST_STYLE_locals_dict_table[] = { + { MP_ROM_QSTR(MP_QSTR_BG), MP_ROM_PTR(MP_ROM_INT(LV_DDLIST_STYLE_BG)) }, + { MP_ROM_QSTR(MP_QSTR_SEL), MP_ROM_PTR(MP_ROM_INT(LV_DDLIST_STYLE_SEL)) }, + { MP_ROM_QSTR(MP_QSTR_SB), MP_ROM_PTR(MP_ROM_INT(LV_DDLIST_STYLE_SB)) } +}; + +STATIC MP_DEFINE_CONST_DICT(LV_DDLIST_STYLE_locals_dict, LV_DDLIST_STYLE_locals_dict_table); + +STATIC void LV_DDLIST_STYLE_print(const mp_print_t *print, + mp_obj_t self_in, + mp_print_kind_t kind) +{ + mp_printf(print, "lvgl LV_DDLIST_STYLE"); +} + + + +STATIC const mp_obj_type_t mp_LV_DDLIST_STYLE_type = { + { &mp_type_type }, + .name = MP_QSTR_LV_DDLIST_STYLE, + .print = LV_DDLIST_STYLE_print, + + .locals_dict = (mp_obj_dict_t*)&LV_DDLIST_STYLE_locals_dict, +}; + + +/* + * lvgl LV_ROLLER_STYLE object definitions + */ + + +STATIC const mp_rom_map_elem_t LV_ROLLER_STYLE_locals_dict_table[] = { + { MP_ROM_QSTR(MP_QSTR_BG), MP_ROM_PTR(MP_ROM_INT(LV_ROLLER_STYLE_BG)) }, + { MP_ROM_QSTR(MP_QSTR_SEL), MP_ROM_PTR(MP_ROM_INT(LV_ROLLER_STYLE_SEL)) } +}; + +STATIC MP_DEFINE_CONST_DICT(LV_ROLLER_STYLE_locals_dict, LV_ROLLER_STYLE_locals_dict_table); + +STATIC void LV_ROLLER_STYLE_print(const mp_print_t *print, + mp_obj_t self_in, + mp_print_kind_t kind) +{ + mp_printf(print, "lvgl LV_ROLLER_STYLE"); +} + + + +STATIC const mp_obj_type_t mp_LV_ROLLER_STYLE_type = { + { &mp_type_type }, + .name = MP_QSTR_LV_ROLLER_STYLE, + .print = LV_ROLLER_STYLE_print, + + .locals_dict = (mp_obj_dict_t*)&LV_ROLLER_STYLE_locals_dict, +}; + + +/* + * lvgl LV_CURSOR object definitions + */ + + +STATIC const mp_rom_map_elem_t LV_CURSOR_locals_dict_table[] = { + { MP_ROM_QSTR(MP_QSTR_NONE), MP_ROM_PTR(MP_ROM_INT(LV_CURSOR_NONE)) }, + { MP_ROM_QSTR(MP_QSTR_LINE), MP_ROM_PTR(MP_ROM_INT(LV_CURSOR_LINE)) }, + { MP_ROM_QSTR(MP_QSTR_BLOCK), MP_ROM_PTR(MP_ROM_INT(LV_CURSOR_BLOCK)) }, + { MP_ROM_QSTR(MP_QSTR_OUTLINE), MP_ROM_PTR(MP_ROM_INT(LV_CURSOR_OUTLINE)) }, + { MP_ROM_QSTR(MP_QSTR_UNDERLINE), MP_ROM_PTR(MP_ROM_INT(LV_CURSOR_UNDERLINE)) }, + { MP_ROM_QSTR(MP_QSTR_HIDDEN), MP_ROM_PTR(MP_ROM_INT(LV_CURSOR_HIDDEN)) } +}; + +STATIC MP_DEFINE_CONST_DICT(LV_CURSOR_locals_dict, LV_CURSOR_locals_dict_table); + +STATIC void LV_CURSOR_print(const mp_print_t *print, + mp_obj_t self_in, + mp_print_kind_t kind) +{ + mp_printf(print, "lvgl LV_CURSOR"); +} + + + +STATIC const mp_obj_type_t mp_LV_CURSOR_type = { + { &mp_type_type }, + .name = MP_QSTR_LV_CURSOR, + .print = LV_CURSOR_print, + + .locals_dict = (mp_obj_dict_t*)&LV_CURSOR_locals_dict, +}; + + +/* + * lvgl LV_TA_STYLE object definitions + */ + + +STATIC const mp_rom_map_elem_t LV_TA_STYLE_locals_dict_table[] = { + { MP_ROM_QSTR(MP_QSTR_BG), MP_ROM_PTR(MP_ROM_INT(LV_TA_STYLE_BG)) }, + { MP_ROM_QSTR(MP_QSTR_SB), MP_ROM_PTR(MP_ROM_INT(LV_TA_STYLE_SB)) }, + { MP_ROM_QSTR(MP_QSTR_EDGE_FLASH), MP_ROM_PTR(MP_ROM_INT(LV_TA_STYLE_EDGE_FLASH)) }, + { MP_ROM_QSTR(MP_QSTR_CURSOR), MP_ROM_PTR(MP_ROM_INT(LV_TA_STYLE_CURSOR)) } +}; + +STATIC MP_DEFINE_CONST_DICT(LV_TA_STYLE_locals_dict, LV_TA_STYLE_locals_dict_table); + +STATIC void LV_TA_STYLE_print(const mp_print_t *print, + mp_obj_t self_in, + mp_print_kind_t kind) +{ + mp_printf(print, "lvgl LV_TA_STYLE"); +} + + + +STATIC const mp_obj_type_t mp_LV_TA_STYLE_type = { + { &mp_type_type }, + .name = MP_QSTR_LV_TA_STYLE, + .print = LV_TA_STYLE_print, + + .locals_dict = (mp_obj_dict_t*)&LV_TA_STYLE_locals_dict, +}; + + +/* + * lvgl LV_CANVAS_STYLE object definitions + */ + + +STATIC const mp_rom_map_elem_t LV_CANVAS_STYLE_locals_dict_table[] = { + { MP_ROM_QSTR(MP_QSTR_MAIN), MP_ROM_PTR(MP_ROM_INT(LV_CANVAS_STYLE_MAIN)) } +}; + +STATIC MP_DEFINE_CONST_DICT(LV_CANVAS_STYLE_locals_dict, LV_CANVAS_STYLE_locals_dict_table); + +STATIC void LV_CANVAS_STYLE_print(const mp_print_t *print, + mp_obj_t self_in, + mp_print_kind_t kind) +{ + mp_printf(print, "lvgl LV_CANVAS_STYLE"); +} + + + +STATIC const mp_obj_type_t mp_LV_CANVAS_STYLE_type = { + { &mp_type_type }, + .name = MP_QSTR_LV_CANVAS_STYLE, + .print = LV_CANVAS_STYLE_print, + + .locals_dict = (mp_obj_dict_t*)&LV_CANVAS_STYLE_locals_dict, +}; + + +/* + * lvgl LV_WIN_STYLE object definitions + */ + + +STATIC const mp_rom_map_elem_t LV_WIN_STYLE_locals_dict_table[] = { + { MP_ROM_QSTR(MP_QSTR_BG), MP_ROM_PTR(MP_ROM_INT(LV_WIN_STYLE_BG)) }, + { MP_ROM_QSTR(MP_QSTR_CONTENT_BG), MP_ROM_PTR(MP_ROM_INT(LV_WIN_STYLE_CONTENT_BG)) }, + { MP_ROM_QSTR(MP_QSTR_CONTENT_SCRL), MP_ROM_PTR(MP_ROM_INT(LV_WIN_STYLE_CONTENT_SCRL)) }, + { MP_ROM_QSTR(MP_QSTR_SB), MP_ROM_PTR(MP_ROM_INT(LV_WIN_STYLE_SB)) }, + { MP_ROM_QSTR(MP_QSTR_HEADER), MP_ROM_PTR(MP_ROM_INT(LV_WIN_STYLE_HEADER)) }, + { MP_ROM_QSTR(MP_QSTR_BTN_REL), MP_ROM_PTR(MP_ROM_INT(LV_WIN_STYLE_BTN_REL)) }, + { MP_ROM_QSTR(MP_QSTR_BTN_PR), MP_ROM_PTR(MP_ROM_INT(LV_WIN_STYLE_BTN_PR)) } +}; + +STATIC MP_DEFINE_CONST_DICT(LV_WIN_STYLE_locals_dict, LV_WIN_STYLE_locals_dict_table); + +STATIC void LV_WIN_STYLE_print(const mp_print_t *print, + mp_obj_t self_in, + mp_print_kind_t kind) +{ + mp_printf(print, "lvgl LV_WIN_STYLE"); +} + + + +STATIC const mp_obj_type_t mp_LV_WIN_STYLE_type = { + { &mp_type_type }, + .name = MP_QSTR_LV_WIN_STYLE, + .print = LV_WIN_STYLE_print, + + .locals_dict = (mp_obj_dict_t*)&LV_WIN_STYLE_locals_dict, +}; + + +/* + * lvgl LV_TABVIEW_BTNS_POS object definitions + */ + + +STATIC const mp_rom_map_elem_t LV_TABVIEW_BTNS_POS_locals_dict_table[] = { + { MP_ROM_QSTR(MP_QSTR_TOP), MP_ROM_PTR(MP_ROM_INT(LV_TABVIEW_BTNS_POS_TOP)) }, + { MP_ROM_QSTR(MP_QSTR_BOTTOM), MP_ROM_PTR(MP_ROM_INT(LV_TABVIEW_BTNS_POS_BOTTOM)) } +}; + +STATIC MP_DEFINE_CONST_DICT(LV_TABVIEW_BTNS_POS_locals_dict, LV_TABVIEW_BTNS_POS_locals_dict_table); + +STATIC void LV_TABVIEW_BTNS_POS_print(const mp_print_t *print, + mp_obj_t self_in, + mp_print_kind_t kind) +{ + mp_printf(print, "lvgl LV_TABVIEW_BTNS_POS"); +} + + + +STATIC const mp_obj_type_t mp_LV_TABVIEW_BTNS_POS_type = { + { &mp_type_type }, + .name = MP_QSTR_LV_TABVIEW_BTNS_POS, + .print = LV_TABVIEW_BTNS_POS_print, + + .locals_dict = (mp_obj_dict_t*)&LV_TABVIEW_BTNS_POS_locals_dict, +}; + + +/* + * lvgl LV_TABVIEW_STYLE object definitions + */ + + +STATIC const mp_rom_map_elem_t LV_TABVIEW_STYLE_locals_dict_table[] = { + { MP_ROM_QSTR(MP_QSTR_BG), MP_ROM_PTR(MP_ROM_INT(LV_TABVIEW_STYLE_BG)) }, + { MP_ROM_QSTR(MP_QSTR_INDIC), MP_ROM_PTR(MP_ROM_INT(LV_TABVIEW_STYLE_INDIC)) }, + { MP_ROM_QSTR(MP_QSTR_BTN_BG), MP_ROM_PTR(MP_ROM_INT(LV_TABVIEW_STYLE_BTN_BG)) }, + { MP_ROM_QSTR(MP_QSTR_BTN_REL), MP_ROM_PTR(MP_ROM_INT(LV_TABVIEW_STYLE_BTN_REL)) }, + { MP_ROM_QSTR(MP_QSTR_BTN_PR), MP_ROM_PTR(MP_ROM_INT(LV_TABVIEW_STYLE_BTN_PR)) }, + { MP_ROM_QSTR(MP_QSTR_BTN_TGL_REL), MP_ROM_PTR(MP_ROM_INT(LV_TABVIEW_STYLE_BTN_TGL_REL)) }, + { MP_ROM_QSTR(MP_QSTR_BTN_TGL_PR), MP_ROM_PTR(MP_ROM_INT(LV_TABVIEW_STYLE_BTN_TGL_PR)) } +}; + +STATIC MP_DEFINE_CONST_DICT(LV_TABVIEW_STYLE_locals_dict, LV_TABVIEW_STYLE_locals_dict_table); + +STATIC void LV_TABVIEW_STYLE_print(const mp_print_t *print, + mp_obj_t self_in, + mp_print_kind_t kind) +{ + mp_printf(print, "lvgl LV_TABVIEW_STYLE"); +} + + + +STATIC const mp_obj_type_t mp_LV_TABVIEW_STYLE_type = { + { &mp_type_type }, + .name = MP_QSTR_LV_TABVIEW_STYLE, + .print = LV_TABVIEW_STYLE_print, + + .locals_dict = (mp_obj_dict_t*)&LV_TABVIEW_STYLE_locals_dict, +}; + + +/* + * lvgl LV_TILEVIEW_STYLE object definitions + */ + + +STATIC const mp_rom_map_elem_t LV_TILEVIEW_STYLE_locals_dict_table[] = { + { MP_ROM_QSTR(MP_QSTR_BG), MP_ROM_PTR(MP_ROM_INT(LV_TILEVIEW_STYLE_BG)) } +}; + +STATIC MP_DEFINE_CONST_DICT(LV_TILEVIEW_STYLE_locals_dict, LV_TILEVIEW_STYLE_locals_dict_table); + +STATIC void LV_TILEVIEW_STYLE_print(const mp_print_t *print, + mp_obj_t self_in, + mp_print_kind_t kind) +{ + mp_printf(print, "lvgl LV_TILEVIEW_STYLE"); +} + + + +STATIC const mp_obj_type_t mp_LV_TILEVIEW_STYLE_type = { + { &mp_type_type }, + .name = MP_QSTR_LV_TILEVIEW_STYLE, + .print = LV_TILEVIEW_STYLE_print, + + .locals_dict = (mp_obj_dict_t*)&LV_TILEVIEW_STYLE_locals_dict, +}; + + +/* + * lvgl LV_MBOX_STYLE object definitions + */ + + +STATIC const mp_rom_map_elem_t LV_MBOX_STYLE_locals_dict_table[] = { + { MP_ROM_QSTR(MP_QSTR_BG), MP_ROM_PTR(MP_ROM_INT(LV_MBOX_STYLE_BG)) }, + { MP_ROM_QSTR(MP_QSTR_BTN_BG), MP_ROM_PTR(MP_ROM_INT(LV_MBOX_STYLE_BTN_BG)) }, + { MP_ROM_QSTR(MP_QSTR_BTN_REL), MP_ROM_PTR(MP_ROM_INT(LV_MBOX_STYLE_BTN_REL)) }, + { MP_ROM_QSTR(MP_QSTR_BTN_PR), MP_ROM_PTR(MP_ROM_INT(LV_MBOX_STYLE_BTN_PR)) }, + { MP_ROM_QSTR(MP_QSTR_BTN_TGL_REL), MP_ROM_PTR(MP_ROM_INT(LV_MBOX_STYLE_BTN_TGL_REL)) }, + { MP_ROM_QSTR(MP_QSTR_BTN_TGL_PR), MP_ROM_PTR(MP_ROM_INT(LV_MBOX_STYLE_BTN_TGL_PR)) }, + { MP_ROM_QSTR(MP_QSTR_BTN_INA), MP_ROM_PTR(MP_ROM_INT(LV_MBOX_STYLE_BTN_INA)) } +}; + +STATIC MP_DEFINE_CONST_DICT(LV_MBOX_STYLE_locals_dict, LV_MBOX_STYLE_locals_dict_table); + +STATIC void LV_MBOX_STYLE_print(const mp_print_t *print, + mp_obj_t self_in, + mp_print_kind_t kind) +{ + mp_printf(print, "lvgl LV_MBOX_STYLE"); +} + + + +STATIC const mp_obj_type_t mp_LV_MBOX_STYLE_type = { + { &mp_type_type }, + .name = MP_QSTR_LV_MBOX_STYLE, + .print = LV_MBOX_STYLE_print, + + .locals_dict = (mp_obj_dict_t*)&LV_MBOX_STYLE_locals_dict, +}; + + +/* + * lvgl LV_SW_STYLE object definitions + */ + + +STATIC const mp_rom_map_elem_t LV_SW_STYLE_locals_dict_table[] = { + { MP_ROM_QSTR(MP_QSTR_BG), MP_ROM_PTR(MP_ROM_INT(LV_SW_STYLE_BG)) }, + { MP_ROM_QSTR(MP_QSTR_INDIC), MP_ROM_PTR(MP_ROM_INT(LV_SW_STYLE_INDIC)) }, + { MP_ROM_QSTR(MP_QSTR_KNOB_OFF), MP_ROM_PTR(MP_ROM_INT(LV_SW_STYLE_KNOB_OFF)) }, + { MP_ROM_QSTR(MP_QSTR_KNOB_ON), MP_ROM_PTR(MP_ROM_INT(LV_SW_STYLE_KNOB_ON)) } +}; + +STATIC MP_DEFINE_CONST_DICT(LV_SW_STYLE_locals_dict, LV_SW_STYLE_locals_dict_table); + +STATIC void LV_SW_STYLE_print(const mp_print_t *print, + mp_obj_t self_in, + mp_print_kind_t kind) +{ + mp_printf(print, "lvgl LV_SW_STYLE"); +} + + + +STATIC const mp_obj_type_t mp_LV_SW_STYLE_type = { + { &mp_type_type }, + .name = MP_QSTR_LV_SW_STYLE, + .print = LV_SW_STYLE_print, + + .locals_dict = (mp_obj_dict_t*)&LV_SW_STYLE_locals_dict, +}; + + +/* + * lvgl LV_ARC_STYLE object definitions + */ + + +STATIC const mp_rom_map_elem_t LV_ARC_STYLE_locals_dict_table[] = { + { MP_ROM_QSTR(MP_QSTR_MAIN), MP_ROM_PTR(MP_ROM_INT(LV_ARC_STYLE_MAIN)) } +}; + +STATIC MP_DEFINE_CONST_DICT(LV_ARC_STYLE_locals_dict, LV_ARC_STYLE_locals_dict_table); + +STATIC void LV_ARC_STYLE_print(const mp_print_t *print, + mp_obj_t self_in, + mp_print_kind_t kind) +{ + mp_printf(print, "lvgl LV_ARC_STYLE"); +} + + + +STATIC const mp_obj_type_t mp_LV_ARC_STYLE_type = { + { &mp_type_type }, + .name = MP_QSTR_LV_ARC_STYLE, + .print = LV_ARC_STYLE_print, + + .locals_dict = (mp_obj_dict_t*)&LV_ARC_STYLE_locals_dict, +}; + + +/* + * lvgl LV_PRELOAD_TYPE object definitions + */ + + +STATIC const mp_rom_map_elem_t LV_PRELOAD_TYPE_locals_dict_table[] = { + { MP_ROM_QSTR(MP_QSTR_SPINNING_ARC), MP_ROM_PTR(MP_ROM_INT(LV_PRELOAD_TYPE_SPINNING_ARC)) }, + { MP_ROM_QSTR(MP_QSTR_FILLSPIN_ARC), MP_ROM_PTR(MP_ROM_INT(LV_PRELOAD_TYPE_FILLSPIN_ARC)) } +}; + +STATIC MP_DEFINE_CONST_DICT(LV_PRELOAD_TYPE_locals_dict, LV_PRELOAD_TYPE_locals_dict_table); + +STATIC void LV_PRELOAD_TYPE_print(const mp_print_t *print, + mp_obj_t self_in, + mp_print_kind_t kind) +{ + mp_printf(print, "lvgl LV_PRELOAD_TYPE"); +} + + + +STATIC const mp_obj_type_t mp_LV_PRELOAD_TYPE_type = { + { &mp_type_type }, + .name = MP_QSTR_LV_PRELOAD_TYPE, + .print = LV_PRELOAD_TYPE_print, + + .locals_dict = (mp_obj_dict_t*)&LV_PRELOAD_TYPE_locals_dict, +}; + + +/* + * lvgl LV_PRELOAD_STYLE object definitions + */ + + +STATIC const mp_rom_map_elem_t LV_PRELOAD_STYLE_locals_dict_table[] = { + { MP_ROM_QSTR(MP_QSTR_MAIN), MP_ROM_PTR(MP_ROM_INT(LV_PRELOAD_STYLE_MAIN)) } +}; + +STATIC MP_DEFINE_CONST_DICT(LV_PRELOAD_STYLE_locals_dict, LV_PRELOAD_STYLE_locals_dict_table); + +STATIC void LV_PRELOAD_STYLE_print(const mp_print_t *print, + mp_obj_t self_in, + mp_print_kind_t kind) +{ + mp_printf(print, "lvgl LV_PRELOAD_STYLE"); +} + + + +STATIC const mp_obj_type_t mp_LV_PRELOAD_STYLE_type = { + { &mp_type_type }, + .name = MP_QSTR_LV_PRELOAD_STYLE, + .print = LV_PRELOAD_STYLE_print, + + .locals_dict = (mp_obj_dict_t*)&LV_PRELOAD_STYLE_locals_dict, +}; + + +/* + * lvgl LV_CALENDAR_ACTION object definitions + */ + + +STATIC const mp_rom_map_elem_t LV_CALENDAR_ACTION_locals_dict_table[] = { + { MP_ROM_QSTR(MP_QSTR_CLICK), MP_ROM_PTR(MP_ROM_INT(LV_CALENDAR_ACTION_CLICK)) }, + { MP_ROM_QSTR(MP_QSTR_PR), MP_ROM_PTR(MP_ROM_INT(LV_CALENDAR_ACTION_PR)) }, + { MP_ROM_QSTR(MP_QSTR_LONG_PR), MP_ROM_PTR(MP_ROM_INT(LV_CALENDAR_ACTION_LONG_PR)) }, + { MP_ROM_QSTR(MP_QSTR_LONG_PR_REPEAT), MP_ROM_PTR(MP_ROM_INT(LV_CALENDAR_ACTION_LONG_PR_REPEAT)) }, + { MP_ROM_QSTR(MP_QSTR_NUM), MP_ROM_PTR(MP_ROM_INT(LV_CALENDAR_ACTION_NUM)) } +}; + +STATIC MP_DEFINE_CONST_DICT(LV_CALENDAR_ACTION_locals_dict, LV_CALENDAR_ACTION_locals_dict_table); + +STATIC void LV_CALENDAR_ACTION_print(const mp_print_t *print, + mp_obj_t self_in, + mp_print_kind_t kind) +{ + mp_printf(print, "lvgl LV_CALENDAR_ACTION"); +} + + + +STATIC const mp_obj_type_t mp_LV_CALENDAR_ACTION_type = { + { &mp_type_type }, + .name = MP_QSTR_LV_CALENDAR_ACTION, + .print = LV_CALENDAR_ACTION_print, + + .locals_dict = (mp_obj_dict_t*)&LV_CALENDAR_ACTION_locals_dict, +}; + + +/* + * lvgl LV_CALENDAR_STYLE object definitions + */ + + +STATIC const mp_rom_map_elem_t LV_CALENDAR_STYLE_locals_dict_table[] = { + { MP_ROM_QSTR(MP_QSTR_BG), MP_ROM_PTR(MP_ROM_INT(LV_CALENDAR_STYLE_BG)) }, + { MP_ROM_QSTR(MP_QSTR_HEADER), MP_ROM_PTR(MP_ROM_INT(LV_CALENDAR_STYLE_HEADER)) }, + { MP_ROM_QSTR(MP_QSTR_HEADER_PR), MP_ROM_PTR(MP_ROM_INT(LV_CALENDAR_STYLE_HEADER_PR)) }, + { MP_ROM_QSTR(MP_QSTR_DAY_NAMES), MP_ROM_PTR(MP_ROM_INT(LV_CALENDAR_STYLE_DAY_NAMES)) }, + { MP_ROM_QSTR(MP_QSTR_HIGHLIGHTED_DAYS), MP_ROM_PTR(MP_ROM_INT(LV_CALENDAR_STYLE_HIGHLIGHTED_DAYS)) }, + { MP_ROM_QSTR(MP_QSTR_INACTIVE_DAYS), MP_ROM_PTR(MP_ROM_INT(LV_CALENDAR_STYLE_INACTIVE_DAYS)) }, + { MP_ROM_QSTR(MP_QSTR_WEEK_BOX), MP_ROM_PTR(MP_ROM_INT(LV_CALENDAR_STYLE_WEEK_BOX)) }, + { MP_ROM_QSTR(MP_QSTR_TODAY_BOX), MP_ROM_PTR(MP_ROM_INT(LV_CALENDAR_STYLE_TODAY_BOX)) } +}; + +STATIC MP_DEFINE_CONST_DICT(LV_CALENDAR_STYLE_locals_dict, LV_CALENDAR_STYLE_locals_dict_table); + +STATIC void LV_CALENDAR_STYLE_print(const mp_print_t *print, + mp_obj_t self_in, + mp_print_kind_t kind) +{ + mp_printf(print, "lvgl LV_CALENDAR_STYLE"); +} + + + +STATIC const mp_obj_type_t mp_LV_CALENDAR_STYLE_type = { + { &mp_type_type }, + .name = MP_QSTR_LV_CALENDAR_STYLE, + .print = LV_CALENDAR_STYLE_print, + + .locals_dict = (mp_obj_dict_t*)&LV_CALENDAR_STYLE_locals_dict, +}; + + +/* + * lvgl LV_SPINBOX_STYLE object definitions + */ + + +STATIC const mp_rom_map_elem_t LV_SPINBOX_STYLE_locals_dict_table[] = { + { MP_ROM_QSTR(MP_QSTR_BG), MP_ROM_PTR(MP_ROM_INT(LV_SPINBOX_STYLE_BG)) }, + { MP_ROM_QSTR(MP_QSTR_SB), MP_ROM_PTR(MP_ROM_INT(LV_SPINBOX_STYLE_SB)) }, + { MP_ROM_QSTR(MP_QSTR_CURSOR), MP_ROM_PTR(MP_ROM_INT(LV_SPINBOX_STYLE_CURSOR)) } +}; + +STATIC MP_DEFINE_CONST_DICT(LV_SPINBOX_STYLE_locals_dict, LV_SPINBOX_STYLE_locals_dict_table); + +STATIC void LV_SPINBOX_STYLE_print(const mp_print_t *print, + mp_obj_t self_in, + mp_print_kind_t kind) +{ + mp_printf(print, "lvgl LV_SPINBOX_STYLE"); +} + + + +STATIC const mp_obj_type_t mp_LV_SPINBOX_STYLE_type = { + { &mp_type_type }, + .name = MP_QSTR_LV_SPINBOX_STYLE, + .print = LV_SPINBOX_STYLE_print, + + .locals_dict = (mp_obj_dict_t*)&LV_SPINBOX_STYLE_locals_dict, +}; + + +/* + * Callback function lv_anim_path_t + * int32_t lv_anim_path_t(const struct _lv_anim_t *) + */ + +STATIC int32_t lv_anim_path_t_callback(const struct _lv_anim_t* arg0) +{ + mp_obj_t args[1]; + args[0] = ptr_to_mp((void*)arg0); + mp_obj_t action = mp_to_lv_action(args[0]); + mp_obj_t callback_result = mp_call_function_n_kw(action, 1, 0, args); + return (int32_t)mp_obj_get_int(callback_result); +} + + +/* + * Callback function lv_anim_fp_t + * void lv_anim_fp_t(void *, int32_t) + */ + +STATIC void lv_anim_fp_t_callback(void* arg0, int32_t arg1) +{ + mp_obj_t args[2]; + args[0] = ptr_to_mp((void*)arg0); + args[1] = mp_obj_new_int(arg1); + mp_obj_t action = mp_to_lv_action(args[0]); + mp_call_function_n_kw(action, 2, 0, args); + return; +} + + +/* + * Callback function lv_anim_cb_t + * void lv_anim_cb_t(void *) + */ + +STATIC void lv_anim_cb_t_callback(void* arg0) +{ + mp_obj_t args[1]; + args[0] = ptr_to_mp((void*)arg0); + mp_obj_t action = mp_to_lv_action(args[0]); + mp_call_function_n_kw(action, 1, 0, args); + return; +} + + +/* + * Callback function lv_design_func_t + * bool lv_design_func_t(struct _lv_obj_t *obj, const lv_area_t *mask_p, lv_design_mode_t mode) + */ + +STATIC bool lv_design_func_t_callback(struct _lv_obj_t* arg0, const lv_area_t* arg1, lv_design_mode_t arg2) +{ + mp_obj_t args[3]; + args[0] = lv_to_mp((void*)arg0); + args[1] = ptr_to_mp((void*)arg1); + args[2] = mp_obj_new_int_from_uint(arg2); + mp_obj_t action = mp_to_lv_action(args[0]); + mp_obj_t callback_result = mp_call_function_n_kw(action, 3, 0, args); + return mp_obj_is_true(callback_result); +} + + +/* + * Callback function lv_signal_func_t + * lv_res_t lv_signal_func_t(struct _lv_obj_t *obj, lv_signal_t sign, void *param) + */ + +STATIC lv_res_t lv_signal_func_t_callback(struct _lv_obj_t* arg0, lv_signal_t arg1, void* arg2) +{ + mp_obj_t args[3]; + args[0] = lv_to_mp((void*)arg0); + args[1] = mp_obj_new_int_from_uint(arg1); + args[2] = ptr_to_mp((void*)arg2); + mp_obj_t action = mp_to_lv_action(args[0]); + mp_obj_t callback_result = mp_call_function_n_kw(action, 3, 0, args); + return (uint8_t)mp_obj_get_int(callback_result); +} + + +/* + * Callback function lv_action_t + * lv_res_t lv_action_t(struct _lv_obj_t *obj) + */ + +STATIC lv_res_t lv_action_t_callback(struct _lv_obj_t* arg0) +{ + mp_obj_t args[1]; + args[0] = lv_to_mp((void*)arg0); + mp_obj_t action = mp_to_lv_action(args[0]); + mp_obj_t callback_result = mp_call_function_n_kw(action, 1, 0, args); + return (uint8_t)mp_obj_get_int(callback_result); +} + + +/* + * Callback function lv_indev_feedback_t + * void lv_indev_feedback_t(struct _lv_indev_t *, lv_signal_t) + */ + +STATIC void lv_indev_feedback_t_callback(struct _lv_indev_t* arg0, lv_signal_t arg1) +{ + mp_obj_t args[2]; + args[0] = ptr_to_mp((void*)arg0); + args[1] = mp_obj_new_int_from_uint(arg1); + mp_obj_t action = mp_to_lv_action(args[0]); + mp_call_function_n_kw(action, 2, 0, args); + return; +} + +typedef __typeof__( ((lv_style_t*)(0))->body ) lv_style_body_t; + +/* + * Struct lv_color16_t + */ + +STATIC inline const mp_obj_type_t *get_mp_lv_color16_t_type(); + +STATIC inline lv_color16_t* mp_write_ptr_lv_color16_t(mp_obj_t self_in) +{ + mp_lv_struct_t *self = MP_OBJ_TO_PTR(cast(self_in, get_mp_lv_color16_t_type())); + return (lv_color16_t*)self->data; +} + +#define mp_write_lv_color16_t(struct_obj) *mp_write_ptr_lv_color16_t(struct_obj) + +STATIC inline mp_obj_t mp_read_ptr_lv_color16_t(lv_color16_t *field) +{ + return lv_to_mp_struct(get_mp_lv_color16_t_type(), field); +} + +#define mp_read_lv_color16_t(field) mp_read_ptr_lv_color16_t(copy_buffer(&field, sizeof(lv_color16_t))) +#define mp_read_byref_lv_color16_t(field) mp_read_ptr_lv_color16_t(&field) + +STATIC void mp_lv_color16_t_attr(mp_obj_t self_in, qstr attr, mp_obj_t *dest) +{ + mp_lv_struct_t *self = MP_OBJ_TO_PTR(self_in); + lv_color16_t *data = (lv_color16_t*)self->data; + + if (dest[0] == MP_OBJ_NULL) { + // load attribute + switch(attr) + { + case MP_QSTR_blue: dest[0] = mp_obj_new_int_from_uint(data->blue); break; // converting from uint16_t; + case MP_QSTR_green: dest[0] = mp_obj_new_int_from_uint(data->green); break; // converting from uint16_t; + case MP_QSTR_red: dest[0] = mp_obj_new_int_from_uint(data->red); break; // converting from uint16_t; + case MP_QSTR_full: dest[0] = mp_obj_new_int_from_uint(data->full); break; // converting from uint16_t; + default: field_not_found(MP_QSTR_lv_color16_t, attr); + } + } else { + if (dest[1]) + { + // store attribute + switch(attr) + { + case MP_QSTR_blue: data->blue = (uint16_t)mp_obj_get_int(dest[1]); break; // converting to uint16_t; + case MP_QSTR_green: data->green = (uint16_t)mp_obj_get_int(dest[1]); break; // converting to uint16_t; + case MP_QSTR_red: data->red = (uint16_t)mp_obj_get_int(dest[1]); break; // converting to uint16_t; + case MP_QSTR_full: data->full = (uint16_t)mp_obj_get_int(dest[1]); break; // converting to uint16_t; + default: field_not_found(MP_QSTR_lv_color16_t, attr); + } + + dest[0] = MP_OBJ_NULL; // indicate success + } + } +} + +STATIC void mp_lv_color16_t_print(const mp_print_t *print, + mp_obj_t self_in, + mp_print_kind_t kind) +{ + mp_printf(print, "lvgl struct lv_color16_t"); +} + +STATIC const mp_rom_map_elem_t mp_lv_color16_t_locals_dict_table[] = { + { MP_ROM_QSTR(MP_QSTR_SIZE), MP_ROM_PTR(MP_ROM_INT(sizeof(lv_color16_t))) }, + { MP_ROM_QSTR(MP_QSTR_cast), MP_ROM_PTR(&mp_lv_cast_class_method) }, +}; + +STATIC MP_DEFINE_CONST_DICT(mp_lv_color16_t_locals_dict, mp_lv_color16_t_locals_dict_table); + +STATIC const mp_obj_type_t mp_lv_color16_t_type = { + { &mp_type_type }, + .name = MP_QSTR_lv_color16_t, + .print = mp_lv_color16_t_print, + .make_new = make_new_lv_struct, + .attr = mp_lv_color16_t_attr, + .locals_dict = (mp_obj_dict_t*)&mp_lv_color16_t_locals_dict, + .buffer_p = { .get_buffer = mp_blob_get_buffer } +}; + +STATIC inline const mp_obj_type_t *get_mp_lv_color16_t_type() +{ + return &mp_lv_color16_t_type; +} + +typedef __typeof__( ((lv_style_body_t*)(0))->border ) lv_style_body_border_t; + +/* + * Struct lv_style_body_border_t + */ + +STATIC inline const mp_obj_type_t *get_mp_lv_style_body_border_t_type(); + +STATIC inline lv_style_body_border_t* mp_write_ptr_lv_style_body_border_t(mp_obj_t self_in) +{ + mp_lv_struct_t *self = MP_OBJ_TO_PTR(cast(self_in, get_mp_lv_style_body_border_t_type())); + return (lv_style_body_border_t*)self->data; +} + +#define mp_write_lv_style_body_border_t(struct_obj) *mp_write_ptr_lv_style_body_border_t(struct_obj) + +STATIC inline mp_obj_t mp_read_ptr_lv_style_body_border_t(lv_style_body_border_t *field) +{ + return lv_to_mp_struct(get_mp_lv_style_body_border_t_type(), field); +} + +#define mp_read_lv_style_body_border_t(field) mp_read_ptr_lv_style_body_border_t(copy_buffer(&field, sizeof(lv_style_body_border_t))) +#define mp_read_byref_lv_style_body_border_t(field) mp_read_ptr_lv_style_body_border_t(&field) + +STATIC void mp_lv_style_body_border_t_attr(mp_obj_t self_in, qstr attr, mp_obj_t *dest) +{ + mp_lv_struct_t *self = MP_OBJ_TO_PTR(self_in); + lv_style_body_border_t *data = (lv_style_body_border_t*)self->data; + + if (dest[0] == MP_OBJ_NULL) { + // load attribute + switch(attr) + { + case MP_QSTR_color: dest[0] = mp_read_byref_lv_color16_t(data->color); break; // converting from lv_color_t; + case MP_QSTR_width: dest[0] = mp_obj_new_int(data->width); break; // converting from lv_coord_t; + case MP_QSTR_part: dest[0] = mp_obj_new_int_from_uint(data->part); break; // converting from lv_border_part_t; + case MP_QSTR_opa: dest[0] = mp_obj_new_int_from_uint(data->opa); break; // converting from lv_opa_t; + default: field_not_found(MP_QSTR_lv_style_body_border_t, attr); + } + } else { + if (dest[1]) + { + // store attribute + switch(attr) + { + case MP_QSTR_color: data->color = mp_write_lv_color16_t(dest[1]); break; // converting to lv_color_t; + case MP_QSTR_width: data->width = (int16_t)mp_obj_get_int(dest[1]); break; // converting to lv_coord_t; + case MP_QSTR_part: data->part = (uint8_t)mp_obj_get_int(dest[1]); break; // converting to lv_border_part_t; + case MP_QSTR_opa: data->opa = (uint8_t)mp_obj_get_int(dest[1]); break; // converting to lv_opa_t; + default: field_not_found(MP_QSTR_lv_style_body_border_t, attr); + } + + dest[0] = MP_OBJ_NULL; // indicate success + } + } +} + +STATIC void mp_lv_style_body_border_t_print(const mp_print_t *print, + mp_obj_t self_in, + mp_print_kind_t kind) +{ + mp_printf(print, "lvgl struct lv_style_body_border_t"); +} + +STATIC const mp_rom_map_elem_t mp_lv_style_body_border_t_locals_dict_table[] = { + { MP_ROM_QSTR(MP_QSTR_SIZE), MP_ROM_PTR(MP_ROM_INT(sizeof(lv_style_body_border_t))) }, + { MP_ROM_QSTR(MP_QSTR_cast), MP_ROM_PTR(&mp_lv_cast_class_method) }, +}; + +STATIC MP_DEFINE_CONST_DICT(mp_lv_style_body_border_t_locals_dict, mp_lv_style_body_border_t_locals_dict_table); + +STATIC const mp_obj_type_t mp_lv_style_body_border_t_type = { + { &mp_type_type }, + .name = MP_QSTR_lv_style_body_border_t, + .print = mp_lv_style_body_border_t_print, + .make_new = make_new_lv_struct, + .attr = mp_lv_style_body_border_t_attr, + .locals_dict = (mp_obj_dict_t*)&mp_lv_style_body_border_t_locals_dict, + .buffer_p = { .get_buffer = mp_blob_get_buffer } +}; + +STATIC inline const mp_obj_type_t *get_mp_lv_style_body_border_t_type() +{ + return &mp_lv_style_body_border_t_type; +} + +typedef __typeof__( ((lv_style_body_t*)(0))->shadow ) lv_style_body_shadow_t; + +/* + * Struct lv_style_body_shadow_t + */ + +STATIC inline const mp_obj_type_t *get_mp_lv_style_body_shadow_t_type(); + +STATIC inline lv_style_body_shadow_t* mp_write_ptr_lv_style_body_shadow_t(mp_obj_t self_in) +{ + mp_lv_struct_t *self = MP_OBJ_TO_PTR(cast(self_in, get_mp_lv_style_body_shadow_t_type())); + return (lv_style_body_shadow_t*)self->data; +} + +#define mp_write_lv_style_body_shadow_t(struct_obj) *mp_write_ptr_lv_style_body_shadow_t(struct_obj) + +STATIC inline mp_obj_t mp_read_ptr_lv_style_body_shadow_t(lv_style_body_shadow_t *field) +{ + return lv_to_mp_struct(get_mp_lv_style_body_shadow_t_type(), field); +} + +#define mp_read_lv_style_body_shadow_t(field) mp_read_ptr_lv_style_body_shadow_t(copy_buffer(&field, sizeof(lv_style_body_shadow_t))) +#define mp_read_byref_lv_style_body_shadow_t(field) mp_read_ptr_lv_style_body_shadow_t(&field) + +STATIC void mp_lv_style_body_shadow_t_attr(mp_obj_t self_in, qstr attr, mp_obj_t *dest) +{ + mp_lv_struct_t *self = MP_OBJ_TO_PTR(self_in); + lv_style_body_shadow_t *data = (lv_style_body_shadow_t*)self->data; + + if (dest[0] == MP_OBJ_NULL) { + // load attribute + switch(attr) + { + case MP_QSTR_color: dest[0] = mp_read_byref_lv_color16_t(data->color); break; // converting from lv_color_t; + case MP_QSTR_width: dest[0] = mp_obj_new_int(data->width); break; // converting from lv_coord_t; + case MP_QSTR_type: dest[0] = mp_obj_new_int_from_uint(data->type); break; // converting from lv_shadow_type_t; + default: field_not_found(MP_QSTR_lv_style_body_shadow_t, attr); + } + } else { + if (dest[1]) + { + // store attribute + switch(attr) + { + case MP_QSTR_color: data->color = mp_write_lv_color16_t(dest[1]); break; // converting to lv_color_t; + case MP_QSTR_width: data->width = (int16_t)mp_obj_get_int(dest[1]); break; // converting to lv_coord_t; + case MP_QSTR_type: data->type = (uint8_t)mp_obj_get_int(dest[1]); break; // converting to lv_shadow_type_t; + default: field_not_found(MP_QSTR_lv_style_body_shadow_t, attr); + } + + dest[0] = MP_OBJ_NULL; // indicate success + } + } +} + +STATIC void mp_lv_style_body_shadow_t_print(const mp_print_t *print, + mp_obj_t self_in, + mp_print_kind_t kind) +{ + mp_printf(print, "lvgl struct lv_style_body_shadow_t"); +} + +STATIC const mp_rom_map_elem_t mp_lv_style_body_shadow_t_locals_dict_table[] = { + { MP_ROM_QSTR(MP_QSTR_SIZE), MP_ROM_PTR(MP_ROM_INT(sizeof(lv_style_body_shadow_t))) }, + { MP_ROM_QSTR(MP_QSTR_cast), MP_ROM_PTR(&mp_lv_cast_class_method) }, +}; + +STATIC MP_DEFINE_CONST_DICT(mp_lv_style_body_shadow_t_locals_dict, mp_lv_style_body_shadow_t_locals_dict_table); + +STATIC const mp_obj_type_t mp_lv_style_body_shadow_t_type = { + { &mp_type_type }, + .name = MP_QSTR_lv_style_body_shadow_t, + .print = mp_lv_style_body_shadow_t_print, + .make_new = make_new_lv_struct, + .attr = mp_lv_style_body_shadow_t_attr, + .locals_dict = (mp_obj_dict_t*)&mp_lv_style_body_shadow_t_locals_dict, + .buffer_p = { .get_buffer = mp_blob_get_buffer } +}; + +STATIC inline const mp_obj_type_t *get_mp_lv_style_body_shadow_t_type() +{ + return &mp_lv_style_body_shadow_t_type; +} + +typedef __typeof__( ((lv_style_body_t*)(0))->padding ) lv_style_body_padding_t; + +/* + * Struct lv_style_body_padding_t + */ + +STATIC inline const mp_obj_type_t *get_mp_lv_style_body_padding_t_type(); + +STATIC inline lv_style_body_padding_t* mp_write_ptr_lv_style_body_padding_t(mp_obj_t self_in) +{ + mp_lv_struct_t *self = MP_OBJ_TO_PTR(cast(self_in, get_mp_lv_style_body_padding_t_type())); + return (lv_style_body_padding_t*)self->data; +} + +#define mp_write_lv_style_body_padding_t(struct_obj) *mp_write_ptr_lv_style_body_padding_t(struct_obj) + +STATIC inline mp_obj_t mp_read_ptr_lv_style_body_padding_t(lv_style_body_padding_t *field) +{ + return lv_to_mp_struct(get_mp_lv_style_body_padding_t_type(), field); +} + +#define mp_read_lv_style_body_padding_t(field) mp_read_ptr_lv_style_body_padding_t(copy_buffer(&field, sizeof(lv_style_body_padding_t))) +#define mp_read_byref_lv_style_body_padding_t(field) mp_read_ptr_lv_style_body_padding_t(&field) + +STATIC void mp_lv_style_body_padding_t_attr(mp_obj_t self_in, qstr attr, mp_obj_t *dest) +{ + mp_lv_struct_t *self = MP_OBJ_TO_PTR(self_in); + lv_style_body_padding_t *data = (lv_style_body_padding_t*)self->data; + + if (dest[0] == MP_OBJ_NULL) { + // load attribute + switch(attr) + { + case MP_QSTR_ver: dest[0] = mp_obj_new_int(data->ver); break; // converting from lv_coord_t; + case MP_QSTR_hor: dest[0] = mp_obj_new_int(data->hor); break; // converting from lv_coord_t; + case MP_QSTR_inner: dest[0] = mp_obj_new_int(data->inner); break; // converting from lv_coord_t; + default: field_not_found(MP_QSTR_lv_style_body_padding_t, attr); + } + } else { + if (dest[1]) + { + // store attribute + switch(attr) + { + case MP_QSTR_ver: data->ver = (int16_t)mp_obj_get_int(dest[1]); break; // converting to lv_coord_t; + case MP_QSTR_hor: data->hor = (int16_t)mp_obj_get_int(dest[1]); break; // converting to lv_coord_t; + case MP_QSTR_inner: data->inner = (int16_t)mp_obj_get_int(dest[1]); break; // converting to lv_coord_t; + default: field_not_found(MP_QSTR_lv_style_body_padding_t, attr); + } + + dest[0] = MP_OBJ_NULL; // indicate success + } + } +} + +STATIC void mp_lv_style_body_padding_t_print(const mp_print_t *print, + mp_obj_t self_in, + mp_print_kind_t kind) +{ + mp_printf(print, "lvgl struct lv_style_body_padding_t"); +} + +STATIC const mp_rom_map_elem_t mp_lv_style_body_padding_t_locals_dict_table[] = { + { MP_ROM_QSTR(MP_QSTR_SIZE), MP_ROM_PTR(MP_ROM_INT(sizeof(lv_style_body_padding_t))) }, + { MP_ROM_QSTR(MP_QSTR_cast), MP_ROM_PTR(&mp_lv_cast_class_method) }, +}; + +STATIC MP_DEFINE_CONST_DICT(mp_lv_style_body_padding_t_locals_dict, mp_lv_style_body_padding_t_locals_dict_table); + +STATIC const mp_obj_type_t mp_lv_style_body_padding_t_type = { + { &mp_type_type }, + .name = MP_QSTR_lv_style_body_padding_t, + .print = mp_lv_style_body_padding_t_print, + .make_new = make_new_lv_struct, + .attr = mp_lv_style_body_padding_t_attr, + .locals_dict = (mp_obj_dict_t*)&mp_lv_style_body_padding_t_locals_dict, + .buffer_p = { .get_buffer = mp_blob_get_buffer } +}; + +STATIC inline const mp_obj_type_t *get_mp_lv_style_body_padding_t_type() +{ + return &mp_lv_style_body_padding_t_type; +} + + +/* + * Struct lv_style_body_t + */ + +STATIC inline const mp_obj_type_t *get_mp_lv_style_body_t_type(); + +STATIC inline lv_style_body_t* mp_write_ptr_lv_style_body_t(mp_obj_t self_in) +{ + mp_lv_struct_t *self = MP_OBJ_TO_PTR(cast(self_in, get_mp_lv_style_body_t_type())); + return (lv_style_body_t*)self->data; +} + +#define mp_write_lv_style_body_t(struct_obj) *mp_write_ptr_lv_style_body_t(struct_obj) + +STATIC inline mp_obj_t mp_read_ptr_lv_style_body_t(lv_style_body_t *field) +{ + return lv_to_mp_struct(get_mp_lv_style_body_t_type(), field); +} + +#define mp_read_lv_style_body_t(field) mp_read_ptr_lv_style_body_t(copy_buffer(&field, sizeof(lv_style_body_t))) +#define mp_read_byref_lv_style_body_t(field) mp_read_ptr_lv_style_body_t(&field) + +STATIC void mp_lv_style_body_t_attr(mp_obj_t self_in, qstr attr, mp_obj_t *dest) +{ + mp_lv_struct_t *self = MP_OBJ_TO_PTR(self_in); + lv_style_body_t *data = (lv_style_body_t*)self->data; + + if (dest[0] == MP_OBJ_NULL) { + // load attribute + switch(attr) + { + case MP_QSTR_main_color: dest[0] = mp_read_byref_lv_color16_t(data->main_color); break; // converting from lv_color_t; + case MP_QSTR_grad_color: dest[0] = mp_read_byref_lv_color16_t(data->grad_color); break; // converting from lv_color_t; + case MP_QSTR_radius: dest[0] = mp_obj_new_int(data->radius); break; // converting from lv_coord_t; + case MP_QSTR_opa: dest[0] = mp_obj_new_int_from_uint(data->opa); break; // converting from lv_opa_t; + case MP_QSTR_border: dest[0] = mp_read_byref_lv_style_body_border_t(data->border); break; // converting from lv_style_body_border_t; + case MP_QSTR_shadow: dest[0] = mp_read_byref_lv_style_body_shadow_t(data->shadow); break; // converting from lv_style_body_shadow_t; + case MP_QSTR_padding: dest[0] = mp_read_byref_lv_style_body_padding_t(data->padding); break; // converting from lv_style_body_padding_t; + case MP_QSTR_empty: dest[0] = mp_obj_new_int_from_uint(data->empty); break; // converting from uint8_t; + default: field_not_found(MP_QSTR_lv_style_body_t, attr); + } + } else { + if (dest[1]) + { + // store attribute + switch(attr) + { + case MP_QSTR_main_color: data->main_color = mp_write_lv_color16_t(dest[1]); break; // converting to lv_color_t; + case MP_QSTR_grad_color: data->grad_color = mp_write_lv_color16_t(dest[1]); break; // converting to lv_color_t; + case MP_QSTR_radius: data->radius = (int16_t)mp_obj_get_int(dest[1]); break; // converting to lv_coord_t; + case MP_QSTR_opa: data->opa = (uint8_t)mp_obj_get_int(dest[1]); break; // converting to lv_opa_t; + case MP_QSTR_border: data->border = mp_write_lv_style_body_border_t(dest[1]); break; // converting to lv_style_body_border_t; + case MP_QSTR_shadow: data->shadow = mp_write_lv_style_body_shadow_t(dest[1]); break; // converting to lv_style_body_shadow_t; + case MP_QSTR_padding: data->padding = mp_write_lv_style_body_padding_t(dest[1]); break; // converting to lv_style_body_padding_t; + case MP_QSTR_empty: data->empty = (uint8_t)mp_obj_get_int(dest[1]); break; // converting to uint8_t; + default: field_not_found(MP_QSTR_lv_style_body_t, attr); + } + + dest[0] = MP_OBJ_NULL; // indicate success + } + } +} + +STATIC void mp_lv_style_body_t_print(const mp_print_t *print, + mp_obj_t self_in, + mp_print_kind_t kind) +{ + mp_printf(print, "lvgl struct lv_style_body_t"); +} + +STATIC const mp_rom_map_elem_t mp_lv_style_body_t_locals_dict_table[] = { + { MP_ROM_QSTR(MP_QSTR_SIZE), MP_ROM_PTR(MP_ROM_INT(sizeof(lv_style_body_t))) }, + { MP_ROM_QSTR(MP_QSTR_cast), MP_ROM_PTR(&mp_lv_cast_class_method) }, +}; + +STATIC MP_DEFINE_CONST_DICT(mp_lv_style_body_t_locals_dict, mp_lv_style_body_t_locals_dict_table); + +STATIC const mp_obj_type_t mp_lv_style_body_t_type = { + { &mp_type_type }, + .name = MP_QSTR_lv_style_body_t, + .print = mp_lv_style_body_t_print, + .make_new = make_new_lv_struct, + .attr = mp_lv_style_body_t_attr, + .locals_dict = (mp_obj_dict_t*)&mp_lv_style_body_t_locals_dict, + .buffer_p = { .get_buffer = mp_blob_get_buffer } +}; + +STATIC inline const mp_obj_type_t *get_mp_lv_style_body_t_type() +{ + return &mp_lv_style_body_t_type; +} + +typedef __typeof__( ((lv_style_t*)(0))->text ) lv_style_text_t; + +/* + * Struct lv_font_glyph_dsc_t + */ + +STATIC inline const mp_obj_type_t *get_mp_lv_font_glyph_dsc_t_type(); + +STATIC inline lv_font_glyph_dsc_t* mp_write_ptr_lv_font_glyph_dsc_t(mp_obj_t self_in) +{ + mp_lv_struct_t *self = MP_OBJ_TO_PTR(cast(self_in, get_mp_lv_font_glyph_dsc_t_type())); + return (lv_font_glyph_dsc_t*)self->data; +} + +#define mp_write_lv_font_glyph_dsc_t(struct_obj) *mp_write_ptr_lv_font_glyph_dsc_t(struct_obj) + +STATIC inline mp_obj_t mp_read_ptr_lv_font_glyph_dsc_t(lv_font_glyph_dsc_t *field) +{ + return lv_to_mp_struct(get_mp_lv_font_glyph_dsc_t_type(), field); +} + +#define mp_read_lv_font_glyph_dsc_t(field) mp_read_ptr_lv_font_glyph_dsc_t(copy_buffer(&field, sizeof(lv_font_glyph_dsc_t))) +#define mp_read_byref_lv_font_glyph_dsc_t(field) mp_read_ptr_lv_font_glyph_dsc_t(&field) + +STATIC void mp_lv_font_glyph_dsc_t_attr(mp_obj_t self_in, qstr attr, mp_obj_t *dest) +{ + mp_lv_struct_t *self = MP_OBJ_TO_PTR(self_in); + lv_font_glyph_dsc_t *data = (lv_font_glyph_dsc_t*)self->data; + + if (dest[0] == MP_OBJ_NULL) { + // load attribute + switch(attr) + { + case MP_QSTR_w_px: dest[0] = mp_obj_new_int_from_uint(data->w_px); break; // converting from uint32_t; + case MP_QSTR_glyph_index: dest[0] = mp_obj_new_int_from_uint(data->glyph_index); break; // converting from uint32_t; + default: field_not_found(MP_QSTR_lv_font_glyph_dsc_t, attr); + } + } else { + if (dest[1]) + { + // store attribute + switch(attr) + { + case MP_QSTR_w_px: data->w_px = (uint32_t)mp_obj_get_int(dest[1]); break; // converting to uint32_t; + case MP_QSTR_glyph_index: data->glyph_index = (uint32_t)mp_obj_get_int(dest[1]); break; // converting to uint32_t; + default: field_not_found(MP_QSTR_lv_font_glyph_dsc_t, attr); + } + + dest[0] = MP_OBJ_NULL; // indicate success + } + } +} + +STATIC void mp_lv_font_glyph_dsc_t_print(const mp_print_t *print, + mp_obj_t self_in, + mp_print_kind_t kind) +{ + mp_printf(print, "lvgl struct lv_font_glyph_dsc_t"); +} + +STATIC const mp_rom_map_elem_t mp_lv_font_glyph_dsc_t_locals_dict_table[] = { + { MP_ROM_QSTR(MP_QSTR_SIZE), MP_ROM_PTR(MP_ROM_INT(sizeof(lv_font_glyph_dsc_t))) }, + { MP_ROM_QSTR(MP_QSTR_cast), MP_ROM_PTR(&mp_lv_cast_class_method) }, +}; + +STATIC MP_DEFINE_CONST_DICT(mp_lv_font_glyph_dsc_t_locals_dict, mp_lv_font_glyph_dsc_t_locals_dict_table); + +STATIC const mp_obj_type_t mp_lv_font_glyph_dsc_t_type = { + { &mp_type_type }, + .name = MP_QSTR_lv_font_glyph_dsc_t, + .print = mp_lv_font_glyph_dsc_t_print, + .make_new = make_new_lv_struct, + .attr = mp_lv_font_glyph_dsc_t_attr, + .locals_dict = (mp_obj_dict_t*)&mp_lv_font_glyph_dsc_t_locals_dict, + .buffer_p = { .get_buffer = mp_blob_get_buffer } +}; + +STATIC inline const mp_obj_type_t *get_mp_lv_font_glyph_dsc_t_type() +{ + return &mp_lv_font_glyph_dsc_t_type; +} + + +/* + * Struct lv_font_t + */ + +STATIC inline const mp_obj_type_t *get_mp_lv_font_t_type(); + +STATIC inline lv_font_t* mp_write_ptr_lv_font_t(mp_obj_t self_in) +{ + mp_lv_struct_t *self = MP_OBJ_TO_PTR(cast(self_in, get_mp_lv_font_t_type())); + return (lv_font_t*)self->data; +} + +#define mp_write_lv_font_t(struct_obj) *mp_write_ptr_lv_font_t(struct_obj) + +STATIC inline mp_obj_t mp_read_ptr_lv_font_t(lv_font_t *field) +{ + return lv_to_mp_struct(get_mp_lv_font_t_type(), field); +} + +#define mp_read_lv_font_t(field) mp_read_ptr_lv_font_t(copy_buffer(&field, sizeof(lv_font_t))) +#define mp_read_byref_lv_font_t(field) mp_read_ptr_lv_font_t(&field) + +STATIC void mp_lv_font_t_attr(mp_obj_t self_in, qstr attr, mp_obj_t *dest) +{ + mp_lv_struct_t *self = MP_OBJ_TO_PTR(self_in); + lv_font_t *data = (lv_font_t*)self->data; + + if (dest[0] == MP_OBJ_NULL) { + // load attribute + switch(attr) + { + case MP_QSTR_unicode_first: dest[0] = mp_obj_new_int_from_uint(data->unicode_first); break; // converting from uint32_t; + case MP_QSTR_unicode_last: dest[0] = mp_obj_new_int_from_uint(data->unicode_last); break; // converting from uint32_t; + case MP_QSTR_glyph_bitmap: dest[0] = ptr_to_mp((void*)data->glyph_bitmap); break; // converting from uint8_t*; + case MP_QSTR_glyph_dsc: dest[0] = mp_read_ptr_lv_font_glyph_dsc_t((void*)data->glyph_dsc); break; // converting from lv_font_glyph_dsc_t*; + case MP_QSTR_unicode_list: dest[0] = ptr_to_mp((void*)data->unicode_list); break; // converting from uint32_t*; + case MP_QSTR_get_bitmap: dest[0] = ptr_to_mp((void*)data->get_bitmap); break; // converting from const uint8_t *get_bitmap(const struct _lv_font_struct *, uint32_t)*; + case MP_QSTR_get_width: dest[0] = ptr_to_mp((void*)data->get_width); break; // converting from int16_t get_width(const struct _lv_font_struct *, uint32_t)*; + case MP_QSTR_next_page: dest[0] = ptr_to_mp((void*)data->next_page); break; // converting from struct _lv_font_struct*; + case MP_QSTR_h_px: dest[0] = mp_obj_new_int_from_uint(data->h_px); break; // converting from uint32_t; + case MP_QSTR_bpp: dest[0] = mp_obj_new_int_from_uint(data->bpp); break; // converting from uint32_t; + case MP_QSTR_monospace: dest[0] = mp_obj_new_int_from_uint(data->monospace); break; // converting from uint32_t; + case MP_QSTR_glyph_cnt: dest[0] = mp_obj_new_int_from_uint(data->glyph_cnt); break; // converting from uint16_t; + default: field_not_found(MP_QSTR_lv_font_t, attr); + } + } else { + if (dest[1]) + { + // store attribute + switch(attr) + { + case MP_QSTR_unicode_first: data->unicode_first = (uint32_t)mp_obj_get_int(dest[1]); break; // converting to uint32_t; + case MP_QSTR_unicode_last: data->unicode_last = (uint32_t)mp_obj_get_int(dest[1]); break; // converting to uint32_t; + case MP_QSTR_glyph_bitmap: data->glyph_bitmap = (void*)mp_to_ptr(dest[1]); break; // converting to uint8_t*; + case MP_QSTR_glyph_dsc: data->glyph_dsc = (void*)mp_write_ptr_lv_font_glyph_dsc_t(dest[1]); break; // converting to lv_font_glyph_dsc_t*; + case MP_QSTR_unicode_list: data->unicode_list = (void*)mp_to_ptr(dest[1]); break; // converting to uint32_t*; + case MP_QSTR_get_bitmap: data->get_bitmap = (void*)mp_to_ptr(dest[1]); break; // converting to const uint8_t *get_bitmap(const struct _lv_font_struct *, uint32_t)*; + case MP_QSTR_get_width: data->get_width = (void*)mp_to_ptr(dest[1]); break; // converting to int16_t get_width(const struct _lv_font_struct *, uint32_t)*; + case MP_QSTR_next_page: data->next_page = (void*)mp_to_ptr(dest[1]); break; // converting to struct _lv_font_struct*; + case MP_QSTR_h_px: data->h_px = (uint32_t)mp_obj_get_int(dest[1]); break; // converting to uint32_t; + case MP_QSTR_bpp: data->bpp = (uint32_t)mp_obj_get_int(dest[1]); break; // converting to uint32_t; + case MP_QSTR_monospace: data->monospace = (uint32_t)mp_obj_get_int(dest[1]); break; // converting to uint32_t; + case MP_QSTR_glyph_cnt: data->glyph_cnt = (uint16_t)mp_obj_get_int(dest[1]); break; // converting to uint16_t; + default: field_not_found(MP_QSTR_lv_font_t, attr); + } + + dest[0] = MP_OBJ_NULL; // indicate success + } + } +} + +STATIC void mp_lv_font_t_print(const mp_print_t *print, + mp_obj_t self_in, + mp_print_kind_t kind) +{ + mp_printf(print, "lvgl struct lv_font_t"); +} + +STATIC const mp_rom_map_elem_t mp_lv_font_t_locals_dict_table[] = { + { MP_ROM_QSTR(MP_QSTR_SIZE), MP_ROM_PTR(MP_ROM_INT(sizeof(lv_font_t))) }, + { MP_ROM_QSTR(MP_QSTR_cast), MP_ROM_PTR(&mp_lv_cast_class_method) }, +}; + +STATIC MP_DEFINE_CONST_DICT(mp_lv_font_t_locals_dict, mp_lv_font_t_locals_dict_table); + +STATIC const mp_obj_type_t mp_lv_font_t_type = { + { &mp_type_type }, + .name = MP_QSTR_lv_font_t, + .print = mp_lv_font_t_print, + .make_new = make_new_lv_struct, + .attr = mp_lv_font_t_attr, + .locals_dict = (mp_obj_dict_t*)&mp_lv_font_t_locals_dict, + .buffer_p = { .get_buffer = mp_blob_get_buffer } +}; + +STATIC inline const mp_obj_type_t *get_mp_lv_font_t_type() +{ + return &mp_lv_font_t_type; +} + + +/* + * Struct lv_style_text_t + */ + +STATIC inline const mp_obj_type_t *get_mp_lv_style_text_t_type(); + +STATIC inline lv_style_text_t* mp_write_ptr_lv_style_text_t(mp_obj_t self_in) +{ + mp_lv_struct_t *self = MP_OBJ_TO_PTR(cast(self_in, get_mp_lv_style_text_t_type())); + return (lv_style_text_t*)self->data; +} + +#define mp_write_lv_style_text_t(struct_obj) *mp_write_ptr_lv_style_text_t(struct_obj) + +STATIC inline mp_obj_t mp_read_ptr_lv_style_text_t(lv_style_text_t *field) +{ + return lv_to_mp_struct(get_mp_lv_style_text_t_type(), field); +} + +#define mp_read_lv_style_text_t(field) mp_read_ptr_lv_style_text_t(copy_buffer(&field, sizeof(lv_style_text_t))) +#define mp_read_byref_lv_style_text_t(field) mp_read_ptr_lv_style_text_t(&field) + +STATIC void mp_lv_style_text_t_attr(mp_obj_t self_in, qstr attr, mp_obj_t *dest) +{ + mp_lv_struct_t *self = MP_OBJ_TO_PTR(self_in); + lv_style_text_t *data = (lv_style_text_t*)self->data; + + if (dest[0] == MP_OBJ_NULL) { + // load attribute + switch(attr) + { + case MP_QSTR_color: dest[0] = mp_read_byref_lv_color16_t(data->color); break; // converting from lv_color_t; + case MP_QSTR_font: dest[0] = mp_read_ptr_lv_font_t((void*)data->font); break; // converting from lv_font_t*; + case MP_QSTR_letter_space: dest[0] = mp_obj_new_int(data->letter_space); break; // converting from lv_coord_t; + case MP_QSTR_line_space: dest[0] = mp_obj_new_int(data->line_space); break; // converting from lv_coord_t; + case MP_QSTR_opa: dest[0] = mp_obj_new_int_from_uint(data->opa); break; // converting from lv_opa_t; + default: field_not_found(MP_QSTR_lv_style_text_t, attr); + } + } else { + if (dest[1]) + { + // store attribute + switch(attr) + { + case MP_QSTR_color: data->color = mp_write_lv_color16_t(dest[1]); break; // converting to lv_color_t; + case MP_QSTR_font: data->font = (void*)mp_write_ptr_lv_font_t(dest[1]); break; // converting to lv_font_t*; + case MP_QSTR_letter_space: data->letter_space = (int16_t)mp_obj_get_int(dest[1]); break; // converting to lv_coord_t; + case MP_QSTR_line_space: data->line_space = (int16_t)mp_obj_get_int(dest[1]); break; // converting to lv_coord_t; + case MP_QSTR_opa: data->opa = (uint8_t)mp_obj_get_int(dest[1]); break; // converting to lv_opa_t; + default: field_not_found(MP_QSTR_lv_style_text_t, attr); + } + + dest[0] = MP_OBJ_NULL; // indicate success + } + } +} + +STATIC void mp_lv_style_text_t_print(const mp_print_t *print, + mp_obj_t self_in, + mp_print_kind_t kind) +{ + mp_printf(print, "lvgl struct lv_style_text_t"); +} + +STATIC const mp_rom_map_elem_t mp_lv_style_text_t_locals_dict_table[] = { + { MP_ROM_QSTR(MP_QSTR_SIZE), MP_ROM_PTR(MP_ROM_INT(sizeof(lv_style_text_t))) }, + { MP_ROM_QSTR(MP_QSTR_cast), MP_ROM_PTR(&mp_lv_cast_class_method) }, +}; + +STATIC MP_DEFINE_CONST_DICT(mp_lv_style_text_t_locals_dict, mp_lv_style_text_t_locals_dict_table); + +STATIC const mp_obj_type_t mp_lv_style_text_t_type = { + { &mp_type_type }, + .name = MP_QSTR_lv_style_text_t, + .print = mp_lv_style_text_t_print, + .make_new = make_new_lv_struct, + .attr = mp_lv_style_text_t_attr, + .locals_dict = (mp_obj_dict_t*)&mp_lv_style_text_t_locals_dict, + .buffer_p = { .get_buffer = mp_blob_get_buffer } +}; + +STATIC inline const mp_obj_type_t *get_mp_lv_style_text_t_type() +{ + return &mp_lv_style_text_t_type; +} + +typedef __typeof__( ((lv_style_t*)(0))->image ) lv_style_image_t; + +/* + * Struct lv_style_image_t + */ + +STATIC inline const mp_obj_type_t *get_mp_lv_style_image_t_type(); + +STATIC inline lv_style_image_t* mp_write_ptr_lv_style_image_t(mp_obj_t self_in) +{ + mp_lv_struct_t *self = MP_OBJ_TO_PTR(cast(self_in, get_mp_lv_style_image_t_type())); + return (lv_style_image_t*)self->data; +} + +#define mp_write_lv_style_image_t(struct_obj) *mp_write_ptr_lv_style_image_t(struct_obj) + +STATIC inline mp_obj_t mp_read_ptr_lv_style_image_t(lv_style_image_t *field) +{ + return lv_to_mp_struct(get_mp_lv_style_image_t_type(), field); +} + +#define mp_read_lv_style_image_t(field) mp_read_ptr_lv_style_image_t(copy_buffer(&field, sizeof(lv_style_image_t))) +#define mp_read_byref_lv_style_image_t(field) mp_read_ptr_lv_style_image_t(&field) + +STATIC void mp_lv_style_image_t_attr(mp_obj_t self_in, qstr attr, mp_obj_t *dest) +{ + mp_lv_struct_t *self = MP_OBJ_TO_PTR(self_in); + lv_style_image_t *data = (lv_style_image_t*)self->data; + + if (dest[0] == MP_OBJ_NULL) { + // load attribute + switch(attr) + { + case MP_QSTR_color: dest[0] = mp_read_byref_lv_color16_t(data->color); break; // converting from lv_color_t; + case MP_QSTR_intense: dest[0] = mp_obj_new_int_from_uint(data->intense); break; // converting from lv_opa_t; + case MP_QSTR_opa: dest[0] = mp_obj_new_int_from_uint(data->opa); break; // converting from lv_opa_t; + default: field_not_found(MP_QSTR_lv_style_image_t, attr); + } + } else { + if (dest[1]) + { + // store attribute + switch(attr) + { + case MP_QSTR_color: data->color = mp_write_lv_color16_t(dest[1]); break; // converting to lv_color_t; + case MP_QSTR_intense: data->intense = (uint8_t)mp_obj_get_int(dest[1]); break; // converting to lv_opa_t; + case MP_QSTR_opa: data->opa = (uint8_t)mp_obj_get_int(dest[1]); break; // converting to lv_opa_t; + default: field_not_found(MP_QSTR_lv_style_image_t, attr); + } + + dest[0] = MP_OBJ_NULL; // indicate success + } + } +} + +STATIC void mp_lv_style_image_t_print(const mp_print_t *print, + mp_obj_t self_in, + mp_print_kind_t kind) +{ + mp_printf(print, "lvgl struct lv_style_image_t"); +} + +STATIC const mp_rom_map_elem_t mp_lv_style_image_t_locals_dict_table[] = { + { MP_ROM_QSTR(MP_QSTR_SIZE), MP_ROM_PTR(MP_ROM_INT(sizeof(lv_style_image_t))) }, + { MP_ROM_QSTR(MP_QSTR_cast), MP_ROM_PTR(&mp_lv_cast_class_method) }, +}; + +STATIC MP_DEFINE_CONST_DICT(mp_lv_style_image_t_locals_dict, mp_lv_style_image_t_locals_dict_table); + +STATIC const mp_obj_type_t mp_lv_style_image_t_type = { + { &mp_type_type }, + .name = MP_QSTR_lv_style_image_t, + .print = mp_lv_style_image_t_print, + .make_new = make_new_lv_struct, + .attr = mp_lv_style_image_t_attr, + .locals_dict = (mp_obj_dict_t*)&mp_lv_style_image_t_locals_dict, + .buffer_p = { .get_buffer = mp_blob_get_buffer } +}; + +STATIC inline const mp_obj_type_t *get_mp_lv_style_image_t_type() +{ + return &mp_lv_style_image_t_type; +} + +typedef __typeof__( ((lv_style_t*)(0))->line ) lv_style_line_t; + +/* + * Struct lv_style_line_t + */ + +STATIC inline const mp_obj_type_t *get_mp_lv_style_line_t_type(); + +STATIC inline lv_style_line_t* mp_write_ptr_lv_style_line_t(mp_obj_t self_in) +{ + mp_lv_struct_t *self = MP_OBJ_TO_PTR(cast(self_in, get_mp_lv_style_line_t_type())); + return (lv_style_line_t*)self->data; +} + +#define mp_write_lv_style_line_t(struct_obj) *mp_write_ptr_lv_style_line_t(struct_obj) + +STATIC inline mp_obj_t mp_read_ptr_lv_style_line_t(lv_style_line_t *field) +{ + return lv_to_mp_struct(get_mp_lv_style_line_t_type(), field); +} + +#define mp_read_lv_style_line_t(field) mp_read_ptr_lv_style_line_t(copy_buffer(&field, sizeof(lv_style_line_t))) +#define mp_read_byref_lv_style_line_t(field) mp_read_ptr_lv_style_line_t(&field) + +STATIC void mp_lv_style_line_t_attr(mp_obj_t self_in, qstr attr, mp_obj_t *dest) +{ + mp_lv_struct_t *self = MP_OBJ_TO_PTR(self_in); + lv_style_line_t *data = (lv_style_line_t*)self->data; + + if (dest[0] == MP_OBJ_NULL) { + // load attribute + switch(attr) + { + case MP_QSTR_color: dest[0] = mp_read_byref_lv_color16_t(data->color); break; // converting from lv_color_t; + case MP_QSTR_width: dest[0] = mp_obj_new_int(data->width); break; // converting from lv_coord_t; + case MP_QSTR_opa: dest[0] = mp_obj_new_int_from_uint(data->opa); break; // converting from lv_opa_t; + case MP_QSTR_rounded: dest[0] = mp_obj_new_int_from_uint(data->rounded); break; // converting from uint8_t; + default: field_not_found(MP_QSTR_lv_style_line_t, attr); + } + } else { + if (dest[1]) + { + // store attribute + switch(attr) + { + case MP_QSTR_color: data->color = mp_write_lv_color16_t(dest[1]); break; // converting to lv_color_t; + case MP_QSTR_width: data->width = (int16_t)mp_obj_get_int(dest[1]); break; // converting to lv_coord_t; + case MP_QSTR_opa: data->opa = (uint8_t)mp_obj_get_int(dest[1]); break; // converting to lv_opa_t; + case MP_QSTR_rounded: data->rounded = (uint8_t)mp_obj_get_int(dest[1]); break; // converting to uint8_t; + default: field_not_found(MP_QSTR_lv_style_line_t, attr); + } + + dest[0] = MP_OBJ_NULL; // indicate success + } + } +} + +STATIC void mp_lv_style_line_t_print(const mp_print_t *print, + mp_obj_t self_in, + mp_print_kind_t kind) +{ + mp_printf(print, "lvgl struct lv_style_line_t"); +} + +STATIC const mp_rom_map_elem_t mp_lv_style_line_t_locals_dict_table[] = { + { MP_ROM_QSTR(MP_QSTR_SIZE), MP_ROM_PTR(MP_ROM_INT(sizeof(lv_style_line_t))) }, + { MP_ROM_QSTR(MP_QSTR_cast), MP_ROM_PTR(&mp_lv_cast_class_method) }, +}; + +STATIC MP_DEFINE_CONST_DICT(mp_lv_style_line_t_locals_dict, mp_lv_style_line_t_locals_dict_table); + +STATIC const mp_obj_type_t mp_lv_style_line_t_type = { + { &mp_type_type }, + .name = MP_QSTR_lv_style_line_t, + .print = mp_lv_style_line_t_print, + .make_new = make_new_lv_struct, + .attr = mp_lv_style_line_t_attr, + .locals_dict = (mp_obj_dict_t*)&mp_lv_style_line_t_locals_dict, + .buffer_p = { .get_buffer = mp_blob_get_buffer } +}; + +STATIC inline const mp_obj_type_t *get_mp_lv_style_line_t_type() +{ + return &mp_lv_style_line_t_type; +} + + +/* + * Struct lv_style_t + */ + +STATIC inline const mp_obj_type_t *get_mp_lv_style_t_type(); + +STATIC inline lv_style_t* mp_write_ptr_lv_style_t(mp_obj_t self_in) +{ + mp_lv_struct_t *self = MP_OBJ_TO_PTR(cast(self_in, get_mp_lv_style_t_type())); + return (lv_style_t*)self->data; +} + +#define mp_write_lv_style_t(struct_obj) *mp_write_ptr_lv_style_t(struct_obj) + +STATIC inline mp_obj_t mp_read_ptr_lv_style_t(lv_style_t *field) +{ + return lv_to_mp_struct(get_mp_lv_style_t_type(), field); +} + +#define mp_read_lv_style_t(field) mp_read_ptr_lv_style_t(copy_buffer(&field, sizeof(lv_style_t))) +#define mp_read_byref_lv_style_t(field) mp_read_ptr_lv_style_t(&field) + +STATIC void mp_lv_style_t_attr(mp_obj_t self_in, qstr attr, mp_obj_t *dest) +{ + mp_lv_struct_t *self = MP_OBJ_TO_PTR(self_in); + lv_style_t *data = (lv_style_t*)self->data; + + if (dest[0] == MP_OBJ_NULL) { + // load attribute + switch(attr) + { + case MP_QSTR_glass: dest[0] = mp_obj_new_int_from_uint(data->glass); break; // converting from uint8_t; + case MP_QSTR_body: dest[0] = mp_read_byref_lv_style_body_t(data->body); break; // converting from lv_style_body_t; + case MP_QSTR_text: dest[0] = mp_read_byref_lv_style_text_t(data->text); break; // converting from lv_style_text_t; + case MP_QSTR_image: dest[0] = mp_read_byref_lv_style_image_t(data->image); break; // converting from lv_style_image_t; + case MP_QSTR_line: dest[0] = mp_read_byref_lv_style_line_t(data->line); break; // converting from lv_style_line_t; + default: field_not_found(MP_QSTR_lv_style_t, attr); + } + } else { + if (dest[1]) + { + // store attribute + switch(attr) + { + case MP_QSTR_glass: data->glass = (uint8_t)mp_obj_get_int(dest[1]); break; // converting to uint8_t; + case MP_QSTR_body: data->body = mp_write_lv_style_body_t(dest[1]); break; // converting to lv_style_body_t; + case MP_QSTR_text: data->text = mp_write_lv_style_text_t(dest[1]); break; // converting to lv_style_text_t; + case MP_QSTR_image: data->image = mp_write_lv_style_image_t(dest[1]); break; // converting to lv_style_image_t; + case MP_QSTR_line: data->line = mp_write_lv_style_line_t(dest[1]); break; // converting to lv_style_line_t; + default: field_not_found(MP_QSTR_lv_style_t, attr); + } + + dest[0] = MP_OBJ_NULL; // indicate success + } + } +} + +STATIC void mp_lv_style_t_print(const mp_print_t *print, + mp_obj_t self_in, + mp_print_kind_t kind) +{ + mp_printf(print, "lvgl struct lv_style_t"); +} + +STATIC const mp_rom_map_elem_t mp_lv_style_t_locals_dict_table[] = { + { MP_ROM_QSTR(MP_QSTR_SIZE), MP_ROM_PTR(MP_ROM_INT(sizeof(lv_style_t))) }, + { MP_ROM_QSTR(MP_QSTR_cast), MP_ROM_PTR(&mp_lv_cast_class_method) }, +}; + +STATIC MP_DEFINE_CONST_DICT(mp_lv_style_t_locals_dict, mp_lv_style_t_locals_dict_table); + +STATIC const mp_obj_type_t mp_lv_style_t_type = { + { &mp_type_type }, + .name = MP_QSTR_lv_style_t, + .print = mp_lv_style_t_print, + .make_new = make_new_lv_struct, + .attr = mp_lv_style_t_attr, + .locals_dict = (mp_obj_dict_t*)&mp_lv_style_t_locals_dict, + .buffer_p = { .get_buffer = mp_blob_get_buffer } +}; + +STATIC inline const mp_obj_type_t *get_mp_lv_style_t_type() +{ + return &mp_lv_style_t_type; +} + + +/* + * Callback function lv_group_style_mod_func_t + * void lv_group_style_mod_func_t(lv_style_t *) + */ + +STATIC void lv_group_style_mod_func_t_callback(lv_style_t* arg0) +{ + mp_obj_t args[1]; + args[0] = mp_read_ptr_lv_style_t((void*)arg0); + mp_obj_t action = mp_to_lv_action(args[0]); + mp_call_function_n_kw(action, 1, 0, args); + return; +} + + +/* + * Callback function lv_group_focus_cb_t + * void lv_group_focus_cb_t(struct _lv_group_t *) + */ + +STATIC void lv_group_focus_cb_t_callback(struct _lv_group_t* arg0) +{ + mp_obj_t args[1]; + args[0] = ptr_to_mp((void*)arg0); + mp_obj_t action = mp_to_lv_action(args[0]); + mp_call_function_n_kw(action, 1, 0, args); + return; +} + + +/* + * Struct lv_img_header_t + */ + +STATIC inline const mp_obj_type_t *get_mp_lv_img_header_t_type(); + +STATIC inline lv_img_header_t* mp_write_ptr_lv_img_header_t(mp_obj_t self_in) +{ + mp_lv_struct_t *self = MP_OBJ_TO_PTR(cast(self_in, get_mp_lv_img_header_t_type())); + return (lv_img_header_t*)self->data; +} + +#define mp_write_lv_img_header_t(struct_obj) *mp_write_ptr_lv_img_header_t(struct_obj) + +STATIC inline mp_obj_t mp_read_ptr_lv_img_header_t(lv_img_header_t *field) +{ + return lv_to_mp_struct(get_mp_lv_img_header_t_type(), field); +} + +#define mp_read_lv_img_header_t(field) mp_read_ptr_lv_img_header_t(copy_buffer(&field, sizeof(lv_img_header_t))) +#define mp_read_byref_lv_img_header_t(field) mp_read_ptr_lv_img_header_t(&field) + +STATIC void mp_lv_img_header_t_attr(mp_obj_t self_in, qstr attr, mp_obj_t *dest) +{ + mp_lv_struct_t *self = MP_OBJ_TO_PTR(self_in); + lv_img_header_t *data = (lv_img_header_t*)self->data; + + if (dest[0] == MP_OBJ_NULL) { + // load attribute + switch(attr) + { + case MP_QSTR_cf: dest[0] = mp_obj_new_int_from_uint(data->cf); break; // converting from uint32_t; + case MP_QSTR_always_zero: dest[0] = mp_obj_new_int_from_uint(data->always_zero); break; // converting from uint32_t; + case MP_QSTR_reserved: dest[0] = mp_obj_new_int_from_uint(data->reserved); break; // converting from uint32_t; + case MP_QSTR_w: dest[0] = mp_obj_new_int_from_uint(data->w); break; // converting from uint32_t; + case MP_QSTR_h: dest[0] = mp_obj_new_int_from_uint(data->h); break; // converting from uint32_t; + default: field_not_found(MP_QSTR_lv_img_header_t, attr); + } + } else { + if (dest[1]) + { + // store attribute + switch(attr) + { + case MP_QSTR_cf: data->cf = (uint32_t)mp_obj_get_int(dest[1]); break; // converting to uint32_t; + case MP_QSTR_always_zero: data->always_zero = (uint32_t)mp_obj_get_int(dest[1]); break; // converting to uint32_t; + case MP_QSTR_reserved: data->reserved = (uint32_t)mp_obj_get_int(dest[1]); break; // converting to uint32_t; + case MP_QSTR_w: data->w = (uint32_t)mp_obj_get_int(dest[1]); break; // converting to uint32_t; + case MP_QSTR_h: data->h = (uint32_t)mp_obj_get_int(dest[1]); break; // converting to uint32_t; + default: field_not_found(MP_QSTR_lv_img_header_t, attr); + } + + dest[0] = MP_OBJ_NULL; // indicate success + } + } +} + +STATIC void mp_lv_img_header_t_print(const mp_print_t *print, + mp_obj_t self_in, + mp_print_kind_t kind) +{ + mp_printf(print, "lvgl struct lv_img_header_t"); +} + +STATIC const mp_rom_map_elem_t mp_lv_img_header_t_locals_dict_table[] = { + { MP_ROM_QSTR(MP_QSTR_SIZE), MP_ROM_PTR(MP_ROM_INT(sizeof(lv_img_header_t))) }, + { MP_ROM_QSTR(MP_QSTR_cast), MP_ROM_PTR(&mp_lv_cast_class_method) }, +}; + +STATIC MP_DEFINE_CONST_DICT(mp_lv_img_header_t_locals_dict, mp_lv_img_header_t_locals_dict_table); + +STATIC const mp_obj_type_t mp_lv_img_header_t_type = { + { &mp_type_type }, + .name = MP_QSTR_lv_img_header_t, + .print = mp_lv_img_header_t_print, + .make_new = make_new_lv_struct, + .attr = mp_lv_img_header_t_attr, + .locals_dict = (mp_obj_dict_t*)&mp_lv_img_header_t_locals_dict, + .buffer_p = { .get_buffer = mp_blob_get_buffer } +}; + +STATIC inline const mp_obj_type_t *get_mp_lv_img_header_t_type() +{ + return &mp_lv_img_header_t_type; +} + + +/* + * Callback function lv_img_decoder_info_f_t + * lv_res_t lv_img_decoder_info_f_t(const void *src, lv_img_header_t *header) + */ + +STATIC lv_res_t lv_img_decoder_info_f_t_callback(const void* arg0, lv_img_header_t* arg1) +{ + mp_obj_t args[2]; + args[0] = ptr_to_mp((void*)arg0); + args[1] = mp_read_ptr_lv_img_header_t((void*)arg1); + mp_obj_t action = mp_to_lv_action(args[0]); + mp_obj_t callback_result = mp_call_function_n_kw(action, 2, 0, args); + return (uint8_t)mp_obj_get_int(callback_result); +} + + +/* + * Callback function lv_img_decoder_open_f_t + * const uint8_t *lv_img_decoder_open_f_t(const void *src, const lv_style_t *style) + */ + +STATIC const uint8_t* lv_img_decoder_open_f_t_callback(const void* arg0, const lv_style_t* arg1) +{ + mp_obj_t args[2]; + args[0] = ptr_to_mp((void*)arg0); + args[1] = ptr_to_mp((void*)arg1); + mp_obj_t action = mp_to_lv_action(args[0]); + mp_obj_t callback_result = mp_call_function_n_kw(action, 2, 0, args); + return mp_to_ptr(callback_result); +} + + +/* + * Callback function lv_img_decoder_read_line_f_t + * lv_res_t lv_img_decoder_read_line_f_t(lv_coord_t x, lv_coord_t y, lv_coord_t len, uint8_t *buf) + */ + +STATIC lv_res_t lv_img_decoder_read_line_f_t_callback(lv_coord_t arg0, lv_coord_t arg1, lv_coord_t arg2, uint8_t* arg3) +{ + mp_obj_t args[4]; + args[0] = mp_obj_new_int(arg0); + args[1] = mp_obj_new_int(arg1); + args[2] = mp_obj_new_int(arg2); + args[3] = ptr_to_mp((void*)arg3); + mp_obj_t action = mp_to_lv_action(args[0]); + mp_obj_t callback_result = mp_call_function_n_kw(action, 4, 0, args); + return (uint8_t)mp_obj_get_int(callback_result); +} + + +/* + * Function NOT generated: + * Callback: Missing conversion to void + * void lv_img_decoder_close_f_t(void) + */ + + +/* + * Callback function lv_btnm_action_t + * lv_res_t lv_btnm_action_t(lv_obj_t *, const char *txt) + */ + +STATIC lv_res_t lv_btnm_action_t_callback(lv_obj_t* arg0, const char* arg1) +{ + mp_obj_t args[2]; + args[0] = lv_to_mp((void*)arg0); + args[1] = convert_to_str((void*)arg1); + mp_obj_t action = mp_to_lv_action(args[0]); + mp_obj_t callback_result = mp_call_function_n_kw(action, 2, 0, args); + return (uint8_t)mp_obj_get_int(callback_result); +} + + +/* + * Callback function lv_tabview_action_t + * lv_res_t lv_tabview_action_t(lv_obj_t *, uint16_t) + */ + +STATIC lv_res_t lv_tabview_action_t_callback(lv_obj_t* arg0, uint16_t arg1) +{ + mp_obj_t args[2]; + args[0] = lv_to_mp((void*)arg0); + args[1] = mp_obj_new_int_from_uint(arg1); + mp_obj_t action = mp_to_lv_action(args[0]); + mp_obj_t callback_result = mp_call_function_n_kw(action, 2, 0, args); + return (uint8_t)mp_obj_get_int(callback_result); +} + + +/* + * Callback function lv_tileview_action_t + * lv_res_t lv_tileview_action_t(lv_obj_t *, lv_coord_t, lv_coord_t) + */ + +STATIC lv_res_t lv_tileview_action_t_callback(lv_obj_t* arg0, lv_coord_t arg1, lv_coord_t arg2) +{ + mp_obj_t args[3]; + args[0] = lv_to_mp((void*)arg0); + args[1] = mp_obj_new_int(arg1); + args[2] = mp_obj_new_int(arg2); + mp_obj_t action = mp_to_lv_action(args[0]); + mp_obj_t callback_result = mp_call_function_n_kw(action, 3, 0, args); + return (uint8_t)mp_obj_get_int(callback_result); +} + + +/* + * Callback function lv_spinbox_value_changed_cb_t + * void lv_spinbox_value_changed_cb_t(lv_obj_t *spinbox, int32_t new_value) + */ + +STATIC void lv_spinbox_value_changed_cb_t_callback(lv_obj_t* arg0, int32_t arg1) +{ + mp_obj_t args[2]; + args[0] = lv_to_mp((void*)arg0); + args[1] = mp_obj_new_int(arg1); + mp_obj_t action = mp_to_lv_action(args[0]); + mp_call_function_n_kw(action, 2, 0, args); + return; +} + + +/* + * lvgl extension definition for: + * lv_res_t lv_obj_del(lv_obj_t *obj) + */ + +STATIC mp_obj_t mp_lv_obj_del(size_t n_args, const mp_obj_t *args) +{ + lv_obj_t *obj = mp_to_lv(args[0]); + lv_res_t res = lv_obj_del(obj); + return mp_obj_new_int_from_uint(res); +} + +STATIC MP_DEFINE_CONST_FUN_OBJ_VAR_BETWEEN(mp_lv_obj_del_obj, 1, 1, mp_lv_obj_del); + + + +/* + * lvgl extension definition for: + * void lv_obj_clean(lv_obj_t *obj) + */ + +STATIC mp_obj_t mp_lv_obj_clean(size_t n_args, const mp_obj_t *args) +{ + lv_obj_t *obj = mp_to_lv(args[0]); + lv_obj_clean(obj); + return mp_const_none; +} + +STATIC MP_DEFINE_CONST_FUN_OBJ_VAR_BETWEEN(mp_lv_obj_clean_obj, 1, 1, mp_lv_obj_clean); + + + +/* + * lvgl extension definition for: + * void lv_obj_invalidate(const lv_obj_t *obj) + */ + +STATIC mp_obj_t mp_lv_obj_invalidate(size_t n_args, const mp_obj_t *args) +{ + const lv_obj_t *obj = mp_to_lv(args[0]); + lv_obj_invalidate(obj); + return mp_const_none; +} + +STATIC MP_DEFINE_CONST_FUN_OBJ_VAR_BETWEEN(mp_lv_obj_invalidate_obj, 1, 1, mp_lv_obj_invalidate); + + + +/* + * lvgl extension definition for: + * void lv_obj_set_parent(lv_obj_t *obj, lv_obj_t *parent) + */ + +STATIC mp_obj_t mp_lv_obj_set_parent(size_t n_args, const mp_obj_t *args) +{ + lv_obj_t *obj = mp_to_lv(args[0]); + lv_obj_t *parent = mp_to_lv(args[1]); + lv_obj_set_parent(obj, parent); + return mp_const_none; +} + +STATIC MP_DEFINE_CONST_FUN_OBJ_VAR_BETWEEN(mp_lv_obj_set_parent_obj, 2, 2, mp_lv_obj_set_parent); + + + +/* + * lvgl extension definition for: + * void lv_obj_set_pos(lv_obj_t *obj, lv_coord_t x, lv_coord_t y) + */ + +STATIC mp_obj_t mp_lv_obj_set_pos(size_t n_args, const mp_obj_t *args) +{ + lv_obj_t *obj = mp_to_lv(args[0]); + lv_coord_t x = (int16_t)mp_obj_get_int(args[1]); + lv_coord_t y = (int16_t)mp_obj_get_int(args[2]); + lv_obj_set_pos(obj, x, y); + return mp_const_none; +} + +STATIC MP_DEFINE_CONST_FUN_OBJ_VAR_BETWEEN(mp_lv_obj_set_pos_obj, 3, 3, mp_lv_obj_set_pos); + + + +/* + * lvgl extension definition for: + * void lv_obj_set_x(lv_obj_t *obj, lv_coord_t x) + */ + +STATIC mp_obj_t mp_lv_obj_set_x(size_t n_args, const mp_obj_t *args) +{ + lv_obj_t *obj = mp_to_lv(args[0]); + lv_coord_t x = (int16_t)mp_obj_get_int(args[1]); + lv_obj_set_x(obj, x); + return mp_const_none; +} + +STATIC MP_DEFINE_CONST_FUN_OBJ_VAR_BETWEEN(mp_lv_obj_set_x_obj, 2, 2, mp_lv_obj_set_x); + + + +/* + * lvgl extension definition for: + * void lv_obj_set_y(lv_obj_t *obj, lv_coord_t y) + */ + +STATIC mp_obj_t mp_lv_obj_set_y(size_t n_args, const mp_obj_t *args) +{ + lv_obj_t *obj = mp_to_lv(args[0]); + lv_coord_t y = (int16_t)mp_obj_get_int(args[1]); + lv_obj_set_y(obj, y); + return mp_const_none; +} + +STATIC MP_DEFINE_CONST_FUN_OBJ_VAR_BETWEEN(mp_lv_obj_set_y_obj, 2, 2, mp_lv_obj_set_y); + + + +/* + * lvgl extension definition for: + * void lv_obj_set_size(lv_obj_t *obj, lv_coord_t w, lv_coord_t h) + */ + +STATIC mp_obj_t mp_lv_obj_set_size(size_t n_args, const mp_obj_t *args) +{ + lv_obj_t *obj = mp_to_lv(args[0]); + lv_coord_t w = (int16_t)mp_obj_get_int(args[1]); + lv_coord_t h = (int16_t)mp_obj_get_int(args[2]); + lv_obj_set_size(obj, w, h); + return mp_const_none; +} + +STATIC MP_DEFINE_CONST_FUN_OBJ_VAR_BETWEEN(mp_lv_obj_set_size_obj, 3, 3, mp_lv_obj_set_size); + + + +/* + * lvgl extension definition for: + * void lv_obj_set_width(lv_obj_t *obj, lv_coord_t w) + */ + +STATIC mp_obj_t mp_lv_obj_set_width(size_t n_args, const mp_obj_t *args) +{ + lv_obj_t *obj = mp_to_lv(args[0]); + lv_coord_t w = (int16_t)mp_obj_get_int(args[1]); + lv_obj_set_width(obj, w); + return mp_const_none; +} + +STATIC MP_DEFINE_CONST_FUN_OBJ_VAR_BETWEEN(mp_lv_obj_set_width_obj, 2, 2, mp_lv_obj_set_width); + + + +/* + * lvgl extension definition for: + * void lv_obj_set_height(lv_obj_t *obj, lv_coord_t h) + */ + +STATIC mp_obj_t mp_lv_obj_set_height(size_t n_args, const mp_obj_t *args) +{ + lv_obj_t *obj = mp_to_lv(args[0]); + lv_coord_t h = (int16_t)mp_obj_get_int(args[1]); + lv_obj_set_height(obj, h); + return mp_const_none; +} + +STATIC MP_DEFINE_CONST_FUN_OBJ_VAR_BETWEEN(mp_lv_obj_set_height_obj, 2, 2, mp_lv_obj_set_height); + + + +/* + * lvgl extension definition for: + * void lv_obj_align(lv_obj_t *obj, const lv_obj_t *base, lv_align_t align, lv_coord_t x_mod, lv_coord_t y_mod) + */ + +STATIC mp_obj_t mp_lv_obj_align(size_t n_args, const mp_obj_t *args) +{ + lv_obj_t *obj = mp_to_lv(args[0]); + const lv_obj_t *base = mp_to_lv(args[1]); + lv_align_t align = (uint8_t)mp_obj_get_int(args[2]); + lv_coord_t x_mod = (int16_t)mp_obj_get_int(args[3]); + lv_coord_t y_mod = (int16_t)mp_obj_get_int(args[4]); + lv_obj_align(obj, base, align, x_mod, y_mod); + return mp_const_none; +} + +STATIC MP_DEFINE_CONST_FUN_OBJ_VAR_BETWEEN(mp_lv_obj_align_obj, 5, 5, mp_lv_obj_align); + + + +/* + * lvgl extension definition for: + * void lv_obj_align_origo(lv_obj_t *obj, const lv_obj_t *base, lv_align_t align, lv_coord_t x_mod, lv_coord_t y_mod) + */ + +STATIC mp_obj_t mp_lv_obj_align_origo(size_t n_args, const mp_obj_t *args) +{ + lv_obj_t *obj = mp_to_lv(args[0]); + const lv_obj_t *base = mp_to_lv(args[1]); + lv_align_t align = (uint8_t)mp_obj_get_int(args[2]); + lv_coord_t x_mod = (int16_t)mp_obj_get_int(args[3]); + lv_coord_t y_mod = (int16_t)mp_obj_get_int(args[4]); + lv_obj_align_origo(obj, base, align, x_mod, y_mod); + return mp_const_none; +} + +STATIC MP_DEFINE_CONST_FUN_OBJ_VAR_BETWEEN(mp_lv_obj_align_origo_obj, 5, 5, mp_lv_obj_align_origo); + + + +/* + * lvgl extension definition for: + * void lv_obj_realign(lv_obj_t *obj) + */ + +STATIC mp_obj_t mp_lv_obj_realign(size_t n_args, const mp_obj_t *args) +{ + lv_obj_t *obj = mp_to_lv(args[0]); + lv_obj_realign(obj); + return mp_const_none; +} + +STATIC MP_DEFINE_CONST_FUN_OBJ_VAR_BETWEEN(mp_lv_obj_realign_obj, 1, 1, mp_lv_obj_realign); + + + +/* + * lvgl extension definition for: + * void lv_obj_set_auto_realign(lv_obj_t *obj, bool en) + */ + +STATIC mp_obj_t mp_lv_obj_set_auto_realign(size_t n_args, const mp_obj_t *args) +{ + lv_obj_t *obj = mp_to_lv(args[0]); + bool en = mp_obj_is_true(args[1]); + lv_obj_set_auto_realign(obj, en); + return mp_const_none; +} + +STATIC MP_DEFINE_CONST_FUN_OBJ_VAR_BETWEEN(mp_lv_obj_set_auto_realign_obj, 2, 2, mp_lv_obj_set_auto_realign); + + + +/* + * lvgl extension definition for: + * void lv_obj_set_style(lv_obj_t *obj, lv_style_t *style) + */ + +STATIC mp_obj_t mp_lv_obj_set_style(size_t n_args, const mp_obj_t *args) +{ + lv_obj_t *obj = mp_to_lv(args[0]); + lv_style_t *style = mp_write_ptr_lv_style_t(args[1]); + lv_obj_set_style(obj, style); + return mp_const_none; +} + +STATIC MP_DEFINE_CONST_FUN_OBJ_VAR_BETWEEN(mp_lv_obj_set_style_obj, 2, 2, mp_lv_obj_set_style); + + + +/* + * lvgl extension definition for: + * void lv_obj_refresh_style(lv_obj_t *obj) + */ + +STATIC mp_obj_t mp_lv_obj_refresh_style(size_t n_args, const mp_obj_t *args) +{ + lv_obj_t *obj = mp_to_lv(args[0]); + lv_obj_refresh_style(obj); + return mp_const_none; +} + +STATIC MP_DEFINE_CONST_FUN_OBJ_VAR_BETWEEN(mp_lv_obj_refresh_style_obj, 1, 1, mp_lv_obj_refresh_style); + + + +/* + * lvgl extension definition for: + * void lv_obj_report_style_mod(lv_style_t *style) + */ + +STATIC mp_obj_t mp_lv_obj_report_style_mod(size_t n_args, const mp_obj_t *args) +{ + lv_style_t *style = mp_write_ptr_lv_style_t(args[0]); + lv_obj_report_style_mod(style); + return mp_const_none; +} + +STATIC MP_DEFINE_CONST_FUN_OBJ_VAR_BETWEEN(mp_lv_obj_report_style_mod_obj, 1, 1, mp_lv_obj_report_style_mod); + + + +/* + * lvgl extension definition for: + * void lv_obj_set_hidden(lv_obj_t *obj, bool en) + */ + +STATIC mp_obj_t mp_lv_obj_set_hidden(size_t n_args, const mp_obj_t *args) +{ + lv_obj_t *obj = mp_to_lv(args[0]); + bool en = mp_obj_is_true(args[1]); + lv_obj_set_hidden(obj, en); + return mp_const_none; +} + +STATIC MP_DEFINE_CONST_FUN_OBJ_VAR_BETWEEN(mp_lv_obj_set_hidden_obj, 2, 2, mp_lv_obj_set_hidden); + + + +/* + * lvgl extension definition for: + * void lv_obj_set_click(lv_obj_t *obj, bool en) + */ + +STATIC mp_obj_t mp_lv_obj_set_click(size_t n_args, const mp_obj_t *args) +{ + lv_obj_t *obj = mp_to_lv(args[0]); + bool en = mp_obj_is_true(args[1]); + lv_obj_set_click(obj, en); + return mp_const_none; +} + +STATIC MP_DEFINE_CONST_FUN_OBJ_VAR_BETWEEN(mp_lv_obj_set_click_obj, 2, 2, mp_lv_obj_set_click); + + + +/* + * lvgl extension definition for: + * void lv_obj_set_top(lv_obj_t *obj, bool en) + */ + +STATIC mp_obj_t mp_lv_obj_set_top(size_t n_args, const mp_obj_t *args) +{ + lv_obj_t *obj = mp_to_lv(args[0]); + bool en = mp_obj_is_true(args[1]); + lv_obj_set_top(obj, en); + return mp_const_none; +} + +STATIC MP_DEFINE_CONST_FUN_OBJ_VAR_BETWEEN(mp_lv_obj_set_top_obj, 2, 2, mp_lv_obj_set_top); + + + +/* + * lvgl extension definition for: + * void lv_obj_set_drag(lv_obj_t *obj, bool en) + */ + +STATIC mp_obj_t mp_lv_obj_set_drag(size_t n_args, const mp_obj_t *args) +{ + lv_obj_t *obj = mp_to_lv(args[0]); + bool en = mp_obj_is_true(args[1]); + lv_obj_set_drag(obj, en); + return mp_const_none; +} + +STATIC MP_DEFINE_CONST_FUN_OBJ_VAR_BETWEEN(mp_lv_obj_set_drag_obj, 2, 2, mp_lv_obj_set_drag); + + + +/* + * lvgl extension definition for: + * void lv_obj_set_drag_throw(lv_obj_t *obj, bool en) + */ + +STATIC mp_obj_t mp_lv_obj_set_drag_throw(size_t n_args, const mp_obj_t *args) +{ + lv_obj_t *obj = mp_to_lv(args[0]); + bool en = mp_obj_is_true(args[1]); + lv_obj_set_drag_throw(obj, en); + return mp_const_none; +} + +STATIC MP_DEFINE_CONST_FUN_OBJ_VAR_BETWEEN(mp_lv_obj_set_drag_throw_obj, 2, 2, mp_lv_obj_set_drag_throw); + + + +/* + * lvgl extension definition for: + * void lv_obj_set_drag_parent(lv_obj_t *obj, bool en) + */ + +STATIC mp_obj_t mp_lv_obj_set_drag_parent(size_t n_args, const mp_obj_t *args) +{ + lv_obj_t *obj = mp_to_lv(args[0]); + bool en = mp_obj_is_true(args[1]); + lv_obj_set_drag_parent(obj, en); + return mp_const_none; +} + +STATIC MP_DEFINE_CONST_FUN_OBJ_VAR_BETWEEN(mp_lv_obj_set_drag_parent_obj, 2, 2, mp_lv_obj_set_drag_parent); + + + +/* + * lvgl extension definition for: + * void lv_obj_set_opa_scale_enable(lv_obj_t *obj, bool en) + */ + +STATIC mp_obj_t mp_lv_obj_set_opa_scale_enable(size_t n_args, const mp_obj_t *args) +{ + lv_obj_t *obj = mp_to_lv(args[0]); + bool en = mp_obj_is_true(args[1]); + lv_obj_set_opa_scale_enable(obj, en); + return mp_const_none; +} + +STATIC MP_DEFINE_CONST_FUN_OBJ_VAR_BETWEEN(mp_lv_obj_set_opa_scale_enable_obj, 2, 2, mp_lv_obj_set_opa_scale_enable); + + + +/* + * lvgl extension definition for: + * void lv_obj_set_opa_scale(lv_obj_t *obj, lv_opa_t opa_scale) + */ + +STATIC mp_obj_t mp_lv_obj_set_opa_scale(size_t n_args, const mp_obj_t *args) +{ + lv_obj_t *obj = mp_to_lv(args[0]); + lv_opa_t opa_scale = (uint8_t)mp_obj_get_int(args[1]); + lv_obj_set_opa_scale(obj, opa_scale); + return mp_const_none; +} + +STATIC MP_DEFINE_CONST_FUN_OBJ_VAR_BETWEEN(mp_lv_obj_set_opa_scale_obj, 2, 2, mp_lv_obj_set_opa_scale); + + + +/* + * lvgl extension definition for: + * void lv_obj_set_protect(lv_obj_t *obj, uint8_t prot) + */ + +STATIC mp_obj_t mp_lv_obj_set_protect(size_t n_args, const mp_obj_t *args) +{ + lv_obj_t *obj = mp_to_lv(args[0]); + uint8_t prot = (uint8_t)mp_obj_get_int(args[1]); + lv_obj_set_protect(obj, prot); + return mp_const_none; +} + +STATIC MP_DEFINE_CONST_FUN_OBJ_VAR_BETWEEN(mp_lv_obj_set_protect_obj, 2, 2, mp_lv_obj_set_protect); + + + +/* + * lvgl extension definition for: + * void lv_obj_clear_protect(lv_obj_t *obj, uint8_t prot) + */ + +STATIC mp_obj_t mp_lv_obj_clear_protect(size_t n_args, const mp_obj_t *args) +{ + lv_obj_t *obj = mp_to_lv(args[0]); + uint8_t prot = (uint8_t)mp_obj_get_int(args[1]); + lv_obj_clear_protect(obj, prot); + return mp_const_none; +} + +STATIC MP_DEFINE_CONST_FUN_OBJ_VAR_BETWEEN(mp_lv_obj_clear_protect_obj, 2, 2, mp_lv_obj_clear_protect); + + + +/* + * lvgl extension definition for: + * void lv_obj_set_signal_func(lv_obj_t *obj, lv_signal_func_t fp) + */ + +STATIC mp_obj_t mp_lv_obj_set_signal_func(size_t n_args, const mp_obj_t *args) +{ + lv_obj_t *obj = mp_to_lv(args[0]); + set_action(args[0], args[1]); + lv_signal_func_t fp = &lv_signal_func_t_callback; + lv_obj_set_signal_func(obj, fp); + return mp_const_none; +} + +STATIC MP_DEFINE_CONST_FUN_OBJ_VAR_BETWEEN(mp_lv_obj_set_signal_func_obj, 2, 2, mp_lv_obj_set_signal_func); + + + +/* + * lvgl extension definition for: + * void lv_obj_set_design_func(lv_obj_t *obj, lv_design_func_t fp) + */ + +STATIC mp_obj_t mp_lv_obj_set_design_func(size_t n_args, const mp_obj_t *args) +{ + lv_obj_t *obj = mp_to_lv(args[0]); + set_action(args[0], args[1]); + lv_design_func_t fp = &lv_design_func_t_callback; + lv_obj_set_design_func(obj, fp); + return mp_const_none; +} + +STATIC MP_DEFINE_CONST_FUN_OBJ_VAR_BETWEEN(mp_lv_obj_set_design_func_obj, 2, 2, mp_lv_obj_set_design_func); + + + +/* + * lvgl extension definition for: + * void *lv_obj_allocate_ext_attr(lv_obj_t *obj, uint16_t ext_size) + */ + +STATIC mp_obj_t mp_lv_obj_allocate_ext_attr(size_t n_args, const mp_obj_t *args) +{ + lv_obj_t *obj = mp_to_lv(args[0]); + uint16_t ext_size = (uint16_t)mp_obj_get_int(args[1]); + void* res = lv_obj_allocate_ext_attr(obj, ext_size); + return ptr_to_mp((void*)res); +} + +STATIC MP_DEFINE_CONST_FUN_OBJ_VAR_BETWEEN(mp_lv_obj_allocate_ext_attr_obj, 2, 2, mp_lv_obj_allocate_ext_attr); + + + +/* + * lvgl extension definition for: + * void lv_obj_refresh_ext_size(lv_obj_t *obj) + */ + +STATIC mp_obj_t mp_lv_obj_refresh_ext_size(size_t n_args, const mp_obj_t *args) +{ + lv_obj_t *obj = mp_to_lv(args[0]); + lv_obj_refresh_ext_size(obj); + return mp_const_none; +} + +STATIC MP_DEFINE_CONST_FUN_OBJ_VAR_BETWEEN(mp_lv_obj_refresh_ext_size_obj, 1, 1, mp_lv_obj_refresh_ext_size); + + + +/* + * lvgl extension definition for: + * void lv_obj_set_free_num(lv_obj_t *obj, uint32_t free_num) + */ + +STATIC mp_obj_t mp_lv_obj_set_free_num(size_t n_args, const mp_obj_t *args) +{ + lv_obj_t *obj = mp_to_lv(args[0]); + uint32_t free_num = (uint32_t)mp_obj_get_int(args[1]); + lv_obj_set_free_num(obj, free_num); + return mp_const_none; +} + +STATIC MP_DEFINE_CONST_FUN_OBJ_VAR_BETWEEN(mp_lv_obj_set_free_num_obj, 2, 2, mp_lv_obj_set_free_num); + + + +/* + * lvgl extension definition for: + * void lv_obj_set_free_ptr(lv_obj_t *obj, void *free_p) + */ + +STATIC mp_obj_t mp_lv_obj_set_free_ptr(size_t n_args, const mp_obj_t *args) +{ + lv_obj_t *obj = mp_to_lv(args[0]); + void *free_p = mp_to_ptr(args[1]); + lv_obj_set_free_ptr(obj, free_p); + return mp_const_none; +} + +STATIC MP_DEFINE_CONST_FUN_OBJ_VAR_BETWEEN(mp_lv_obj_set_free_ptr_obj, 2, 2, mp_lv_obj_set_free_ptr); + + + +/* + * lvgl extension definition for: + * void lv_obj_animate(lv_obj_t *obj, lv_anim_builtin_t type, uint16_t time, uint16_t delay, void (*cb)(lv_obj_t *)) + */ + +STATIC mp_obj_t mp_lv_obj_animate(size_t n_args, const mp_obj_t *args) +{ + lv_obj_t *obj = mp_to_lv(args[0]); + lv_anim_builtin_t type = (uint8_t)mp_obj_get_int(args[1]); + uint16_t time = (uint16_t)mp_obj_get_int(args[2]); + uint16_t delay = (uint16_t)mp_obj_get_int(args[3]); + void (*cb)(lv_obj_t *) = mp_to_ptr(args[4]); + lv_obj_animate(obj, type, time, delay, cb); + return mp_const_none; +} + +STATIC MP_DEFINE_CONST_FUN_OBJ_VAR_BETWEEN(mp_lv_obj_animate_obj, 5, 5, mp_lv_obj_animate); + + + +/* + * lvgl extension definition for: + * lv_obj_t *lv_obj_get_screen(const lv_obj_t *obj) + */ + +STATIC mp_obj_t mp_lv_obj_get_screen(size_t n_args, const mp_obj_t *args) +{ + const lv_obj_t *obj = mp_to_lv(args[0]); + lv_obj_t* res = lv_obj_get_screen(obj); + return lv_to_mp((void*)res); +} + +STATIC MP_DEFINE_CONST_FUN_OBJ_VAR_BETWEEN(mp_lv_obj_get_screen_obj, 1, 1, mp_lv_obj_get_screen); + + + +/* + * lvgl extension definition for: + * lv_obj_t *lv_obj_get_parent(const lv_obj_t *obj) + */ + +STATIC mp_obj_t mp_lv_obj_get_parent(size_t n_args, const mp_obj_t *args) +{ + const lv_obj_t *obj = mp_to_lv(args[0]); + lv_obj_t* res = lv_obj_get_parent(obj); + return lv_to_mp((void*)res); +} + +STATIC MP_DEFINE_CONST_FUN_OBJ_VAR_BETWEEN(mp_lv_obj_get_parent_obj, 1, 1, mp_lv_obj_get_parent); + + + +/* + * lvgl extension definition for: + * lv_obj_t *lv_obj_get_child(const lv_obj_t *obj, const lv_obj_t *child) + */ + +STATIC mp_obj_t mp_lv_obj_get_child(size_t n_args, const mp_obj_t *args) +{ + const lv_obj_t *obj = mp_to_lv(args[0]); + const lv_obj_t *child = mp_to_lv(args[1]); + lv_obj_t* res = lv_obj_get_child(obj, child); + return lv_to_mp((void*)res); +} + +STATIC MP_DEFINE_CONST_FUN_OBJ_VAR_BETWEEN(mp_lv_obj_get_child_obj, 2, 2, mp_lv_obj_get_child); + + + +/* + * lvgl extension definition for: + * lv_obj_t *lv_obj_get_child_back(const lv_obj_t *obj, const lv_obj_t *child) + */ + +STATIC mp_obj_t mp_lv_obj_get_child_back(size_t n_args, const mp_obj_t *args) +{ + const lv_obj_t *obj = mp_to_lv(args[0]); + const lv_obj_t *child = mp_to_lv(args[1]); + lv_obj_t* res = lv_obj_get_child_back(obj, child); + return lv_to_mp((void*)res); +} + +STATIC MP_DEFINE_CONST_FUN_OBJ_VAR_BETWEEN(mp_lv_obj_get_child_back_obj, 2, 2, mp_lv_obj_get_child_back); + + + +/* + * lvgl extension definition for: + * uint16_t lv_obj_count_children(const lv_obj_t *obj) + */ + +STATIC mp_obj_t mp_lv_obj_count_children(size_t n_args, const mp_obj_t *args) +{ + const lv_obj_t *obj = mp_to_lv(args[0]); + uint16_t res = lv_obj_count_children(obj); + return mp_obj_new_int_from_uint(res); +} + +STATIC MP_DEFINE_CONST_FUN_OBJ_VAR_BETWEEN(mp_lv_obj_count_children_obj, 1, 1, mp_lv_obj_count_children); + + + +/* + * Struct lv_area_t + */ + +STATIC inline const mp_obj_type_t *get_mp_lv_area_t_type(); + +STATIC inline lv_area_t* mp_write_ptr_lv_area_t(mp_obj_t self_in) +{ + mp_lv_struct_t *self = MP_OBJ_TO_PTR(cast(self_in, get_mp_lv_area_t_type())); + return (lv_area_t*)self->data; +} + +#define mp_write_lv_area_t(struct_obj) *mp_write_ptr_lv_area_t(struct_obj) + +STATIC inline mp_obj_t mp_read_ptr_lv_area_t(lv_area_t *field) +{ + return lv_to_mp_struct(get_mp_lv_area_t_type(), field); +} + +#define mp_read_lv_area_t(field) mp_read_ptr_lv_area_t(copy_buffer(&field, sizeof(lv_area_t))) +#define mp_read_byref_lv_area_t(field) mp_read_ptr_lv_area_t(&field) + +STATIC void mp_lv_area_t_attr(mp_obj_t self_in, qstr attr, mp_obj_t *dest) +{ + mp_lv_struct_t *self = MP_OBJ_TO_PTR(self_in); + lv_area_t *data = (lv_area_t*)self->data; + + if (dest[0] == MP_OBJ_NULL) { + // load attribute + switch(attr) + { + case MP_QSTR_x1: dest[0] = mp_obj_new_int(data->x1); break; // converting from lv_coord_t; + case MP_QSTR_y1: dest[0] = mp_obj_new_int(data->y1); break; // converting from lv_coord_t; + case MP_QSTR_x2: dest[0] = mp_obj_new_int(data->x2); break; // converting from lv_coord_t; + case MP_QSTR_y2: dest[0] = mp_obj_new_int(data->y2); break; // converting from lv_coord_t; + default: field_not_found(MP_QSTR_lv_area_t, attr); + } + } else { + if (dest[1]) + { + // store attribute + switch(attr) + { + case MP_QSTR_x1: data->x1 = (int16_t)mp_obj_get_int(dest[1]); break; // converting to lv_coord_t; + case MP_QSTR_y1: data->y1 = (int16_t)mp_obj_get_int(dest[1]); break; // converting to lv_coord_t; + case MP_QSTR_x2: data->x2 = (int16_t)mp_obj_get_int(dest[1]); break; // converting to lv_coord_t; + case MP_QSTR_y2: data->y2 = (int16_t)mp_obj_get_int(dest[1]); break; // converting to lv_coord_t; + default: field_not_found(MP_QSTR_lv_area_t, attr); + } + + dest[0] = MP_OBJ_NULL; // indicate success + } + } +} + +STATIC void mp_lv_area_t_print(const mp_print_t *print, + mp_obj_t self_in, + mp_print_kind_t kind) +{ + mp_printf(print, "lvgl struct lv_area_t"); +} + +STATIC const mp_rom_map_elem_t mp_lv_area_t_locals_dict_table[] = { + { MP_ROM_QSTR(MP_QSTR_SIZE), MP_ROM_PTR(MP_ROM_INT(sizeof(lv_area_t))) }, + { MP_ROM_QSTR(MP_QSTR_cast), MP_ROM_PTR(&mp_lv_cast_class_method) }, +}; + +STATIC MP_DEFINE_CONST_DICT(mp_lv_area_t_locals_dict, mp_lv_area_t_locals_dict_table); + +STATIC const mp_obj_type_t mp_lv_area_t_type = { + { &mp_type_type }, + .name = MP_QSTR_lv_area_t, + .print = mp_lv_area_t_print, + .make_new = make_new_lv_struct, + .attr = mp_lv_area_t_attr, + .locals_dict = (mp_obj_dict_t*)&mp_lv_area_t_locals_dict, + .buffer_p = { .get_buffer = mp_blob_get_buffer } +}; + +STATIC inline const mp_obj_type_t *get_mp_lv_area_t_type() +{ + return &mp_lv_area_t_type; +} + + +/* + * lvgl extension definition for: + * void lv_obj_get_coords(const lv_obj_t *obj, lv_area_t *cords_p) + */ + +STATIC mp_obj_t mp_lv_obj_get_coords(size_t n_args, const mp_obj_t *args) +{ + const lv_obj_t *obj = mp_to_lv(args[0]); + lv_area_t *cords_p = mp_write_ptr_lv_area_t(args[1]); + lv_obj_get_coords(obj, cords_p); + return mp_const_none; +} + +STATIC MP_DEFINE_CONST_FUN_OBJ_VAR_BETWEEN(mp_lv_obj_get_coords_obj, 2, 2, mp_lv_obj_get_coords); + + + +/* + * lvgl extension definition for: + * lv_coord_t lv_obj_get_x(const lv_obj_t *obj) + */ + +STATIC mp_obj_t mp_lv_obj_get_x(size_t n_args, const mp_obj_t *args) +{ + const lv_obj_t *obj = mp_to_lv(args[0]); + lv_coord_t res = lv_obj_get_x(obj); + return mp_obj_new_int(res); +} + +STATIC MP_DEFINE_CONST_FUN_OBJ_VAR_BETWEEN(mp_lv_obj_get_x_obj, 1, 1, mp_lv_obj_get_x); + + + +/* + * lvgl extension definition for: + * lv_coord_t lv_obj_get_y(const lv_obj_t *obj) + */ + +STATIC mp_obj_t mp_lv_obj_get_y(size_t n_args, const mp_obj_t *args) +{ + const lv_obj_t *obj = mp_to_lv(args[0]); + lv_coord_t res = lv_obj_get_y(obj); + return mp_obj_new_int(res); +} + +STATIC MP_DEFINE_CONST_FUN_OBJ_VAR_BETWEEN(mp_lv_obj_get_y_obj, 1, 1, mp_lv_obj_get_y); + + + +/* + * lvgl extension definition for: + * lv_coord_t lv_obj_get_width(const lv_obj_t *obj) + */ + +STATIC mp_obj_t mp_lv_obj_get_width(size_t n_args, const mp_obj_t *args) +{ + const lv_obj_t *obj = mp_to_lv(args[0]); + lv_coord_t res = lv_obj_get_width(obj); + return mp_obj_new_int(res); +} + +STATIC MP_DEFINE_CONST_FUN_OBJ_VAR_BETWEEN(mp_lv_obj_get_width_obj, 1, 1, mp_lv_obj_get_width); + + + +/* + * lvgl extension definition for: + * lv_coord_t lv_obj_get_height(const lv_obj_t *obj) + */ + +STATIC mp_obj_t mp_lv_obj_get_height(size_t n_args, const mp_obj_t *args) +{ + const lv_obj_t *obj = mp_to_lv(args[0]); + lv_coord_t res = lv_obj_get_height(obj); + return mp_obj_new_int(res); +} + +STATIC MP_DEFINE_CONST_FUN_OBJ_VAR_BETWEEN(mp_lv_obj_get_height_obj, 1, 1, mp_lv_obj_get_height); + + + +/* + * lvgl extension definition for: + * lv_coord_t lv_obj_get_ext_size(const lv_obj_t *obj) + */ + +STATIC mp_obj_t mp_lv_obj_get_ext_size(size_t n_args, const mp_obj_t *args) +{ + const lv_obj_t *obj = mp_to_lv(args[0]); + lv_coord_t res = lv_obj_get_ext_size(obj); + return mp_obj_new_int(res); +} + +STATIC MP_DEFINE_CONST_FUN_OBJ_VAR_BETWEEN(mp_lv_obj_get_ext_size_obj, 1, 1, mp_lv_obj_get_ext_size); + + + +/* + * lvgl extension definition for: + * bool lv_obj_get_auto_realign(lv_obj_t *obj) + */ + +STATIC mp_obj_t mp_lv_obj_get_auto_realign(size_t n_args, const mp_obj_t *args) +{ + lv_obj_t *obj = mp_to_lv(args[0]); + bool res = lv_obj_get_auto_realign(obj); + return convert_to_bool(res); +} + +STATIC MP_DEFINE_CONST_FUN_OBJ_VAR_BETWEEN(mp_lv_obj_get_auto_realign_obj, 1, 1, mp_lv_obj_get_auto_realign); + + + +/* + * lvgl extension definition for: + * lv_style_t *lv_obj_get_style(const lv_obj_t *obj) + */ + +STATIC mp_obj_t mp_lv_obj_get_style(size_t n_args, const mp_obj_t *args) +{ + const lv_obj_t *obj = mp_to_lv(args[0]); + lv_style_t* res = lv_obj_get_style(obj); + return mp_read_ptr_lv_style_t((void*)res); +} + +STATIC MP_DEFINE_CONST_FUN_OBJ_VAR_BETWEEN(mp_lv_obj_get_style_obj, 1, 1, mp_lv_obj_get_style); + + + +/* + * lvgl extension definition for: + * bool lv_obj_get_hidden(const lv_obj_t *obj) + */ + +STATIC mp_obj_t mp_lv_obj_get_hidden(size_t n_args, const mp_obj_t *args) +{ + const lv_obj_t *obj = mp_to_lv(args[0]); + bool res = lv_obj_get_hidden(obj); + return convert_to_bool(res); +} + +STATIC MP_DEFINE_CONST_FUN_OBJ_VAR_BETWEEN(mp_lv_obj_get_hidden_obj, 1, 1, mp_lv_obj_get_hidden); + + + +/* + * lvgl extension definition for: + * bool lv_obj_get_click(const lv_obj_t *obj) + */ + +STATIC mp_obj_t mp_lv_obj_get_click(size_t n_args, const mp_obj_t *args) +{ + const lv_obj_t *obj = mp_to_lv(args[0]); + bool res = lv_obj_get_click(obj); + return convert_to_bool(res); +} + +STATIC MP_DEFINE_CONST_FUN_OBJ_VAR_BETWEEN(mp_lv_obj_get_click_obj, 1, 1, mp_lv_obj_get_click); + + + +/* + * lvgl extension definition for: + * bool lv_obj_get_top(const lv_obj_t *obj) + */ + +STATIC mp_obj_t mp_lv_obj_get_top(size_t n_args, const mp_obj_t *args) +{ + const lv_obj_t *obj = mp_to_lv(args[0]); + bool res = lv_obj_get_top(obj); + return convert_to_bool(res); +} + +STATIC MP_DEFINE_CONST_FUN_OBJ_VAR_BETWEEN(mp_lv_obj_get_top_obj, 1, 1, mp_lv_obj_get_top); + + + +/* + * lvgl extension definition for: + * bool lv_obj_get_drag(const lv_obj_t *obj) + */ + +STATIC mp_obj_t mp_lv_obj_get_drag(size_t n_args, const mp_obj_t *args) +{ + const lv_obj_t *obj = mp_to_lv(args[0]); + bool res = lv_obj_get_drag(obj); + return convert_to_bool(res); +} + +STATIC MP_DEFINE_CONST_FUN_OBJ_VAR_BETWEEN(mp_lv_obj_get_drag_obj, 1, 1, mp_lv_obj_get_drag); + + + +/* + * lvgl extension definition for: + * bool lv_obj_get_drag_throw(const lv_obj_t *obj) + */ + +STATIC mp_obj_t mp_lv_obj_get_drag_throw(size_t n_args, const mp_obj_t *args) +{ + const lv_obj_t *obj = mp_to_lv(args[0]); + bool res = lv_obj_get_drag_throw(obj); + return convert_to_bool(res); +} + +STATIC MP_DEFINE_CONST_FUN_OBJ_VAR_BETWEEN(mp_lv_obj_get_drag_throw_obj, 1, 1, mp_lv_obj_get_drag_throw); + + + +/* + * lvgl extension definition for: + * bool lv_obj_get_drag_parent(const lv_obj_t *obj) + */ + +STATIC mp_obj_t mp_lv_obj_get_drag_parent(size_t n_args, const mp_obj_t *args) +{ + const lv_obj_t *obj = mp_to_lv(args[0]); + bool res = lv_obj_get_drag_parent(obj); + return convert_to_bool(res); +} + +STATIC MP_DEFINE_CONST_FUN_OBJ_VAR_BETWEEN(mp_lv_obj_get_drag_parent_obj, 1, 1, mp_lv_obj_get_drag_parent); + + + +/* + * lvgl extension definition for: + * lv_opa_t lv_obj_get_opa_scale_enable(const lv_obj_t *obj) + */ + +STATIC mp_obj_t mp_lv_obj_get_opa_scale_enable(size_t n_args, const mp_obj_t *args) +{ + const lv_obj_t *obj = mp_to_lv(args[0]); + lv_opa_t res = lv_obj_get_opa_scale_enable(obj); + return mp_obj_new_int_from_uint(res); +} + +STATIC MP_DEFINE_CONST_FUN_OBJ_VAR_BETWEEN(mp_lv_obj_get_opa_scale_enable_obj, 1, 1, mp_lv_obj_get_opa_scale_enable); + + + +/* + * lvgl extension definition for: + * lv_opa_t lv_obj_get_opa_scale(const lv_obj_t *obj) + */ + +STATIC mp_obj_t mp_lv_obj_get_opa_scale(size_t n_args, const mp_obj_t *args) +{ + const lv_obj_t *obj = mp_to_lv(args[0]); + lv_opa_t res = lv_obj_get_opa_scale(obj); + return mp_obj_new_int_from_uint(res); +} + +STATIC MP_DEFINE_CONST_FUN_OBJ_VAR_BETWEEN(mp_lv_obj_get_opa_scale_obj, 1, 1, mp_lv_obj_get_opa_scale); + + + +/* + * lvgl extension definition for: + * uint8_t lv_obj_get_protect(const lv_obj_t *obj) + */ + +STATIC mp_obj_t mp_lv_obj_get_protect(size_t n_args, const mp_obj_t *args) +{ + const lv_obj_t *obj = mp_to_lv(args[0]); + uint8_t res = lv_obj_get_protect(obj); + return mp_obj_new_int_from_uint(res); +} + +STATIC MP_DEFINE_CONST_FUN_OBJ_VAR_BETWEEN(mp_lv_obj_get_protect_obj, 1, 1, mp_lv_obj_get_protect); + + + +/* + * lvgl extension definition for: + * bool lv_obj_is_protected(const lv_obj_t *obj, uint8_t prot) + */ + +STATIC mp_obj_t mp_lv_obj_is_protected(size_t n_args, const mp_obj_t *args) +{ + const lv_obj_t *obj = mp_to_lv(args[0]); + uint8_t prot = (uint8_t)mp_obj_get_int(args[1]); + bool res = lv_obj_is_protected(obj, prot); + return convert_to_bool(res); +} + +STATIC MP_DEFINE_CONST_FUN_OBJ_VAR_BETWEEN(mp_lv_obj_is_protected_obj, 2, 2, mp_lv_obj_is_protected); + + + +/* + * lvgl extension definition for: + * lv_signal_func_t lv_obj_get_signal_func(const lv_obj_t *obj) + */ + +STATIC mp_obj_t mp_lv_obj_get_signal_func(size_t n_args, const mp_obj_t *args) +{ + const lv_obj_t *obj = mp_to_lv(args[0]); + lv_signal_func_t res = lv_obj_get_signal_func(obj); + return ptr_to_mp(res); +} + +STATIC MP_DEFINE_CONST_FUN_OBJ_VAR_BETWEEN(mp_lv_obj_get_signal_func_obj, 1, 1, mp_lv_obj_get_signal_func); + + + +/* + * lvgl extension definition for: + * lv_design_func_t lv_obj_get_design_func(const lv_obj_t *obj) + */ + +STATIC mp_obj_t mp_lv_obj_get_design_func(size_t n_args, const mp_obj_t *args) +{ + const lv_obj_t *obj = mp_to_lv(args[0]); + lv_design_func_t res = lv_obj_get_design_func(obj); + return ptr_to_mp(res); +} + +STATIC MP_DEFINE_CONST_FUN_OBJ_VAR_BETWEEN(mp_lv_obj_get_design_func_obj, 1, 1, mp_lv_obj_get_design_func); + + + +/* + * lvgl extension definition for: + * void *lv_obj_get_ext_attr(const lv_obj_t *obj) + */ + +STATIC mp_obj_t mp_lv_obj_get_ext_attr(size_t n_args, const mp_obj_t *args) +{ + const lv_obj_t *obj = mp_to_lv(args[0]); + void* res = lv_obj_get_ext_attr(obj); + return ptr_to_mp((void*)res); +} + +STATIC MP_DEFINE_CONST_FUN_OBJ_VAR_BETWEEN(mp_lv_obj_get_ext_attr_obj, 1, 1, mp_lv_obj_get_ext_attr); + + + +/* + * Function NOT generated: + * Missing conversion to char8 when generating struct lv_obj_type_t.type + * void lv_obj_get_type(lv_obj_t *obj, lv_obj_type_t *buf) + */ + + +/* + * lvgl extension definition for: + * uint32_t lv_obj_get_free_num(const lv_obj_t *obj) + */ + +STATIC mp_obj_t mp_lv_obj_get_free_num(size_t n_args, const mp_obj_t *args) +{ + const lv_obj_t *obj = mp_to_lv(args[0]); + uint32_t res = lv_obj_get_free_num(obj); + return mp_obj_new_int_from_uint(res); +} + +STATIC MP_DEFINE_CONST_FUN_OBJ_VAR_BETWEEN(mp_lv_obj_get_free_num_obj, 1, 1, mp_lv_obj_get_free_num); + + + +/* + * lvgl extension definition for: + * void *lv_obj_get_free_ptr(const lv_obj_t *obj) + */ + +STATIC mp_obj_t mp_lv_obj_get_free_ptr(size_t n_args, const mp_obj_t *args) +{ + const lv_obj_t *obj = mp_to_lv(args[0]); + void* res = lv_obj_get_free_ptr(obj); + return ptr_to_mp((void*)res); +} + +STATIC MP_DEFINE_CONST_FUN_OBJ_VAR_BETWEEN(mp_lv_obj_get_free_ptr_obj, 1, 1, mp_lv_obj_get_free_ptr); + + + +/* + * lvgl extension definition for: + * void *lv_obj_get_group(const lv_obj_t *obj) + */ + +STATIC mp_obj_t mp_lv_obj_get_group(size_t n_args, const mp_obj_t *args) +{ + const lv_obj_t *obj = mp_to_lv(args[0]); + void* res = lv_obj_get_group(obj); + return ptr_to_mp((void*)res); +} + +STATIC MP_DEFINE_CONST_FUN_OBJ_VAR_BETWEEN(mp_lv_obj_get_group_obj, 1, 1, mp_lv_obj_get_group); + + + +/* + * lvgl extension definition for: + * bool lv_obj_is_focused(const lv_obj_t *obj) + */ + +STATIC mp_obj_t mp_lv_obj_is_focused(size_t n_args, const mp_obj_t *args) +{ + const lv_obj_t *obj = mp_to_lv(args[0]); + bool res = lv_obj_is_focused(obj); + return convert_to_bool(res); +} + +STATIC MP_DEFINE_CONST_FUN_OBJ_VAR_BETWEEN(mp_lv_obj_is_focused_obj, 1, 1, mp_lv_obj_is_focused); + + + +/* + * lvgl obj object definitions + */ + + +STATIC const mp_rom_map_elem_t obj_locals_dict_table[] = { + { MP_ROM_QSTR(MP_QSTR_delete), MP_ROM_PTR(&mp_lv_obj_del_obj) }, + { MP_ROM_QSTR(MP_QSTR_clean), MP_ROM_PTR(&mp_lv_obj_clean_obj) }, + { MP_ROM_QSTR(MP_QSTR_invalidate), MP_ROM_PTR(&mp_lv_obj_invalidate_obj) }, + { MP_ROM_QSTR(MP_QSTR_set_parent), MP_ROM_PTR(&mp_lv_obj_set_parent_obj) }, + { MP_ROM_QSTR(MP_QSTR_set_pos), MP_ROM_PTR(&mp_lv_obj_set_pos_obj) }, + { MP_ROM_QSTR(MP_QSTR_set_x), MP_ROM_PTR(&mp_lv_obj_set_x_obj) }, + { MP_ROM_QSTR(MP_QSTR_set_y), MP_ROM_PTR(&mp_lv_obj_set_y_obj) }, + { MP_ROM_QSTR(MP_QSTR_set_size), MP_ROM_PTR(&mp_lv_obj_set_size_obj) }, + { MP_ROM_QSTR(MP_QSTR_set_width), MP_ROM_PTR(&mp_lv_obj_set_width_obj) }, + { MP_ROM_QSTR(MP_QSTR_set_height), MP_ROM_PTR(&mp_lv_obj_set_height_obj) }, + { MP_ROM_QSTR(MP_QSTR_align), MP_ROM_PTR(&mp_lv_obj_align_obj) }, + { MP_ROM_QSTR(MP_QSTR_align_origo), MP_ROM_PTR(&mp_lv_obj_align_origo_obj) }, + { MP_ROM_QSTR(MP_QSTR_realign), MP_ROM_PTR(&mp_lv_obj_realign_obj) }, + { MP_ROM_QSTR(MP_QSTR_set_auto_realign), MP_ROM_PTR(&mp_lv_obj_set_auto_realign_obj) }, + { MP_ROM_QSTR(MP_QSTR_set_style), MP_ROM_PTR(&mp_lv_obj_set_style_obj) }, + { MP_ROM_QSTR(MP_QSTR_refresh_style), MP_ROM_PTR(&mp_lv_obj_refresh_style_obj) }, + { MP_ROM_QSTR(MP_QSTR_report_style_mod), MP_ROM_PTR(&mp_lv_obj_report_style_mod_obj) }, + { MP_ROM_QSTR(MP_QSTR_set_hidden), MP_ROM_PTR(&mp_lv_obj_set_hidden_obj) }, + { MP_ROM_QSTR(MP_QSTR_set_click), MP_ROM_PTR(&mp_lv_obj_set_click_obj) }, + { MP_ROM_QSTR(MP_QSTR_set_top), MP_ROM_PTR(&mp_lv_obj_set_top_obj) }, + { MP_ROM_QSTR(MP_QSTR_set_drag), MP_ROM_PTR(&mp_lv_obj_set_drag_obj) }, + { MP_ROM_QSTR(MP_QSTR_set_drag_throw), MP_ROM_PTR(&mp_lv_obj_set_drag_throw_obj) }, + { MP_ROM_QSTR(MP_QSTR_set_drag_parent), MP_ROM_PTR(&mp_lv_obj_set_drag_parent_obj) }, + { MP_ROM_QSTR(MP_QSTR_set_opa_scale_enable), MP_ROM_PTR(&mp_lv_obj_set_opa_scale_enable_obj) }, + { MP_ROM_QSTR(MP_QSTR_set_opa_scale), MP_ROM_PTR(&mp_lv_obj_set_opa_scale_obj) }, + { MP_ROM_QSTR(MP_QSTR_set_protect), MP_ROM_PTR(&mp_lv_obj_set_protect_obj) }, + { MP_ROM_QSTR(MP_QSTR_clear_protect), MP_ROM_PTR(&mp_lv_obj_clear_protect_obj) }, + { MP_ROM_QSTR(MP_QSTR_set_signal_func), MP_ROM_PTR(&mp_lv_obj_set_signal_func_obj) }, + { MP_ROM_QSTR(MP_QSTR_set_design_func), MP_ROM_PTR(&mp_lv_obj_set_design_func_obj) }, + { MP_ROM_QSTR(MP_QSTR_allocate_ext_attr), MP_ROM_PTR(&mp_lv_obj_allocate_ext_attr_obj) }, + { MP_ROM_QSTR(MP_QSTR_refresh_ext_size), MP_ROM_PTR(&mp_lv_obj_refresh_ext_size_obj) }, + { MP_ROM_QSTR(MP_QSTR_set_free_num), MP_ROM_PTR(&mp_lv_obj_set_free_num_obj) }, + { MP_ROM_QSTR(MP_QSTR_set_free_ptr), MP_ROM_PTR(&mp_lv_obj_set_free_ptr_obj) }, + { MP_ROM_QSTR(MP_QSTR_animate), MP_ROM_PTR(&mp_lv_obj_animate_obj) }, + { MP_ROM_QSTR(MP_QSTR_get_screen), MP_ROM_PTR(&mp_lv_obj_get_screen_obj) }, + { MP_ROM_QSTR(MP_QSTR_get_parent), MP_ROM_PTR(&mp_lv_obj_get_parent_obj) }, + { MP_ROM_QSTR(MP_QSTR_get_child), MP_ROM_PTR(&mp_lv_obj_get_child_obj) }, + { MP_ROM_QSTR(MP_QSTR_get_child_back), MP_ROM_PTR(&mp_lv_obj_get_child_back_obj) }, + { MP_ROM_QSTR(MP_QSTR_count_children), MP_ROM_PTR(&mp_lv_obj_count_children_obj) }, + { MP_ROM_QSTR(MP_QSTR_get_coords), MP_ROM_PTR(&mp_lv_obj_get_coords_obj) }, + { MP_ROM_QSTR(MP_QSTR_get_x), MP_ROM_PTR(&mp_lv_obj_get_x_obj) }, + { MP_ROM_QSTR(MP_QSTR_get_y), MP_ROM_PTR(&mp_lv_obj_get_y_obj) }, + { MP_ROM_QSTR(MP_QSTR_get_width), MP_ROM_PTR(&mp_lv_obj_get_width_obj) }, + { MP_ROM_QSTR(MP_QSTR_get_height), MP_ROM_PTR(&mp_lv_obj_get_height_obj) }, + { MP_ROM_QSTR(MP_QSTR_get_ext_size), MP_ROM_PTR(&mp_lv_obj_get_ext_size_obj) }, + { MP_ROM_QSTR(MP_QSTR_get_auto_realign), MP_ROM_PTR(&mp_lv_obj_get_auto_realign_obj) }, + { MP_ROM_QSTR(MP_QSTR_get_style), MP_ROM_PTR(&mp_lv_obj_get_style_obj) }, + { MP_ROM_QSTR(MP_QSTR_get_hidden), MP_ROM_PTR(&mp_lv_obj_get_hidden_obj) }, + { MP_ROM_QSTR(MP_QSTR_get_click), MP_ROM_PTR(&mp_lv_obj_get_click_obj) }, + { MP_ROM_QSTR(MP_QSTR_get_top), MP_ROM_PTR(&mp_lv_obj_get_top_obj) }, + { MP_ROM_QSTR(MP_QSTR_get_drag), MP_ROM_PTR(&mp_lv_obj_get_drag_obj) }, + { MP_ROM_QSTR(MP_QSTR_get_drag_throw), MP_ROM_PTR(&mp_lv_obj_get_drag_throw_obj) }, + { MP_ROM_QSTR(MP_QSTR_get_drag_parent), MP_ROM_PTR(&mp_lv_obj_get_drag_parent_obj) }, + { MP_ROM_QSTR(MP_QSTR_get_opa_scale_enable), MP_ROM_PTR(&mp_lv_obj_get_opa_scale_enable_obj) }, + { MP_ROM_QSTR(MP_QSTR_get_opa_scale), MP_ROM_PTR(&mp_lv_obj_get_opa_scale_obj) }, + { MP_ROM_QSTR(MP_QSTR_get_protect), MP_ROM_PTR(&mp_lv_obj_get_protect_obj) }, + { MP_ROM_QSTR(MP_QSTR_is_protected), MP_ROM_PTR(&mp_lv_obj_is_protected_obj) }, + { MP_ROM_QSTR(MP_QSTR_get_signal_func), MP_ROM_PTR(&mp_lv_obj_get_signal_func_obj) }, + { MP_ROM_QSTR(MP_QSTR_get_design_func), MP_ROM_PTR(&mp_lv_obj_get_design_func_obj) }, + { MP_ROM_QSTR(MP_QSTR_get_ext_attr), MP_ROM_PTR(&mp_lv_obj_get_ext_attr_obj) }, + { MP_ROM_QSTR(MP_QSTR_get_free_num), MP_ROM_PTR(&mp_lv_obj_get_free_num_obj) }, + { MP_ROM_QSTR(MP_QSTR_get_free_ptr), MP_ROM_PTR(&mp_lv_obj_get_free_ptr_obj) }, + { MP_ROM_QSTR(MP_QSTR_get_group), MP_ROM_PTR(&mp_lv_obj_get_group_obj) }, + { MP_ROM_QSTR(MP_QSTR_is_focused), MP_ROM_PTR(&mp_lv_obj_is_focused_obj) } +}; + +STATIC MP_DEFINE_CONST_DICT(obj_locals_dict, obj_locals_dict_table); + +STATIC void obj_print(const mp_print_t *print, + mp_obj_t self_in, + mp_print_kind_t kind) +{ + mp_printf(print, "lvgl obj"); +} + + +STATIC mp_obj_t obj_make_new( + const mp_obj_type_t *type, + size_t n_args, + size_t n_kw, + const mp_obj_t *args) +{ + return make_new(&lv_obj_create, type, n_args, n_kw, args); +} + + +STATIC const mp_obj_type_t mp_obj_type = { + { &mp_type_type }, + .name = MP_QSTR_obj, + .print = obj_print, + .make_new = obj_make_new, + .locals_dict = (mp_obj_dict_t*)&obj_locals_dict, +}; + + +/* + * lvgl extension definition for: + * inline static void lv_cont_set_style(lv_obj_t *cont, lv_style_t *style) + */ + +STATIC mp_obj_t mp_lv_cont_set_style(size_t n_args, const mp_obj_t *args) +{ + lv_obj_t *cont = mp_to_lv(args[0]); + lv_style_t *style = mp_write_ptr_lv_style_t(args[1]); + lv_cont_set_style(cont, style); + return mp_const_none; +} + +STATIC MP_DEFINE_CONST_FUN_OBJ_VAR_BETWEEN(mp_lv_cont_set_style_obj, 2, 2, mp_lv_cont_set_style); + + + +/* + * lvgl extension definition for: + * inline static lv_style_t *lv_cont_get_style(const lv_obj_t *cont) + */ + +STATIC mp_obj_t mp_lv_cont_get_style(size_t n_args, const mp_obj_t *args) +{ + const lv_obj_t *cont = mp_to_lv(args[0]); + lv_style_t* res = lv_cont_get_style(cont); + return mp_read_ptr_lv_style_t((void*)res); +} + +STATIC MP_DEFINE_CONST_FUN_OBJ_VAR_BETWEEN(mp_lv_cont_get_style_obj, 1, 1, mp_lv_cont_get_style); + + + +/* + * lvgl extension definition for: + * void lv_cont_set_layout(lv_obj_t *cont, lv_layout_t layout) + */ + +STATIC mp_obj_t mp_lv_cont_set_layout(size_t n_args, const mp_obj_t *args) +{ + lv_obj_t *cont = mp_to_lv(args[0]); + lv_layout_t layout = (uint8_t)mp_obj_get_int(args[1]); + lv_cont_set_layout(cont, layout); + return mp_const_none; +} + +STATIC MP_DEFINE_CONST_FUN_OBJ_VAR_BETWEEN(mp_lv_cont_set_layout_obj, 2, 2, mp_lv_cont_set_layout); + + + +/* + * lvgl extension definition for: + * void lv_cont_set_fit(lv_obj_t *cont, bool hor_en, bool ver_en) + */ + +STATIC mp_obj_t mp_lv_cont_set_fit(size_t n_args, const mp_obj_t *args) +{ + lv_obj_t *cont = mp_to_lv(args[0]); + bool hor_en = mp_obj_is_true(args[1]); + bool ver_en = mp_obj_is_true(args[2]); + lv_cont_set_fit(cont, hor_en, ver_en); + return mp_const_none; +} + +STATIC MP_DEFINE_CONST_FUN_OBJ_VAR_BETWEEN(mp_lv_cont_set_fit_obj, 3, 3, mp_lv_cont_set_fit); + + + +/* + * lvgl extension definition for: + * lv_layout_t lv_cont_get_layout(const lv_obj_t *cont) + */ + +STATIC mp_obj_t mp_lv_cont_get_layout(size_t n_args, const mp_obj_t *args) +{ + const lv_obj_t *cont = mp_to_lv(args[0]); + lv_layout_t res = lv_cont_get_layout(cont); + return mp_obj_new_int_from_uint(res); +} + +STATIC MP_DEFINE_CONST_FUN_OBJ_VAR_BETWEEN(mp_lv_cont_get_layout_obj, 1, 1, mp_lv_cont_get_layout); + + + +/* + * lvgl extension definition for: + * bool lv_cont_get_hor_fit(const lv_obj_t *cont) + */ + +STATIC mp_obj_t mp_lv_cont_get_hor_fit(size_t n_args, const mp_obj_t *args) +{ + const lv_obj_t *cont = mp_to_lv(args[0]); + bool res = lv_cont_get_hor_fit(cont); + return convert_to_bool(res); +} + +STATIC MP_DEFINE_CONST_FUN_OBJ_VAR_BETWEEN(mp_lv_cont_get_hor_fit_obj, 1, 1, mp_lv_cont_get_hor_fit); + + + +/* + * lvgl extension definition for: + * bool lv_cont_get_ver_fit(const lv_obj_t *cont) + */ + +STATIC mp_obj_t mp_lv_cont_get_ver_fit(size_t n_args, const mp_obj_t *args) +{ + const lv_obj_t *cont = mp_to_lv(args[0]); + bool res = lv_cont_get_ver_fit(cont); + return convert_to_bool(res); +} + +STATIC MP_DEFINE_CONST_FUN_OBJ_VAR_BETWEEN(mp_lv_cont_get_ver_fit_obj, 1, 1, mp_lv_cont_get_ver_fit); + + + +/* + * lvgl extension definition for: + * lv_coord_t lv_cont_get_fit_width(lv_obj_t *cont) + */ + +STATIC mp_obj_t mp_lv_cont_get_fit_width(size_t n_args, const mp_obj_t *args) +{ + lv_obj_t *cont = mp_to_lv(args[0]); + lv_coord_t res = lv_cont_get_fit_width(cont); + return mp_obj_new_int(res); +} + +STATIC MP_DEFINE_CONST_FUN_OBJ_VAR_BETWEEN(mp_lv_cont_get_fit_width_obj, 1, 1, mp_lv_cont_get_fit_width); + + + +/* + * lvgl extension definition for: + * lv_coord_t lv_cont_get_fit_height(lv_obj_t *cont) + */ + +STATIC mp_obj_t mp_lv_cont_get_fit_height(size_t n_args, const mp_obj_t *args) +{ + lv_obj_t *cont = mp_to_lv(args[0]); + lv_coord_t res = lv_cont_get_fit_height(cont); + return mp_obj_new_int(res); +} + +STATIC MP_DEFINE_CONST_FUN_OBJ_VAR_BETWEEN(mp_lv_cont_get_fit_height_obj, 1, 1, mp_lv_cont_get_fit_height); + + + +/* + * lvgl cont object definitions + */ + + +STATIC const mp_rom_map_elem_t cont_locals_dict_table[] = { + { MP_ROM_QSTR(MP_QSTR_set_style), MP_ROM_PTR(&mp_lv_cont_set_style_obj) }, + { MP_ROM_QSTR(MP_QSTR_get_style), MP_ROM_PTR(&mp_lv_cont_get_style_obj) }, + { MP_ROM_QSTR(MP_QSTR_set_layout), MP_ROM_PTR(&mp_lv_cont_set_layout_obj) }, + { MP_ROM_QSTR(MP_QSTR_set_fit), MP_ROM_PTR(&mp_lv_cont_set_fit_obj) }, + { MP_ROM_QSTR(MP_QSTR_get_layout), MP_ROM_PTR(&mp_lv_cont_get_layout_obj) }, + { MP_ROM_QSTR(MP_QSTR_get_hor_fit), MP_ROM_PTR(&mp_lv_cont_get_hor_fit_obj) }, + { MP_ROM_QSTR(MP_QSTR_get_ver_fit), MP_ROM_PTR(&mp_lv_cont_get_ver_fit_obj) }, + { MP_ROM_QSTR(MP_QSTR_get_fit_width), MP_ROM_PTR(&mp_lv_cont_get_fit_width_obj) }, + { MP_ROM_QSTR(MP_QSTR_get_fit_height), MP_ROM_PTR(&mp_lv_cont_get_fit_height_obj) }, + { MP_ROM_QSTR(MP_QSTR_delete), MP_ROM_PTR(&mp_lv_obj_del_obj) }, + { MP_ROM_QSTR(MP_QSTR_clean), MP_ROM_PTR(&mp_lv_obj_clean_obj) }, + { MP_ROM_QSTR(MP_QSTR_invalidate), MP_ROM_PTR(&mp_lv_obj_invalidate_obj) }, + { MP_ROM_QSTR(MP_QSTR_set_parent), MP_ROM_PTR(&mp_lv_obj_set_parent_obj) }, + { MP_ROM_QSTR(MP_QSTR_set_pos), MP_ROM_PTR(&mp_lv_obj_set_pos_obj) }, + { MP_ROM_QSTR(MP_QSTR_set_x), MP_ROM_PTR(&mp_lv_obj_set_x_obj) }, + { MP_ROM_QSTR(MP_QSTR_set_y), MP_ROM_PTR(&mp_lv_obj_set_y_obj) }, + { MP_ROM_QSTR(MP_QSTR_set_size), MP_ROM_PTR(&mp_lv_obj_set_size_obj) }, + { MP_ROM_QSTR(MP_QSTR_set_width), MP_ROM_PTR(&mp_lv_obj_set_width_obj) }, + { MP_ROM_QSTR(MP_QSTR_set_height), MP_ROM_PTR(&mp_lv_obj_set_height_obj) }, + { MP_ROM_QSTR(MP_QSTR_align), MP_ROM_PTR(&mp_lv_obj_align_obj) }, + { MP_ROM_QSTR(MP_QSTR_align_origo), MP_ROM_PTR(&mp_lv_obj_align_origo_obj) }, + { MP_ROM_QSTR(MP_QSTR_realign), MP_ROM_PTR(&mp_lv_obj_realign_obj) }, + { MP_ROM_QSTR(MP_QSTR_set_auto_realign), MP_ROM_PTR(&mp_lv_obj_set_auto_realign_obj) }, + { MP_ROM_QSTR(MP_QSTR_set_style), MP_ROM_PTR(&mp_lv_obj_set_style_obj) }, + { MP_ROM_QSTR(MP_QSTR_refresh_style), MP_ROM_PTR(&mp_lv_obj_refresh_style_obj) }, + { MP_ROM_QSTR(MP_QSTR_report_style_mod), MP_ROM_PTR(&mp_lv_obj_report_style_mod_obj) }, + { MP_ROM_QSTR(MP_QSTR_set_hidden), MP_ROM_PTR(&mp_lv_obj_set_hidden_obj) }, + { MP_ROM_QSTR(MP_QSTR_set_click), MP_ROM_PTR(&mp_lv_obj_set_click_obj) }, + { MP_ROM_QSTR(MP_QSTR_set_top), MP_ROM_PTR(&mp_lv_obj_set_top_obj) }, + { MP_ROM_QSTR(MP_QSTR_set_drag), MP_ROM_PTR(&mp_lv_obj_set_drag_obj) }, + { MP_ROM_QSTR(MP_QSTR_set_drag_throw), MP_ROM_PTR(&mp_lv_obj_set_drag_throw_obj) }, + { MP_ROM_QSTR(MP_QSTR_set_drag_parent), MP_ROM_PTR(&mp_lv_obj_set_drag_parent_obj) }, + { MP_ROM_QSTR(MP_QSTR_set_opa_scale_enable), MP_ROM_PTR(&mp_lv_obj_set_opa_scale_enable_obj) }, + { MP_ROM_QSTR(MP_QSTR_set_opa_scale), MP_ROM_PTR(&mp_lv_obj_set_opa_scale_obj) }, + { MP_ROM_QSTR(MP_QSTR_set_protect), MP_ROM_PTR(&mp_lv_obj_set_protect_obj) }, + { MP_ROM_QSTR(MP_QSTR_clear_protect), MP_ROM_PTR(&mp_lv_obj_clear_protect_obj) }, + { MP_ROM_QSTR(MP_QSTR_set_signal_func), MP_ROM_PTR(&mp_lv_obj_set_signal_func_obj) }, + { MP_ROM_QSTR(MP_QSTR_set_design_func), MP_ROM_PTR(&mp_lv_obj_set_design_func_obj) }, + { MP_ROM_QSTR(MP_QSTR_allocate_ext_attr), MP_ROM_PTR(&mp_lv_obj_allocate_ext_attr_obj) }, + { MP_ROM_QSTR(MP_QSTR_refresh_ext_size), MP_ROM_PTR(&mp_lv_obj_refresh_ext_size_obj) }, + { MP_ROM_QSTR(MP_QSTR_set_free_num), MP_ROM_PTR(&mp_lv_obj_set_free_num_obj) }, + { MP_ROM_QSTR(MP_QSTR_set_free_ptr), MP_ROM_PTR(&mp_lv_obj_set_free_ptr_obj) }, + { MP_ROM_QSTR(MP_QSTR_animate), MP_ROM_PTR(&mp_lv_obj_animate_obj) }, + { MP_ROM_QSTR(MP_QSTR_get_screen), MP_ROM_PTR(&mp_lv_obj_get_screen_obj) }, + { MP_ROM_QSTR(MP_QSTR_get_parent), MP_ROM_PTR(&mp_lv_obj_get_parent_obj) }, + { MP_ROM_QSTR(MP_QSTR_get_child), MP_ROM_PTR(&mp_lv_obj_get_child_obj) }, + { MP_ROM_QSTR(MP_QSTR_get_child_back), MP_ROM_PTR(&mp_lv_obj_get_child_back_obj) }, + { MP_ROM_QSTR(MP_QSTR_count_children), MP_ROM_PTR(&mp_lv_obj_count_children_obj) }, + { MP_ROM_QSTR(MP_QSTR_get_coords), MP_ROM_PTR(&mp_lv_obj_get_coords_obj) }, + { MP_ROM_QSTR(MP_QSTR_get_x), MP_ROM_PTR(&mp_lv_obj_get_x_obj) }, + { MP_ROM_QSTR(MP_QSTR_get_y), MP_ROM_PTR(&mp_lv_obj_get_y_obj) }, + { MP_ROM_QSTR(MP_QSTR_get_width), MP_ROM_PTR(&mp_lv_obj_get_width_obj) }, + { MP_ROM_QSTR(MP_QSTR_get_height), MP_ROM_PTR(&mp_lv_obj_get_height_obj) }, + { MP_ROM_QSTR(MP_QSTR_get_ext_size), MP_ROM_PTR(&mp_lv_obj_get_ext_size_obj) }, + { MP_ROM_QSTR(MP_QSTR_get_auto_realign), MP_ROM_PTR(&mp_lv_obj_get_auto_realign_obj) }, + { MP_ROM_QSTR(MP_QSTR_get_style), MP_ROM_PTR(&mp_lv_obj_get_style_obj) }, + { MP_ROM_QSTR(MP_QSTR_get_hidden), MP_ROM_PTR(&mp_lv_obj_get_hidden_obj) }, + { MP_ROM_QSTR(MP_QSTR_get_click), MP_ROM_PTR(&mp_lv_obj_get_click_obj) }, + { MP_ROM_QSTR(MP_QSTR_get_top), MP_ROM_PTR(&mp_lv_obj_get_top_obj) }, + { MP_ROM_QSTR(MP_QSTR_get_drag), MP_ROM_PTR(&mp_lv_obj_get_drag_obj) }, + { MP_ROM_QSTR(MP_QSTR_get_drag_throw), MP_ROM_PTR(&mp_lv_obj_get_drag_throw_obj) }, + { MP_ROM_QSTR(MP_QSTR_get_drag_parent), MP_ROM_PTR(&mp_lv_obj_get_drag_parent_obj) }, + { MP_ROM_QSTR(MP_QSTR_get_opa_scale_enable), MP_ROM_PTR(&mp_lv_obj_get_opa_scale_enable_obj) }, + { MP_ROM_QSTR(MP_QSTR_get_opa_scale), MP_ROM_PTR(&mp_lv_obj_get_opa_scale_obj) }, + { MP_ROM_QSTR(MP_QSTR_get_protect), MP_ROM_PTR(&mp_lv_obj_get_protect_obj) }, + { MP_ROM_QSTR(MP_QSTR_is_protected), MP_ROM_PTR(&mp_lv_obj_is_protected_obj) }, + { MP_ROM_QSTR(MP_QSTR_get_signal_func), MP_ROM_PTR(&mp_lv_obj_get_signal_func_obj) }, + { MP_ROM_QSTR(MP_QSTR_get_design_func), MP_ROM_PTR(&mp_lv_obj_get_design_func_obj) }, + { MP_ROM_QSTR(MP_QSTR_get_ext_attr), MP_ROM_PTR(&mp_lv_obj_get_ext_attr_obj) }, + { MP_ROM_QSTR(MP_QSTR_get_free_num), MP_ROM_PTR(&mp_lv_obj_get_free_num_obj) }, + { MP_ROM_QSTR(MP_QSTR_get_free_ptr), MP_ROM_PTR(&mp_lv_obj_get_free_ptr_obj) }, + { MP_ROM_QSTR(MP_QSTR_get_group), MP_ROM_PTR(&mp_lv_obj_get_group_obj) }, + { MP_ROM_QSTR(MP_QSTR_is_focused), MP_ROM_PTR(&mp_lv_obj_is_focused_obj) } +}; + +STATIC MP_DEFINE_CONST_DICT(cont_locals_dict, cont_locals_dict_table); + +STATIC void cont_print(const mp_print_t *print, + mp_obj_t self_in, + mp_print_kind_t kind) +{ + mp_printf(print, "lvgl cont"); +} + + +STATIC mp_obj_t cont_make_new( + const mp_obj_type_t *type, + size_t n_args, + size_t n_kw, + const mp_obj_t *args) +{ + return make_new(&lv_cont_create, type, n_args, n_kw, args); +} + + +STATIC const mp_obj_type_t mp_cont_type = { + { &mp_type_type }, + .name = MP_QSTR_cont, + .print = cont_print, + .make_new = cont_make_new, + .locals_dict = (mp_obj_dict_t*)&cont_locals_dict, +}; + + +/* + * lvgl extension definition for: + * inline static void lv_btn_set_layout(lv_obj_t *btn, lv_layout_t layout) + */ + +STATIC mp_obj_t mp_lv_btn_set_layout(size_t n_args, const mp_obj_t *args) +{ + lv_obj_t *btn = mp_to_lv(args[0]); + lv_layout_t layout = (uint8_t)mp_obj_get_int(args[1]); + lv_btn_set_layout(btn, layout); + return mp_const_none; +} + +STATIC MP_DEFINE_CONST_FUN_OBJ_VAR_BETWEEN(mp_lv_btn_set_layout_obj, 2, 2, mp_lv_btn_set_layout); + + + +/* + * lvgl extension definition for: + * inline static void lv_btn_set_fit(lv_obj_t *btn, bool hor_en, bool ver_en) + */ + +STATIC mp_obj_t mp_lv_btn_set_fit(size_t n_args, const mp_obj_t *args) +{ + lv_obj_t *btn = mp_to_lv(args[0]); + bool hor_en = mp_obj_is_true(args[1]); + bool ver_en = mp_obj_is_true(args[2]); + lv_btn_set_fit(btn, hor_en, ver_en); + return mp_const_none; +} + +STATIC MP_DEFINE_CONST_FUN_OBJ_VAR_BETWEEN(mp_lv_btn_set_fit_obj, 3, 3, mp_lv_btn_set_fit); + + + +/* + * lvgl extension definition for: + * inline static lv_layout_t lv_btn_get_layout(const lv_obj_t *btn) + */ + +STATIC mp_obj_t mp_lv_btn_get_layout(size_t n_args, const mp_obj_t *args) +{ + const lv_obj_t *btn = mp_to_lv(args[0]); + lv_layout_t res = lv_btn_get_layout(btn); + return mp_obj_new_int_from_uint(res); +} + +STATIC MP_DEFINE_CONST_FUN_OBJ_VAR_BETWEEN(mp_lv_btn_get_layout_obj, 1, 1, mp_lv_btn_get_layout); + + + +/* + * lvgl extension definition for: + * inline static bool lv_btn_get_hor_fit(const lv_obj_t *btn) + */ + +STATIC mp_obj_t mp_lv_btn_get_hor_fit(size_t n_args, const mp_obj_t *args) +{ + const lv_obj_t *btn = mp_to_lv(args[0]); + bool res = lv_btn_get_hor_fit(btn); + return convert_to_bool(res); +} + +STATIC MP_DEFINE_CONST_FUN_OBJ_VAR_BETWEEN(mp_lv_btn_get_hor_fit_obj, 1, 1, mp_lv_btn_get_hor_fit); + + + +/* + * lvgl extension definition for: + * inline static bool lv_btn_get_ver_fit(const lv_obj_t *btn) + */ + +STATIC mp_obj_t mp_lv_btn_get_ver_fit(size_t n_args, const mp_obj_t *args) +{ + const lv_obj_t *btn = mp_to_lv(args[0]); + bool res = lv_btn_get_ver_fit(btn); + return convert_to_bool(res); +} + +STATIC MP_DEFINE_CONST_FUN_OBJ_VAR_BETWEEN(mp_lv_btn_get_ver_fit_obj, 1, 1, mp_lv_btn_get_ver_fit); + + + +/* + * lvgl extension definition for: + * void lv_btn_set_toggle(lv_obj_t *btn, bool tgl) + */ + +STATIC mp_obj_t mp_lv_btn_set_toggle(size_t n_args, const mp_obj_t *args) +{ + lv_obj_t *btn = mp_to_lv(args[0]); + bool tgl = mp_obj_is_true(args[1]); + lv_btn_set_toggle(btn, tgl); + return mp_const_none; +} + +STATIC MP_DEFINE_CONST_FUN_OBJ_VAR_BETWEEN(mp_lv_btn_set_toggle_obj, 2, 2, mp_lv_btn_set_toggle); + + + +/* + * lvgl extension definition for: + * void lv_btn_set_state(lv_obj_t *btn, lv_btn_state_t state) + */ + +STATIC mp_obj_t mp_lv_btn_set_state(size_t n_args, const mp_obj_t *args) +{ + lv_obj_t *btn = mp_to_lv(args[0]); + lv_btn_state_t state = (uint8_t)mp_obj_get_int(args[1]); + lv_btn_set_state(btn, state); + return mp_const_none; +} + +STATIC MP_DEFINE_CONST_FUN_OBJ_VAR_BETWEEN(mp_lv_btn_set_state_obj, 2, 2, mp_lv_btn_set_state); + + + +/* + * lvgl extension definition for: + * void lv_btn_toggle(lv_obj_t *btn) + */ + +STATIC mp_obj_t mp_lv_btn_toggle(size_t n_args, const mp_obj_t *args) +{ + lv_obj_t *btn = mp_to_lv(args[0]); + lv_btn_toggle(btn); + return mp_const_none; +} + +STATIC MP_DEFINE_CONST_FUN_OBJ_VAR_BETWEEN(mp_lv_btn_toggle_obj, 1, 1, mp_lv_btn_toggle); + + + +/* + * lvgl extension definition for: + * void lv_btn_set_action(lv_obj_t *btn, lv_btn_action_t type, lv_action_t action) + */ + +STATIC mp_obj_t mp_lv_btn_set_action(size_t n_args, const mp_obj_t *args) +{ + lv_obj_t *btn = mp_to_lv(args[0]); + lv_btn_action_t type = (uint8_t)mp_obj_get_int(args[1]); + set_action(args[0], args[2]); + lv_action_t action = &lv_action_t_callback; + lv_btn_set_action(btn, type, action); + return mp_const_none; +} + +STATIC MP_DEFINE_CONST_FUN_OBJ_VAR_BETWEEN(mp_lv_btn_set_action_obj, 3, 3, mp_lv_btn_set_action); + + + +/* + * lvgl extension definition for: + * void lv_btn_set_ink_in_time(lv_obj_t *btn, uint16_t time) + */ + +STATIC mp_obj_t mp_lv_btn_set_ink_in_time(size_t n_args, const mp_obj_t *args) +{ + lv_obj_t *btn = mp_to_lv(args[0]); + uint16_t time = (uint16_t)mp_obj_get_int(args[1]); + lv_btn_set_ink_in_time(btn, time); + return mp_const_none; +} + +STATIC MP_DEFINE_CONST_FUN_OBJ_VAR_BETWEEN(mp_lv_btn_set_ink_in_time_obj, 2, 2, mp_lv_btn_set_ink_in_time); + + + +/* + * lvgl extension definition for: + * void lv_btn_set_ink_wait_time(lv_obj_t *btn, uint16_t time) + */ + +STATIC mp_obj_t mp_lv_btn_set_ink_wait_time(size_t n_args, const mp_obj_t *args) +{ + lv_obj_t *btn = mp_to_lv(args[0]); + uint16_t time = (uint16_t)mp_obj_get_int(args[1]); + lv_btn_set_ink_wait_time(btn, time); + return mp_const_none; +} + +STATIC MP_DEFINE_CONST_FUN_OBJ_VAR_BETWEEN(mp_lv_btn_set_ink_wait_time_obj, 2, 2, mp_lv_btn_set_ink_wait_time); + + + +/* + * lvgl extension definition for: + * void lv_btn_set_ink_out_time(lv_obj_t *btn, uint16_t time) + */ + +STATIC mp_obj_t mp_lv_btn_set_ink_out_time(size_t n_args, const mp_obj_t *args) +{ + lv_obj_t *btn = mp_to_lv(args[0]); + uint16_t time = (uint16_t)mp_obj_get_int(args[1]); + lv_btn_set_ink_out_time(btn, time); + return mp_const_none; +} + +STATIC MP_DEFINE_CONST_FUN_OBJ_VAR_BETWEEN(mp_lv_btn_set_ink_out_time_obj, 2, 2, mp_lv_btn_set_ink_out_time); + + + +/* + * lvgl extension definition for: + * void lv_btn_set_style(lv_obj_t *btn, lv_btn_style_t type, lv_style_t *style) + */ + +STATIC mp_obj_t mp_lv_btn_set_style(size_t n_args, const mp_obj_t *args) +{ + lv_obj_t *btn = mp_to_lv(args[0]); + lv_btn_style_t type = (uint8_t)mp_obj_get_int(args[1]); + lv_style_t *style = mp_write_ptr_lv_style_t(args[2]); + lv_btn_set_style(btn, type, style); + return mp_const_none; +} + +STATIC MP_DEFINE_CONST_FUN_OBJ_VAR_BETWEEN(mp_lv_btn_set_style_obj, 3, 3, mp_lv_btn_set_style); + + + +/* + * lvgl extension definition for: + * lv_btn_state_t lv_btn_get_state(const lv_obj_t *btn) + */ + +STATIC mp_obj_t mp_lv_btn_get_state(size_t n_args, const mp_obj_t *args) +{ + const lv_obj_t *btn = mp_to_lv(args[0]); + lv_btn_state_t res = lv_btn_get_state(btn); + return mp_obj_new_int_from_uint(res); +} + +STATIC MP_DEFINE_CONST_FUN_OBJ_VAR_BETWEEN(mp_lv_btn_get_state_obj, 1, 1, mp_lv_btn_get_state); + + + +/* + * lvgl extension definition for: + * bool lv_btn_get_toggle(const lv_obj_t *btn) + */ + +STATIC mp_obj_t mp_lv_btn_get_toggle(size_t n_args, const mp_obj_t *args) +{ + const lv_obj_t *btn = mp_to_lv(args[0]); + bool res = lv_btn_get_toggle(btn); + return convert_to_bool(res); +} + +STATIC MP_DEFINE_CONST_FUN_OBJ_VAR_BETWEEN(mp_lv_btn_get_toggle_obj, 1, 1, mp_lv_btn_get_toggle); + + + +/* + * lvgl extension definition for: + * lv_action_t lv_btn_get_action(const lv_obj_t *btn, lv_btn_action_t type) + */ + +STATIC mp_obj_t mp_lv_btn_get_action(size_t n_args, const mp_obj_t *args) +{ + const lv_obj_t *btn = mp_to_lv(args[0]); + lv_btn_action_t type = (uint8_t)mp_obj_get_int(args[1]); + lv_action_t res = lv_btn_get_action(btn, type); + return ptr_to_mp(res); +} + +STATIC MP_DEFINE_CONST_FUN_OBJ_VAR_BETWEEN(mp_lv_btn_get_action_obj, 2, 2, mp_lv_btn_get_action); + + + +/* + * lvgl extension definition for: + * uint16_t lv_btn_get_ink_in_time(const lv_obj_t *btn) + */ + +STATIC mp_obj_t mp_lv_btn_get_ink_in_time(size_t n_args, const mp_obj_t *args) +{ + const lv_obj_t *btn = mp_to_lv(args[0]); + uint16_t res = lv_btn_get_ink_in_time(btn); + return mp_obj_new_int_from_uint(res); +} + +STATIC MP_DEFINE_CONST_FUN_OBJ_VAR_BETWEEN(mp_lv_btn_get_ink_in_time_obj, 1, 1, mp_lv_btn_get_ink_in_time); + + + +/* + * lvgl extension definition for: + * uint16_t lv_btn_get_ink_wait_time(const lv_obj_t *btn) + */ + +STATIC mp_obj_t mp_lv_btn_get_ink_wait_time(size_t n_args, const mp_obj_t *args) +{ + const lv_obj_t *btn = mp_to_lv(args[0]); + uint16_t res = lv_btn_get_ink_wait_time(btn); + return mp_obj_new_int_from_uint(res); +} + +STATIC MP_DEFINE_CONST_FUN_OBJ_VAR_BETWEEN(mp_lv_btn_get_ink_wait_time_obj, 1, 1, mp_lv_btn_get_ink_wait_time); + + + +/* + * lvgl extension definition for: + * uint16_t lv_btn_get_ink_out_time(const lv_obj_t *btn) + */ + +STATIC mp_obj_t mp_lv_btn_get_ink_out_time(size_t n_args, const mp_obj_t *args) +{ + const lv_obj_t *btn = mp_to_lv(args[0]); + uint16_t res = lv_btn_get_ink_out_time(btn); + return mp_obj_new_int_from_uint(res); +} + +STATIC MP_DEFINE_CONST_FUN_OBJ_VAR_BETWEEN(mp_lv_btn_get_ink_out_time_obj, 1, 1, mp_lv_btn_get_ink_out_time); + + + +/* + * lvgl extension definition for: + * lv_style_t *lv_btn_get_style(const lv_obj_t *btn, lv_btn_style_t type) + */ + +STATIC mp_obj_t mp_lv_btn_get_style(size_t n_args, const mp_obj_t *args) +{ + const lv_obj_t *btn = mp_to_lv(args[0]); + lv_btn_style_t type = (uint8_t)mp_obj_get_int(args[1]); + lv_style_t* res = lv_btn_get_style(btn, type); + return mp_read_ptr_lv_style_t((void*)res); +} + +STATIC MP_DEFINE_CONST_FUN_OBJ_VAR_BETWEEN(mp_lv_btn_get_style_obj, 2, 2, mp_lv_btn_get_style); + + + +/* + * lvgl btn object definitions + */ + + +STATIC const mp_rom_map_elem_t btn_locals_dict_table[] = { + { MP_ROM_QSTR(MP_QSTR_set_layout), MP_ROM_PTR(&mp_lv_btn_set_layout_obj) }, + { MP_ROM_QSTR(MP_QSTR_set_fit), MP_ROM_PTR(&mp_lv_btn_set_fit_obj) }, + { MP_ROM_QSTR(MP_QSTR_get_layout), MP_ROM_PTR(&mp_lv_btn_get_layout_obj) }, + { MP_ROM_QSTR(MP_QSTR_get_hor_fit), MP_ROM_PTR(&mp_lv_btn_get_hor_fit_obj) }, + { MP_ROM_QSTR(MP_QSTR_get_ver_fit), MP_ROM_PTR(&mp_lv_btn_get_ver_fit_obj) }, + { MP_ROM_QSTR(MP_QSTR_set_toggle), MP_ROM_PTR(&mp_lv_btn_set_toggle_obj) }, + { MP_ROM_QSTR(MP_QSTR_set_state), MP_ROM_PTR(&mp_lv_btn_set_state_obj) }, + { MP_ROM_QSTR(MP_QSTR_toggle), MP_ROM_PTR(&mp_lv_btn_toggle_obj) }, + { MP_ROM_QSTR(MP_QSTR_set_action), MP_ROM_PTR(&mp_lv_btn_set_action_obj) }, + { MP_ROM_QSTR(MP_QSTR_set_ink_in_time), MP_ROM_PTR(&mp_lv_btn_set_ink_in_time_obj) }, + { MP_ROM_QSTR(MP_QSTR_set_ink_wait_time), MP_ROM_PTR(&mp_lv_btn_set_ink_wait_time_obj) }, + { MP_ROM_QSTR(MP_QSTR_set_ink_out_time), MP_ROM_PTR(&mp_lv_btn_set_ink_out_time_obj) }, + { MP_ROM_QSTR(MP_QSTR_set_style), MP_ROM_PTR(&mp_lv_btn_set_style_obj) }, + { MP_ROM_QSTR(MP_QSTR_get_state), MP_ROM_PTR(&mp_lv_btn_get_state_obj) }, + { MP_ROM_QSTR(MP_QSTR_get_toggle), MP_ROM_PTR(&mp_lv_btn_get_toggle_obj) }, + { MP_ROM_QSTR(MP_QSTR_get_action), MP_ROM_PTR(&mp_lv_btn_get_action_obj) }, + { MP_ROM_QSTR(MP_QSTR_get_ink_in_time), MP_ROM_PTR(&mp_lv_btn_get_ink_in_time_obj) }, + { MP_ROM_QSTR(MP_QSTR_get_ink_wait_time), MP_ROM_PTR(&mp_lv_btn_get_ink_wait_time_obj) }, + { MP_ROM_QSTR(MP_QSTR_get_ink_out_time), MP_ROM_PTR(&mp_lv_btn_get_ink_out_time_obj) }, + { MP_ROM_QSTR(MP_QSTR_get_style), MP_ROM_PTR(&mp_lv_btn_get_style_obj) }, + { MP_ROM_QSTR(MP_QSTR_delete), MP_ROM_PTR(&mp_lv_obj_del_obj) }, + { MP_ROM_QSTR(MP_QSTR_clean), MP_ROM_PTR(&mp_lv_obj_clean_obj) }, + { MP_ROM_QSTR(MP_QSTR_invalidate), MP_ROM_PTR(&mp_lv_obj_invalidate_obj) }, + { MP_ROM_QSTR(MP_QSTR_set_parent), MP_ROM_PTR(&mp_lv_obj_set_parent_obj) }, + { MP_ROM_QSTR(MP_QSTR_set_pos), MP_ROM_PTR(&mp_lv_obj_set_pos_obj) }, + { MP_ROM_QSTR(MP_QSTR_set_x), MP_ROM_PTR(&mp_lv_obj_set_x_obj) }, + { MP_ROM_QSTR(MP_QSTR_set_y), MP_ROM_PTR(&mp_lv_obj_set_y_obj) }, + { MP_ROM_QSTR(MP_QSTR_set_size), MP_ROM_PTR(&mp_lv_obj_set_size_obj) }, + { MP_ROM_QSTR(MP_QSTR_set_width), MP_ROM_PTR(&mp_lv_obj_set_width_obj) }, + { MP_ROM_QSTR(MP_QSTR_set_height), MP_ROM_PTR(&mp_lv_obj_set_height_obj) }, + { MP_ROM_QSTR(MP_QSTR_align), MP_ROM_PTR(&mp_lv_obj_align_obj) }, + { MP_ROM_QSTR(MP_QSTR_align_origo), MP_ROM_PTR(&mp_lv_obj_align_origo_obj) }, + { MP_ROM_QSTR(MP_QSTR_realign), MP_ROM_PTR(&mp_lv_obj_realign_obj) }, + { MP_ROM_QSTR(MP_QSTR_set_auto_realign), MP_ROM_PTR(&mp_lv_obj_set_auto_realign_obj) }, + { MP_ROM_QSTR(MP_QSTR_set_style), MP_ROM_PTR(&mp_lv_obj_set_style_obj) }, + { MP_ROM_QSTR(MP_QSTR_refresh_style), MP_ROM_PTR(&mp_lv_obj_refresh_style_obj) }, + { MP_ROM_QSTR(MP_QSTR_report_style_mod), MP_ROM_PTR(&mp_lv_obj_report_style_mod_obj) }, + { MP_ROM_QSTR(MP_QSTR_set_hidden), MP_ROM_PTR(&mp_lv_obj_set_hidden_obj) }, + { MP_ROM_QSTR(MP_QSTR_set_click), MP_ROM_PTR(&mp_lv_obj_set_click_obj) }, + { MP_ROM_QSTR(MP_QSTR_set_top), MP_ROM_PTR(&mp_lv_obj_set_top_obj) }, + { MP_ROM_QSTR(MP_QSTR_set_drag), MP_ROM_PTR(&mp_lv_obj_set_drag_obj) }, + { MP_ROM_QSTR(MP_QSTR_set_drag_throw), MP_ROM_PTR(&mp_lv_obj_set_drag_throw_obj) }, + { MP_ROM_QSTR(MP_QSTR_set_drag_parent), MP_ROM_PTR(&mp_lv_obj_set_drag_parent_obj) }, + { MP_ROM_QSTR(MP_QSTR_set_opa_scale_enable), MP_ROM_PTR(&mp_lv_obj_set_opa_scale_enable_obj) }, + { MP_ROM_QSTR(MP_QSTR_set_opa_scale), MP_ROM_PTR(&mp_lv_obj_set_opa_scale_obj) }, + { MP_ROM_QSTR(MP_QSTR_set_protect), MP_ROM_PTR(&mp_lv_obj_set_protect_obj) }, + { MP_ROM_QSTR(MP_QSTR_clear_protect), MP_ROM_PTR(&mp_lv_obj_clear_protect_obj) }, + { MP_ROM_QSTR(MP_QSTR_set_signal_func), MP_ROM_PTR(&mp_lv_obj_set_signal_func_obj) }, + { MP_ROM_QSTR(MP_QSTR_set_design_func), MP_ROM_PTR(&mp_lv_obj_set_design_func_obj) }, + { MP_ROM_QSTR(MP_QSTR_allocate_ext_attr), MP_ROM_PTR(&mp_lv_obj_allocate_ext_attr_obj) }, + { MP_ROM_QSTR(MP_QSTR_refresh_ext_size), MP_ROM_PTR(&mp_lv_obj_refresh_ext_size_obj) }, + { MP_ROM_QSTR(MP_QSTR_set_free_num), MP_ROM_PTR(&mp_lv_obj_set_free_num_obj) }, + { MP_ROM_QSTR(MP_QSTR_set_free_ptr), MP_ROM_PTR(&mp_lv_obj_set_free_ptr_obj) }, + { MP_ROM_QSTR(MP_QSTR_animate), MP_ROM_PTR(&mp_lv_obj_animate_obj) }, + { MP_ROM_QSTR(MP_QSTR_get_screen), MP_ROM_PTR(&mp_lv_obj_get_screen_obj) }, + { MP_ROM_QSTR(MP_QSTR_get_parent), MP_ROM_PTR(&mp_lv_obj_get_parent_obj) }, + { MP_ROM_QSTR(MP_QSTR_get_child), MP_ROM_PTR(&mp_lv_obj_get_child_obj) }, + { MP_ROM_QSTR(MP_QSTR_get_child_back), MP_ROM_PTR(&mp_lv_obj_get_child_back_obj) }, + { MP_ROM_QSTR(MP_QSTR_count_children), MP_ROM_PTR(&mp_lv_obj_count_children_obj) }, + { MP_ROM_QSTR(MP_QSTR_get_coords), MP_ROM_PTR(&mp_lv_obj_get_coords_obj) }, + { MP_ROM_QSTR(MP_QSTR_get_x), MP_ROM_PTR(&mp_lv_obj_get_x_obj) }, + { MP_ROM_QSTR(MP_QSTR_get_y), MP_ROM_PTR(&mp_lv_obj_get_y_obj) }, + { MP_ROM_QSTR(MP_QSTR_get_width), MP_ROM_PTR(&mp_lv_obj_get_width_obj) }, + { MP_ROM_QSTR(MP_QSTR_get_height), MP_ROM_PTR(&mp_lv_obj_get_height_obj) }, + { MP_ROM_QSTR(MP_QSTR_get_ext_size), MP_ROM_PTR(&mp_lv_obj_get_ext_size_obj) }, + { MP_ROM_QSTR(MP_QSTR_get_auto_realign), MP_ROM_PTR(&mp_lv_obj_get_auto_realign_obj) }, + { MP_ROM_QSTR(MP_QSTR_get_style), MP_ROM_PTR(&mp_lv_obj_get_style_obj) }, + { MP_ROM_QSTR(MP_QSTR_get_hidden), MP_ROM_PTR(&mp_lv_obj_get_hidden_obj) }, + { MP_ROM_QSTR(MP_QSTR_get_click), MP_ROM_PTR(&mp_lv_obj_get_click_obj) }, + { MP_ROM_QSTR(MP_QSTR_get_top), MP_ROM_PTR(&mp_lv_obj_get_top_obj) }, + { MP_ROM_QSTR(MP_QSTR_get_drag), MP_ROM_PTR(&mp_lv_obj_get_drag_obj) }, + { MP_ROM_QSTR(MP_QSTR_get_drag_throw), MP_ROM_PTR(&mp_lv_obj_get_drag_throw_obj) }, + { MP_ROM_QSTR(MP_QSTR_get_drag_parent), MP_ROM_PTR(&mp_lv_obj_get_drag_parent_obj) }, + { MP_ROM_QSTR(MP_QSTR_get_opa_scale_enable), MP_ROM_PTR(&mp_lv_obj_get_opa_scale_enable_obj) }, + { MP_ROM_QSTR(MP_QSTR_get_opa_scale), MP_ROM_PTR(&mp_lv_obj_get_opa_scale_obj) }, + { MP_ROM_QSTR(MP_QSTR_get_protect), MP_ROM_PTR(&mp_lv_obj_get_protect_obj) }, + { MP_ROM_QSTR(MP_QSTR_is_protected), MP_ROM_PTR(&mp_lv_obj_is_protected_obj) }, + { MP_ROM_QSTR(MP_QSTR_get_signal_func), MP_ROM_PTR(&mp_lv_obj_get_signal_func_obj) }, + { MP_ROM_QSTR(MP_QSTR_get_design_func), MP_ROM_PTR(&mp_lv_obj_get_design_func_obj) }, + { MP_ROM_QSTR(MP_QSTR_get_ext_attr), MP_ROM_PTR(&mp_lv_obj_get_ext_attr_obj) }, + { MP_ROM_QSTR(MP_QSTR_get_free_num), MP_ROM_PTR(&mp_lv_obj_get_free_num_obj) }, + { MP_ROM_QSTR(MP_QSTR_get_free_ptr), MP_ROM_PTR(&mp_lv_obj_get_free_ptr_obj) }, + { MP_ROM_QSTR(MP_QSTR_get_group), MP_ROM_PTR(&mp_lv_obj_get_group_obj) }, + { MP_ROM_QSTR(MP_QSTR_is_focused), MP_ROM_PTR(&mp_lv_obj_is_focused_obj) }, + { MP_ROM_QSTR(MP_QSTR_STATE), MP_ROM_PTR(&mp_LV_BTN_STATE_type) }, + { MP_ROM_QSTR(MP_QSTR_ACTION), MP_ROM_PTR(&mp_LV_BTN_ACTION_type) }, + { MP_ROM_QSTR(MP_QSTR_STYLE), MP_ROM_PTR(&mp_LV_BTN_STYLE_type) } +}; + +STATIC MP_DEFINE_CONST_DICT(btn_locals_dict, btn_locals_dict_table); + +STATIC void btn_print(const mp_print_t *print, + mp_obj_t self_in, + mp_print_kind_t kind) +{ + mp_printf(print, "lvgl btn"); +} + + +STATIC mp_obj_t btn_make_new( + const mp_obj_type_t *type, + size_t n_args, + size_t n_kw, + const mp_obj_t *args) +{ + return make_new(&lv_btn_create, type, n_args, n_kw, args); +} + + +STATIC const mp_obj_type_t mp_btn_type = { + { &mp_type_type }, + .name = MP_QSTR_btn, + .print = btn_print, + .make_new = btn_make_new, + .locals_dict = (mp_obj_dict_t*)&btn_locals_dict, +}; + + +/* + * lvgl extension definition for: + * inline static void lv_imgbtn_set_toggle(lv_obj_t *imgbtn, bool tgl) + */ + +STATIC mp_obj_t mp_lv_imgbtn_set_toggle(size_t n_args, const mp_obj_t *args) +{ + lv_obj_t *imgbtn = mp_to_lv(args[0]); + bool tgl = mp_obj_is_true(args[1]); + lv_imgbtn_set_toggle(imgbtn, tgl); + return mp_const_none; +} + +STATIC MP_DEFINE_CONST_FUN_OBJ_VAR_BETWEEN(mp_lv_imgbtn_set_toggle_obj, 2, 2, mp_lv_imgbtn_set_toggle); + + + +/* + * lvgl extension definition for: + * inline static void lv_imgbtn_set_state(lv_obj_t *imgbtn, lv_btn_state_t state) + */ + +STATIC mp_obj_t mp_lv_imgbtn_set_state(size_t n_args, const mp_obj_t *args) +{ + lv_obj_t *imgbtn = mp_to_lv(args[0]); + lv_btn_state_t state = (uint8_t)mp_obj_get_int(args[1]); + lv_imgbtn_set_state(imgbtn, state); + return mp_const_none; +} + +STATIC MP_DEFINE_CONST_FUN_OBJ_VAR_BETWEEN(mp_lv_imgbtn_set_state_obj, 2, 2, mp_lv_imgbtn_set_state); + + + +/* + * lvgl extension definition for: + * inline static void lv_imgbtn_toggle(lv_obj_t *imgbtn) + */ + +STATIC mp_obj_t mp_lv_imgbtn_toggle(size_t n_args, const mp_obj_t *args) +{ + lv_obj_t *imgbtn = mp_to_lv(args[0]); + lv_imgbtn_toggle(imgbtn); + return mp_const_none; +} + +STATIC MP_DEFINE_CONST_FUN_OBJ_VAR_BETWEEN(mp_lv_imgbtn_toggle_obj, 1, 1, mp_lv_imgbtn_toggle); + + + +/* + * lvgl extension definition for: + * inline static void lv_imgbtn_set_action(lv_obj_t *imgbtn, lv_btn_action_t type, lv_action_t action) + */ + +STATIC mp_obj_t mp_lv_imgbtn_set_action(size_t n_args, const mp_obj_t *args) +{ + lv_obj_t *imgbtn = mp_to_lv(args[0]); + lv_btn_action_t type = (uint8_t)mp_obj_get_int(args[1]); + set_action(args[0], args[2]); + lv_action_t action = &lv_action_t_callback; + lv_imgbtn_set_action(imgbtn, type, action); + return mp_const_none; +} + +STATIC MP_DEFINE_CONST_FUN_OBJ_VAR_BETWEEN(mp_lv_imgbtn_set_action_obj, 3, 3, mp_lv_imgbtn_set_action); + + + +/* + * lvgl extension definition for: + * inline static lv_btn_state_t lv_imgbtn_get_state(const lv_obj_t *imgbtn) + */ + +STATIC mp_obj_t mp_lv_imgbtn_get_state(size_t n_args, const mp_obj_t *args) +{ + const lv_obj_t *imgbtn = mp_to_lv(args[0]); + lv_btn_state_t res = lv_imgbtn_get_state(imgbtn); + return mp_obj_new_int_from_uint(res); +} + +STATIC MP_DEFINE_CONST_FUN_OBJ_VAR_BETWEEN(mp_lv_imgbtn_get_state_obj, 1, 1, mp_lv_imgbtn_get_state); + + + +/* + * lvgl extension definition for: + * inline static bool lv_imgbtn_get_toggle(const lv_obj_t *imgbtn) + */ + +STATIC mp_obj_t mp_lv_imgbtn_get_toggle(size_t n_args, const mp_obj_t *args) +{ + const lv_obj_t *imgbtn = mp_to_lv(args[0]); + bool res = lv_imgbtn_get_toggle(imgbtn); + return convert_to_bool(res); +} + +STATIC MP_DEFINE_CONST_FUN_OBJ_VAR_BETWEEN(mp_lv_imgbtn_get_toggle_obj, 1, 1, mp_lv_imgbtn_get_toggle); + + + +/* + * lvgl extension definition for: + * inline static lv_action_t lv_imgbtn_get_action(const lv_obj_t *imgbtn, lv_btn_action_t type) + */ + +STATIC mp_obj_t mp_lv_imgbtn_get_action(size_t n_args, const mp_obj_t *args) +{ + const lv_obj_t *imgbtn = mp_to_lv(args[0]); + lv_btn_action_t type = (uint8_t)mp_obj_get_int(args[1]); + lv_action_t res = lv_imgbtn_get_action(imgbtn, type); + return ptr_to_mp(res); +} + +STATIC MP_DEFINE_CONST_FUN_OBJ_VAR_BETWEEN(mp_lv_imgbtn_get_action_obj, 2, 2, mp_lv_imgbtn_get_action); + + + +/* + * lvgl extension definition for: + * void lv_imgbtn_set_src(lv_obj_t *imgbtn, lv_btn_state_t state, const void *src) + */ + +STATIC mp_obj_t mp_lv_imgbtn_set_src(size_t n_args, const mp_obj_t *args) +{ + lv_obj_t *imgbtn = mp_to_lv(args[0]); + lv_btn_state_t state = (uint8_t)mp_obj_get_int(args[1]); + const void *src = mp_to_ptr(args[2]); + lv_imgbtn_set_src(imgbtn, state, src); + return mp_const_none; +} + +STATIC MP_DEFINE_CONST_FUN_OBJ_VAR_BETWEEN(mp_lv_imgbtn_set_src_obj, 3, 3, mp_lv_imgbtn_set_src); + + + +/* + * lvgl extension definition for: + * void lv_imgbtn_set_style(lv_obj_t *imgbtn, lv_imgbtn_style_t type, lv_style_t *style) + */ + +STATIC mp_obj_t mp_lv_imgbtn_set_style(size_t n_args, const mp_obj_t *args) +{ + lv_obj_t *imgbtn = mp_to_lv(args[0]); + lv_imgbtn_style_t type = (uint8_t)mp_obj_get_int(args[1]); + lv_style_t *style = mp_write_ptr_lv_style_t(args[2]); + lv_imgbtn_set_style(imgbtn, type, style); + return mp_const_none; +} + +STATIC MP_DEFINE_CONST_FUN_OBJ_VAR_BETWEEN(mp_lv_imgbtn_set_style_obj, 3, 3, mp_lv_imgbtn_set_style); + + + +/* + * lvgl extension definition for: + * const void *lv_imgbtn_get_src(lv_obj_t *imgbtn, lv_btn_state_t state) + */ + +STATIC mp_obj_t mp_lv_imgbtn_get_src(size_t n_args, const mp_obj_t *args) +{ + lv_obj_t *imgbtn = mp_to_lv(args[0]); + lv_btn_state_t state = (uint8_t)mp_obj_get_int(args[1]); + const void* res = lv_imgbtn_get_src(imgbtn, state); + return ptr_to_mp((void*)res); +} + +STATIC MP_DEFINE_CONST_FUN_OBJ_VAR_BETWEEN(mp_lv_imgbtn_get_src_obj, 2, 2, mp_lv_imgbtn_get_src); + + + +/* + * lvgl extension definition for: + * lv_style_t *lv_imgbtn_get_style(const lv_obj_t *imgbtn, lv_imgbtn_style_t type) + */ + +STATIC mp_obj_t mp_lv_imgbtn_get_style(size_t n_args, const mp_obj_t *args) +{ + const lv_obj_t *imgbtn = mp_to_lv(args[0]); + lv_imgbtn_style_t type = (uint8_t)mp_obj_get_int(args[1]); + lv_style_t* res = lv_imgbtn_get_style(imgbtn, type); + return mp_read_ptr_lv_style_t((void*)res); +} + +STATIC MP_DEFINE_CONST_FUN_OBJ_VAR_BETWEEN(mp_lv_imgbtn_get_style_obj, 2, 2, mp_lv_imgbtn_get_style); + + + +/* + * lvgl imgbtn object definitions + */ + + +STATIC const mp_rom_map_elem_t imgbtn_locals_dict_table[] = { + { MP_ROM_QSTR(MP_QSTR_set_toggle), MP_ROM_PTR(&mp_lv_imgbtn_set_toggle_obj) }, + { MP_ROM_QSTR(MP_QSTR_set_state), MP_ROM_PTR(&mp_lv_imgbtn_set_state_obj) }, + { MP_ROM_QSTR(MP_QSTR_toggle), MP_ROM_PTR(&mp_lv_imgbtn_toggle_obj) }, + { MP_ROM_QSTR(MP_QSTR_set_action), MP_ROM_PTR(&mp_lv_imgbtn_set_action_obj) }, + { MP_ROM_QSTR(MP_QSTR_get_state), MP_ROM_PTR(&mp_lv_imgbtn_get_state_obj) }, + { MP_ROM_QSTR(MP_QSTR_get_toggle), MP_ROM_PTR(&mp_lv_imgbtn_get_toggle_obj) }, + { MP_ROM_QSTR(MP_QSTR_get_action), MP_ROM_PTR(&mp_lv_imgbtn_get_action_obj) }, + { MP_ROM_QSTR(MP_QSTR_set_src), MP_ROM_PTR(&mp_lv_imgbtn_set_src_obj) }, + { MP_ROM_QSTR(MP_QSTR_set_style), MP_ROM_PTR(&mp_lv_imgbtn_set_style_obj) }, + { MP_ROM_QSTR(MP_QSTR_get_src), MP_ROM_PTR(&mp_lv_imgbtn_get_src_obj) }, + { MP_ROM_QSTR(MP_QSTR_get_style), MP_ROM_PTR(&mp_lv_imgbtn_get_style_obj) }, + { MP_ROM_QSTR(MP_QSTR_delete), MP_ROM_PTR(&mp_lv_obj_del_obj) }, + { MP_ROM_QSTR(MP_QSTR_clean), MP_ROM_PTR(&mp_lv_obj_clean_obj) }, + { MP_ROM_QSTR(MP_QSTR_invalidate), MP_ROM_PTR(&mp_lv_obj_invalidate_obj) }, + { MP_ROM_QSTR(MP_QSTR_set_parent), MP_ROM_PTR(&mp_lv_obj_set_parent_obj) }, + { MP_ROM_QSTR(MP_QSTR_set_pos), MP_ROM_PTR(&mp_lv_obj_set_pos_obj) }, + { MP_ROM_QSTR(MP_QSTR_set_x), MP_ROM_PTR(&mp_lv_obj_set_x_obj) }, + { MP_ROM_QSTR(MP_QSTR_set_y), MP_ROM_PTR(&mp_lv_obj_set_y_obj) }, + { MP_ROM_QSTR(MP_QSTR_set_size), MP_ROM_PTR(&mp_lv_obj_set_size_obj) }, + { MP_ROM_QSTR(MP_QSTR_set_width), MP_ROM_PTR(&mp_lv_obj_set_width_obj) }, + { MP_ROM_QSTR(MP_QSTR_set_height), MP_ROM_PTR(&mp_lv_obj_set_height_obj) }, + { MP_ROM_QSTR(MP_QSTR_align), MP_ROM_PTR(&mp_lv_obj_align_obj) }, + { MP_ROM_QSTR(MP_QSTR_align_origo), MP_ROM_PTR(&mp_lv_obj_align_origo_obj) }, + { MP_ROM_QSTR(MP_QSTR_realign), MP_ROM_PTR(&mp_lv_obj_realign_obj) }, + { MP_ROM_QSTR(MP_QSTR_set_auto_realign), MP_ROM_PTR(&mp_lv_obj_set_auto_realign_obj) }, + { MP_ROM_QSTR(MP_QSTR_set_style), MP_ROM_PTR(&mp_lv_obj_set_style_obj) }, + { MP_ROM_QSTR(MP_QSTR_refresh_style), MP_ROM_PTR(&mp_lv_obj_refresh_style_obj) }, + { MP_ROM_QSTR(MP_QSTR_report_style_mod), MP_ROM_PTR(&mp_lv_obj_report_style_mod_obj) }, + { MP_ROM_QSTR(MP_QSTR_set_hidden), MP_ROM_PTR(&mp_lv_obj_set_hidden_obj) }, + { MP_ROM_QSTR(MP_QSTR_set_click), MP_ROM_PTR(&mp_lv_obj_set_click_obj) }, + { MP_ROM_QSTR(MP_QSTR_set_top), MP_ROM_PTR(&mp_lv_obj_set_top_obj) }, + { MP_ROM_QSTR(MP_QSTR_set_drag), MP_ROM_PTR(&mp_lv_obj_set_drag_obj) }, + { MP_ROM_QSTR(MP_QSTR_set_drag_throw), MP_ROM_PTR(&mp_lv_obj_set_drag_throw_obj) }, + { MP_ROM_QSTR(MP_QSTR_set_drag_parent), MP_ROM_PTR(&mp_lv_obj_set_drag_parent_obj) }, + { MP_ROM_QSTR(MP_QSTR_set_opa_scale_enable), MP_ROM_PTR(&mp_lv_obj_set_opa_scale_enable_obj) }, + { MP_ROM_QSTR(MP_QSTR_set_opa_scale), MP_ROM_PTR(&mp_lv_obj_set_opa_scale_obj) }, + { MP_ROM_QSTR(MP_QSTR_set_protect), MP_ROM_PTR(&mp_lv_obj_set_protect_obj) }, + { MP_ROM_QSTR(MP_QSTR_clear_protect), MP_ROM_PTR(&mp_lv_obj_clear_protect_obj) }, + { MP_ROM_QSTR(MP_QSTR_set_signal_func), MP_ROM_PTR(&mp_lv_obj_set_signal_func_obj) }, + { MP_ROM_QSTR(MP_QSTR_set_design_func), MP_ROM_PTR(&mp_lv_obj_set_design_func_obj) }, + { MP_ROM_QSTR(MP_QSTR_allocate_ext_attr), MP_ROM_PTR(&mp_lv_obj_allocate_ext_attr_obj) }, + { MP_ROM_QSTR(MP_QSTR_refresh_ext_size), MP_ROM_PTR(&mp_lv_obj_refresh_ext_size_obj) }, + { MP_ROM_QSTR(MP_QSTR_set_free_num), MP_ROM_PTR(&mp_lv_obj_set_free_num_obj) }, + { MP_ROM_QSTR(MP_QSTR_set_free_ptr), MP_ROM_PTR(&mp_lv_obj_set_free_ptr_obj) }, + { MP_ROM_QSTR(MP_QSTR_animate), MP_ROM_PTR(&mp_lv_obj_animate_obj) }, + { MP_ROM_QSTR(MP_QSTR_get_screen), MP_ROM_PTR(&mp_lv_obj_get_screen_obj) }, + { MP_ROM_QSTR(MP_QSTR_get_parent), MP_ROM_PTR(&mp_lv_obj_get_parent_obj) }, + { MP_ROM_QSTR(MP_QSTR_get_child), MP_ROM_PTR(&mp_lv_obj_get_child_obj) }, + { MP_ROM_QSTR(MP_QSTR_get_child_back), MP_ROM_PTR(&mp_lv_obj_get_child_back_obj) }, + { MP_ROM_QSTR(MP_QSTR_count_children), MP_ROM_PTR(&mp_lv_obj_count_children_obj) }, + { MP_ROM_QSTR(MP_QSTR_get_coords), MP_ROM_PTR(&mp_lv_obj_get_coords_obj) }, + { MP_ROM_QSTR(MP_QSTR_get_x), MP_ROM_PTR(&mp_lv_obj_get_x_obj) }, + { MP_ROM_QSTR(MP_QSTR_get_y), MP_ROM_PTR(&mp_lv_obj_get_y_obj) }, + { MP_ROM_QSTR(MP_QSTR_get_width), MP_ROM_PTR(&mp_lv_obj_get_width_obj) }, + { MP_ROM_QSTR(MP_QSTR_get_height), MP_ROM_PTR(&mp_lv_obj_get_height_obj) }, + { MP_ROM_QSTR(MP_QSTR_get_ext_size), MP_ROM_PTR(&mp_lv_obj_get_ext_size_obj) }, + { MP_ROM_QSTR(MP_QSTR_get_auto_realign), MP_ROM_PTR(&mp_lv_obj_get_auto_realign_obj) }, + { MP_ROM_QSTR(MP_QSTR_get_style), MP_ROM_PTR(&mp_lv_obj_get_style_obj) }, + { MP_ROM_QSTR(MP_QSTR_get_hidden), MP_ROM_PTR(&mp_lv_obj_get_hidden_obj) }, + { MP_ROM_QSTR(MP_QSTR_get_click), MP_ROM_PTR(&mp_lv_obj_get_click_obj) }, + { MP_ROM_QSTR(MP_QSTR_get_top), MP_ROM_PTR(&mp_lv_obj_get_top_obj) }, + { MP_ROM_QSTR(MP_QSTR_get_drag), MP_ROM_PTR(&mp_lv_obj_get_drag_obj) }, + { MP_ROM_QSTR(MP_QSTR_get_drag_throw), MP_ROM_PTR(&mp_lv_obj_get_drag_throw_obj) }, + { MP_ROM_QSTR(MP_QSTR_get_drag_parent), MP_ROM_PTR(&mp_lv_obj_get_drag_parent_obj) }, + { MP_ROM_QSTR(MP_QSTR_get_opa_scale_enable), MP_ROM_PTR(&mp_lv_obj_get_opa_scale_enable_obj) }, + { MP_ROM_QSTR(MP_QSTR_get_opa_scale), MP_ROM_PTR(&mp_lv_obj_get_opa_scale_obj) }, + { MP_ROM_QSTR(MP_QSTR_get_protect), MP_ROM_PTR(&mp_lv_obj_get_protect_obj) }, + { MP_ROM_QSTR(MP_QSTR_is_protected), MP_ROM_PTR(&mp_lv_obj_is_protected_obj) }, + { MP_ROM_QSTR(MP_QSTR_get_signal_func), MP_ROM_PTR(&mp_lv_obj_get_signal_func_obj) }, + { MP_ROM_QSTR(MP_QSTR_get_design_func), MP_ROM_PTR(&mp_lv_obj_get_design_func_obj) }, + { MP_ROM_QSTR(MP_QSTR_get_ext_attr), MP_ROM_PTR(&mp_lv_obj_get_ext_attr_obj) }, + { MP_ROM_QSTR(MP_QSTR_get_free_num), MP_ROM_PTR(&mp_lv_obj_get_free_num_obj) }, + { MP_ROM_QSTR(MP_QSTR_get_free_ptr), MP_ROM_PTR(&mp_lv_obj_get_free_ptr_obj) }, + { MP_ROM_QSTR(MP_QSTR_get_group), MP_ROM_PTR(&mp_lv_obj_get_group_obj) }, + { MP_ROM_QSTR(MP_QSTR_is_focused), MP_ROM_PTR(&mp_lv_obj_is_focused_obj) }, + { MP_ROM_QSTR(MP_QSTR_STYLE), MP_ROM_PTR(&mp_LV_IMGBTN_STYLE_type) } +}; + +STATIC MP_DEFINE_CONST_DICT(imgbtn_locals_dict, imgbtn_locals_dict_table); + +STATIC void imgbtn_print(const mp_print_t *print, + mp_obj_t self_in, + mp_print_kind_t kind) +{ + mp_printf(print, "lvgl imgbtn"); +} + + +STATIC mp_obj_t imgbtn_make_new( + const mp_obj_type_t *type, + size_t n_args, + size_t n_kw, + const mp_obj_t *args) +{ + return make_new(&lv_imgbtn_create, type, n_args, n_kw, args); +} + + +STATIC const mp_obj_type_t mp_imgbtn_type = { + { &mp_type_type }, + .name = MP_QSTR_imgbtn, + .print = imgbtn_print, + .make_new = imgbtn_make_new, + .locals_dict = (mp_obj_dict_t*)&imgbtn_locals_dict, +}; + + +/* + * lvgl extension definition for: + * inline static void lv_label_set_style(lv_obj_t *label, lv_style_t *style) + */ + +STATIC mp_obj_t mp_lv_label_set_style(size_t n_args, const mp_obj_t *args) +{ + lv_obj_t *label = mp_to_lv(args[0]); + lv_style_t *style = mp_write_ptr_lv_style_t(args[1]); + lv_label_set_style(label, style); + return mp_const_none; +} + +STATIC MP_DEFINE_CONST_FUN_OBJ_VAR_BETWEEN(mp_lv_label_set_style_obj, 2, 2, mp_lv_label_set_style); + + + +/* + * lvgl extension definition for: + * inline static lv_style_t *lv_label_get_style(const lv_obj_t *label) + */ + +STATIC mp_obj_t mp_lv_label_get_style(size_t n_args, const mp_obj_t *args) +{ + const lv_obj_t *label = mp_to_lv(args[0]); + lv_style_t* res = lv_label_get_style(label); + return mp_read_ptr_lv_style_t((void*)res); +} + +STATIC MP_DEFINE_CONST_FUN_OBJ_VAR_BETWEEN(mp_lv_label_get_style_obj, 1, 1, mp_lv_label_get_style); + + + +/* + * lvgl extension definition for: + * void lv_label_set_text(lv_obj_t *label, const char *text) + */ + +STATIC mp_obj_t mp_lv_label_set_text(size_t n_args, const mp_obj_t *args) +{ + lv_obj_t *label = mp_to_lv(args[0]); + const char *text = (char*)mp_obj_str_get_str(args[1]); + lv_label_set_text(label, text); + return mp_const_none; +} + +STATIC MP_DEFINE_CONST_FUN_OBJ_VAR_BETWEEN(mp_lv_label_set_text_obj, 2, 2, mp_lv_label_set_text); + + + +/* + * lvgl extension definition for: + * void lv_label_set_array_text(lv_obj_t *label, const char *array, uint16_t size) + */ + +STATIC mp_obj_t mp_lv_label_set_array_text(size_t n_args, const mp_obj_t *args) +{ + lv_obj_t *label = mp_to_lv(args[0]); + const char *array = (char*)mp_obj_str_get_str(args[1]); + uint16_t size = (uint16_t)mp_obj_get_int(args[2]); + lv_label_set_array_text(label, array, size); + return mp_const_none; +} + +STATIC MP_DEFINE_CONST_FUN_OBJ_VAR_BETWEEN(mp_lv_label_set_array_text_obj, 3, 3, mp_lv_label_set_array_text); + + + +/* + * lvgl extension definition for: + * void lv_label_set_static_text(lv_obj_t *label, const char *text) + */ + +STATIC mp_obj_t mp_lv_label_set_static_text(size_t n_args, const mp_obj_t *args) +{ + lv_obj_t *label = mp_to_lv(args[0]); + const char *text = (char*)mp_obj_str_get_str(args[1]); + lv_label_set_static_text(label, text); + return mp_const_none; +} + +STATIC MP_DEFINE_CONST_FUN_OBJ_VAR_BETWEEN(mp_lv_label_set_static_text_obj, 2, 2, mp_lv_label_set_static_text); + + + +/* + * lvgl extension definition for: + * void lv_label_set_long_mode(lv_obj_t *label, lv_label_long_mode_t long_mode) + */ + +STATIC mp_obj_t mp_lv_label_set_long_mode(size_t n_args, const mp_obj_t *args) +{ + lv_obj_t *label = mp_to_lv(args[0]); + lv_label_long_mode_t long_mode = (uint8_t)mp_obj_get_int(args[1]); + lv_label_set_long_mode(label, long_mode); + return mp_const_none; +} + +STATIC MP_DEFINE_CONST_FUN_OBJ_VAR_BETWEEN(mp_lv_label_set_long_mode_obj, 2, 2, mp_lv_label_set_long_mode); + + + +/* + * lvgl extension definition for: + * void lv_label_set_align(lv_obj_t *label, lv_label_align_t align) + */ + +STATIC mp_obj_t mp_lv_label_set_align(size_t n_args, const mp_obj_t *args) +{ + lv_obj_t *label = mp_to_lv(args[0]); + lv_label_align_t align = (uint8_t)mp_obj_get_int(args[1]); + lv_label_set_align(label, align); + return mp_const_none; +} + +STATIC MP_DEFINE_CONST_FUN_OBJ_VAR_BETWEEN(mp_lv_label_set_align_obj, 2, 2, mp_lv_label_set_align); + + + +/* + * lvgl extension definition for: + * void lv_label_set_recolor(lv_obj_t *label, bool en) + */ + +STATIC mp_obj_t mp_lv_label_set_recolor(size_t n_args, const mp_obj_t *args) +{ + lv_obj_t *label = mp_to_lv(args[0]); + bool en = mp_obj_is_true(args[1]); + lv_label_set_recolor(label, en); + return mp_const_none; +} + +STATIC MP_DEFINE_CONST_FUN_OBJ_VAR_BETWEEN(mp_lv_label_set_recolor_obj, 2, 2, mp_lv_label_set_recolor); + + + +/* + * lvgl extension definition for: + * void lv_label_set_body_draw(lv_obj_t *label, bool en) + */ + +STATIC mp_obj_t mp_lv_label_set_body_draw(size_t n_args, const mp_obj_t *args) +{ + lv_obj_t *label = mp_to_lv(args[0]); + bool en = mp_obj_is_true(args[1]); + lv_label_set_body_draw(label, en); + return mp_const_none; +} + +STATIC MP_DEFINE_CONST_FUN_OBJ_VAR_BETWEEN(mp_lv_label_set_body_draw_obj, 2, 2, mp_lv_label_set_body_draw); + + + +/* + * lvgl extension definition for: + * void lv_label_set_anim_speed(lv_obj_t *label, uint16_t anim_speed) + */ + +STATIC mp_obj_t mp_lv_label_set_anim_speed(size_t n_args, const mp_obj_t *args) +{ + lv_obj_t *label = mp_to_lv(args[0]); + uint16_t anim_speed = (uint16_t)mp_obj_get_int(args[1]); + lv_label_set_anim_speed(label, anim_speed); + return mp_const_none; +} + +STATIC MP_DEFINE_CONST_FUN_OBJ_VAR_BETWEEN(mp_lv_label_set_anim_speed_obj, 2, 2, mp_lv_label_set_anim_speed); + + + +/* + * lvgl extension definition for: + * char *lv_label_get_text(const lv_obj_t *label) + */ + +STATIC mp_obj_t mp_lv_label_get_text(size_t n_args, const mp_obj_t *args) +{ + const lv_obj_t *label = mp_to_lv(args[0]); + char* res = lv_label_get_text(label); + return convert_to_str((void*)res); +} + +STATIC MP_DEFINE_CONST_FUN_OBJ_VAR_BETWEEN(mp_lv_label_get_text_obj, 1, 1, mp_lv_label_get_text); + + + +/* + * lvgl extension definition for: + * lv_label_long_mode_t lv_label_get_long_mode(const lv_obj_t *label) + */ + +STATIC mp_obj_t mp_lv_label_get_long_mode(size_t n_args, const mp_obj_t *args) +{ + const lv_obj_t *label = mp_to_lv(args[0]); + lv_label_long_mode_t res = lv_label_get_long_mode(label); + return mp_obj_new_int_from_uint(res); +} + +STATIC MP_DEFINE_CONST_FUN_OBJ_VAR_BETWEEN(mp_lv_label_get_long_mode_obj, 1, 1, mp_lv_label_get_long_mode); + + + +/* + * lvgl extension definition for: + * lv_label_align_t lv_label_get_align(const lv_obj_t *label) + */ + +STATIC mp_obj_t mp_lv_label_get_align(size_t n_args, const mp_obj_t *args) +{ + const lv_obj_t *label = mp_to_lv(args[0]); + lv_label_align_t res = lv_label_get_align(label); + return mp_obj_new_int_from_uint(res); +} + +STATIC MP_DEFINE_CONST_FUN_OBJ_VAR_BETWEEN(mp_lv_label_get_align_obj, 1, 1, mp_lv_label_get_align); + + + +/* + * lvgl extension definition for: + * bool lv_label_get_recolor(const lv_obj_t *label) + */ + +STATIC mp_obj_t mp_lv_label_get_recolor(size_t n_args, const mp_obj_t *args) +{ + const lv_obj_t *label = mp_to_lv(args[0]); + bool res = lv_label_get_recolor(label); + return convert_to_bool(res); +} + +STATIC MP_DEFINE_CONST_FUN_OBJ_VAR_BETWEEN(mp_lv_label_get_recolor_obj, 1, 1, mp_lv_label_get_recolor); + + + +/* + * lvgl extension definition for: + * bool lv_label_get_body_draw(const lv_obj_t *label) + */ + +STATIC mp_obj_t mp_lv_label_get_body_draw(size_t n_args, const mp_obj_t *args) +{ + const lv_obj_t *label = mp_to_lv(args[0]); + bool res = lv_label_get_body_draw(label); + return convert_to_bool(res); +} + +STATIC MP_DEFINE_CONST_FUN_OBJ_VAR_BETWEEN(mp_lv_label_get_body_draw_obj, 1, 1, mp_lv_label_get_body_draw); + + + +/* + * lvgl extension definition for: + * uint16_t lv_label_get_anim_speed(const lv_obj_t *label) + */ + +STATIC mp_obj_t mp_lv_label_get_anim_speed(size_t n_args, const mp_obj_t *args) +{ + const lv_obj_t *label = mp_to_lv(args[0]); + uint16_t res = lv_label_get_anim_speed(label); + return mp_obj_new_int_from_uint(res); +} + +STATIC MP_DEFINE_CONST_FUN_OBJ_VAR_BETWEEN(mp_lv_label_get_anim_speed_obj, 1, 1, mp_lv_label_get_anim_speed); + + + +/* + * Struct lv_point_t + */ + +STATIC inline const mp_obj_type_t *get_mp_lv_point_t_type(); + +STATIC inline lv_point_t* mp_write_ptr_lv_point_t(mp_obj_t self_in) +{ + mp_lv_struct_t *self = MP_OBJ_TO_PTR(cast(self_in, get_mp_lv_point_t_type())); + return (lv_point_t*)self->data; +} + +#define mp_write_lv_point_t(struct_obj) *mp_write_ptr_lv_point_t(struct_obj) + +STATIC inline mp_obj_t mp_read_ptr_lv_point_t(lv_point_t *field) +{ + return lv_to_mp_struct(get_mp_lv_point_t_type(), field); +} + +#define mp_read_lv_point_t(field) mp_read_ptr_lv_point_t(copy_buffer(&field, sizeof(lv_point_t))) +#define mp_read_byref_lv_point_t(field) mp_read_ptr_lv_point_t(&field) + +STATIC void mp_lv_point_t_attr(mp_obj_t self_in, qstr attr, mp_obj_t *dest) +{ + mp_lv_struct_t *self = MP_OBJ_TO_PTR(self_in); + lv_point_t *data = (lv_point_t*)self->data; + + if (dest[0] == MP_OBJ_NULL) { + // load attribute + switch(attr) + { + case MP_QSTR_x: dest[0] = mp_obj_new_int(data->x); break; // converting from lv_coord_t; + case MP_QSTR_y: dest[0] = mp_obj_new_int(data->y); break; // converting from lv_coord_t; + default: field_not_found(MP_QSTR_lv_point_t, attr); + } + } else { + if (dest[1]) + { + // store attribute + switch(attr) + { + case MP_QSTR_x: data->x = (int16_t)mp_obj_get_int(dest[1]); break; // converting to lv_coord_t; + case MP_QSTR_y: data->y = (int16_t)mp_obj_get_int(dest[1]); break; // converting to lv_coord_t; + default: field_not_found(MP_QSTR_lv_point_t, attr); + } + + dest[0] = MP_OBJ_NULL; // indicate success + } + } +} + +STATIC void mp_lv_point_t_print(const mp_print_t *print, + mp_obj_t self_in, + mp_print_kind_t kind) +{ + mp_printf(print, "lvgl struct lv_point_t"); +} + +STATIC const mp_rom_map_elem_t mp_lv_point_t_locals_dict_table[] = { + { MP_ROM_QSTR(MP_QSTR_SIZE), MP_ROM_PTR(MP_ROM_INT(sizeof(lv_point_t))) }, + { MP_ROM_QSTR(MP_QSTR_cast), MP_ROM_PTR(&mp_lv_cast_class_method) }, +}; + +STATIC MP_DEFINE_CONST_DICT(mp_lv_point_t_locals_dict, mp_lv_point_t_locals_dict_table); + +STATIC const mp_obj_type_t mp_lv_point_t_type = { + { &mp_type_type }, + .name = MP_QSTR_lv_point_t, + .print = mp_lv_point_t_print, + .make_new = make_new_lv_struct, + .attr = mp_lv_point_t_attr, + .locals_dict = (mp_obj_dict_t*)&mp_lv_point_t_locals_dict, + .buffer_p = { .get_buffer = mp_blob_get_buffer } +}; + +STATIC inline const mp_obj_type_t *get_mp_lv_point_t_type() +{ + return &mp_lv_point_t_type; +} + + +/* + * lvgl extension definition for: + * void lv_label_get_letter_pos(const lv_obj_t *label, uint16_t index, lv_point_t *pos) + */ + +STATIC mp_obj_t mp_lv_label_get_letter_pos(size_t n_args, const mp_obj_t *args) +{ + const lv_obj_t *label = mp_to_lv(args[0]); + uint16_t index = (uint16_t)mp_obj_get_int(args[1]); + lv_point_t *pos = mp_write_ptr_lv_point_t(args[2]); + lv_label_get_letter_pos(label, index, pos); + return mp_const_none; +} + +STATIC MP_DEFINE_CONST_FUN_OBJ_VAR_BETWEEN(mp_lv_label_get_letter_pos_obj, 3, 3, mp_lv_label_get_letter_pos); + + + +/* + * lvgl extension definition for: + * uint16_t lv_label_get_letter_on(const lv_obj_t *label, lv_point_t *pos) + */ + +STATIC mp_obj_t mp_lv_label_get_letter_on(size_t n_args, const mp_obj_t *args) +{ + const lv_obj_t *label = mp_to_lv(args[0]); + lv_point_t *pos = mp_write_ptr_lv_point_t(args[1]); + uint16_t res = lv_label_get_letter_on(label, pos); + return mp_obj_new_int_from_uint(res); +} + +STATIC MP_DEFINE_CONST_FUN_OBJ_VAR_BETWEEN(mp_lv_label_get_letter_on_obj, 2, 2, mp_lv_label_get_letter_on); + + + +/* + * lvgl extension definition for: + * void lv_label_ins_text(lv_obj_t *label, uint32_t pos, const char *txt) + */ + +STATIC mp_obj_t mp_lv_label_ins_text(size_t n_args, const mp_obj_t *args) +{ + lv_obj_t *label = mp_to_lv(args[0]); + uint32_t pos = (uint32_t)mp_obj_get_int(args[1]); + const char *txt = (char*)mp_obj_str_get_str(args[2]); + lv_label_ins_text(label, pos, txt); + return mp_const_none; +} + +STATIC MP_DEFINE_CONST_FUN_OBJ_VAR_BETWEEN(mp_lv_label_ins_text_obj, 3, 3, mp_lv_label_ins_text); + + + +/* + * lvgl extension definition for: + * void lv_label_cut_text(lv_obj_t *label, uint32_t pos, uint32_t cnt) + */ + +STATIC mp_obj_t mp_lv_label_cut_text(size_t n_args, const mp_obj_t *args) +{ + lv_obj_t *label = mp_to_lv(args[0]); + uint32_t pos = (uint32_t)mp_obj_get_int(args[1]); + uint32_t cnt = (uint32_t)mp_obj_get_int(args[2]); + lv_label_cut_text(label, pos, cnt); + return mp_const_none; +} + +STATIC MP_DEFINE_CONST_FUN_OBJ_VAR_BETWEEN(mp_lv_label_cut_text_obj, 3, 3, mp_lv_label_cut_text); + + + +/* + * lvgl label object definitions + */ + + +STATIC const mp_rom_map_elem_t label_locals_dict_table[] = { + { MP_ROM_QSTR(MP_QSTR_set_style), MP_ROM_PTR(&mp_lv_label_set_style_obj) }, + { MP_ROM_QSTR(MP_QSTR_get_style), MP_ROM_PTR(&mp_lv_label_get_style_obj) }, + { MP_ROM_QSTR(MP_QSTR_set_text), MP_ROM_PTR(&mp_lv_label_set_text_obj) }, + { MP_ROM_QSTR(MP_QSTR_set_array_text), MP_ROM_PTR(&mp_lv_label_set_array_text_obj) }, + { MP_ROM_QSTR(MP_QSTR_set_static_text), MP_ROM_PTR(&mp_lv_label_set_static_text_obj) }, + { MP_ROM_QSTR(MP_QSTR_set_long_mode), MP_ROM_PTR(&mp_lv_label_set_long_mode_obj) }, + { MP_ROM_QSTR(MP_QSTR_set_align), MP_ROM_PTR(&mp_lv_label_set_align_obj) }, + { MP_ROM_QSTR(MP_QSTR_set_recolor), MP_ROM_PTR(&mp_lv_label_set_recolor_obj) }, + { MP_ROM_QSTR(MP_QSTR_set_body_draw), MP_ROM_PTR(&mp_lv_label_set_body_draw_obj) }, + { MP_ROM_QSTR(MP_QSTR_set_anim_speed), MP_ROM_PTR(&mp_lv_label_set_anim_speed_obj) }, + { MP_ROM_QSTR(MP_QSTR_get_text), MP_ROM_PTR(&mp_lv_label_get_text_obj) }, + { MP_ROM_QSTR(MP_QSTR_get_long_mode), MP_ROM_PTR(&mp_lv_label_get_long_mode_obj) }, + { MP_ROM_QSTR(MP_QSTR_get_align), MP_ROM_PTR(&mp_lv_label_get_align_obj) }, + { MP_ROM_QSTR(MP_QSTR_get_recolor), MP_ROM_PTR(&mp_lv_label_get_recolor_obj) }, + { MP_ROM_QSTR(MP_QSTR_get_body_draw), MP_ROM_PTR(&mp_lv_label_get_body_draw_obj) }, + { MP_ROM_QSTR(MP_QSTR_get_anim_speed), MP_ROM_PTR(&mp_lv_label_get_anim_speed_obj) }, + { MP_ROM_QSTR(MP_QSTR_get_letter_pos), MP_ROM_PTR(&mp_lv_label_get_letter_pos_obj) }, + { MP_ROM_QSTR(MP_QSTR_get_letter_on), MP_ROM_PTR(&mp_lv_label_get_letter_on_obj) }, + { MP_ROM_QSTR(MP_QSTR_ins_text), MP_ROM_PTR(&mp_lv_label_ins_text_obj) }, + { MP_ROM_QSTR(MP_QSTR_cut_text), MP_ROM_PTR(&mp_lv_label_cut_text_obj) }, + { MP_ROM_QSTR(MP_QSTR_delete), MP_ROM_PTR(&mp_lv_obj_del_obj) }, + { MP_ROM_QSTR(MP_QSTR_clean), MP_ROM_PTR(&mp_lv_obj_clean_obj) }, + { MP_ROM_QSTR(MP_QSTR_invalidate), MP_ROM_PTR(&mp_lv_obj_invalidate_obj) }, + { MP_ROM_QSTR(MP_QSTR_set_parent), MP_ROM_PTR(&mp_lv_obj_set_parent_obj) }, + { MP_ROM_QSTR(MP_QSTR_set_pos), MP_ROM_PTR(&mp_lv_obj_set_pos_obj) }, + { MP_ROM_QSTR(MP_QSTR_set_x), MP_ROM_PTR(&mp_lv_obj_set_x_obj) }, + { MP_ROM_QSTR(MP_QSTR_set_y), MP_ROM_PTR(&mp_lv_obj_set_y_obj) }, + { MP_ROM_QSTR(MP_QSTR_set_size), MP_ROM_PTR(&mp_lv_obj_set_size_obj) }, + { MP_ROM_QSTR(MP_QSTR_set_width), MP_ROM_PTR(&mp_lv_obj_set_width_obj) }, + { MP_ROM_QSTR(MP_QSTR_set_height), MP_ROM_PTR(&mp_lv_obj_set_height_obj) }, + { MP_ROM_QSTR(MP_QSTR_align), MP_ROM_PTR(&mp_lv_obj_align_obj) }, + { MP_ROM_QSTR(MP_QSTR_align_origo), MP_ROM_PTR(&mp_lv_obj_align_origo_obj) }, + { MP_ROM_QSTR(MP_QSTR_realign), MP_ROM_PTR(&mp_lv_obj_realign_obj) }, + { MP_ROM_QSTR(MP_QSTR_set_auto_realign), MP_ROM_PTR(&mp_lv_obj_set_auto_realign_obj) }, + { MP_ROM_QSTR(MP_QSTR_set_style), MP_ROM_PTR(&mp_lv_obj_set_style_obj) }, + { MP_ROM_QSTR(MP_QSTR_refresh_style), MP_ROM_PTR(&mp_lv_obj_refresh_style_obj) }, + { MP_ROM_QSTR(MP_QSTR_report_style_mod), MP_ROM_PTR(&mp_lv_obj_report_style_mod_obj) }, + { MP_ROM_QSTR(MP_QSTR_set_hidden), MP_ROM_PTR(&mp_lv_obj_set_hidden_obj) }, + { MP_ROM_QSTR(MP_QSTR_set_click), MP_ROM_PTR(&mp_lv_obj_set_click_obj) }, + { MP_ROM_QSTR(MP_QSTR_set_top), MP_ROM_PTR(&mp_lv_obj_set_top_obj) }, + { MP_ROM_QSTR(MP_QSTR_set_drag), MP_ROM_PTR(&mp_lv_obj_set_drag_obj) }, + { MP_ROM_QSTR(MP_QSTR_set_drag_throw), MP_ROM_PTR(&mp_lv_obj_set_drag_throw_obj) }, + { MP_ROM_QSTR(MP_QSTR_set_drag_parent), MP_ROM_PTR(&mp_lv_obj_set_drag_parent_obj) }, + { MP_ROM_QSTR(MP_QSTR_set_opa_scale_enable), MP_ROM_PTR(&mp_lv_obj_set_opa_scale_enable_obj) }, + { MP_ROM_QSTR(MP_QSTR_set_opa_scale), MP_ROM_PTR(&mp_lv_obj_set_opa_scale_obj) }, + { MP_ROM_QSTR(MP_QSTR_set_protect), MP_ROM_PTR(&mp_lv_obj_set_protect_obj) }, + { MP_ROM_QSTR(MP_QSTR_clear_protect), MP_ROM_PTR(&mp_lv_obj_clear_protect_obj) }, + { MP_ROM_QSTR(MP_QSTR_set_signal_func), MP_ROM_PTR(&mp_lv_obj_set_signal_func_obj) }, + { MP_ROM_QSTR(MP_QSTR_set_design_func), MP_ROM_PTR(&mp_lv_obj_set_design_func_obj) }, + { MP_ROM_QSTR(MP_QSTR_allocate_ext_attr), MP_ROM_PTR(&mp_lv_obj_allocate_ext_attr_obj) }, + { MP_ROM_QSTR(MP_QSTR_refresh_ext_size), MP_ROM_PTR(&mp_lv_obj_refresh_ext_size_obj) }, + { MP_ROM_QSTR(MP_QSTR_set_free_num), MP_ROM_PTR(&mp_lv_obj_set_free_num_obj) }, + { MP_ROM_QSTR(MP_QSTR_set_free_ptr), MP_ROM_PTR(&mp_lv_obj_set_free_ptr_obj) }, + { MP_ROM_QSTR(MP_QSTR_animate), MP_ROM_PTR(&mp_lv_obj_animate_obj) }, + { MP_ROM_QSTR(MP_QSTR_get_screen), MP_ROM_PTR(&mp_lv_obj_get_screen_obj) }, + { MP_ROM_QSTR(MP_QSTR_get_parent), MP_ROM_PTR(&mp_lv_obj_get_parent_obj) }, + { MP_ROM_QSTR(MP_QSTR_get_child), MP_ROM_PTR(&mp_lv_obj_get_child_obj) }, + { MP_ROM_QSTR(MP_QSTR_get_child_back), MP_ROM_PTR(&mp_lv_obj_get_child_back_obj) }, + { MP_ROM_QSTR(MP_QSTR_count_children), MP_ROM_PTR(&mp_lv_obj_count_children_obj) }, + { MP_ROM_QSTR(MP_QSTR_get_coords), MP_ROM_PTR(&mp_lv_obj_get_coords_obj) }, + { MP_ROM_QSTR(MP_QSTR_get_x), MP_ROM_PTR(&mp_lv_obj_get_x_obj) }, + { MP_ROM_QSTR(MP_QSTR_get_y), MP_ROM_PTR(&mp_lv_obj_get_y_obj) }, + { MP_ROM_QSTR(MP_QSTR_get_width), MP_ROM_PTR(&mp_lv_obj_get_width_obj) }, + { MP_ROM_QSTR(MP_QSTR_get_height), MP_ROM_PTR(&mp_lv_obj_get_height_obj) }, + { MP_ROM_QSTR(MP_QSTR_get_ext_size), MP_ROM_PTR(&mp_lv_obj_get_ext_size_obj) }, + { MP_ROM_QSTR(MP_QSTR_get_auto_realign), MP_ROM_PTR(&mp_lv_obj_get_auto_realign_obj) }, + { MP_ROM_QSTR(MP_QSTR_get_style), MP_ROM_PTR(&mp_lv_obj_get_style_obj) }, + { MP_ROM_QSTR(MP_QSTR_get_hidden), MP_ROM_PTR(&mp_lv_obj_get_hidden_obj) }, + { MP_ROM_QSTR(MP_QSTR_get_click), MP_ROM_PTR(&mp_lv_obj_get_click_obj) }, + { MP_ROM_QSTR(MP_QSTR_get_top), MP_ROM_PTR(&mp_lv_obj_get_top_obj) }, + { MP_ROM_QSTR(MP_QSTR_get_drag), MP_ROM_PTR(&mp_lv_obj_get_drag_obj) }, + { MP_ROM_QSTR(MP_QSTR_get_drag_throw), MP_ROM_PTR(&mp_lv_obj_get_drag_throw_obj) }, + { MP_ROM_QSTR(MP_QSTR_get_drag_parent), MP_ROM_PTR(&mp_lv_obj_get_drag_parent_obj) }, + { MP_ROM_QSTR(MP_QSTR_get_opa_scale_enable), MP_ROM_PTR(&mp_lv_obj_get_opa_scale_enable_obj) }, + { MP_ROM_QSTR(MP_QSTR_get_opa_scale), MP_ROM_PTR(&mp_lv_obj_get_opa_scale_obj) }, + { MP_ROM_QSTR(MP_QSTR_get_protect), MP_ROM_PTR(&mp_lv_obj_get_protect_obj) }, + { MP_ROM_QSTR(MP_QSTR_is_protected), MP_ROM_PTR(&mp_lv_obj_is_protected_obj) }, + { MP_ROM_QSTR(MP_QSTR_get_signal_func), MP_ROM_PTR(&mp_lv_obj_get_signal_func_obj) }, + { MP_ROM_QSTR(MP_QSTR_get_design_func), MP_ROM_PTR(&mp_lv_obj_get_design_func_obj) }, + { MP_ROM_QSTR(MP_QSTR_get_ext_attr), MP_ROM_PTR(&mp_lv_obj_get_ext_attr_obj) }, + { MP_ROM_QSTR(MP_QSTR_get_free_num), MP_ROM_PTR(&mp_lv_obj_get_free_num_obj) }, + { MP_ROM_QSTR(MP_QSTR_get_free_ptr), MP_ROM_PTR(&mp_lv_obj_get_free_ptr_obj) }, + { MP_ROM_QSTR(MP_QSTR_get_group), MP_ROM_PTR(&mp_lv_obj_get_group_obj) }, + { MP_ROM_QSTR(MP_QSTR_is_focused), MP_ROM_PTR(&mp_lv_obj_is_focused_obj) }, + { MP_ROM_QSTR(MP_QSTR_LONG), MP_ROM_PTR(&mp_LV_LABEL_LONG_type) }, + { MP_ROM_QSTR(MP_QSTR_ALIGN), MP_ROM_PTR(&mp_LV_LABEL_ALIGN_type) } +}; + +STATIC MP_DEFINE_CONST_DICT(label_locals_dict, label_locals_dict_table); + +STATIC void label_print(const mp_print_t *print, + mp_obj_t self_in, + mp_print_kind_t kind) +{ + mp_printf(print, "lvgl label"); +} + + +STATIC mp_obj_t label_make_new( + const mp_obj_type_t *type, + size_t n_args, + size_t n_kw, + const mp_obj_t *args) +{ + return make_new(&lv_label_create, type, n_args, n_kw, args); +} + + +STATIC const mp_obj_type_t mp_label_type = { + { &mp_type_type }, + .name = MP_QSTR_label, + .print = label_print, + .make_new = label_make_new, + .locals_dict = (mp_obj_dict_t*)&label_locals_dict, +}; + + +/* + * lvgl extension definition for: + * inline static void lv_img_set_file(lv_obj_t *img, const char *fn) + */ + +STATIC mp_obj_t mp_lv_img_set_file(size_t n_args, const mp_obj_t *args) +{ + lv_obj_t *img = mp_to_lv(args[0]); + const char *fn = (char*)mp_obj_str_get_str(args[1]); + lv_img_set_file(img, fn); + return mp_const_none; +} + +STATIC MP_DEFINE_CONST_FUN_OBJ_VAR_BETWEEN(mp_lv_img_set_file_obj, 2, 2, mp_lv_img_set_file); + + + +/* + * lvgl extension definition for: + * inline static void lv_img_set_style(lv_obj_t *img, lv_style_t *style) + */ + +STATIC mp_obj_t mp_lv_img_set_style(size_t n_args, const mp_obj_t *args) +{ + lv_obj_t *img = mp_to_lv(args[0]); + lv_style_t *style = mp_write_ptr_lv_style_t(args[1]); + lv_img_set_style(img, style); + return mp_const_none; +} + +STATIC MP_DEFINE_CONST_FUN_OBJ_VAR_BETWEEN(mp_lv_img_set_style_obj, 2, 2, mp_lv_img_set_style); + + + +/* + * lvgl extension definition for: + * inline static void lv_img_set_upscale(lv_obj_t *img, bool upcale) + */ + +STATIC mp_obj_t mp_lv_img_set_upscale(size_t n_args, const mp_obj_t *args) +{ + lv_obj_t *img = mp_to_lv(args[0]); + bool upcale = mp_obj_is_true(args[1]); + lv_img_set_upscale(img, upcale); + return mp_const_none; +} + +STATIC MP_DEFINE_CONST_FUN_OBJ_VAR_BETWEEN(mp_lv_img_set_upscale_obj, 2, 2, mp_lv_img_set_upscale); + + + +/* + * lvgl extension definition for: + * inline static lv_style_t *lv_img_get_style(const lv_obj_t *img) + */ + +STATIC mp_obj_t mp_lv_img_get_style(size_t n_args, const mp_obj_t *args) +{ + const lv_obj_t *img = mp_to_lv(args[0]); + lv_style_t* res = lv_img_get_style(img); + return mp_read_ptr_lv_style_t((void*)res); +} + +STATIC MP_DEFINE_CONST_FUN_OBJ_VAR_BETWEEN(mp_lv_img_get_style_obj, 1, 1, mp_lv_img_get_style); + + + +/* + * lvgl extension definition for: + * inline static bool lv_img_get_upscale(const lv_obj_t *img) + */ + +STATIC mp_obj_t mp_lv_img_get_upscale(size_t n_args, const mp_obj_t *args) +{ + const lv_obj_t *img = mp_to_lv(args[0]); + bool res = lv_img_get_upscale(img); + return convert_to_bool(res); +} + +STATIC MP_DEFINE_CONST_FUN_OBJ_VAR_BETWEEN(mp_lv_img_get_upscale_obj, 1, 1, mp_lv_img_get_upscale); + + + +/* + * lvgl extension definition for: + * lv_img_src_t lv_img_src_get_type(const void *src) + */ + +STATIC mp_obj_t mp_lv_img_src_get_type(size_t n_args, const mp_obj_t *args) +{ + const void *src = mp_to_ptr(args[0]); + lv_img_src_t res = lv_img_src_get_type(src); + return mp_obj_new_int_from_uint(res); +} + +STATIC MP_DEFINE_CONST_FUN_OBJ_VAR_BETWEEN(mp_lv_img_src_get_type_obj, 1, 1, mp_lv_img_src_get_type); + + + +/* + * lvgl extension definition for: + * void lv_img_decoder_set_custom(lv_img_decoder_info_f_t info_fp, lv_img_decoder_open_f_t open_fp, lv_img_decoder_read_line_f_t read_fp, lv_img_decoder_close_f_t close_fp) + */ + +STATIC mp_obj_t mp_lv_img_decoder_set_custom(size_t n_args, const mp_obj_t *args) +{ + set_action(args[0], args[0]); + lv_img_decoder_info_f_t info_fp = &lv_img_decoder_info_f_t_callback; + set_action(args[0], args[1]); + lv_img_decoder_open_f_t open_fp = &lv_img_decoder_open_f_t_callback; + set_action(args[0], args[2]); + lv_img_decoder_read_line_f_t read_fp = &lv_img_decoder_read_line_f_t_callback; + lv_img_decoder_close_f_t close_fp = mp_to_ptr(args[3]); + lv_img_decoder_set_custom(info_fp, open_fp, read_fp, close_fp); + return mp_const_none; +} + +STATIC MP_DEFINE_CONST_FUN_OBJ_VAR_BETWEEN(mp_lv_img_decoder_set_custom_obj, 4, 4, mp_lv_img_decoder_set_custom); + + + +/* + * lvgl extension definition for: + * lv_res_t lv_img_dsc_get_info(const char *src, lv_img_header_t *header) + */ + +STATIC mp_obj_t mp_lv_img_dsc_get_info(size_t n_args, const mp_obj_t *args) +{ + const char *src = (char*)mp_obj_str_get_str(args[0]); + lv_img_header_t *header = mp_write_ptr_lv_img_header_t(args[1]); + lv_res_t res = lv_img_dsc_get_info(src, header); + return mp_obj_new_int_from_uint(res); +} + +STATIC MP_DEFINE_CONST_FUN_OBJ_VAR_BETWEEN(mp_lv_img_dsc_get_info_obj, 2, 2, mp_lv_img_dsc_get_info); + + + +/* + * lvgl extension definition for: + * uint8_t lv_img_color_format_get_px_size(lv_img_cf_t cf) + */ + +STATIC mp_obj_t mp_lv_img_color_format_get_px_size(size_t n_args, const mp_obj_t *args) +{ + lv_img_cf_t cf = (uint8_t)mp_obj_get_int(args[0]); + uint8_t res = lv_img_color_format_get_px_size(cf); + return mp_obj_new_int_from_uint(res); +} + +STATIC MP_DEFINE_CONST_FUN_OBJ_VAR_BETWEEN(mp_lv_img_color_format_get_px_size_obj, 1, 1, mp_lv_img_color_format_get_px_size); + + + +/* + * lvgl extension definition for: + * bool lv_img_color_format_is_chroma_keyed(lv_img_cf_t cf) + */ + +STATIC mp_obj_t mp_lv_img_color_format_is_chroma_keyed(size_t n_args, const mp_obj_t *args) +{ + lv_img_cf_t cf = (uint8_t)mp_obj_get_int(args[0]); + bool res = lv_img_color_format_is_chroma_keyed(cf); + return convert_to_bool(res); +} + +STATIC MP_DEFINE_CONST_FUN_OBJ_VAR_BETWEEN(mp_lv_img_color_format_is_chroma_keyed_obj, 1, 1, mp_lv_img_color_format_is_chroma_keyed); + + + +/* + * lvgl extension definition for: + * bool lv_img_color_format_has_alpha(lv_img_cf_t cf) + */ + +STATIC mp_obj_t mp_lv_img_color_format_has_alpha(size_t n_args, const mp_obj_t *args) +{ + lv_img_cf_t cf = (uint8_t)mp_obj_get_int(args[0]); + bool res = lv_img_color_format_has_alpha(cf); + return convert_to_bool(res); +} + +STATIC MP_DEFINE_CONST_FUN_OBJ_VAR_BETWEEN(mp_lv_img_color_format_has_alpha_obj, 1, 1, mp_lv_img_color_format_has_alpha); + + + +/* + * lvgl extension definition for: + * void lv_img_set_src(lv_obj_t *img, const void *src_img) + */ + +STATIC mp_obj_t mp_lv_img_set_src(size_t n_args, const mp_obj_t *args) +{ + lv_obj_t *img = mp_to_lv(args[0]); + const void *src_img = mp_to_ptr(args[1]); + lv_img_set_src(img, src_img); + return mp_const_none; +} + +STATIC MP_DEFINE_CONST_FUN_OBJ_VAR_BETWEEN(mp_lv_img_set_src_obj, 2, 2, mp_lv_img_set_src); + + + +/* + * lvgl extension definition for: + * void lv_img_set_auto_size(lv_obj_t *img, bool autosize_en) + */ + +STATIC mp_obj_t mp_lv_img_set_auto_size(size_t n_args, const mp_obj_t *args) +{ + lv_obj_t *img = mp_to_lv(args[0]); + bool autosize_en = mp_obj_is_true(args[1]); + lv_img_set_auto_size(img, autosize_en); + return mp_const_none; +} + +STATIC MP_DEFINE_CONST_FUN_OBJ_VAR_BETWEEN(mp_lv_img_set_auto_size_obj, 2, 2, mp_lv_img_set_auto_size); + + + +/* + * lvgl extension definition for: + * const void *lv_img_get_src(lv_obj_t *img) + */ + +STATIC mp_obj_t mp_lv_img_get_src(size_t n_args, const mp_obj_t *args) +{ + lv_obj_t *img = mp_to_lv(args[0]); + const void* res = lv_img_get_src(img); + return ptr_to_mp((void*)res); +} + +STATIC MP_DEFINE_CONST_FUN_OBJ_VAR_BETWEEN(mp_lv_img_get_src_obj, 1, 1, mp_lv_img_get_src); + + + +/* + * lvgl extension definition for: + * const char *lv_img_get_file_name(const lv_obj_t *img) + */ + +STATIC mp_obj_t mp_lv_img_get_file_name(size_t n_args, const mp_obj_t *args) +{ + const lv_obj_t *img = mp_to_lv(args[0]); + const char* res = lv_img_get_file_name(img); + return convert_to_str((void*)res); +} + +STATIC MP_DEFINE_CONST_FUN_OBJ_VAR_BETWEEN(mp_lv_img_get_file_name_obj, 1, 1, mp_lv_img_get_file_name); + + + +/* + * lvgl extension definition for: + * bool lv_img_get_auto_size(const lv_obj_t *img) + */ + +STATIC mp_obj_t mp_lv_img_get_auto_size(size_t n_args, const mp_obj_t *args) +{ + const lv_obj_t *img = mp_to_lv(args[0]); + bool res = lv_img_get_auto_size(img); + return convert_to_bool(res); +} + +STATIC MP_DEFINE_CONST_FUN_OBJ_VAR_BETWEEN(mp_lv_img_get_auto_size_obj, 1, 1, mp_lv_img_get_auto_size); + + + +/* + * lvgl img object definitions + */ + + +STATIC const mp_rom_map_elem_t img_locals_dict_table[] = { + { MP_ROM_QSTR(MP_QSTR_set_file), MP_ROM_PTR(&mp_lv_img_set_file_obj) }, + { MP_ROM_QSTR(MP_QSTR_set_style), MP_ROM_PTR(&mp_lv_img_set_style_obj) }, + { MP_ROM_QSTR(MP_QSTR_set_upscale), MP_ROM_PTR(&mp_lv_img_set_upscale_obj) }, + { MP_ROM_QSTR(MP_QSTR_get_style), MP_ROM_PTR(&mp_lv_img_get_style_obj) }, + { MP_ROM_QSTR(MP_QSTR_get_upscale), MP_ROM_PTR(&mp_lv_img_get_upscale_obj) }, + { MP_ROM_QSTR(MP_QSTR_src_get_type), MP_ROM_PTR(&mp_lv_img_src_get_type_obj) }, + { MP_ROM_QSTR(MP_QSTR_decoder_set_custom), MP_ROM_PTR(&mp_lv_img_decoder_set_custom_obj) }, + { MP_ROM_QSTR(MP_QSTR_dsc_get_info), MP_ROM_PTR(&mp_lv_img_dsc_get_info_obj) }, + { MP_ROM_QSTR(MP_QSTR_color_format_get_px_size), MP_ROM_PTR(&mp_lv_img_color_format_get_px_size_obj) }, + { MP_ROM_QSTR(MP_QSTR_color_format_is_chroma_keyed), MP_ROM_PTR(&mp_lv_img_color_format_is_chroma_keyed_obj) }, + { MP_ROM_QSTR(MP_QSTR_color_format_has_alpha), MP_ROM_PTR(&mp_lv_img_color_format_has_alpha_obj) }, + { MP_ROM_QSTR(MP_QSTR_set_src), MP_ROM_PTR(&mp_lv_img_set_src_obj) }, + { MP_ROM_QSTR(MP_QSTR_set_auto_size), MP_ROM_PTR(&mp_lv_img_set_auto_size_obj) }, + { MP_ROM_QSTR(MP_QSTR_get_src), MP_ROM_PTR(&mp_lv_img_get_src_obj) }, + { MP_ROM_QSTR(MP_QSTR_get_file_name), MP_ROM_PTR(&mp_lv_img_get_file_name_obj) }, + { MP_ROM_QSTR(MP_QSTR_get_auto_size), MP_ROM_PTR(&mp_lv_img_get_auto_size_obj) }, + { MP_ROM_QSTR(MP_QSTR_delete), MP_ROM_PTR(&mp_lv_obj_del_obj) }, + { MP_ROM_QSTR(MP_QSTR_clean), MP_ROM_PTR(&mp_lv_obj_clean_obj) }, + { MP_ROM_QSTR(MP_QSTR_invalidate), MP_ROM_PTR(&mp_lv_obj_invalidate_obj) }, + { MP_ROM_QSTR(MP_QSTR_set_parent), MP_ROM_PTR(&mp_lv_obj_set_parent_obj) }, + { MP_ROM_QSTR(MP_QSTR_set_pos), MP_ROM_PTR(&mp_lv_obj_set_pos_obj) }, + { MP_ROM_QSTR(MP_QSTR_set_x), MP_ROM_PTR(&mp_lv_obj_set_x_obj) }, + { MP_ROM_QSTR(MP_QSTR_set_y), MP_ROM_PTR(&mp_lv_obj_set_y_obj) }, + { MP_ROM_QSTR(MP_QSTR_set_size), MP_ROM_PTR(&mp_lv_obj_set_size_obj) }, + { MP_ROM_QSTR(MP_QSTR_set_width), MP_ROM_PTR(&mp_lv_obj_set_width_obj) }, + { MP_ROM_QSTR(MP_QSTR_set_height), MP_ROM_PTR(&mp_lv_obj_set_height_obj) }, + { MP_ROM_QSTR(MP_QSTR_align), MP_ROM_PTR(&mp_lv_obj_align_obj) }, + { MP_ROM_QSTR(MP_QSTR_align_origo), MP_ROM_PTR(&mp_lv_obj_align_origo_obj) }, + { MP_ROM_QSTR(MP_QSTR_realign), MP_ROM_PTR(&mp_lv_obj_realign_obj) }, + { MP_ROM_QSTR(MP_QSTR_set_auto_realign), MP_ROM_PTR(&mp_lv_obj_set_auto_realign_obj) }, + { MP_ROM_QSTR(MP_QSTR_set_style), MP_ROM_PTR(&mp_lv_obj_set_style_obj) }, + { MP_ROM_QSTR(MP_QSTR_refresh_style), MP_ROM_PTR(&mp_lv_obj_refresh_style_obj) }, + { MP_ROM_QSTR(MP_QSTR_report_style_mod), MP_ROM_PTR(&mp_lv_obj_report_style_mod_obj) }, + { MP_ROM_QSTR(MP_QSTR_set_hidden), MP_ROM_PTR(&mp_lv_obj_set_hidden_obj) }, + { MP_ROM_QSTR(MP_QSTR_set_click), MP_ROM_PTR(&mp_lv_obj_set_click_obj) }, + { MP_ROM_QSTR(MP_QSTR_set_top), MP_ROM_PTR(&mp_lv_obj_set_top_obj) }, + { MP_ROM_QSTR(MP_QSTR_set_drag), MP_ROM_PTR(&mp_lv_obj_set_drag_obj) }, + { MP_ROM_QSTR(MP_QSTR_set_drag_throw), MP_ROM_PTR(&mp_lv_obj_set_drag_throw_obj) }, + { MP_ROM_QSTR(MP_QSTR_set_drag_parent), MP_ROM_PTR(&mp_lv_obj_set_drag_parent_obj) }, + { MP_ROM_QSTR(MP_QSTR_set_opa_scale_enable), MP_ROM_PTR(&mp_lv_obj_set_opa_scale_enable_obj) }, + { MP_ROM_QSTR(MP_QSTR_set_opa_scale), MP_ROM_PTR(&mp_lv_obj_set_opa_scale_obj) }, + { MP_ROM_QSTR(MP_QSTR_set_protect), MP_ROM_PTR(&mp_lv_obj_set_protect_obj) }, + { MP_ROM_QSTR(MP_QSTR_clear_protect), MP_ROM_PTR(&mp_lv_obj_clear_protect_obj) }, + { MP_ROM_QSTR(MP_QSTR_set_signal_func), MP_ROM_PTR(&mp_lv_obj_set_signal_func_obj) }, + { MP_ROM_QSTR(MP_QSTR_set_design_func), MP_ROM_PTR(&mp_lv_obj_set_design_func_obj) }, + { MP_ROM_QSTR(MP_QSTR_allocate_ext_attr), MP_ROM_PTR(&mp_lv_obj_allocate_ext_attr_obj) }, + { MP_ROM_QSTR(MP_QSTR_refresh_ext_size), MP_ROM_PTR(&mp_lv_obj_refresh_ext_size_obj) }, + { MP_ROM_QSTR(MP_QSTR_set_free_num), MP_ROM_PTR(&mp_lv_obj_set_free_num_obj) }, + { MP_ROM_QSTR(MP_QSTR_set_free_ptr), MP_ROM_PTR(&mp_lv_obj_set_free_ptr_obj) }, + { MP_ROM_QSTR(MP_QSTR_animate), MP_ROM_PTR(&mp_lv_obj_animate_obj) }, + { MP_ROM_QSTR(MP_QSTR_get_screen), MP_ROM_PTR(&mp_lv_obj_get_screen_obj) }, + { MP_ROM_QSTR(MP_QSTR_get_parent), MP_ROM_PTR(&mp_lv_obj_get_parent_obj) }, + { MP_ROM_QSTR(MP_QSTR_get_child), MP_ROM_PTR(&mp_lv_obj_get_child_obj) }, + { MP_ROM_QSTR(MP_QSTR_get_child_back), MP_ROM_PTR(&mp_lv_obj_get_child_back_obj) }, + { MP_ROM_QSTR(MP_QSTR_count_children), MP_ROM_PTR(&mp_lv_obj_count_children_obj) }, + { MP_ROM_QSTR(MP_QSTR_get_coords), MP_ROM_PTR(&mp_lv_obj_get_coords_obj) }, + { MP_ROM_QSTR(MP_QSTR_get_x), MP_ROM_PTR(&mp_lv_obj_get_x_obj) }, + { MP_ROM_QSTR(MP_QSTR_get_y), MP_ROM_PTR(&mp_lv_obj_get_y_obj) }, + { MP_ROM_QSTR(MP_QSTR_get_width), MP_ROM_PTR(&mp_lv_obj_get_width_obj) }, + { MP_ROM_QSTR(MP_QSTR_get_height), MP_ROM_PTR(&mp_lv_obj_get_height_obj) }, + { MP_ROM_QSTR(MP_QSTR_get_ext_size), MP_ROM_PTR(&mp_lv_obj_get_ext_size_obj) }, + { MP_ROM_QSTR(MP_QSTR_get_auto_realign), MP_ROM_PTR(&mp_lv_obj_get_auto_realign_obj) }, + { MP_ROM_QSTR(MP_QSTR_get_style), MP_ROM_PTR(&mp_lv_obj_get_style_obj) }, + { MP_ROM_QSTR(MP_QSTR_get_hidden), MP_ROM_PTR(&mp_lv_obj_get_hidden_obj) }, + { MP_ROM_QSTR(MP_QSTR_get_click), MP_ROM_PTR(&mp_lv_obj_get_click_obj) }, + { MP_ROM_QSTR(MP_QSTR_get_top), MP_ROM_PTR(&mp_lv_obj_get_top_obj) }, + { MP_ROM_QSTR(MP_QSTR_get_drag), MP_ROM_PTR(&mp_lv_obj_get_drag_obj) }, + { MP_ROM_QSTR(MP_QSTR_get_drag_throw), MP_ROM_PTR(&mp_lv_obj_get_drag_throw_obj) }, + { MP_ROM_QSTR(MP_QSTR_get_drag_parent), MP_ROM_PTR(&mp_lv_obj_get_drag_parent_obj) }, + { MP_ROM_QSTR(MP_QSTR_get_opa_scale_enable), MP_ROM_PTR(&mp_lv_obj_get_opa_scale_enable_obj) }, + { MP_ROM_QSTR(MP_QSTR_get_opa_scale), MP_ROM_PTR(&mp_lv_obj_get_opa_scale_obj) }, + { MP_ROM_QSTR(MP_QSTR_get_protect), MP_ROM_PTR(&mp_lv_obj_get_protect_obj) }, + { MP_ROM_QSTR(MP_QSTR_is_protected), MP_ROM_PTR(&mp_lv_obj_is_protected_obj) }, + { MP_ROM_QSTR(MP_QSTR_get_signal_func), MP_ROM_PTR(&mp_lv_obj_get_signal_func_obj) }, + { MP_ROM_QSTR(MP_QSTR_get_design_func), MP_ROM_PTR(&mp_lv_obj_get_design_func_obj) }, + { MP_ROM_QSTR(MP_QSTR_get_ext_attr), MP_ROM_PTR(&mp_lv_obj_get_ext_attr_obj) }, + { MP_ROM_QSTR(MP_QSTR_get_free_num), MP_ROM_PTR(&mp_lv_obj_get_free_num_obj) }, + { MP_ROM_QSTR(MP_QSTR_get_free_ptr), MP_ROM_PTR(&mp_lv_obj_get_free_ptr_obj) }, + { MP_ROM_QSTR(MP_QSTR_get_group), MP_ROM_PTR(&mp_lv_obj_get_group_obj) }, + { MP_ROM_QSTR(MP_QSTR_is_focused), MP_ROM_PTR(&mp_lv_obj_is_focused_obj) }, + { MP_ROM_QSTR(MP_QSTR_SRC), MP_ROM_PTR(&mp_LV_IMG_SRC_type) }, + { MP_ROM_QSTR(MP_QSTR_CF), MP_ROM_PTR(&mp_LV_IMG_CF_type) } +}; + +STATIC MP_DEFINE_CONST_DICT(img_locals_dict, img_locals_dict_table); + +STATIC void img_print(const mp_print_t *print, + mp_obj_t self_in, + mp_print_kind_t kind) +{ + mp_printf(print, "lvgl img"); +} + + +STATIC mp_obj_t img_make_new( + const mp_obj_type_t *type, + size_t n_args, + size_t n_kw, + const mp_obj_t *args) +{ + return make_new(&lv_img_create, type, n_args, n_kw, args); +} + + +STATIC const mp_obj_type_t mp_img_type = { + { &mp_type_type }, + .name = MP_QSTR_img, + .print = img_print, + .make_new = img_make_new, + .locals_dict = (mp_obj_dict_t*)&img_locals_dict, +}; + + +/* + * lvgl extension definition for: + * inline static void lv_line_set_style(lv_obj_t *line, lv_style_t *style) + */ + +STATIC mp_obj_t mp_lv_line_set_style(size_t n_args, const mp_obj_t *args) +{ + lv_obj_t *line = mp_to_lv(args[0]); + lv_style_t *style = mp_write_ptr_lv_style_t(args[1]); + lv_line_set_style(line, style); + return mp_const_none; +} + +STATIC MP_DEFINE_CONST_FUN_OBJ_VAR_BETWEEN(mp_lv_line_set_style_obj, 2, 2, mp_lv_line_set_style); + + + +/* + * lvgl extension definition for: + * inline static void lv_line_set_upscale(lv_obj_t *line, bool upcale) + */ + +STATIC mp_obj_t mp_lv_line_set_upscale(size_t n_args, const mp_obj_t *args) +{ + lv_obj_t *line = mp_to_lv(args[0]); + bool upcale = mp_obj_is_true(args[1]); + lv_line_set_upscale(line, upcale); + return mp_const_none; +} + +STATIC MP_DEFINE_CONST_FUN_OBJ_VAR_BETWEEN(mp_lv_line_set_upscale_obj, 2, 2, mp_lv_line_set_upscale); + + + +/* + * lvgl extension definition for: + * inline static lv_style_t *lv_line_get_style(const lv_obj_t *line) + */ + +STATIC mp_obj_t mp_lv_line_get_style(size_t n_args, const mp_obj_t *args) +{ + const lv_obj_t *line = mp_to_lv(args[0]); + lv_style_t* res = lv_line_get_style(line); + return mp_read_ptr_lv_style_t((void*)res); +} + +STATIC MP_DEFINE_CONST_FUN_OBJ_VAR_BETWEEN(mp_lv_line_get_style_obj, 1, 1, mp_lv_line_get_style); + + + +/* + * lvgl extension definition for: + * inline static bool lv_line_get_upscale(const lv_obj_t *line) + */ + +STATIC mp_obj_t mp_lv_line_get_upscale(size_t n_args, const mp_obj_t *args) +{ + const lv_obj_t *line = mp_to_lv(args[0]); + bool res = lv_line_get_upscale(line); + return convert_to_bool(res); +} + +STATIC MP_DEFINE_CONST_FUN_OBJ_VAR_BETWEEN(mp_lv_line_get_upscale_obj, 1, 1, mp_lv_line_get_upscale); + + + +/* + * lvgl extension definition for: + * void lv_line_set_points(lv_obj_t *line, const lv_point_t *point_a, uint16_t point_num) + */ + +STATIC mp_obj_t mp_lv_line_set_points(size_t n_args, const mp_obj_t *args) +{ + lv_obj_t *line = mp_to_lv(args[0]); + const lv_point_t *point_a = mp_write_ptr_lv_point_t(args[1]); + uint16_t point_num = (uint16_t)mp_obj_get_int(args[2]); + lv_line_set_points(line, point_a, point_num); + return mp_const_none; +} + +STATIC MP_DEFINE_CONST_FUN_OBJ_VAR_BETWEEN(mp_lv_line_set_points_obj, 3, 3, mp_lv_line_set_points); + + + +/* + * lvgl extension definition for: + * void lv_line_set_auto_size(lv_obj_t *line, bool en) + */ + +STATIC mp_obj_t mp_lv_line_set_auto_size(size_t n_args, const mp_obj_t *args) +{ + lv_obj_t *line = mp_to_lv(args[0]); + bool en = mp_obj_is_true(args[1]); + lv_line_set_auto_size(line, en); + return mp_const_none; +} + +STATIC MP_DEFINE_CONST_FUN_OBJ_VAR_BETWEEN(mp_lv_line_set_auto_size_obj, 2, 2, mp_lv_line_set_auto_size); + + + +/* + * lvgl extension definition for: + * void lv_line_set_y_invert(lv_obj_t *line, bool en) + */ + +STATIC mp_obj_t mp_lv_line_set_y_invert(size_t n_args, const mp_obj_t *args) +{ + lv_obj_t *line = mp_to_lv(args[0]); + bool en = mp_obj_is_true(args[1]); + lv_line_set_y_invert(line, en); + return mp_const_none; +} + +STATIC MP_DEFINE_CONST_FUN_OBJ_VAR_BETWEEN(mp_lv_line_set_y_invert_obj, 2, 2, mp_lv_line_set_y_invert); + + + +/* + * lvgl extension definition for: + * bool lv_line_get_auto_size(const lv_obj_t *line) + */ + +STATIC mp_obj_t mp_lv_line_get_auto_size(size_t n_args, const mp_obj_t *args) +{ + const lv_obj_t *line = mp_to_lv(args[0]); + bool res = lv_line_get_auto_size(line); + return convert_to_bool(res); +} + +STATIC MP_DEFINE_CONST_FUN_OBJ_VAR_BETWEEN(mp_lv_line_get_auto_size_obj, 1, 1, mp_lv_line_get_auto_size); + + + +/* + * lvgl extension definition for: + * bool lv_line_get_y_invert(const lv_obj_t *line) + */ + +STATIC mp_obj_t mp_lv_line_get_y_invert(size_t n_args, const mp_obj_t *args) +{ + const lv_obj_t *line = mp_to_lv(args[0]); + bool res = lv_line_get_y_invert(line); + return convert_to_bool(res); +} + +STATIC MP_DEFINE_CONST_FUN_OBJ_VAR_BETWEEN(mp_lv_line_get_y_invert_obj, 1, 1, mp_lv_line_get_y_invert); + + + +/* + * lvgl line object definitions + */ + + +STATIC const mp_rom_map_elem_t line_locals_dict_table[] = { + { MP_ROM_QSTR(MP_QSTR_set_style), MP_ROM_PTR(&mp_lv_line_set_style_obj) }, + { MP_ROM_QSTR(MP_QSTR_set_upscale), MP_ROM_PTR(&mp_lv_line_set_upscale_obj) }, + { MP_ROM_QSTR(MP_QSTR_get_style), MP_ROM_PTR(&mp_lv_line_get_style_obj) }, + { MP_ROM_QSTR(MP_QSTR_get_upscale), MP_ROM_PTR(&mp_lv_line_get_upscale_obj) }, + { MP_ROM_QSTR(MP_QSTR_set_points), MP_ROM_PTR(&mp_lv_line_set_points_obj) }, + { MP_ROM_QSTR(MP_QSTR_set_auto_size), MP_ROM_PTR(&mp_lv_line_set_auto_size_obj) }, + { MP_ROM_QSTR(MP_QSTR_set_y_invert), MP_ROM_PTR(&mp_lv_line_set_y_invert_obj) }, + { MP_ROM_QSTR(MP_QSTR_get_auto_size), MP_ROM_PTR(&mp_lv_line_get_auto_size_obj) }, + { MP_ROM_QSTR(MP_QSTR_get_y_invert), MP_ROM_PTR(&mp_lv_line_get_y_invert_obj) }, + { MP_ROM_QSTR(MP_QSTR_delete), MP_ROM_PTR(&mp_lv_obj_del_obj) }, + { MP_ROM_QSTR(MP_QSTR_clean), MP_ROM_PTR(&mp_lv_obj_clean_obj) }, + { MP_ROM_QSTR(MP_QSTR_invalidate), MP_ROM_PTR(&mp_lv_obj_invalidate_obj) }, + { MP_ROM_QSTR(MP_QSTR_set_parent), MP_ROM_PTR(&mp_lv_obj_set_parent_obj) }, + { MP_ROM_QSTR(MP_QSTR_set_pos), MP_ROM_PTR(&mp_lv_obj_set_pos_obj) }, + { MP_ROM_QSTR(MP_QSTR_set_x), MP_ROM_PTR(&mp_lv_obj_set_x_obj) }, + { MP_ROM_QSTR(MP_QSTR_set_y), MP_ROM_PTR(&mp_lv_obj_set_y_obj) }, + { MP_ROM_QSTR(MP_QSTR_set_size), MP_ROM_PTR(&mp_lv_obj_set_size_obj) }, + { MP_ROM_QSTR(MP_QSTR_set_width), MP_ROM_PTR(&mp_lv_obj_set_width_obj) }, + { MP_ROM_QSTR(MP_QSTR_set_height), MP_ROM_PTR(&mp_lv_obj_set_height_obj) }, + { MP_ROM_QSTR(MP_QSTR_align), MP_ROM_PTR(&mp_lv_obj_align_obj) }, + { MP_ROM_QSTR(MP_QSTR_align_origo), MP_ROM_PTR(&mp_lv_obj_align_origo_obj) }, + { MP_ROM_QSTR(MP_QSTR_realign), MP_ROM_PTR(&mp_lv_obj_realign_obj) }, + { MP_ROM_QSTR(MP_QSTR_set_auto_realign), MP_ROM_PTR(&mp_lv_obj_set_auto_realign_obj) }, + { MP_ROM_QSTR(MP_QSTR_set_style), MP_ROM_PTR(&mp_lv_obj_set_style_obj) }, + { MP_ROM_QSTR(MP_QSTR_refresh_style), MP_ROM_PTR(&mp_lv_obj_refresh_style_obj) }, + { MP_ROM_QSTR(MP_QSTR_report_style_mod), MP_ROM_PTR(&mp_lv_obj_report_style_mod_obj) }, + { MP_ROM_QSTR(MP_QSTR_set_hidden), MP_ROM_PTR(&mp_lv_obj_set_hidden_obj) }, + { MP_ROM_QSTR(MP_QSTR_set_click), MP_ROM_PTR(&mp_lv_obj_set_click_obj) }, + { MP_ROM_QSTR(MP_QSTR_set_top), MP_ROM_PTR(&mp_lv_obj_set_top_obj) }, + { MP_ROM_QSTR(MP_QSTR_set_drag), MP_ROM_PTR(&mp_lv_obj_set_drag_obj) }, + { MP_ROM_QSTR(MP_QSTR_set_drag_throw), MP_ROM_PTR(&mp_lv_obj_set_drag_throw_obj) }, + { MP_ROM_QSTR(MP_QSTR_set_drag_parent), MP_ROM_PTR(&mp_lv_obj_set_drag_parent_obj) }, + { MP_ROM_QSTR(MP_QSTR_set_opa_scale_enable), MP_ROM_PTR(&mp_lv_obj_set_opa_scale_enable_obj) }, + { MP_ROM_QSTR(MP_QSTR_set_opa_scale), MP_ROM_PTR(&mp_lv_obj_set_opa_scale_obj) }, + { MP_ROM_QSTR(MP_QSTR_set_protect), MP_ROM_PTR(&mp_lv_obj_set_protect_obj) }, + { MP_ROM_QSTR(MP_QSTR_clear_protect), MP_ROM_PTR(&mp_lv_obj_clear_protect_obj) }, + { MP_ROM_QSTR(MP_QSTR_set_signal_func), MP_ROM_PTR(&mp_lv_obj_set_signal_func_obj) }, + { MP_ROM_QSTR(MP_QSTR_set_design_func), MP_ROM_PTR(&mp_lv_obj_set_design_func_obj) }, + { MP_ROM_QSTR(MP_QSTR_allocate_ext_attr), MP_ROM_PTR(&mp_lv_obj_allocate_ext_attr_obj) }, + { MP_ROM_QSTR(MP_QSTR_refresh_ext_size), MP_ROM_PTR(&mp_lv_obj_refresh_ext_size_obj) }, + { MP_ROM_QSTR(MP_QSTR_set_free_num), MP_ROM_PTR(&mp_lv_obj_set_free_num_obj) }, + { MP_ROM_QSTR(MP_QSTR_set_free_ptr), MP_ROM_PTR(&mp_lv_obj_set_free_ptr_obj) }, + { MP_ROM_QSTR(MP_QSTR_animate), MP_ROM_PTR(&mp_lv_obj_animate_obj) }, + { MP_ROM_QSTR(MP_QSTR_get_screen), MP_ROM_PTR(&mp_lv_obj_get_screen_obj) }, + { MP_ROM_QSTR(MP_QSTR_get_parent), MP_ROM_PTR(&mp_lv_obj_get_parent_obj) }, + { MP_ROM_QSTR(MP_QSTR_get_child), MP_ROM_PTR(&mp_lv_obj_get_child_obj) }, + { MP_ROM_QSTR(MP_QSTR_get_child_back), MP_ROM_PTR(&mp_lv_obj_get_child_back_obj) }, + { MP_ROM_QSTR(MP_QSTR_count_children), MP_ROM_PTR(&mp_lv_obj_count_children_obj) }, + { MP_ROM_QSTR(MP_QSTR_get_coords), MP_ROM_PTR(&mp_lv_obj_get_coords_obj) }, + { MP_ROM_QSTR(MP_QSTR_get_x), MP_ROM_PTR(&mp_lv_obj_get_x_obj) }, + { MP_ROM_QSTR(MP_QSTR_get_y), MP_ROM_PTR(&mp_lv_obj_get_y_obj) }, + { MP_ROM_QSTR(MP_QSTR_get_width), MP_ROM_PTR(&mp_lv_obj_get_width_obj) }, + { MP_ROM_QSTR(MP_QSTR_get_height), MP_ROM_PTR(&mp_lv_obj_get_height_obj) }, + { MP_ROM_QSTR(MP_QSTR_get_ext_size), MP_ROM_PTR(&mp_lv_obj_get_ext_size_obj) }, + { MP_ROM_QSTR(MP_QSTR_get_auto_realign), MP_ROM_PTR(&mp_lv_obj_get_auto_realign_obj) }, + { MP_ROM_QSTR(MP_QSTR_get_style), MP_ROM_PTR(&mp_lv_obj_get_style_obj) }, + { MP_ROM_QSTR(MP_QSTR_get_hidden), MP_ROM_PTR(&mp_lv_obj_get_hidden_obj) }, + { MP_ROM_QSTR(MP_QSTR_get_click), MP_ROM_PTR(&mp_lv_obj_get_click_obj) }, + { MP_ROM_QSTR(MP_QSTR_get_top), MP_ROM_PTR(&mp_lv_obj_get_top_obj) }, + { MP_ROM_QSTR(MP_QSTR_get_drag), MP_ROM_PTR(&mp_lv_obj_get_drag_obj) }, + { MP_ROM_QSTR(MP_QSTR_get_drag_throw), MP_ROM_PTR(&mp_lv_obj_get_drag_throw_obj) }, + { MP_ROM_QSTR(MP_QSTR_get_drag_parent), MP_ROM_PTR(&mp_lv_obj_get_drag_parent_obj) }, + { MP_ROM_QSTR(MP_QSTR_get_opa_scale_enable), MP_ROM_PTR(&mp_lv_obj_get_opa_scale_enable_obj) }, + { MP_ROM_QSTR(MP_QSTR_get_opa_scale), MP_ROM_PTR(&mp_lv_obj_get_opa_scale_obj) }, + { MP_ROM_QSTR(MP_QSTR_get_protect), MP_ROM_PTR(&mp_lv_obj_get_protect_obj) }, + { MP_ROM_QSTR(MP_QSTR_is_protected), MP_ROM_PTR(&mp_lv_obj_is_protected_obj) }, + { MP_ROM_QSTR(MP_QSTR_get_signal_func), MP_ROM_PTR(&mp_lv_obj_get_signal_func_obj) }, + { MP_ROM_QSTR(MP_QSTR_get_design_func), MP_ROM_PTR(&mp_lv_obj_get_design_func_obj) }, + { MP_ROM_QSTR(MP_QSTR_get_ext_attr), MP_ROM_PTR(&mp_lv_obj_get_ext_attr_obj) }, + { MP_ROM_QSTR(MP_QSTR_get_free_num), MP_ROM_PTR(&mp_lv_obj_get_free_num_obj) }, + { MP_ROM_QSTR(MP_QSTR_get_free_ptr), MP_ROM_PTR(&mp_lv_obj_get_free_ptr_obj) }, + { MP_ROM_QSTR(MP_QSTR_get_group), MP_ROM_PTR(&mp_lv_obj_get_group_obj) }, + { MP_ROM_QSTR(MP_QSTR_is_focused), MP_ROM_PTR(&mp_lv_obj_is_focused_obj) } +}; + +STATIC MP_DEFINE_CONST_DICT(line_locals_dict, line_locals_dict_table); + +STATIC void line_print(const mp_print_t *print, + mp_obj_t self_in, + mp_print_kind_t kind) +{ + mp_printf(print, "lvgl line"); +} + + +STATIC mp_obj_t line_make_new( + const mp_obj_type_t *type, + size_t n_args, + size_t n_kw, + const mp_obj_t *args) +{ + return make_new(&lv_line_create, type, n_args, n_kw, args); +} + + +STATIC const mp_obj_type_t mp_line_type = { + { &mp_type_type }, + .name = MP_QSTR_line, + .print = line_print, + .make_new = line_make_new, + .locals_dict = (mp_obj_dict_t*)&line_locals_dict, +}; + + +/* + * lvgl extension definition for: + * inline static void lv_page_set_scrl_fit(lv_obj_t *page, bool hor_en, bool ver_en) + */ + +STATIC mp_obj_t mp_lv_page_set_scrl_fit(size_t n_args, const mp_obj_t *args) +{ + lv_obj_t *page = mp_to_lv(args[0]); + bool hor_en = mp_obj_is_true(args[1]); + bool ver_en = mp_obj_is_true(args[2]); + lv_page_set_scrl_fit(page, hor_en, ver_en); + return mp_const_none; +} + +STATIC MP_DEFINE_CONST_FUN_OBJ_VAR_BETWEEN(mp_lv_page_set_scrl_fit_obj, 3, 3, mp_lv_page_set_scrl_fit); + + + +/* + * lvgl extension definition for: + * inline static void lv_page_set_scrl_width(lv_obj_t *page, lv_coord_t w) + */ + +STATIC mp_obj_t mp_lv_page_set_scrl_width(size_t n_args, const mp_obj_t *args) +{ + lv_obj_t *page = mp_to_lv(args[0]); + lv_coord_t w = (int16_t)mp_obj_get_int(args[1]); + lv_page_set_scrl_width(page, w); + return mp_const_none; +} + +STATIC MP_DEFINE_CONST_FUN_OBJ_VAR_BETWEEN(mp_lv_page_set_scrl_width_obj, 2, 2, mp_lv_page_set_scrl_width); + + + +/* + * lvgl extension definition for: + * inline static void lv_page_set_scrl_height(lv_obj_t *page, lv_coord_t h) + */ + +STATIC mp_obj_t mp_lv_page_set_scrl_height(size_t n_args, const mp_obj_t *args) +{ + lv_obj_t *page = mp_to_lv(args[0]); + lv_coord_t h = (int16_t)mp_obj_get_int(args[1]); + lv_page_set_scrl_height(page, h); + return mp_const_none; +} + +STATIC MP_DEFINE_CONST_FUN_OBJ_VAR_BETWEEN(mp_lv_page_set_scrl_height_obj, 2, 2, mp_lv_page_set_scrl_height); + + + +/* + * lvgl extension definition for: + * inline static void lv_page_set_scrl_layout(lv_obj_t *page, lv_layout_t layout) + */ + +STATIC mp_obj_t mp_lv_page_set_scrl_layout(size_t n_args, const mp_obj_t *args) +{ + lv_obj_t *page = mp_to_lv(args[0]); + lv_layout_t layout = (uint8_t)mp_obj_get_int(args[1]); + lv_page_set_scrl_layout(page, layout); + return mp_const_none; +} + +STATIC MP_DEFINE_CONST_FUN_OBJ_VAR_BETWEEN(mp_lv_page_set_scrl_layout_obj, 2, 2, mp_lv_page_set_scrl_layout); + + + +/* + * lvgl extension definition for: + * inline static lv_coord_t lv_page_get_scrl_width(const lv_obj_t *page) + */ + +STATIC mp_obj_t mp_lv_page_get_scrl_width(size_t n_args, const mp_obj_t *args) +{ + const lv_obj_t *page = mp_to_lv(args[0]); + lv_coord_t res = lv_page_get_scrl_width(page); + return mp_obj_new_int(res); +} + +STATIC MP_DEFINE_CONST_FUN_OBJ_VAR_BETWEEN(mp_lv_page_get_scrl_width_obj, 1, 1, mp_lv_page_get_scrl_width); + + + +/* + * lvgl extension definition for: + * inline static lv_coord_t lv_page_get_scrl_height(const lv_obj_t *page) + */ + +STATIC mp_obj_t mp_lv_page_get_scrl_height(size_t n_args, const mp_obj_t *args) +{ + const lv_obj_t *page = mp_to_lv(args[0]); + lv_coord_t res = lv_page_get_scrl_height(page); + return mp_obj_new_int(res); +} + +STATIC MP_DEFINE_CONST_FUN_OBJ_VAR_BETWEEN(mp_lv_page_get_scrl_height_obj, 1, 1, mp_lv_page_get_scrl_height); + + + +/* + * lvgl extension definition for: + * inline static lv_layout_t lv_page_get_scrl_layout(const lv_obj_t *page) + */ + +STATIC mp_obj_t mp_lv_page_get_scrl_layout(size_t n_args, const mp_obj_t *args) +{ + const lv_obj_t *page = mp_to_lv(args[0]); + lv_layout_t res = lv_page_get_scrl_layout(page); + return mp_obj_new_int_from_uint(res); +} + +STATIC MP_DEFINE_CONST_FUN_OBJ_VAR_BETWEEN(mp_lv_page_get_scrl_layout_obj, 1, 1, mp_lv_page_get_scrl_layout); + + + +/* + * lvgl extension definition for: + * inline static bool lv_page_get_scrl_hor_fit(const lv_obj_t *page) + */ + +STATIC mp_obj_t mp_lv_page_get_scrl_hor_fit(size_t n_args, const mp_obj_t *args) +{ + const lv_obj_t *page = mp_to_lv(args[0]); + bool res = lv_page_get_scrl_hor_fit(page); + return convert_to_bool(res); +} + +STATIC MP_DEFINE_CONST_FUN_OBJ_VAR_BETWEEN(mp_lv_page_get_scrl_hor_fit_obj, 1, 1, mp_lv_page_get_scrl_hor_fit); + + + +/* + * lvgl extension definition for: + * inline static bool lv_page_get_scrl_fit_ver(const lv_obj_t *page) + */ + +STATIC mp_obj_t mp_lv_page_get_scrl_fit_ver(size_t n_args, const mp_obj_t *args) +{ + const lv_obj_t *page = mp_to_lv(args[0]); + bool res = lv_page_get_scrl_fit_ver(page); + return convert_to_bool(res); +} + +STATIC MP_DEFINE_CONST_FUN_OBJ_VAR_BETWEEN(mp_lv_page_get_scrl_fit_ver_obj, 1, 1, mp_lv_page_get_scrl_fit_ver); + + + +/* + * lvgl extension definition for: + * void lv_page_clean(lv_obj_t *obj) + */ + +STATIC mp_obj_t mp_lv_page_clean(size_t n_args, const mp_obj_t *args) +{ + lv_obj_t *obj = mp_to_lv(args[0]); + lv_page_clean(obj); + return mp_const_none; +} + +STATIC MP_DEFINE_CONST_FUN_OBJ_VAR_BETWEEN(mp_lv_page_clean_obj, 1, 1, mp_lv_page_clean); + + + +/* + * lvgl extension definition for: + * lv_action_t lv_page_get_pr_action(lv_obj_t *page) + */ + +STATIC mp_obj_t mp_lv_page_get_pr_action(size_t n_args, const mp_obj_t *args) +{ + lv_obj_t *page = mp_to_lv(args[0]); + lv_action_t res = lv_page_get_pr_action(page); + return ptr_to_mp(res); +} + +STATIC MP_DEFINE_CONST_FUN_OBJ_VAR_BETWEEN(mp_lv_page_get_pr_action_obj, 1, 1, mp_lv_page_get_pr_action); + + + +/* + * lvgl extension definition for: + * lv_action_t lv_page_get_rel_action(lv_obj_t *page) + */ + +STATIC mp_obj_t mp_lv_page_get_rel_action(size_t n_args, const mp_obj_t *args) +{ + lv_obj_t *page = mp_to_lv(args[0]); + lv_action_t res = lv_page_get_rel_action(page); + return ptr_to_mp(res); +} + +STATIC MP_DEFINE_CONST_FUN_OBJ_VAR_BETWEEN(mp_lv_page_get_rel_action_obj, 1, 1, mp_lv_page_get_rel_action); + + + +/* + * lvgl extension definition for: + * lv_obj_t *lv_page_get_scrl(const lv_obj_t *page) + */ + +STATIC mp_obj_t mp_lv_page_get_scrl(size_t n_args, const mp_obj_t *args) +{ + const lv_obj_t *page = mp_to_lv(args[0]); + lv_obj_t* res = lv_page_get_scrl(page); + return lv_to_mp((void*)res); +} + +STATIC MP_DEFINE_CONST_FUN_OBJ_VAR_BETWEEN(mp_lv_page_get_scrl_obj, 1, 1, mp_lv_page_get_scrl); + + + +/* + * lvgl extension definition for: + * void lv_page_set_rel_action(lv_obj_t *page, lv_action_t rel_action) + */ + +STATIC mp_obj_t mp_lv_page_set_rel_action(size_t n_args, const mp_obj_t *args) +{ + lv_obj_t *page = mp_to_lv(args[0]); + set_action(args[0], args[1]); + lv_action_t rel_action = &lv_action_t_callback; + lv_page_set_rel_action(page, rel_action); + return mp_const_none; +} + +STATIC MP_DEFINE_CONST_FUN_OBJ_VAR_BETWEEN(mp_lv_page_set_rel_action_obj, 2, 2, mp_lv_page_set_rel_action); + + + +/* + * lvgl extension definition for: + * void lv_page_set_pr_action(lv_obj_t *page, lv_action_t pr_action) + */ + +STATIC mp_obj_t mp_lv_page_set_pr_action(size_t n_args, const mp_obj_t *args) +{ + lv_obj_t *page = mp_to_lv(args[0]); + set_action(args[0], args[1]); + lv_action_t pr_action = &lv_action_t_callback; + lv_page_set_pr_action(page, pr_action); + return mp_const_none; +} + +STATIC MP_DEFINE_CONST_FUN_OBJ_VAR_BETWEEN(mp_lv_page_set_pr_action_obj, 2, 2, mp_lv_page_set_pr_action); + + + +/* + * lvgl extension definition for: + * void lv_page_set_sb_mode(lv_obj_t *page, lv_sb_mode_t sb_mode) + */ + +STATIC mp_obj_t mp_lv_page_set_sb_mode(size_t n_args, const mp_obj_t *args) +{ + lv_obj_t *page = mp_to_lv(args[0]); + lv_sb_mode_t sb_mode = (uint8_t)mp_obj_get_int(args[1]); + lv_page_set_sb_mode(page, sb_mode); + return mp_const_none; +} + +STATIC MP_DEFINE_CONST_FUN_OBJ_VAR_BETWEEN(mp_lv_page_set_sb_mode_obj, 2, 2, mp_lv_page_set_sb_mode); + + + +/* + * lvgl extension definition for: + * void lv_page_set_arrow_scroll(lv_obj_t *page, bool en) + */ + +STATIC mp_obj_t mp_lv_page_set_arrow_scroll(size_t n_args, const mp_obj_t *args) +{ + lv_obj_t *page = mp_to_lv(args[0]); + bool en = mp_obj_is_true(args[1]); + lv_page_set_arrow_scroll(page, en); + return mp_const_none; +} + +STATIC MP_DEFINE_CONST_FUN_OBJ_VAR_BETWEEN(mp_lv_page_set_arrow_scroll_obj, 2, 2, mp_lv_page_set_arrow_scroll); + + + +/* + * lvgl extension definition for: + * void lv_page_set_scroll_propagation(lv_obj_t *page, bool en) + */ + +STATIC mp_obj_t mp_lv_page_set_scroll_propagation(size_t n_args, const mp_obj_t *args) +{ + lv_obj_t *page = mp_to_lv(args[0]); + bool en = mp_obj_is_true(args[1]); + lv_page_set_scroll_propagation(page, en); + return mp_const_none; +} + +STATIC MP_DEFINE_CONST_FUN_OBJ_VAR_BETWEEN(mp_lv_page_set_scroll_propagation_obj, 2, 2, mp_lv_page_set_scroll_propagation); + + + +/* + * lvgl extension definition for: + * void lv_page_set_edge_flash(lv_obj_t *page, bool en) + */ + +STATIC mp_obj_t mp_lv_page_set_edge_flash(size_t n_args, const mp_obj_t *args) +{ + lv_obj_t *page = mp_to_lv(args[0]); + bool en = mp_obj_is_true(args[1]); + lv_page_set_edge_flash(page, en); + return mp_const_none; +} + +STATIC MP_DEFINE_CONST_FUN_OBJ_VAR_BETWEEN(mp_lv_page_set_edge_flash_obj, 2, 2, mp_lv_page_set_edge_flash); + + + +/* + * lvgl extension definition for: + * void lv_page_set_style(lv_obj_t *page, lv_page_style_t type, lv_style_t *style) + */ + +STATIC mp_obj_t mp_lv_page_set_style(size_t n_args, const mp_obj_t *args) +{ + lv_obj_t *page = mp_to_lv(args[0]); + lv_page_style_t type = (uint8_t)mp_obj_get_int(args[1]); + lv_style_t *style = mp_write_ptr_lv_style_t(args[2]); + lv_page_set_style(page, type, style); + return mp_const_none; +} + +STATIC MP_DEFINE_CONST_FUN_OBJ_VAR_BETWEEN(mp_lv_page_set_style_obj, 3, 3, mp_lv_page_set_style); + + + +/* + * lvgl extension definition for: + * lv_sb_mode_t lv_page_get_sb_mode(const lv_obj_t *page) + */ + +STATIC mp_obj_t mp_lv_page_get_sb_mode(size_t n_args, const mp_obj_t *args) +{ + const lv_obj_t *page = mp_to_lv(args[0]); + lv_sb_mode_t res = lv_page_get_sb_mode(page); + return mp_obj_new_int_from_uint(res); +} + +STATIC MP_DEFINE_CONST_FUN_OBJ_VAR_BETWEEN(mp_lv_page_get_sb_mode_obj, 1, 1, mp_lv_page_get_sb_mode); + + + +/* + * lvgl extension definition for: + * bool lv_page_get_arrow_scroll(const lv_obj_t *page) + */ + +STATIC mp_obj_t mp_lv_page_get_arrow_scroll(size_t n_args, const mp_obj_t *args) +{ + const lv_obj_t *page = mp_to_lv(args[0]); + bool res = lv_page_get_arrow_scroll(page); + return convert_to_bool(res); +} + +STATIC MP_DEFINE_CONST_FUN_OBJ_VAR_BETWEEN(mp_lv_page_get_arrow_scroll_obj, 1, 1, mp_lv_page_get_arrow_scroll); + + + +/* + * lvgl extension definition for: + * bool lv_page_get_scroll_propagation(lv_obj_t *page) + */ + +STATIC mp_obj_t mp_lv_page_get_scroll_propagation(size_t n_args, const mp_obj_t *args) +{ + lv_obj_t *page = mp_to_lv(args[0]); + bool res = lv_page_get_scroll_propagation(page); + return convert_to_bool(res); +} + +STATIC MP_DEFINE_CONST_FUN_OBJ_VAR_BETWEEN(mp_lv_page_get_scroll_propagation_obj, 1, 1, mp_lv_page_get_scroll_propagation); + + + +/* + * lvgl extension definition for: + * bool lv_page_get_edge_flash(lv_obj_t *page) + */ + +STATIC mp_obj_t mp_lv_page_get_edge_flash(size_t n_args, const mp_obj_t *args) +{ + lv_obj_t *page = mp_to_lv(args[0]); + bool res = lv_page_get_edge_flash(page); + return convert_to_bool(res); +} + +STATIC MP_DEFINE_CONST_FUN_OBJ_VAR_BETWEEN(mp_lv_page_get_edge_flash_obj, 1, 1, mp_lv_page_get_edge_flash); + + + +/* + * lvgl extension definition for: + * lv_coord_t lv_page_get_fit_width(lv_obj_t *page) + */ + +STATIC mp_obj_t mp_lv_page_get_fit_width(size_t n_args, const mp_obj_t *args) +{ + lv_obj_t *page = mp_to_lv(args[0]); + lv_coord_t res = lv_page_get_fit_width(page); + return mp_obj_new_int(res); +} + +STATIC MP_DEFINE_CONST_FUN_OBJ_VAR_BETWEEN(mp_lv_page_get_fit_width_obj, 1, 1, mp_lv_page_get_fit_width); + + + +/* + * lvgl extension definition for: + * lv_coord_t lv_page_get_fit_height(lv_obj_t *page) + */ + +STATIC mp_obj_t mp_lv_page_get_fit_height(size_t n_args, const mp_obj_t *args) +{ + lv_obj_t *page = mp_to_lv(args[0]); + lv_coord_t res = lv_page_get_fit_height(page); + return mp_obj_new_int(res); +} + +STATIC MP_DEFINE_CONST_FUN_OBJ_VAR_BETWEEN(mp_lv_page_get_fit_height_obj, 1, 1, mp_lv_page_get_fit_height); + + + +/* + * lvgl extension definition for: + * lv_style_t *lv_page_get_style(const lv_obj_t *page, lv_page_style_t type) + */ + +STATIC mp_obj_t mp_lv_page_get_style(size_t n_args, const mp_obj_t *args) +{ + const lv_obj_t *page = mp_to_lv(args[0]); + lv_page_style_t type = (uint8_t)mp_obj_get_int(args[1]); + lv_style_t* res = lv_page_get_style(page, type); + return mp_read_ptr_lv_style_t((void*)res); +} + +STATIC MP_DEFINE_CONST_FUN_OBJ_VAR_BETWEEN(mp_lv_page_get_style_obj, 2, 2, mp_lv_page_get_style); + + + +/* + * lvgl extension definition for: + * void lv_page_glue_obj(lv_obj_t *obj, bool glue) + */ + +STATIC mp_obj_t mp_lv_page_glue_obj(size_t n_args, const mp_obj_t *args) +{ + lv_obj_t *obj = mp_to_lv(args[0]); + bool glue = mp_obj_is_true(args[1]); + lv_page_glue_obj(obj, glue); + return mp_const_none; +} + +STATIC MP_DEFINE_CONST_FUN_OBJ_VAR_BETWEEN(mp_lv_page_glue_obj_obj, 2, 2, mp_lv_page_glue_obj); + + + +/* + * lvgl extension definition for: + * void lv_page_focus(lv_obj_t *page, const lv_obj_t *obj, uint16_t anim_time) + */ + +STATIC mp_obj_t mp_lv_page_focus(size_t n_args, const mp_obj_t *args) +{ + lv_obj_t *page = mp_to_lv(args[0]); + const lv_obj_t *obj = mp_to_lv(args[1]); + uint16_t anim_time = (uint16_t)mp_obj_get_int(args[2]); + lv_page_focus(page, obj, anim_time); + return mp_const_none; +} + +STATIC MP_DEFINE_CONST_FUN_OBJ_VAR_BETWEEN(mp_lv_page_focus_obj, 3, 3, mp_lv_page_focus); + + + +/* + * lvgl extension definition for: + * void lv_page_scroll_hor(lv_obj_t *page, lv_coord_t dist) + */ + +STATIC mp_obj_t mp_lv_page_scroll_hor(size_t n_args, const mp_obj_t *args) +{ + lv_obj_t *page = mp_to_lv(args[0]); + lv_coord_t dist = (int16_t)mp_obj_get_int(args[1]); + lv_page_scroll_hor(page, dist); + return mp_const_none; +} + +STATIC MP_DEFINE_CONST_FUN_OBJ_VAR_BETWEEN(mp_lv_page_scroll_hor_obj, 2, 2, mp_lv_page_scroll_hor); + + + +/* + * lvgl extension definition for: + * void lv_page_scroll_ver(lv_obj_t *page, lv_coord_t dist) + */ + +STATIC mp_obj_t mp_lv_page_scroll_ver(size_t n_args, const mp_obj_t *args) +{ + lv_obj_t *page = mp_to_lv(args[0]); + lv_coord_t dist = (int16_t)mp_obj_get_int(args[1]); + lv_page_scroll_ver(page, dist); + return mp_const_none; +} + +STATIC MP_DEFINE_CONST_FUN_OBJ_VAR_BETWEEN(mp_lv_page_scroll_ver_obj, 2, 2, mp_lv_page_scroll_ver); + + + +/* + * lvgl extension definition for: + * void lv_page_start_edge_flash(lv_obj_t *page) + */ + +STATIC mp_obj_t mp_lv_page_start_edge_flash(size_t n_args, const mp_obj_t *args) +{ + lv_obj_t *page = mp_to_lv(args[0]); + lv_page_start_edge_flash(page); + return mp_const_none; +} + +STATIC MP_DEFINE_CONST_FUN_OBJ_VAR_BETWEEN(mp_lv_page_start_edge_flash_obj, 1, 1, mp_lv_page_start_edge_flash); + + + +/* + * lvgl page object definitions + */ + + +STATIC const mp_rom_map_elem_t page_locals_dict_table[] = { + { MP_ROM_QSTR(MP_QSTR_set_scrl_fit), MP_ROM_PTR(&mp_lv_page_set_scrl_fit_obj) }, + { MP_ROM_QSTR(MP_QSTR_set_scrl_width), MP_ROM_PTR(&mp_lv_page_set_scrl_width_obj) }, + { MP_ROM_QSTR(MP_QSTR_set_scrl_height), MP_ROM_PTR(&mp_lv_page_set_scrl_height_obj) }, + { MP_ROM_QSTR(MP_QSTR_set_scrl_layout), MP_ROM_PTR(&mp_lv_page_set_scrl_layout_obj) }, + { MP_ROM_QSTR(MP_QSTR_get_scrl_width), MP_ROM_PTR(&mp_lv_page_get_scrl_width_obj) }, + { MP_ROM_QSTR(MP_QSTR_get_scrl_height), MP_ROM_PTR(&mp_lv_page_get_scrl_height_obj) }, + { MP_ROM_QSTR(MP_QSTR_get_scrl_layout), MP_ROM_PTR(&mp_lv_page_get_scrl_layout_obj) }, + { MP_ROM_QSTR(MP_QSTR_get_scrl_hor_fit), MP_ROM_PTR(&mp_lv_page_get_scrl_hor_fit_obj) }, + { MP_ROM_QSTR(MP_QSTR_get_scrl_fit_ver), MP_ROM_PTR(&mp_lv_page_get_scrl_fit_ver_obj) }, + { MP_ROM_QSTR(MP_QSTR_clean), MP_ROM_PTR(&mp_lv_page_clean_obj) }, + { MP_ROM_QSTR(MP_QSTR_get_pr_action), MP_ROM_PTR(&mp_lv_page_get_pr_action_obj) }, + { MP_ROM_QSTR(MP_QSTR_get_rel_action), MP_ROM_PTR(&mp_lv_page_get_rel_action_obj) }, + { MP_ROM_QSTR(MP_QSTR_get_scrl), MP_ROM_PTR(&mp_lv_page_get_scrl_obj) }, + { MP_ROM_QSTR(MP_QSTR_set_rel_action), MP_ROM_PTR(&mp_lv_page_set_rel_action_obj) }, + { MP_ROM_QSTR(MP_QSTR_set_pr_action), MP_ROM_PTR(&mp_lv_page_set_pr_action_obj) }, + { MP_ROM_QSTR(MP_QSTR_set_sb_mode), MP_ROM_PTR(&mp_lv_page_set_sb_mode_obj) }, + { MP_ROM_QSTR(MP_QSTR_set_arrow_scroll), MP_ROM_PTR(&mp_lv_page_set_arrow_scroll_obj) }, + { MP_ROM_QSTR(MP_QSTR_set_scroll_propagation), MP_ROM_PTR(&mp_lv_page_set_scroll_propagation_obj) }, + { MP_ROM_QSTR(MP_QSTR_set_edge_flash), MP_ROM_PTR(&mp_lv_page_set_edge_flash_obj) }, + { MP_ROM_QSTR(MP_QSTR_set_style), MP_ROM_PTR(&mp_lv_page_set_style_obj) }, + { MP_ROM_QSTR(MP_QSTR_get_sb_mode), MP_ROM_PTR(&mp_lv_page_get_sb_mode_obj) }, + { MP_ROM_QSTR(MP_QSTR_get_arrow_scroll), MP_ROM_PTR(&mp_lv_page_get_arrow_scroll_obj) }, + { MP_ROM_QSTR(MP_QSTR_get_scroll_propagation), MP_ROM_PTR(&mp_lv_page_get_scroll_propagation_obj) }, + { MP_ROM_QSTR(MP_QSTR_get_edge_flash), MP_ROM_PTR(&mp_lv_page_get_edge_flash_obj) }, + { MP_ROM_QSTR(MP_QSTR_get_fit_width), MP_ROM_PTR(&mp_lv_page_get_fit_width_obj) }, + { MP_ROM_QSTR(MP_QSTR_get_fit_height), MP_ROM_PTR(&mp_lv_page_get_fit_height_obj) }, + { MP_ROM_QSTR(MP_QSTR_get_style), MP_ROM_PTR(&mp_lv_page_get_style_obj) }, + { MP_ROM_QSTR(MP_QSTR_glue_obj), MP_ROM_PTR(&mp_lv_page_glue_obj_obj) }, + { MP_ROM_QSTR(MP_QSTR_focus), MP_ROM_PTR(&mp_lv_page_focus_obj) }, + { MP_ROM_QSTR(MP_QSTR_scroll_hor), MP_ROM_PTR(&mp_lv_page_scroll_hor_obj) }, + { MP_ROM_QSTR(MP_QSTR_scroll_ver), MP_ROM_PTR(&mp_lv_page_scroll_ver_obj) }, + { MP_ROM_QSTR(MP_QSTR_start_edge_flash), MP_ROM_PTR(&mp_lv_page_start_edge_flash_obj) }, + { MP_ROM_QSTR(MP_QSTR_delete), MP_ROM_PTR(&mp_lv_obj_del_obj) }, + { MP_ROM_QSTR(MP_QSTR_clean), MP_ROM_PTR(&mp_lv_obj_clean_obj) }, + { MP_ROM_QSTR(MP_QSTR_invalidate), MP_ROM_PTR(&mp_lv_obj_invalidate_obj) }, + { MP_ROM_QSTR(MP_QSTR_set_parent), MP_ROM_PTR(&mp_lv_obj_set_parent_obj) }, + { MP_ROM_QSTR(MP_QSTR_set_pos), MP_ROM_PTR(&mp_lv_obj_set_pos_obj) }, + { MP_ROM_QSTR(MP_QSTR_set_x), MP_ROM_PTR(&mp_lv_obj_set_x_obj) }, + { MP_ROM_QSTR(MP_QSTR_set_y), MP_ROM_PTR(&mp_lv_obj_set_y_obj) }, + { MP_ROM_QSTR(MP_QSTR_set_size), MP_ROM_PTR(&mp_lv_obj_set_size_obj) }, + { MP_ROM_QSTR(MP_QSTR_set_width), MP_ROM_PTR(&mp_lv_obj_set_width_obj) }, + { MP_ROM_QSTR(MP_QSTR_set_height), MP_ROM_PTR(&mp_lv_obj_set_height_obj) }, + { MP_ROM_QSTR(MP_QSTR_align), MP_ROM_PTR(&mp_lv_obj_align_obj) }, + { MP_ROM_QSTR(MP_QSTR_align_origo), MP_ROM_PTR(&mp_lv_obj_align_origo_obj) }, + { MP_ROM_QSTR(MP_QSTR_realign), MP_ROM_PTR(&mp_lv_obj_realign_obj) }, + { MP_ROM_QSTR(MP_QSTR_set_auto_realign), MP_ROM_PTR(&mp_lv_obj_set_auto_realign_obj) }, + { MP_ROM_QSTR(MP_QSTR_set_style), MP_ROM_PTR(&mp_lv_obj_set_style_obj) }, + { MP_ROM_QSTR(MP_QSTR_refresh_style), MP_ROM_PTR(&mp_lv_obj_refresh_style_obj) }, + { MP_ROM_QSTR(MP_QSTR_report_style_mod), MP_ROM_PTR(&mp_lv_obj_report_style_mod_obj) }, + { MP_ROM_QSTR(MP_QSTR_set_hidden), MP_ROM_PTR(&mp_lv_obj_set_hidden_obj) }, + { MP_ROM_QSTR(MP_QSTR_set_click), MP_ROM_PTR(&mp_lv_obj_set_click_obj) }, + { MP_ROM_QSTR(MP_QSTR_set_top), MP_ROM_PTR(&mp_lv_obj_set_top_obj) }, + { MP_ROM_QSTR(MP_QSTR_set_drag), MP_ROM_PTR(&mp_lv_obj_set_drag_obj) }, + { MP_ROM_QSTR(MP_QSTR_set_drag_throw), MP_ROM_PTR(&mp_lv_obj_set_drag_throw_obj) }, + { MP_ROM_QSTR(MP_QSTR_set_drag_parent), MP_ROM_PTR(&mp_lv_obj_set_drag_parent_obj) }, + { MP_ROM_QSTR(MP_QSTR_set_opa_scale_enable), MP_ROM_PTR(&mp_lv_obj_set_opa_scale_enable_obj) }, + { MP_ROM_QSTR(MP_QSTR_set_opa_scale), MP_ROM_PTR(&mp_lv_obj_set_opa_scale_obj) }, + { MP_ROM_QSTR(MP_QSTR_set_protect), MP_ROM_PTR(&mp_lv_obj_set_protect_obj) }, + { MP_ROM_QSTR(MP_QSTR_clear_protect), MP_ROM_PTR(&mp_lv_obj_clear_protect_obj) }, + { MP_ROM_QSTR(MP_QSTR_set_signal_func), MP_ROM_PTR(&mp_lv_obj_set_signal_func_obj) }, + { MP_ROM_QSTR(MP_QSTR_set_design_func), MP_ROM_PTR(&mp_lv_obj_set_design_func_obj) }, + { MP_ROM_QSTR(MP_QSTR_allocate_ext_attr), MP_ROM_PTR(&mp_lv_obj_allocate_ext_attr_obj) }, + { MP_ROM_QSTR(MP_QSTR_refresh_ext_size), MP_ROM_PTR(&mp_lv_obj_refresh_ext_size_obj) }, + { MP_ROM_QSTR(MP_QSTR_set_free_num), MP_ROM_PTR(&mp_lv_obj_set_free_num_obj) }, + { MP_ROM_QSTR(MP_QSTR_set_free_ptr), MP_ROM_PTR(&mp_lv_obj_set_free_ptr_obj) }, + { MP_ROM_QSTR(MP_QSTR_animate), MP_ROM_PTR(&mp_lv_obj_animate_obj) }, + { MP_ROM_QSTR(MP_QSTR_get_screen), MP_ROM_PTR(&mp_lv_obj_get_screen_obj) }, + { MP_ROM_QSTR(MP_QSTR_get_parent), MP_ROM_PTR(&mp_lv_obj_get_parent_obj) }, + { MP_ROM_QSTR(MP_QSTR_get_child), MP_ROM_PTR(&mp_lv_obj_get_child_obj) }, + { MP_ROM_QSTR(MP_QSTR_get_child_back), MP_ROM_PTR(&mp_lv_obj_get_child_back_obj) }, + { MP_ROM_QSTR(MP_QSTR_count_children), MP_ROM_PTR(&mp_lv_obj_count_children_obj) }, + { MP_ROM_QSTR(MP_QSTR_get_coords), MP_ROM_PTR(&mp_lv_obj_get_coords_obj) }, + { MP_ROM_QSTR(MP_QSTR_get_x), MP_ROM_PTR(&mp_lv_obj_get_x_obj) }, + { MP_ROM_QSTR(MP_QSTR_get_y), MP_ROM_PTR(&mp_lv_obj_get_y_obj) }, + { MP_ROM_QSTR(MP_QSTR_get_width), MP_ROM_PTR(&mp_lv_obj_get_width_obj) }, + { MP_ROM_QSTR(MP_QSTR_get_height), MP_ROM_PTR(&mp_lv_obj_get_height_obj) }, + { MP_ROM_QSTR(MP_QSTR_get_ext_size), MP_ROM_PTR(&mp_lv_obj_get_ext_size_obj) }, + { MP_ROM_QSTR(MP_QSTR_get_auto_realign), MP_ROM_PTR(&mp_lv_obj_get_auto_realign_obj) }, + { MP_ROM_QSTR(MP_QSTR_get_style), MP_ROM_PTR(&mp_lv_obj_get_style_obj) }, + { MP_ROM_QSTR(MP_QSTR_get_hidden), MP_ROM_PTR(&mp_lv_obj_get_hidden_obj) }, + { MP_ROM_QSTR(MP_QSTR_get_click), MP_ROM_PTR(&mp_lv_obj_get_click_obj) }, + { MP_ROM_QSTR(MP_QSTR_get_top), MP_ROM_PTR(&mp_lv_obj_get_top_obj) }, + { MP_ROM_QSTR(MP_QSTR_get_drag), MP_ROM_PTR(&mp_lv_obj_get_drag_obj) }, + { MP_ROM_QSTR(MP_QSTR_get_drag_throw), MP_ROM_PTR(&mp_lv_obj_get_drag_throw_obj) }, + { MP_ROM_QSTR(MP_QSTR_get_drag_parent), MP_ROM_PTR(&mp_lv_obj_get_drag_parent_obj) }, + { MP_ROM_QSTR(MP_QSTR_get_opa_scale_enable), MP_ROM_PTR(&mp_lv_obj_get_opa_scale_enable_obj) }, + { MP_ROM_QSTR(MP_QSTR_get_opa_scale), MP_ROM_PTR(&mp_lv_obj_get_opa_scale_obj) }, + { MP_ROM_QSTR(MP_QSTR_get_protect), MP_ROM_PTR(&mp_lv_obj_get_protect_obj) }, + { MP_ROM_QSTR(MP_QSTR_is_protected), MP_ROM_PTR(&mp_lv_obj_is_protected_obj) }, + { MP_ROM_QSTR(MP_QSTR_get_signal_func), MP_ROM_PTR(&mp_lv_obj_get_signal_func_obj) }, + { MP_ROM_QSTR(MP_QSTR_get_design_func), MP_ROM_PTR(&mp_lv_obj_get_design_func_obj) }, + { MP_ROM_QSTR(MP_QSTR_get_ext_attr), MP_ROM_PTR(&mp_lv_obj_get_ext_attr_obj) }, + { MP_ROM_QSTR(MP_QSTR_get_free_num), MP_ROM_PTR(&mp_lv_obj_get_free_num_obj) }, + { MP_ROM_QSTR(MP_QSTR_get_free_ptr), MP_ROM_PTR(&mp_lv_obj_get_free_ptr_obj) }, + { MP_ROM_QSTR(MP_QSTR_get_group), MP_ROM_PTR(&mp_lv_obj_get_group_obj) }, + { MP_ROM_QSTR(MP_QSTR_is_focused), MP_ROM_PTR(&mp_lv_obj_is_focused_obj) }, + { MP_ROM_QSTR(MP_QSTR_STYLE), MP_ROM_PTR(&mp_LV_PAGE_STYLE_type) } +}; + +STATIC MP_DEFINE_CONST_DICT(page_locals_dict, page_locals_dict_table); + +STATIC void page_print(const mp_print_t *print, + mp_obj_t self_in, + mp_print_kind_t kind) +{ + mp_printf(print, "lvgl page"); +} + + +STATIC mp_obj_t page_make_new( + const mp_obj_type_t *type, + size_t n_args, + size_t n_kw, + const mp_obj_t *args) +{ + return make_new(&lv_page_create, type, n_args, n_kw, args); +} + + +STATIC const mp_obj_type_t mp_page_type = { + { &mp_type_type }, + .name = MP_QSTR_page, + .print = page_print, + .make_new = page_make_new, + .locals_dict = (mp_obj_dict_t*)&page_locals_dict, +}; + + +/* + * lvgl extension definition for: + * inline static void lv_list_set_sb_mode(lv_obj_t *list, lv_sb_mode_t mode) + */ + +STATIC mp_obj_t mp_lv_list_set_sb_mode(size_t n_args, const mp_obj_t *args) +{ + lv_obj_t *list = mp_to_lv(args[0]); + lv_sb_mode_t mode = (uint8_t)mp_obj_get_int(args[1]); + lv_list_set_sb_mode(list, mode); + return mp_const_none; +} + +STATIC MP_DEFINE_CONST_FUN_OBJ_VAR_BETWEEN(mp_lv_list_set_sb_mode_obj, 2, 2, mp_lv_list_set_sb_mode); + + + +/* + * lvgl extension definition for: + * inline static void lv_list_set_scroll_propagation(lv_obj_t *list, bool en) + */ + +STATIC mp_obj_t mp_lv_list_set_scroll_propagation(size_t n_args, const mp_obj_t *args) +{ + lv_obj_t *list = mp_to_lv(args[0]); + bool en = mp_obj_is_true(args[1]); + lv_list_set_scroll_propagation(list, en); + return mp_const_none; +} + +STATIC MP_DEFINE_CONST_FUN_OBJ_VAR_BETWEEN(mp_lv_list_set_scroll_propagation_obj, 2, 2, mp_lv_list_set_scroll_propagation); + + + +/* + * lvgl extension definition for: + * inline static void lv_list_set_edge_flash(lv_obj_t *list, bool en) + */ + +STATIC mp_obj_t mp_lv_list_set_edge_flash(size_t n_args, const mp_obj_t *args) +{ + lv_obj_t *list = mp_to_lv(args[0]); + bool en = mp_obj_is_true(args[1]); + lv_list_set_edge_flash(list, en); + return mp_const_none; +} + +STATIC MP_DEFINE_CONST_FUN_OBJ_VAR_BETWEEN(mp_lv_list_set_edge_flash_obj, 2, 2, mp_lv_list_set_edge_flash); + + + +/* + * lvgl extension definition for: + * inline static lv_sb_mode_t lv_list_get_sb_mode(const lv_obj_t *list) + */ + +STATIC mp_obj_t mp_lv_list_get_sb_mode(size_t n_args, const mp_obj_t *args) +{ + const lv_obj_t *list = mp_to_lv(args[0]); + lv_sb_mode_t res = lv_list_get_sb_mode(list); + return mp_obj_new_int_from_uint(res); +} + +STATIC MP_DEFINE_CONST_FUN_OBJ_VAR_BETWEEN(mp_lv_list_get_sb_mode_obj, 1, 1, mp_lv_list_get_sb_mode); + + + +/* + * lvgl extension definition for: + * inline static bool lv_list_get_scroll_propagation(lv_obj_t *list) + */ + +STATIC mp_obj_t mp_lv_list_get_scroll_propagation(size_t n_args, const mp_obj_t *args) +{ + lv_obj_t *list = mp_to_lv(args[0]); + bool res = lv_list_get_scroll_propagation(list); + return convert_to_bool(res); +} + +STATIC MP_DEFINE_CONST_FUN_OBJ_VAR_BETWEEN(mp_lv_list_get_scroll_propagation_obj, 1, 1, mp_lv_list_get_scroll_propagation); + + + +/* + * lvgl extension definition for: + * inline static bool lv_list_get_edge_flash(lv_obj_t *list) + */ + +STATIC mp_obj_t mp_lv_list_get_edge_flash(size_t n_args, const mp_obj_t *args) +{ + lv_obj_t *list = mp_to_lv(args[0]); + bool res = lv_list_get_edge_flash(list); + return convert_to_bool(res); +} + +STATIC MP_DEFINE_CONST_FUN_OBJ_VAR_BETWEEN(mp_lv_list_get_edge_flash_obj, 1, 1, mp_lv_list_get_edge_flash); + + + +/* + * lvgl extension definition for: + * void lv_list_clean(lv_obj_t *obj) + */ + +STATIC mp_obj_t mp_lv_list_clean(size_t n_args, const mp_obj_t *args) +{ + lv_obj_t *obj = mp_to_lv(args[0]); + lv_list_clean(obj); + return mp_const_none; +} + +STATIC MP_DEFINE_CONST_FUN_OBJ_VAR_BETWEEN(mp_lv_list_clean_obj, 1, 1, mp_lv_list_clean); + + + +/* + * lvgl extension definition for: + * lv_obj_t *lv_list_add(lv_obj_t *list, const void *img_src, const char *txt, lv_action_t rel_action) + */ + +STATIC mp_obj_t mp_lv_list_add(size_t n_args, const mp_obj_t *args) +{ + lv_obj_t *list = mp_to_lv(args[0]); + const void *img_src = mp_to_ptr(args[1]); + const char *txt = (char*)mp_obj_str_get_str(args[2]); + set_action(args[0], args[3]); + lv_action_t rel_action = &lv_action_t_callback; + lv_obj_t* res = lv_list_add(list, img_src, txt, rel_action); + return lv_to_mp((void*)res); +} + +STATIC MP_DEFINE_CONST_FUN_OBJ_VAR_BETWEEN(mp_lv_list_add_obj, 4, 4, mp_lv_list_add); + + + +/* + * lvgl extension definition for: + * bool lv_list_remove(const lv_obj_t *list, uint32_t index) + */ + +STATIC mp_obj_t mp_lv_list_remove(size_t n_args, const mp_obj_t *args) +{ + const lv_obj_t *list = mp_to_lv(args[0]); + uint32_t index = (uint32_t)mp_obj_get_int(args[1]); + bool res = lv_list_remove(list, index); + return convert_to_bool(res); +} + +STATIC MP_DEFINE_CONST_FUN_OBJ_VAR_BETWEEN(mp_lv_list_remove_obj, 2, 2, mp_lv_list_remove); + + + +/* + * lvgl extension definition for: + * void lv_list_set_single_mode(lv_obj_t *list, bool mode) + */ + +STATIC mp_obj_t mp_lv_list_set_single_mode(size_t n_args, const mp_obj_t *args) +{ + lv_obj_t *list = mp_to_lv(args[0]); + bool mode = mp_obj_is_true(args[1]); + lv_list_set_single_mode(list, mode); + return mp_const_none; +} + +STATIC MP_DEFINE_CONST_FUN_OBJ_VAR_BETWEEN(mp_lv_list_set_single_mode_obj, 2, 2, mp_lv_list_set_single_mode); + + + +/* + * lvgl extension definition for: + * void lv_list_set_btn_selected(lv_obj_t *list, lv_obj_t *btn) + */ + +STATIC mp_obj_t mp_lv_list_set_btn_selected(size_t n_args, const mp_obj_t *args) +{ + lv_obj_t *list = mp_to_lv(args[0]); + lv_obj_t *btn = mp_to_lv(args[1]); + lv_list_set_btn_selected(list, btn); + return mp_const_none; +} + +STATIC MP_DEFINE_CONST_FUN_OBJ_VAR_BETWEEN(mp_lv_list_set_btn_selected_obj, 2, 2, mp_lv_list_set_btn_selected); + + + +/* + * lvgl extension definition for: + * void lv_list_set_anim_time(lv_obj_t *list, uint16_t anim_time) + */ + +STATIC mp_obj_t mp_lv_list_set_anim_time(size_t n_args, const mp_obj_t *args) +{ + lv_obj_t *list = mp_to_lv(args[0]); + uint16_t anim_time = (uint16_t)mp_obj_get_int(args[1]); + lv_list_set_anim_time(list, anim_time); + return mp_const_none; +} + +STATIC MP_DEFINE_CONST_FUN_OBJ_VAR_BETWEEN(mp_lv_list_set_anim_time_obj, 2, 2, mp_lv_list_set_anim_time); + + + +/* + * lvgl extension definition for: + * void lv_list_set_style(lv_obj_t *list, lv_list_style_t type, lv_style_t *style) + */ + +STATIC mp_obj_t mp_lv_list_set_style(size_t n_args, const mp_obj_t *args) +{ + lv_obj_t *list = mp_to_lv(args[0]); + lv_list_style_t type = (uint8_t)mp_obj_get_int(args[1]); + lv_style_t *style = mp_write_ptr_lv_style_t(args[2]); + lv_list_set_style(list, type, style); + return mp_const_none; +} + +STATIC MP_DEFINE_CONST_FUN_OBJ_VAR_BETWEEN(mp_lv_list_set_style_obj, 3, 3, mp_lv_list_set_style); + + + +/* + * lvgl extension definition for: + * bool lv_list_get_single_mode(lv_obj_t *list) + */ + +STATIC mp_obj_t mp_lv_list_get_single_mode(size_t n_args, const mp_obj_t *args) +{ + lv_obj_t *list = mp_to_lv(args[0]); + bool res = lv_list_get_single_mode(list); + return convert_to_bool(res); +} + +STATIC MP_DEFINE_CONST_FUN_OBJ_VAR_BETWEEN(mp_lv_list_get_single_mode_obj, 1, 1, mp_lv_list_get_single_mode); + + + +/* + * lvgl extension definition for: + * const char *lv_list_get_btn_text(const lv_obj_t *btn) + */ + +STATIC mp_obj_t mp_lv_list_get_btn_text(size_t n_args, const mp_obj_t *args) +{ + const lv_obj_t *btn = mp_to_lv(args[0]); + const char* res = lv_list_get_btn_text(btn); + return convert_to_str((void*)res); +} + +STATIC MP_DEFINE_CONST_FUN_OBJ_VAR_BETWEEN(mp_lv_list_get_btn_text_obj, 1, 1, mp_lv_list_get_btn_text); + + + +/* + * lvgl extension definition for: + * lv_obj_t *lv_list_get_btn_label(const lv_obj_t *btn) + */ + +STATIC mp_obj_t mp_lv_list_get_btn_label(size_t n_args, const mp_obj_t *args) +{ + const lv_obj_t *btn = mp_to_lv(args[0]); + lv_obj_t* res = lv_list_get_btn_label(btn); + return lv_to_mp((void*)res); +} + +STATIC MP_DEFINE_CONST_FUN_OBJ_VAR_BETWEEN(mp_lv_list_get_btn_label_obj, 1, 1, mp_lv_list_get_btn_label); + + + +/* + * lvgl extension definition for: + * lv_obj_t *lv_list_get_btn_img(const lv_obj_t *btn) + */ + +STATIC mp_obj_t mp_lv_list_get_btn_img(size_t n_args, const mp_obj_t *args) +{ + const lv_obj_t *btn = mp_to_lv(args[0]); + lv_obj_t* res = lv_list_get_btn_img(btn); + return lv_to_mp((void*)res); +} + +STATIC MP_DEFINE_CONST_FUN_OBJ_VAR_BETWEEN(mp_lv_list_get_btn_img_obj, 1, 1, mp_lv_list_get_btn_img); + + + +/* + * lvgl extension definition for: + * lv_obj_t *lv_list_get_prev_btn(const lv_obj_t *list, lv_obj_t *prev_btn) + */ + +STATIC mp_obj_t mp_lv_list_get_prev_btn(size_t n_args, const mp_obj_t *args) +{ + const lv_obj_t *list = mp_to_lv(args[0]); + lv_obj_t *prev_btn = mp_to_lv(args[1]); + lv_obj_t* res = lv_list_get_prev_btn(list, prev_btn); + return lv_to_mp((void*)res); +} + +STATIC MP_DEFINE_CONST_FUN_OBJ_VAR_BETWEEN(mp_lv_list_get_prev_btn_obj, 2, 2, mp_lv_list_get_prev_btn); + + + +/* + * lvgl extension definition for: + * lv_obj_t *lv_list_get_next_btn(const lv_obj_t *list, lv_obj_t *prev_btn) + */ + +STATIC mp_obj_t mp_lv_list_get_next_btn(size_t n_args, const mp_obj_t *args) +{ + const lv_obj_t *list = mp_to_lv(args[0]); + lv_obj_t *prev_btn = mp_to_lv(args[1]); + lv_obj_t* res = lv_list_get_next_btn(list, prev_btn); + return lv_to_mp((void*)res); +} + +STATIC MP_DEFINE_CONST_FUN_OBJ_VAR_BETWEEN(mp_lv_list_get_next_btn_obj, 2, 2, mp_lv_list_get_next_btn); + + + +/* + * lvgl extension definition for: + * int32_t lv_list_get_btn_index(const lv_obj_t *list, const lv_obj_t *btn) + */ + +STATIC mp_obj_t mp_lv_list_get_btn_index(size_t n_args, const mp_obj_t *args) +{ + const lv_obj_t *list = mp_to_lv(args[0]); + const lv_obj_t *btn = mp_to_lv(args[1]); + int32_t res = lv_list_get_btn_index(list, btn); + return mp_obj_new_int(res); +} + +STATIC MP_DEFINE_CONST_FUN_OBJ_VAR_BETWEEN(mp_lv_list_get_btn_index_obj, 2, 2, mp_lv_list_get_btn_index); + + + +/* + * lvgl extension definition for: + * uint32_t lv_list_get_size(const lv_obj_t *list) + */ + +STATIC mp_obj_t mp_lv_list_get_size(size_t n_args, const mp_obj_t *args) +{ + const lv_obj_t *list = mp_to_lv(args[0]); + uint32_t res = lv_list_get_size(list); + return mp_obj_new_int_from_uint(res); +} + +STATIC MP_DEFINE_CONST_FUN_OBJ_VAR_BETWEEN(mp_lv_list_get_size_obj, 1, 1, mp_lv_list_get_size); + + + +/* + * lvgl extension definition for: + * lv_obj_t *lv_list_get_btn_selected(const lv_obj_t *list) + */ + +STATIC mp_obj_t mp_lv_list_get_btn_selected(size_t n_args, const mp_obj_t *args) +{ + const lv_obj_t *list = mp_to_lv(args[0]); + lv_obj_t* res = lv_list_get_btn_selected(list); + return lv_to_mp((void*)res); +} + +STATIC MP_DEFINE_CONST_FUN_OBJ_VAR_BETWEEN(mp_lv_list_get_btn_selected_obj, 1, 1, mp_lv_list_get_btn_selected); + + + +/* + * lvgl extension definition for: + * uint16_t lv_list_get_anim_time(const lv_obj_t *list) + */ + +STATIC mp_obj_t mp_lv_list_get_anim_time(size_t n_args, const mp_obj_t *args) +{ + const lv_obj_t *list = mp_to_lv(args[0]); + uint16_t res = lv_list_get_anim_time(list); + return mp_obj_new_int_from_uint(res); +} + +STATIC MP_DEFINE_CONST_FUN_OBJ_VAR_BETWEEN(mp_lv_list_get_anim_time_obj, 1, 1, mp_lv_list_get_anim_time); + + + +/* + * lvgl extension definition for: + * lv_style_t *lv_list_get_style(const lv_obj_t *list, lv_list_style_t type) + */ + +STATIC mp_obj_t mp_lv_list_get_style(size_t n_args, const mp_obj_t *args) +{ + const lv_obj_t *list = mp_to_lv(args[0]); + lv_list_style_t type = (uint8_t)mp_obj_get_int(args[1]); + lv_style_t* res = lv_list_get_style(list, type); + return mp_read_ptr_lv_style_t((void*)res); +} + +STATIC MP_DEFINE_CONST_FUN_OBJ_VAR_BETWEEN(mp_lv_list_get_style_obj, 2, 2, mp_lv_list_get_style); + + + +/* + * lvgl extension definition for: + * void lv_list_up(const lv_obj_t *list) + */ + +STATIC mp_obj_t mp_lv_list_up(size_t n_args, const mp_obj_t *args) +{ + const lv_obj_t *list = mp_to_lv(args[0]); + lv_list_up(list); + return mp_const_none; +} + +STATIC MP_DEFINE_CONST_FUN_OBJ_VAR_BETWEEN(mp_lv_list_up_obj, 1, 1, mp_lv_list_up); + + + +/* + * lvgl extension definition for: + * void lv_list_down(const lv_obj_t *list) + */ + +STATIC mp_obj_t mp_lv_list_down(size_t n_args, const mp_obj_t *args) +{ + const lv_obj_t *list = mp_to_lv(args[0]); + lv_list_down(list); + return mp_const_none; +} + +STATIC MP_DEFINE_CONST_FUN_OBJ_VAR_BETWEEN(mp_lv_list_down_obj, 1, 1, mp_lv_list_down); + + + +/* + * lvgl extension definition for: + * void lv_list_focus(const lv_obj_t *btn, bool anim_en) + */ + +STATIC mp_obj_t mp_lv_list_focus(size_t n_args, const mp_obj_t *args) +{ + const lv_obj_t *btn = mp_to_lv(args[0]); + bool anim_en = mp_obj_is_true(args[1]); + lv_list_focus(btn, anim_en); + return mp_const_none; +} + +STATIC MP_DEFINE_CONST_FUN_OBJ_VAR_BETWEEN(mp_lv_list_focus_obj, 2, 2, mp_lv_list_focus); + + + +/* + * lvgl list object definitions + */ + + +STATIC const mp_rom_map_elem_t list_locals_dict_table[] = { + { MP_ROM_QSTR(MP_QSTR_set_sb_mode), MP_ROM_PTR(&mp_lv_list_set_sb_mode_obj) }, + { MP_ROM_QSTR(MP_QSTR_set_scroll_propagation), MP_ROM_PTR(&mp_lv_list_set_scroll_propagation_obj) }, + { MP_ROM_QSTR(MP_QSTR_set_edge_flash), MP_ROM_PTR(&mp_lv_list_set_edge_flash_obj) }, + { MP_ROM_QSTR(MP_QSTR_get_sb_mode), MP_ROM_PTR(&mp_lv_list_get_sb_mode_obj) }, + { MP_ROM_QSTR(MP_QSTR_get_scroll_propagation), MP_ROM_PTR(&mp_lv_list_get_scroll_propagation_obj) }, + { MP_ROM_QSTR(MP_QSTR_get_edge_flash), MP_ROM_PTR(&mp_lv_list_get_edge_flash_obj) }, + { MP_ROM_QSTR(MP_QSTR_clean), MP_ROM_PTR(&mp_lv_list_clean_obj) }, + { MP_ROM_QSTR(MP_QSTR_add), MP_ROM_PTR(&mp_lv_list_add_obj) }, + { MP_ROM_QSTR(MP_QSTR_remove), MP_ROM_PTR(&mp_lv_list_remove_obj) }, + { MP_ROM_QSTR(MP_QSTR_set_single_mode), MP_ROM_PTR(&mp_lv_list_set_single_mode_obj) }, + { MP_ROM_QSTR(MP_QSTR_set_btn_selected), MP_ROM_PTR(&mp_lv_list_set_btn_selected_obj) }, + { MP_ROM_QSTR(MP_QSTR_set_anim_time), MP_ROM_PTR(&mp_lv_list_set_anim_time_obj) }, + { MP_ROM_QSTR(MP_QSTR_set_style), MP_ROM_PTR(&mp_lv_list_set_style_obj) }, + { MP_ROM_QSTR(MP_QSTR_get_single_mode), MP_ROM_PTR(&mp_lv_list_get_single_mode_obj) }, + { MP_ROM_QSTR(MP_QSTR_get_btn_text), MP_ROM_PTR(&mp_lv_list_get_btn_text_obj) }, + { MP_ROM_QSTR(MP_QSTR_get_btn_label), MP_ROM_PTR(&mp_lv_list_get_btn_label_obj) }, + { MP_ROM_QSTR(MP_QSTR_get_btn_img), MP_ROM_PTR(&mp_lv_list_get_btn_img_obj) }, + { MP_ROM_QSTR(MP_QSTR_get_prev_btn), MP_ROM_PTR(&mp_lv_list_get_prev_btn_obj) }, + { MP_ROM_QSTR(MP_QSTR_get_next_btn), MP_ROM_PTR(&mp_lv_list_get_next_btn_obj) }, + { MP_ROM_QSTR(MP_QSTR_get_btn_index), MP_ROM_PTR(&mp_lv_list_get_btn_index_obj) }, + { MP_ROM_QSTR(MP_QSTR_get_size), MP_ROM_PTR(&mp_lv_list_get_size_obj) }, + { MP_ROM_QSTR(MP_QSTR_get_btn_selected), MP_ROM_PTR(&mp_lv_list_get_btn_selected_obj) }, + { MP_ROM_QSTR(MP_QSTR_get_anim_time), MP_ROM_PTR(&mp_lv_list_get_anim_time_obj) }, + { MP_ROM_QSTR(MP_QSTR_get_style), MP_ROM_PTR(&mp_lv_list_get_style_obj) }, + { MP_ROM_QSTR(MP_QSTR_up), MP_ROM_PTR(&mp_lv_list_up_obj) }, + { MP_ROM_QSTR(MP_QSTR_down), MP_ROM_PTR(&mp_lv_list_down_obj) }, + { MP_ROM_QSTR(MP_QSTR_focus), MP_ROM_PTR(&mp_lv_list_focus_obj) }, + { MP_ROM_QSTR(MP_QSTR_delete), MP_ROM_PTR(&mp_lv_obj_del_obj) }, + { MP_ROM_QSTR(MP_QSTR_clean), MP_ROM_PTR(&mp_lv_obj_clean_obj) }, + { MP_ROM_QSTR(MP_QSTR_invalidate), MP_ROM_PTR(&mp_lv_obj_invalidate_obj) }, + { MP_ROM_QSTR(MP_QSTR_set_parent), MP_ROM_PTR(&mp_lv_obj_set_parent_obj) }, + { MP_ROM_QSTR(MP_QSTR_set_pos), MP_ROM_PTR(&mp_lv_obj_set_pos_obj) }, + { MP_ROM_QSTR(MP_QSTR_set_x), MP_ROM_PTR(&mp_lv_obj_set_x_obj) }, + { MP_ROM_QSTR(MP_QSTR_set_y), MP_ROM_PTR(&mp_lv_obj_set_y_obj) }, + { MP_ROM_QSTR(MP_QSTR_set_size), MP_ROM_PTR(&mp_lv_obj_set_size_obj) }, + { MP_ROM_QSTR(MP_QSTR_set_width), MP_ROM_PTR(&mp_lv_obj_set_width_obj) }, + { MP_ROM_QSTR(MP_QSTR_set_height), MP_ROM_PTR(&mp_lv_obj_set_height_obj) }, + { MP_ROM_QSTR(MP_QSTR_align), MP_ROM_PTR(&mp_lv_obj_align_obj) }, + { MP_ROM_QSTR(MP_QSTR_align_origo), MP_ROM_PTR(&mp_lv_obj_align_origo_obj) }, + { MP_ROM_QSTR(MP_QSTR_realign), MP_ROM_PTR(&mp_lv_obj_realign_obj) }, + { MP_ROM_QSTR(MP_QSTR_set_auto_realign), MP_ROM_PTR(&mp_lv_obj_set_auto_realign_obj) }, + { MP_ROM_QSTR(MP_QSTR_set_style), MP_ROM_PTR(&mp_lv_obj_set_style_obj) }, + { MP_ROM_QSTR(MP_QSTR_refresh_style), MP_ROM_PTR(&mp_lv_obj_refresh_style_obj) }, + { MP_ROM_QSTR(MP_QSTR_report_style_mod), MP_ROM_PTR(&mp_lv_obj_report_style_mod_obj) }, + { MP_ROM_QSTR(MP_QSTR_set_hidden), MP_ROM_PTR(&mp_lv_obj_set_hidden_obj) }, + { MP_ROM_QSTR(MP_QSTR_set_click), MP_ROM_PTR(&mp_lv_obj_set_click_obj) }, + { MP_ROM_QSTR(MP_QSTR_set_top), MP_ROM_PTR(&mp_lv_obj_set_top_obj) }, + { MP_ROM_QSTR(MP_QSTR_set_drag), MP_ROM_PTR(&mp_lv_obj_set_drag_obj) }, + { MP_ROM_QSTR(MP_QSTR_set_drag_throw), MP_ROM_PTR(&mp_lv_obj_set_drag_throw_obj) }, + { MP_ROM_QSTR(MP_QSTR_set_drag_parent), MP_ROM_PTR(&mp_lv_obj_set_drag_parent_obj) }, + { MP_ROM_QSTR(MP_QSTR_set_opa_scale_enable), MP_ROM_PTR(&mp_lv_obj_set_opa_scale_enable_obj) }, + { MP_ROM_QSTR(MP_QSTR_set_opa_scale), MP_ROM_PTR(&mp_lv_obj_set_opa_scale_obj) }, + { MP_ROM_QSTR(MP_QSTR_set_protect), MP_ROM_PTR(&mp_lv_obj_set_protect_obj) }, + { MP_ROM_QSTR(MP_QSTR_clear_protect), MP_ROM_PTR(&mp_lv_obj_clear_protect_obj) }, + { MP_ROM_QSTR(MP_QSTR_set_signal_func), MP_ROM_PTR(&mp_lv_obj_set_signal_func_obj) }, + { MP_ROM_QSTR(MP_QSTR_set_design_func), MP_ROM_PTR(&mp_lv_obj_set_design_func_obj) }, + { MP_ROM_QSTR(MP_QSTR_allocate_ext_attr), MP_ROM_PTR(&mp_lv_obj_allocate_ext_attr_obj) }, + { MP_ROM_QSTR(MP_QSTR_refresh_ext_size), MP_ROM_PTR(&mp_lv_obj_refresh_ext_size_obj) }, + { MP_ROM_QSTR(MP_QSTR_set_free_num), MP_ROM_PTR(&mp_lv_obj_set_free_num_obj) }, + { MP_ROM_QSTR(MP_QSTR_set_free_ptr), MP_ROM_PTR(&mp_lv_obj_set_free_ptr_obj) }, + { MP_ROM_QSTR(MP_QSTR_animate), MP_ROM_PTR(&mp_lv_obj_animate_obj) }, + { MP_ROM_QSTR(MP_QSTR_get_screen), MP_ROM_PTR(&mp_lv_obj_get_screen_obj) }, + { MP_ROM_QSTR(MP_QSTR_get_parent), MP_ROM_PTR(&mp_lv_obj_get_parent_obj) }, + { MP_ROM_QSTR(MP_QSTR_get_child), MP_ROM_PTR(&mp_lv_obj_get_child_obj) }, + { MP_ROM_QSTR(MP_QSTR_get_child_back), MP_ROM_PTR(&mp_lv_obj_get_child_back_obj) }, + { MP_ROM_QSTR(MP_QSTR_count_children), MP_ROM_PTR(&mp_lv_obj_count_children_obj) }, + { MP_ROM_QSTR(MP_QSTR_get_coords), MP_ROM_PTR(&mp_lv_obj_get_coords_obj) }, + { MP_ROM_QSTR(MP_QSTR_get_x), MP_ROM_PTR(&mp_lv_obj_get_x_obj) }, + { MP_ROM_QSTR(MP_QSTR_get_y), MP_ROM_PTR(&mp_lv_obj_get_y_obj) }, + { MP_ROM_QSTR(MP_QSTR_get_width), MP_ROM_PTR(&mp_lv_obj_get_width_obj) }, + { MP_ROM_QSTR(MP_QSTR_get_height), MP_ROM_PTR(&mp_lv_obj_get_height_obj) }, + { MP_ROM_QSTR(MP_QSTR_get_ext_size), MP_ROM_PTR(&mp_lv_obj_get_ext_size_obj) }, + { MP_ROM_QSTR(MP_QSTR_get_auto_realign), MP_ROM_PTR(&mp_lv_obj_get_auto_realign_obj) }, + { MP_ROM_QSTR(MP_QSTR_get_style), MP_ROM_PTR(&mp_lv_obj_get_style_obj) }, + { MP_ROM_QSTR(MP_QSTR_get_hidden), MP_ROM_PTR(&mp_lv_obj_get_hidden_obj) }, + { MP_ROM_QSTR(MP_QSTR_get_click), MP_ROM_PTR(&mp_lv_obj_get_click_obj) }, + { MP_ROM_QSTR(MP_QSTR_get_top), MP_ROM_PTR(&mp_lv_obj_get_top_obj) }, + { MP_ROM_QSTR(MP_QSTR_get_drag), MP_ROM_PTR(&mp_lv_obj_get_drag_obj) }, + { MP_ROM_QSTR(MP_QSTR_get_drag_throw), MP_ROM_PTR(&mp_lv_obj_get_drag_throw_obj) }, + { MP_ROM_QSTR(MP_QSTR_get_drag_parent), MP_ROM_PTR(&mp_lv_obj_get_drag_parent_obj) }, + { MP_ROM_QSTR(MP_QSTR_get_opa_scale_enable), MP_ROM_PTR(&mp_lv_obj_get_opa_scale_enable_obj) }, + { MP_ROM_QSTR(MP_QSTR_get_opa_scale), MP_ROM_PTR(&mp_lv_obj_get_opa_scale_obj) }, + { MP_ROM_QSTR(MP_QSTR_get_protect), MP_ROM_PTR(&mp_lv_obj_get_protect_obj) }, + { MP_ROM_QSTR(MP_QSTR_is_protected), MP_ROM_PTR(&mp_lv_obj_is_protected_obj) }, + { MP_ROM_QSTR(MP_QSTR_get_signal_func), MP_ROM_PTR(&mp_lv_obj_get_signal_func_obj) }, + { MP_ROM_QSTR(MP_QSTR_get_design_func), MP_ROM_PTR(&mp_lv_obj_get_design_func_obj) }, + { MP_ROM_QSTR(MP_QSTR_get_ext_attr), MP_ROM_PTR(&mp_lv_obj_get_ext_attr_obj) }, + { MP_ROM_QSTR(MP_QSTR_get_free_num), MP_ROM_PTR(&mp_lv_obj_get_free_num_obj) }, + { MP_ROM_QSTR(MP_QSTR_get_free_ptr), MP_ROM_PTR(&mp_lv_obj_get_free_ptr_obj) }, + { MP_ROM_QSTR(MP_QSTR_get_group), MP_ROM_PTR(&mp_lv_obj_get_group_obj) }, + { MP_ROM_QSTR(MP_QSTR_is_focused), MP_ROM_PTR(&mp_lv_obj_is_focused_obj) }, + { MP_ROM_QSTR(MP_QSTR_STYLE), MP_ROM_PTR(&mp_LV_LIST_STYLE_type) } +}; + +STATIC MP_DEFINE_CONST_DICT(list_locals_dict, list_locals_dict_table); + +STATIC void list_print(const mp_print_t *print, + mp_obj_t self_in, + mp_print_kind_t kind) +{ + mp_printf(print, "lvgl list"); +} + + +STATIC mp_obj_t list_make_new( + const mp_obj_type_t *type, + size_t n_args, + size_t n_kw, + const mp_obj_t *args) +{ + return make_new(&lv_list_create, type, n_args, n_kw, args); +} + + +STATIC const mp_obj_type_t mp_list_type = { + { &mp_type_type }, + .name = MP_QSTR_list, + .print = list_print, + .make_new = list_make_new, + .locals_dict = (mp_obj_dict_t*)&list_locals_dict, +}; + + +/* + * lvgl extension definition for: + * inline static void lv_chart_set_style(lv_obj_t *chart, lv_style_t *style) + */ + +STATIC mp_obj_t mp_lv_chart_set_style(size_t n_args, const mp_obj_t *args) +{ + lv_obj_t *chart = mp_to_lv(args[0]); + lv_style_t *style = mp_write_ptr_lv_style_t(args[1]); + lv_chart_set_style(chart, style); + return mp_const_none; +} + +STATIC MP_DEFINE_CONST_FUN_OBJ_VAR_BETWEEN(mp_lv_chart_set_style_obj, 2, 2, mp_lv_chart_set_style); + + + +/* + * lvgl extension definition for: + * inline static lv_style_t *lv_chart_get_style(const lv_obj_t *chart) + */ + +STATIC mp_obj_t mp_lv_chart_get_style(size_t n_args, const mp_obj_t *args) +{ + const lv_obj_t *chart = mp_to_lv(args[0]); + lv_style_t* res = lv_chart_get_style(chart); + return mp_read_ptr_lv_style_t((void*)res); +} + +STATIC MP_DEFINE_CONST_FUN_OBJ_VAR_BETWEEN(mp_lv_chart_get_style_obj, 1, 1, mp_lv_chart_get_style); + + + +/* + * Struct lv_chart_series_t + */ + +STATIC inline const mp_obj_type_t *get_mp_lv_chart_series_t_type(); + +STATIC inline lv_chart_series_t* mp_write_ptr_lv_chart_series_t(mp_obj_t self_in) +{ + mp_lv_struct_t *self = MP_OBJ_TO_PTR(cast(self_in, get_mp_lv_chart_series_t_type())); + return (lv_chart_series_t*)self->data; +} + +#define mp_write_lv_chart_series_t(struct_obj) *mp_write_ptr_lv_chart_series_t(struct_obj) + +STATIC inline mp_obj_t mp_read_ptr_lv_chart_series_t(lv_chart_series_t *field) +{ + return lv_to_mp_struct(get_mp_lv_chart_series_t_type(), field); +} + +#define mp_read_lv_chart_series_t(field) mp_read_ptr_lv_chart_series_t(copy_buffer(&field, sizeof(lv_chart_series_t))) +#define mp_read_byref_lv_chart_series_t(field) mp_read_ptr_lv_chart_series_t(&field) + +STATIC void mp_lv_chart_series_t_attr(mp_obj_t self_in, qstr attr, mp_obj_t *dest) +{ + mp_lv_struct_t *self = MP_OBJ_TO_PTR(self_in); + lv_chart_series_t *data = (lv_chart_series_t*)self->data; + + if (dest[0] == MP_OBJ_NULL) { + // load attribute + switch(attr) + { + case MP_QSTR_points: dest[0] = ptr_to_mp((void*)data->points); break; // converting from lv_coord_t*; + case MP_QSTR_color: dest[0] = mp_read_byref_lv_color16_t(data->color); break; // converting from lv_color_t; + case MP_QSTR_start_point: dest[0] = mp_obj_new_int_from_uint(data->start_point); break; // converting from uint16_t; + default: field_not_found(MP_QSTR_lv_chart_series_t, attr); + } + } else { + if (dest[1]) + { + // store attribute + switch(attr) + { + case MP_QSTR_points: data->points = (void*)mp_to_ptr(dest[1]); break; // converting to lv_coord_t*; + case MP_QSTR_color: data->color = mp_write_lv_color16_t(dest[1]); break; // converting to lv_color_t; + case MP_QSTR_start_point: data->start_point = (uint16_t)mp_obj_get_int(dest[1]); break; // converting to uint16_t; + default: field_not_found(MP_QSTR_lv_chart_series_t, attr); + } + + dest[0] = MP_OBJ_NULL; // indicate success + } + } +} + +STATIC void mp_lv_chart_series_t_print(const mp_print_t *print, + mp_obj_t self_in, + mp_print_kind_t kind) +{ + mp_printf(print, "lvgl struct lv_chart_series_t"); +} + +STATIC const mp_rom_map_elem_t mp_lv_chart_series_t_locals_dict_table[] = { + { MP_ROM_QSTR(MP_QSTR_SIZE), MP_ROM_PTR(MP_ROM_INT(sizeof(lv_chart_series_t))) }, + { MP_ROM_QSTR(MP_QSTR_cast), MP_ROM_PTR(&mp_lv_cast_class_method) }, +}; + +STATIC MP_DEFINE_CONST_DICT(mp_lv_chart_series_t_locals_dict, mp_lv_chart_series_t_locals_dict_table); + +STATIC const mp_obj_type_t mp_lv_chart_series_t_type = { + { &mp_type_type }, + .name = MP_QSTR_lv_chart_series_t, + .print = mp_lv_chart_series_t_print, + .make_new = make_new_lv_struct, + .attr = mp_lv_chart_series_t_attr, + .locals_dict = (mp_obj_dict_t*)&mp_lv_chart_series_t_locals_dict, + .buffer_p = { .get_buffer = mp_blob_get_buffer } +}; + +STATIC inline const mp_obj_type_t *get_mp_lv_chart_series_t_type() +{ + return &mp_lv_chart_series_t_type; +} + + +/* + * lvgl extension definition for: + * lv_chart_series_t *lv_chart_add_series(lv_obj_t *chart, lv_color_t color) + */ + +STATIC mp_obj_t mp_lv_chart_add_series(size_t n_args, const mp_obj_t *args) +{ + lv_obj_t *chart = mp_to_lv(args[0]); + lv_color_t color = mp_write_lv_color16_t(args[1]); + lv_chart_series_t* res = lv_chart_add_series(chart, color); + return mp_read_ptr_lv_chart_series_t((void*)res); +} + +STATIC MP_DEFINE_CONST_FUN_OBJ_VAR_BETWEEN(mp_lv_chart_add_series_obj, 2, 2, mp_lv_chart_add_series); + + + +/* + * lvgl extension definition for: + * void lv_chart_clear_serie(lv_obj_t *chart, lv_chart_series_t *serie) + */ + +STATIC mp_obj_t mp_lv_chart_clear_serie(size_t n_args, const mp_obj_t *args) +{ + lv_obj_t *chart = mp_to_lv(args[0]); + lv_chart_series_t *serie = mp_write_ptr_lv_chart_series_t(args[1]); + lv_chart_clear_serie(chart, serie); + return mp_const_none; +} + +STATIC MP_DEFINE_CONST_FUN_OBJ_VAR_BETWEEN(mp_lv_chart_clear_serie_obj, 2, 2, mp_lv_chart_clear_serie); + + + +/* + * lvgl extension definition for: + * void lv_chart_set_div_line_count(lv_obj_t *chart, uint8_t hdiv, uint8_t vdiv) + */ + +STATIC mp_obj_t mp_lv_chart_set_div_line_count(size_t n_args, const mp_obj_t *args) +{ + lv_obj_t *chart = mp_to_lv(args[0]); + uint8_t hdiv = (uint8_t)mp_obj_get_int(args[1]); + uint8_t vdiv = (uint8_t)mp_obj_get_int(args[2]); + lv_chart_set_div_line_count(chart, hdiv, vdiv); + return mp_const_none; +} + +STATIC MP_DEFINE_CONST_FUN_OBJ_VAR_BETWEEN(mp_lv_chart_set_div_line_count_obj, 3, 3, mp_lv_chart_set_div_line_count); + + + +/* + * lvgl extension definition for: + * void lv_chart_set_range(lv_obj_t *chart, lv_coord_t ymin, lv_coord_t ymax) + */ + +STATIC mp_obj_t mp_lv_chart_set_range(size_t n_args, const mp_obj_t *args) +{ + lv_obj_t *chart = mp_to_lv(args[0]); + lv_coord_t ymin = (int16_t)mp_obj_get_int(args[1]); + lv_coord_t ymax = (int16_t)mp_obj_get_int(args[2]); + lv_chart_set_range(chart, ymin, ymax); + return mp_const_none; +} + +STATIC MP_DEFINE_CONST_FUN_OBJ_VAR_BETWEEN(mp_lv_chart_set_range_obj, 3, 3, mp_lv_chart_set_range); + + + +/* + * lvgl extension definition for: + * void lv_chart_set_type(lv_obj_t *chart, lv_chart_type_t type) + */ + +STATIC mp_obj_t mp_lv_chart_set_type(size_t n_args, const mp_obj_t *args) +{ + lv_obj_t *chart = mp_to_lv(args[0]); + lv_chart_type_t type = (uint8_t)mp_obj_get_int(args[1]); + lv_chart_set_type(chart, type); + return mp_const_none; +} + +STATIC MP_DEFINE_CONST_FUN_OBJ_VAR_BETWEEN(mp_lv_chart_set_type_obj, 2, 2, mp_lv_chart_set_type); + + + +/* + * lvgl extension definition for: + * void lv_chart_set_point_count(lv_obj_t *chart, uint16_t point_cnt) + */ + +STATIC mp_obj_t mp_lv_chart_set_point_count(size_t n_args, const mp_obj_t *args) +{ + lv_obj_t *chart = mp_to_lv(args[0]); + uint16_t point_cnt = (uint16_t)mp_obj_get_int(args[1]); + lv_chart_set_point_count(chart, point_cnt); + return mp_const_none; +} + +STATIC MP_DEFINE_CONST_FUN_OBJ_VAR_BETWEEN(mp_lv_chart_set_point_count_obj, 2, 2, mp_lv_chart_set_point_count); + + + +/* + * lvgl extension definition for: + * void lv_chart_set_series_opa(lv_obj_t *chart, lv_opa_t opa) + */ + +STATIC mp_obj_t mp_lv_chart_set_series_opa(size_t n_args, const mp_obj_t *args) +{ + lv_obj_t *chart = mp_to_lv(args[0]); + lv_opa_t opa = (uint8_t)mp_obj_get_int(args[1]); + lv_chart_set_series_opa(chart, opa); + return mp_const_none; +} + +STATIC MP_DEFINE_CONST_FUN_OBJ_VAR_BETWEEN(mp_lv_chart_set_series_opa_obj, 2, 2, mp_lv_chart_set_series_opa); + + + +/* + * lvgl extension definition for: + * void lv_chart_set_series_width(lv_obj_t *chart, lv_coord_t width) + */ + +STATIC mp_obj_t mp_lv_chart_set_series_width(size_t n_args, const mp_obj_t *args) +{ + lv_obj_t *chart = mp_to_lv(args[0]); + lv_coord_t width = (int16_t)mp_obj_get_int(args[1]); + lv_chart_set_series_width(chart, width); + return mp_const_none; +} + +STATIC MP_DEFINE_CONST_FUN_OBJ_VAR_BETWEEN(mp_lv_chart_set_series_width_obj, 2, 2, mp_lv_chart_set_series_width); + + + +/* + * lvgl extension definition for: + * void lv_chart_set_series_darking(lv_obj_t *chart, lv_opa_t dark_eff) + */ + +STATIC mp_obj_t mp_lv_chart_set_series_darking(size_t n_args, const mp_obj_t *args) +{ + lv_obj_t *chart = mp_to_lv(args[0]); + lv_opa_t dark_eff = (uint8_t)mp_obj_get_int(args[1]); + lv_chart_set_series_darking(chart, dark_eff); + return mp_const_none; +} + +STATIC MP_DEFINE_CONST_FUN_OBJ_VAR_BETWEEN(mp_lv_chart_set_series_darking_obj, 2, 2, mp_lv_chart_set_series_darking); + + + +/* + * lvgl extension definition for: + * void lv_chart_init_points(lv_obj_t *chart, lv_chart_series_t *ser, lv_coord_t y) + */ + +STATIC mp_obj_t mp_lv_chart_init_points(size_t n_args, const mp_obj_t *args) +{ + lv_obj_t *chart = mp_to_lv(args[0]); + lv_chart_series_t *ser = mp_write_ptr_lv_chart_series_t(args[1]); + lv_coord_t y = (int16_t)mp_obj_get_int(args[2]); + lv_chart_init_points(chart, ser, y); + return mp_const_none; +} + +STATIC MP_DEFINE_CONST_FUN_OBJ_VAR_BETWEEN(mp_lv_chart_init_points_obj, 3, 3, mp_lv_chart_init_points); + + + +/* + * lvgl extension definition for: + * void lv_chart_set_points(lv_obj_t *chart, lv_chart_series_t *ser, lv_coord_t *y_array) + */ + +STATIC mp_obj_t mp_lv_chart_set_points(size_t n_args, const mp_obj_t *args) +{ + lv_obj_t *chart = mp_to_lv(args[0]); + lv_chart_series_t *ser = mp_write_ptr_lv_chart_series_t(args[1]); + lv_coord_t *y_array = mp_to_ptr(args[2]); + lv_chart_set_points(chart, ser, y_array); + return mp_const_none; +} + +STATIC MP_DEFINE_CONST_FUN_OBJ_VAR_BETWEEN(mp_lv_chart_set_points_obj, 3, 3, mp_lv_chart_set_points); + + + +/* + * lvgl extension definition for: + * void lv_chart_set_next(lv_obj_t *chart, lv_chart_series_t *ser, lv_coord_t y) + */ + +STATIC mp_obj_t mp_lv_chart_set_next(size_t n_args, const mp_obj_t *args) +{ + lv_obj_t *chart = mp_to_lv(args[0]); + lv_chart_series_t *ser = mp_write_ptr_lv_chart_series_t(args[1]); + lv_coord_t y = (int16_t)mp_obj_get_int(args[2]); + lv_chart_set_next(chart, ser, y); + return mp_const_none; +} + +STATIC MP_DEFINE_CONST_FUN_OBJ_VAR_BETWEEN(mp_lv_chart_set_next_obj, 3, 3, mp_lv_chart_set_next); + + + +/* + * lvgl extension definition for: + * lv_chart_type_t lv_chart_get_type(const lv_obj_t *chart) + */ + +STATIC mp_obj_t mp_lv_chart_get_type(size_t n_args, const mp_obj_t *args) +{ + const lv_obj_t *chart = mp_to_lv(args[0]); + lv_chart_type_t res = lv_chart_get_type(chart); + return mp_obj_new_int_from_uint(res); +} + +STATIC MP_DEFINE_CONST_FUN_OBJ_VAR_BETWEEN(mp_lv_chart_get_type_obj, 1, 1, mp_lv_chart_get_type); + + + +/* + * lvgl extension definition for: + * uint16_t lv_chart_get_point_cnt(const lv_obj_t *chart) + */ + +STATIC mp_obj_t mp_lv_chart_get_point_cnt(size_t n_args, const mp_obj_t *args) +{ + const lv_obj_t *chart = mp_to_lv(args[0]); + uint16_t res = lv_chart_get_point_cnt(chart); + return mp_obj_new_int_from_uint(res); +} + +STATIC MP_DEFINE_CONST_FUN_OBJ_VAR_BETWEEN(mp_lv_chart_get_point_cnt_obj, 1, 1, mp_lv_chart_get_point_cnt); + + + +/* + * lvgl extension definition for: + * lv_opa_t lv_chart_get_series_opa(const lv_obj_t *chart) + */ + +STATIC mp_obj_t mp_lv_chart_get_series_opa(size_t n_args, const mp_obj_t *args) +{ + const lv_obj_t *chart = mp_to_lv(args[0]); + lv_opa_t res = lv_chart_get_series_opa(chart); + return mp_obj_new_int_from_uint(res); +} + +STATIC MP_DEFINE_CONST_FUN_OBJ_VAR_BETWEEN(mp_lv_chart_get_series_opa_obj, 1, 1, mp_lv_chart_get_series_opa); + + + +/* + * lvgl extension definition for: + * lv_coord_t lv_chart_get_series_width(const lv_obj_t *chart) + */ + +STATIC mp_obj_t mp_lv_chart_get_series_width(size_t n_args, const mp_obj_t *args) +{ + const lv_obj_t *chart = mp_to_lv(args[0]); + lv_coord_t res = lv_chart_get_series_width(chart); + return mp_obj_new_int(res); +} + +STATIC MP_DEFINE_CONST_FUN_OBJ_VAR_BETWEEN(mp_lv_chart_get_series_width_obj, 1, 1, mp_lv_chart_get_series_width); + + + +/* + * lvgl extension definition for: + * lv_opa_t lv_chart_get_series_darking(const lv_obj_t *chart) + */ + +STATIC mp_obj_t mp_lv_chart_get_series_darking(size_t n_args, const mp_obj_t *args) +{ + const lv_obj_t *chart = mp_to_lv(args[0]); + lv_opa_t res = lv_chart_get_series_darking(chart); + return mp_obj_new_int_from_uint(res); +} + +STATIC MP_DEFINE_CONST_FUN_OBJ_VAR_BETWEEN(mp_lv_chart_get_series_darking_obj, 1, 1, mp_lv_chart_get_series_darking); + + + +/* + * lvgl extension definition for: + * void lv_chart_refresh(lv_obj_t *chart) + */ + +STATIC mp_obj_t mp_lv_chart_refresh(size_t n_args, const mp_obj_t *args) +{ + lv_obj_t *chart = mp_to_lv(args[0]); + lv_chart_refresh(chart); + return mp_const_none; +} + +STATIC MP_DEFINE_CONST_FUN_OBJ_VAR_BETWEEN(mp_lv_chart_refresh_obj, 1, 1, mp_lv_chart_refresh); + + + +/* + * lvgl chart object definitions + */ + + +STATIC const mp_rom_map_elem_t chart_locals_dict_table[] = { + { MP_ROM_QSTR(MP_QSTR_set_style), MP_ROM_PTR(&mp_lv_chart_set_style_obj) }, + { MP_ROM_QSTR(MP_QSTR_get_style), MP_ROM_PTR(&mp_lv_chart_get_style_obj) }, + { MP_ROM_QSTR(MP_QSTR_add_series), MP_ROM_PTR(&mp_lv_chart_add_series_obj) }, + { MP_ROM_QSTR(MP_QSTR_clear_serie), MP_ROM_PTR(&mp_lv_chart_clear_serie_obj) }, + { MP_ROM_QSTR(MP_QSTR_set_div_line_count), MP_ROM_PTR(&mp_lv_chart_set_div_line_count_obj) }, + { MP_ROM_QSTR(MP_QSTR_set_range), MP_ROM_PTR(&mp_lv_chart_set_range_obj) }, + { MP_ROM_QSTR(MP_QSTR_set_type), MP_ROM_PTR(&mp_lv_chart_set_type_obj) }, + { MP_ROM_QSTR(MP_QSTR_set_point_count), MP_ROM_PTR(&mp_lv_chart_set_point_count_obj) }, + { MP_ROM_QSTR(MP_QSTR_set_series_opa), MP_ROM_PTR(&mp_lv_chart_set_series_opa_obj) }, + { MP_ROM_QSTR(MP_QSTR_set_series_width), MP_ROM_PTR(&mp_lv_chart_set_series_width_obj) }, + { MP_ROM_QSTR(MP_QSTR_set_series_darking), MP_ROM_PTR(&mp_lv_chart_set_series_darking_obj) }, + { MP_ROM_QSTR(MP_QSTR_init_points), MP_ROM_PTR(&mp_lv_chart_init_points_obj) }, + { MP_ROM_QSTR(MP_QSTR_set_points), MP_ROM_PTR(&mp_lv_chart_set_points_obj) }, + { MP_ROM_QSTR(MP_QSTR_set_next), MP_ROM_PTR(&mp_lv_chart_set_next_obj) }, + { MP_ROM_QSTR(MP_QSTR_get_type), MP_ROM_PTR(&mp_lv_chart_get_type_obj) }, + { MP_ROM_QSTR(MP_QSTR_get_point_cnt), MP_ROM_PTR(&mp_lv_chart_get_point_cnt_obj) }, + { MP_ROM_QSTR(MP_QSTR_get_series_opa), MP_ROM_PTR(&mp_lv_chart_get_series_opa_obj) }, + { MP_ROM_QSTR(MP_QSTR_get_series_width), MP_ROM_PTR(&mp_lv_chart_get_series_width_obj) }, + { MP_ROM_QSTR(MP_QSTR_get_series_darking), MP_ROM_PTR(&mp_lv_chart_get_series_darking_obj) }, + { MP_ROM_QSTR(MP_QSTR_refresh), MP_ROM_PTR(&mp_lv_chart_refresh_obj) }, + { MP_ROM_QSTR(MP_QSTR_delete), MP_ROM_PTR(&mp_lv_obj_del_obj) }, + { MP_ROM_QSTR(MP_QSTR_clean), MP_ROM_PTR(&mp_lv_obj_clean_obj) }, + { MP_ROM_QSTR(MP_QSTR_invalidate), MP_ROM_PTR(&mp_lv_obj_invalidate_obj) }, + { MP_ROM_QSTR(MP_QSTR_set_parent), MP_ROM_PTR(&mp_lv_obj_set_parent_obj) }, + { MP_ROM_QSTR(MP_QSTR_set_pos), MP_ROM_PTR(&mp_lv_obj_set_pos_obj) }, + { MP_ROM_QSTR(MP_QSTR_set_x), MP_ROM_PTR(&mp_lv_obj_set_x_obj) }, + { MP_ROM_QSTR(MP_QSTR_set_y), MP_ROM_PTR(&mp_lv_obj_set_y_obj) }, + { MP_ROM_QSTR(MP_QSTR_set_size), MP_ROM_PTR(&mp_lv_obj_set_size_obj) }, + { MP_ROM_QSTR(MP_QSTR_set_width), MP_ROM_PTR(&mp_lv_obj_set_width_obj) }, + { MP_ROM_QSTR(MP_QSTR_set_height), MP_ROM_PTR(&mp_lv_obj_set_height_obj) }, + { MP_ROM_QSTR(MP_QSTR_align), MP_ROM_PTR(&mp_lv_obj_align_obj) }, + { MP_ROM_QSTR(MP_QSTR_align_origo), MP_ROM_PTR(&mp_lv_obj_align_origo_obj) }, + { MP_ROM_QSTR(MP_QSTR_realign), MP_ROM_PTR(&mp_lv_obj_realign_obj) }, + { MP_ROM_QSTR(MP_QSTR_set_auto_realign), MP_ROM_PTR(&mp_lv_obj_set_auto_realign_obj) }, + { MP_ROM_QSTR(MP_QSTR_set_style), MP_ROM_PTR(&mp_lv_obj_set_style_obj) }, + { MP_ROM_QSTR(MP_QSTR_refresh_style), MP_ROM_PTR(&mp_lv_obj_refresh_style_obj) }, + { MP_ROM_QSTR(MP_QSTR_report_style_mod), MP_ROM_PTR(&mp_lv_obj_report_style_mod_obj) }, + { MP_ROM_QSTR(MP_QSTR_set_hidden), MP_ROM_PTR(&mp_lv_obj_set_hidden_obj) }, + { MP_ROM_QSTR(MP_QSTR_set_click), MP_ROM_PTR(&mp_lv_obj_set_click_obj) }, + { MP_ROM_QSTR(MP_QSTR_set_top), MP_ROM_PTR(&mp_lv_obj_set_top_obj) }, + { MP_ROM_QSTR(MP_QSTR_set_drag), MP_ROM_PTR(&mp_lv_obj_set_drag_obj) }, + { MP_ROM_QSTR(MP_QSTR_set_drag_throw), MP_ROM_PTR(&mp_lv_obj_set_drag_throw_obj) }, + { MP_ROM_QSTR(MP_QSTR_set_drag_parent), MP_ROM_PTR(&mp_lv_obj_set_drag_parent_obj) }, + { MP_ROM_QSTR(MP_QSTR_set_opa_scale_enable), MP_ROM_PTR(&mp_lv_obj_set_opa_scale_enable_obj) }, + { MP_ROM_QSTR(MP_QSTR_set_opa_scale), MP_ROM_PTR(&mp_lv_obj_set_opa_scale_obj) }, + { MP_ROM_QSTR(MP_QSTR_set_protect), MP_ROM_PTR(&mp_lv_obj_set_protect_obj) }, + { MP_ROM_QSTR(MP_QSTR_clear_protect), MP_ROM_PTR(&mp_lv_obj_clear_protect_obj) }, + { MP_ROM_QSTR(MP_QSTR_set_signal_func), MP_ROM_PTR(&mp_lv_obj_set_signal_func_obj) }, + { MP_ROM_QSTR(MP_QSTR_set_design_func), MP_ROM_PTR(&mp_lv_obj_set_design_func_obj) }, + { MP_ROM_QSTR(MP_QSTR_allocate_ext_attr), MP_ROM_PTR(&mp_lv_obj_allocate_ext_attr_obj) }, + { MP_ROM_QSTR(MP_QSTR_refresh_ext_size), MP_ROM_PTR(&mp_lv_obj_refresh_ext_size_obj) }, + { MP_ROM_QSTR(MP_QSTR_set_free_num), MP_ROM_PTR(&mp_lv_obj_set_free_num_obj) }, + { MP_ROM_QSTR(MP_QSTR_set_free_ptr), MP_ROM_PTR(&mp_lv_obj_set_free_ptr_obj) }, + { MP_ROM_QSTR(MP_QSTR_animate), MP_ROM_PTR(&mp_lv_obj_animate_obj) }, + { MP_ROM_QSTR(MP_QSTR_get_screen), MP_ROM_PTR(&mp_lv_obj_get_screen_obj) }, + { MP_ROM_QSTR(MP_QSTR_get_parent), MP_ROM_PTR(&mp_lv_obj_get_parent_obj) }, + { MP_ROM_QSTR(MP_QSTR_get_child), MP_ROM_PTR(&mp_lv_obj_get_child_obj) }, + { MP_ROM_QSTR(MP_QSTR_get_child_back), MP_ROM_PTR(&mp_lv_obj_get_child_back_obj) }, + { MP_ROM_QSTR(MP_QSTR_count_children), MP_ROM_PTR(&mp_lv_obj_count_children_obj) }, + { MP_ROM_QSTR(MP_QSTR_get_coords), MP_ROM_PTR(&mp_lv_obj_get_coords_obj) }, + { MP_ROM_QSTR(MP_QSTR_get_x), MP_ROM_PTR(&mp_lv_obj_get_x_obj) }, + { MP_ROM_QSTR(MP_QSTR_get_y), MP_ROM_PTR(&mp_lv_obj_get_y_obj) }, + { MP_ROM_QSTR(MP_QSTR_get_width), MP_ROM_PTR(&mp_lv_obj_get_width_obj) }, + { MP_ROM_QSTR(MP_QSTR_get_height), MP_ROM_PTR(&mp_lv_obj_get_height_obj) }, + { MP_ROM_QSTR(MP_QSTR_get_ext_size), MP_ROM_PTR(&mp_lv_obj_get_ext_size_obj) }, + { MP_ROM_QSTR(MP_QSTR_get_auto_realign), MP_ROM_PTR(&mp_lv_obj_get_auto_realign_obj) }, + { MP_ROM_QSTR(MP_QSTR_get_style), MP_ROM_PTR(&mp_lv_obj_get_style_obj) }, + { MP_ROM_QSTR(MP_QSTR_get_hidden), MP_ROM_PTR(&mp_lv_obj_get_hidden_obj) }, + { MP_ROM_QSTR(MP_QSTR_get_click), MP_ROM_PTR(&mp_lv_obj_get_click_obj) }, + { MP_ROM_QSTR(MP_QSTR_get_top), MP_ROM_PTR(&mp_lv_obj_get_top_obj) }, + { MP_ROM_QSTR(MP_QSTR_get_drag), MP_ROM_PTR(&mp_lv_obj_get_drag_obj) }, + { MP_ROM_QSTR(MP_QSTR_get_drag_throw), MP_ROM_PTR(&mp_lv_obj_get_drag_throw_obj) }, + { MP_ROM_QSTR(MP_QSTR_get_drag_parent), MP_ROM_PTR(&mp_lv_obj_get_drag_parent_obj) }, + { MP_ROM_QSTR(MP_QSTR_get_opa_scale_enable), MP_ROM_PTR(&mp_lv_obj_get_opa_scale_enable_obj) }, + { MP_ROM_QSTR(MP_QSTR_get_opa_scale), MP_ROM_PTR(&mp_lv_obj_get_opa_scale_obj) }, + { MP_ROM_QSTR(MP_QSTR_get_protect), MP_ROM_PTR(&mp_lv_obj_get_protect_obj) }, + { MP_ROM_QSTR(MP_QSTR_is_protected), MP_ROM_PTR(&mp_lv_obj_is_protected_obj) }, + { MP_ROM_QSTR(MP_QSTR_get_signal_func), MP_ROM_PTR(&mp_lv_obj_get_signal_func_obj) }, + { MP_ROM_QSTR(MP_QSTR_get_design_func), MP_ROM_PTR(&mp_lv_obj_get_design_func_obj) }, + { MP_ROM_QSTR(MP_QSTR_get_ext_attr), MP_ROM_PTR(&mp_lv_obj_get_ext_attr_obj) }, + { MP_ROM_QSTR(MP_QSTR_get_free_num), MP_ROM_PTR(&mp_lv_obj_get_free_num_obj) }, + { MP_ROM_QSTR(MP_QSTR_get_free_ptr), MP_ROM_PTR(&mp_lv_obj_get_free_ptr_obj) }, + { MP_ROM_QSTR(MP_QSTR_get_group), MP_ROM_PTR(&mp_lv_obj_get_group_obj) }, + { MP_ROM_QSTR(MP_QSTR_is_focused), MP_ROM_PTR(&mp_lv_obj_is_focused_obj) }, + { MP_ROM_QSTR(MP_QSTR_TYPE), MP_ROM_PTR(&mp_LV_CHART_TYPE_type) } +}; + +STATIC MP_DEFINE_CONST_DICT(chart_locals_dict, chart_locals_dict_table); + +STATIC void chart_print(const mp_print_t *print, + mp_obj_t self_in, + mp_print_kind_t kind) +{ + mp_printf(print, "lvgl chart"); +} + + +STATIC mp_obj_t chart_make_new( + const mp_obj_type_t *type, + size_t n_args, + size_t n_kw, + const mp_obj_t *args) +{ + return make_new(&lv_chart_create, type, n_args, n_kw, args); +} + + +STATIC const mp_obj_type_t mp_chart_type = { + { &mp_type_type }, + .name = MP_QSTR_chart, + .print = chart_print, + .make_new = chart_make_new, + .locals_dict = (mp_obj_dict_t*)&chart_locals_dict, +}; + + +/* + * lvgl extension definition for: + * void lv_table_set_cell_value(lv_obj_t *table, uint16_t row, uint16_t col, const char *txt) + */ + +STATIC mp_obj_t mp_lv_table_set_cell_value(size_t n_args, const mp_obj_t *args) +{ + lv_obj_t *table = mp_to_lv(args[0]); + uint16_t row = (uint16_t)mp_obj_get_int(args[1]); + uint16_t col = (uint16_t)mp_obj_get_int(args[2]); + const char *txt = (char*)mp_obj_str_get_str(args[3]); + lv_table_set_cell_value(table, row, col, txt); + return mp_const_none; +} + +STATIC MP_DEFINE_CONST_FUN_OBJ_VAR_BETWEEN(mp_lv_table_set_cell_value_obj, 4, 4, mp_lv_table_set_cell_value); + + + +/* + * lvgl extension definition for: + * void lv_table_set_row_cnt(lv_obj_t *table, uint16_t row_cnt) + */ + +STATIC mp_obj_t mp_lv_table_set_row_cnt(size_t n_args, const mp_obj_t *args) +{ + lv_obj_t *table = mp_to_lv(args[0]); + uint16_t row_cnt = (uint16_t)mp_obj_get_int(args[1]); + lv_table_set_row_cnt(table, row_cnt); + return mp_const_none; +} + +STATIC MP_DEFINE_CONST_FUN_OBJ_VAR_BETWEEN(mp_lv_table_set_row_cnt_obj, 2, 2, mp_lv_table_set_row_cnt); + + + +/* + * lvgl extension definition for: + * void lv_table_set_col_cnt(lv_obj_t *table, uint16_t col_cnt) + */ + +STATIC mp_obj_t mp_lv_table_set_col_cnt(size_t n_args, const mp_obj_t *args) +{ + lv_obj_t *table = mp_to_lv(args[0]); + uint16_t col_cnt = (uint16_t)mp_obj_get_int(args[1]); + lv_table_set_col_cnt(table, col_cnt); + return mp_const_none; +} + +STATIC MP_DEFINE_CONST_FUN_OBJ_VAR_BETWEEN(mp_lv_table_set_col_cnt_obj, 2, 2, mp_lv_table_set_col_cnt); + + + +/* + * lvgl extension definition for: + * void lv_table_set_col_width(lv_obj_t *table, uint16_t col_id, lv_coord_t w) + */ + +STATIC mp_obj_t mp_lv_table_set_col_width(size_t n_args, const mp_obj_t *args) +{ + lv_obj_t *table = mp_to_lv(args[0]); + uint16_t col_id = (uint16_t)mp_obj_get_int(args[1]); + lv_coord_t w = (int16_t)mp_obj_get_int(args[2]); + lv_table_set_col_width(table, col_id, w); + return mp_const_none; +} + +STATIC MP_DEFINE_CONST_FUN_OBJ_VAR_BETWEEN(mp_lv_table_set_col_width_obj, 3, 3, mp_lv_table_set_col_width); + + + +/* + * lvgl extension definition for: + * void lv_table_set_cell_align(lv_obj_t *table, uint16_t row, uint16_t col, lv_label_align_t align) + */ + +STATIC mp_obj_t mp_lv_table_set_cell_align(size_t n_args, const mp_obj_t *args) +{ + lv_obj_t *table = mp_to_lv(args[0]); + uint16_t row = (uint16_t)mp_obj_get_int(args[1]); + uint16_t col = (uint16_t)mp_obj_get_int(args[2]); + lv_label_align_t align = (uint8_t)mp_obj_get_int(args[3]); + lv_table_set_cell_align(table, row, col, align); + return mp_const_none; +} + +STATIC MP_DEFINE_CONST_FUN_OBJ_VAR_BETWEEN(mp_lv_table_set_cell_align_obj, 4, 4, mp_lv_table_set_cell_align); + + + +/* + * lvgl extension definition for: + * void lv_table_set_cell_type(lv_obj_t *table, uint16_t row, uint16_t col, uint8_t type) + */ + +STATIC mp_obj_t mp_lv_table_set_cell_type(size_t n_args, const mp_obj_t *args) +{ + lv_obj_t *table = mp_to_lv(args[0]); + uint16_t row = (uint16_t)mp_obj_get_int(args[1]); + uint16_t col = (uint16_t)mp_obj_get_int(args[2]); + uint8_t type = (uint8_t)mp_obj_get_int(args[3]); + lv_table_set_cell_type(table, row, col, type); + return mp_const_none; +} + +STATIC MP_DEFINE_CONST_FUN_OBJ_VAR_BETWEEN(mp_lv_table_set_cell_type_obj, 4, 4, mp_lv_table_set_cell_type); + + + +/* + * lvgl extension definition for: + * void lv_table_set_cell_crop(lv_obj_t *table, uint16_t row, uint16_t col, bool crop) + */ + +STATIC mp_obj_t mp_lv_table_set_cell_crop(size_t n_args, const mp_obj_t *args) +{ + lv_obj_t *table = mp_to_lv(args[0]); + uint16_t row = (uint16_t)mp_obj_get_int(args[1]); + uint16_t col = (uint16_t)mp_obj_get_int(args[2]); + bool crop = mp_obj_is_true(args[3]); + lv_table_set_cell_crop(table, row, col, crop); + return mp_const_none; +} + +STATIC MP_DEFINE_CONST_FUN_OBJ_VAR_BETWEEN(mp_lv_table_set_cell_crop_obj, 4, 4, mp_lv_table_set_cell_crop); + + + +/* + * lvgl extension definition for: + * void lv_table_set_cell_merge_right(lv_obj_t *table, uint16_t row, uint16_t col, bool en) + */ + +STATIC mp_obj_t mp_lv_table_set_cell_merge_right(size_t n_args, const mp_obj_t *args) +{ + lv_obj_t *table = mp_to_lv(args[0]); + uint16_t row = (uint16_t)mp_obj_get_int(args[1]); + uint16_t col = (uint16_t)mp_obj_get_int(args[2]); + bool en = mp_obj_is_true(args[3]); + lv_table_set_cell_merge_right(table, row, col, en); + return mp_const_none; +} + +STATIC MP_DEFINE_CONST_FUN_OBJ_VAR_BETWEEN(mp_lv_table_set_cell_merge_right_obj, 4, 4, mp_lv_table_set_cell_merge_right); + + + +/* + * lvgl extension definition for: + * void lv_table_set_style(lv_obj_t *table, lv_table_style_t type, lv_style_t *style) + */ + +STATIC mp_obj_t mp_lv_table_set_style(size_t n_args, const mp_obj_t *args) +{ + lv_obj_t *table = mp_to_lv(args[0]); + lv_table_style_t type = (uint8_t)mp_obj_get_int(args[1]); + lv_style_t *style = mp_write_ptr_lv_style_t(args[2]); + lv_table_set_style(table, type, style); + return mp_const_none; +} + +STATIC MP_DEFINE_CONST_FUN_OBJ_VAR_BETWEEN(mp_lv_table_set_style_obj, 3, 3, mp_lv_table_set_style); + + + +/* + * lvgl extension definition for: + * const char *lv_table_get_cell_value(lv_obj_t *table, uint16_t row, uint16_t col) + */ + +STATIC mp_obj_t mp_lv_table_get_cell_value(size_t n_args, const mp_obj_t *args) +{ + lv_obj_t *table = mp_to_lv(args[0]); + uint16_t row = (uint16_t)mp_obj_get_int(args[1]); + uint16_t col = (uint16_t)mp_obj_get_int(args[2]); + const char* res = lv_table_get_cell_value(table, row, col); + return convert_to_str((void*)res); +} + +STATIC MP_DEFINE_CONST_FUN_OBJ_VAR_BETWEEN(mp_lv_table_get_cell_value_obj, 3, 3, mp_lv_table_get_cell_value); + + + +/* + * lvgl extension definition for: + * uint16_t lv_table_get_row_cnt(lv_obj_t *table) + */ + +STATIC mp_obj_t mp_lv_table_get_row_cnt(size_t n_args, const mp_obj_t *args) +{ + lv_obj_t *table = mp_to_lv(args[0]); + uint16_t res = lv_table_get_row_cnt(table); + return mp_obj_new_int_from_uint(res); +} + +STATIC MP_DEFINE_CONST_FUN_OBJ_VAR_BETWEEN(mp_lv_table_get_row_cnt_obj, 1, 1, mp_lv_table_get_row_cnt); + + + +/* + * lvgl extension definition for: + * uint16_t lv_table_get_col_cnt(lv_obj_t *table) + */ + +STATIC mp_obj_t mp_lv_table_get_col_cnt(size_t n_args, const mp_obj_t *args) +{ + lv_obj_t *table = mp_to_lv(args[0]); + uint16_t res = lv_table_get_col_cnt(table); + return mp_obj_new_int_from_uint(res); +} + +STATIC MP_DEFINE_CONST_FUN_OBJ_VAR_BETWEEN(mp_lv_table_get_col_cnt_obj, 1, 1, mp_lv_table_get_col_cnt); + + + +/* + * lvgl extension definition for: + * lv_coord_t lv_table_get_col_width(lv_obj_t *table, uint16_t col_id) + */ + +STATIC mp_obj_t mp_lv_table_get_col_width(size_t n_args, const mp_obj_t *args) +{ + lv_obj_t *table = mp_to_lv(args[0]); + uint16_t col_id = (uint16_t)mp_obj_get_int(args[1]); + lv_coord_t res = lv_table_get_col_width(table, col_id); + return mp_obj_new_int(res); +} + +STATIC MP_DEFINE_CONST_FUN_OBJ_VAR_BETWEEN(mp_lv_table_get_col_width_obj, 2, 2, mp_lv_table_get_col_width); + + + +/* + * lvgl extension definition for: + * lv_label_align_t lv_table_get_cell_align(lv_obj_t *table, uint16_t row, uint16_t col) + */ + +STATIC mp_obj_t mp_lv_table_get_cell_align(size_t n_args, const mp_obj_t *args) +{ + lv_obj_t *table = mp_to_lv(args[0]); + uint16_t row = (uint16_t)mp_obj_get_int(args[1]); + uint16_t col = (uint16_t)mp_obj_get_int(args[2]); + lv_label_align_t res = lv_table_get_cell_align(table, row, col); + return mp_obj_new_int_from_uint(res); +} + +STATIC MP_DEFINE_CONST_FUN_OBJ_VAR_BETWEEN(mp_lv_table_get_cell_align_obj, 3, 3, mp_lv_table_get_cell_align); + + + +/* + * lvgl extension definition for: + * lv_label_align_t lv_table_get_cell_type(lv_obj_t *table, uint16_t row, uint16_t col) + */ + +STATIC mp_obj_t mp_lv_table_get_cell_type(size_t n_args, const mp_obj_t *args) +{ + lv_obj_t *table = mp_to_lv(args[0]); + uint16_t row = (uint16_t)mp_obj_get_int(args[1]); + uint16_t col = (uint16_t)mp_obj_get_int(args[2]); + lv_label_align_t res = lv_table_get_cell_type(table, row, col); + return mp_obj_new_int_from_uint(res); +} + +STATIC MP_DEFINE_CONST_FUN_OBJ_VAR_BETWEEN(mp_lv_table_get_cell_type_obj, 3, 3, mp_lv_table_get_cell_type); + + + +/* + * lvgl extension definition for: + * lv_label_align_t lv_table_get_cell_crop(lv_obj_t *table, uint16_t row, uint16_t col) + */ + +STATIC mp_obj_t mp_lv_table_get_cell_crop(size_t n_args, const mp_obj_t *args) +{ + lv_obj_t *table = mp_to_lv(args[0]); + uint16_t row = (uint16_t)mp_obj_get_int(args[1]); + uint16_t col = (uint16_t)mp_obj_get_int(args[2]); + lv_label_align_t res = lv_table_get_cell_crop(table, row, col); + return mp_obj_new_int_from_uint(res); +} + +STATIC MP_DEFINE_CONST_FUN_OBJ_VAR_BETWEEN(mp_lv_table_get_cell_crop_obj, 3, 3, mp_lv_table_get_cell_crop); + + + +/* + * lvgl extension definition for: + * bool lv_table_get_cell_merge_right(lv_obj_t *table, uint16_t row, uint16_t col) + */ + +STATIC mp_obj_t mp_lv_table_get_cell_merge_right(size_t n_args, const mp_obj_t *args) +{ + lv_obj_t *table = mp_to_lv(args[0]); + uint16_t row = (uint16_t)mp_obj_get_int(args[1]); + uint16_t col = (uint16_t)mp_obj_get_int(args[2]); + bool res = lv_table_get_cell_merge_right(table, row, col); + return convert_to_bool(res); +} + +STATIC MP_DEFINE_CONST_FUN_OBJ_VAR_BETWEEN(mp_lv_table_get_cell_merge_right_obj, 3, 3, mp_lv_table_get_cell_merge_right); + + + +/* + * lvgl extension definition for: + * lv_style_t *lv_table_get_style(const lv_obj_t *table, lv_table_style_t type) + */ + +STATIC mp_obj_t mp_lv_table_get_style(size_t n_args, const mp_obj_t *args) +{ + const lv_obj_t *table = mp_to_lv(args[0]); + lv_table_style_t type = (uint8_t)mp_obj_get_int(args[1]); + lv_style_t* res = lv_table_get_style(table, type); + return mp_read_ptr_lv_style_t((void*)res); +} + +STATIC MP_DEFINE_CONST_FUN_OBJ_VAR_BETWEEN(mp_lv_table_get_style_obj, 2, 2, mp_lv_table_get_style); + + + +/* + * lvgl table object definitions + */ + + +STATIC const mp_rom_map_elem_t table_locals_dict_table[] = { + { MP_ROM_QSTR(MP_QSTR_set_cell_value), MP_ROM_PTR(&mp_lv_table_set_cell_value_obj) }, + { MP_ROM_QSTR(MP_QSTR_set_row_cnt), MP_ROM_PTR(&mp_lv_table_set_row_cnt_obj) }, + { MP_ROM_QSTR(MP_QSTR_set_col_cnt), MP_ROM_PTR(&mp_lv_table_set_col_cnt_obj) }, + { MP_ROM_QSTR(MP_QSTR_set_col_width), MP_ROM_PTR(&mp_lv_table_set_col_width_obj) }, + { MP_ROM_QSTR(MP_QSTR_set_cell_align), MP_ROM_PTR(&mp_lv_table_set_cell_align_obj) }, + { MP_ROM_QSTR(MP_QSTR_set_cell_type), MP_ROM_PTR(&mp_lv_table_set_cell_type_obj) }, + { MP_ROM_QSTR(MP_QSTR_set_cell_crop), MP_ROM_PTR(&mp_lv_table_set_cell_crop_obj) }, + { MP_ROM_QSTR(MP_QSTR_set_cell_merge_right), MP_ROM_PTR(&mp_lv_table_set_cell_merge_right_obj) }, + { MP_ROM_QSTR(MP_QSTR_set_style), MP_ROM_PTR(&mp_lv_table_set_style_obj) }, + { MP_ROM_QSTR(MP_QSTR_get_cell_value), MP_ROM_PTR(&mp_lv_table_get_cell_value_obj) }, + { MP_ROM_QSTR(MP_QSTR_get_row_cnt), MP_ROM_PTR(&mp_lv_table_get_row_cnt_obj) }, + { MP_ROM_QSTR(MP_QSTR_get_col_cnt), MP_ROM_PTR(&mp_lv_table_get_col_cnt_obj) }, + { MP_ROM_QSTR(MP_QSTR_get_col_width), MP_ROM_PTR(&mp_lv_table_get_col_width_obj) }, + { MP_ROM_QSTR(MP_QSTR_get_cell_align), MP_ROM_PTR(&mp_lv_table_get_cell_align_obj) }, + { MP_ROM_QSTR(MP_QSTR_get_cell_type), MP_ROM_PTR(&mp_lv_table_get_cell_type_obj) }, + { MP_ROM_QSTR(MP_QSTR_get_cell_crop), MP_ROM_PTR(&mp_lv_table_get_cell_crop_obj) }, + { MP_ROM_QSTR(MP_QSTR_get_cell_merge_right), MP_ROM_PTR(&mp_lv_table_get_cell_merge_right_obj) }, + { MP_ROM_QSTR(MP_QSTR_get_style), MP_ROM_PTR(&mp_lv_table_get_style_obj) }, + { MP_ROM_QSTR(MP_QSTR_delete), MP_ROM_PTR(&mp_lv_obj_del_obj) }, + { MP_ROM_QSTR(MP_QSTR_clean), MP_ROM_PTR(&mp_lv_obj_clean_obj) }, + { MP_ROM_QSTR(MP_QSTR_invalidate), MP_ROM_PTR(&mp_lv_obj_invalidate_obj) }, + { MP_ROM_QSTR(MP_QSTR_set_parent), MP_ROM_PTR(&mp_lv_obj_set_parent_obj) }, + { MP_ROM_QSTR(MP_QSTR_set_pos), MP_ROM_PTR(&mp_lv_obj_set_pos_obj) }, + { MP_ROM_QSTR(MP_QSTR_set_x), MP_ROM_PTR(&mp_lv_obj_set_x_obj) }, + { MP_ROM_QSTR(MP_QSTR_set_y), MP_ROM_PTR(&mp_lv_obj_set_y_obj) }, + { MP_ROM_QSTR(MP_QSTR_set_size), MP_ROM_PTR(&mp_lv_obj_set_size_obj) }, + { MP_ROM_QSTR(MP_QSTR_set_width), MP_ROM_PTR(&mp_lv_obj_set_width_obj) }, + { MP_ROM_QSTR(MP_QSTR_set_height), MP_ROM_PTR(&mp_lv_obj_set_height_obj) }, + { MP_ROM_QSTR(MP_QSTR_align), MP_ROM_PTR(&mp_lv_obj_align_obj) }, + { MP_ROM_QSTR(MP_QSTR_align_origo), MP_ROM_PTR(&mp_lv_obj_align_origo_obj) }, + { MP_ROM_QSTR(MP_QSTR_realign), MP_ROM_PTR(&mp_lv_obj_realign_obj) }, + { MP_ROM_QSTR(MP_QSTR_set_auto_realign), MP_ROM_PTR(&mp_lv_obj_set_auto_realign_obj) }, + { MP_ROM_QSTR(MP_QSTR_set_style), MP_ROM_PTR(&mp_lv_obj_set_style_obj) }, + { MP_ROM_QSTR(MP_QSTR_refresh_style), MP_ROM_PTR(&mp_lv_obj_refresh_style_obj) }, + { MP_ROM_QSTR(MP_QSTR_report_style_mod), MP_ROM_PTR(&mp_lv_obj_report_style_mod_obj) }, + { MP_ROM_QSTR(MP_QSTR_set_hidden), MP_ROM_PTR(&mp_lv_obj_set_hidden_obj) }, + { MP_ROM_QSTR(MP_QSTR_set_click), MP_ROM_PTR(&mp_lv_obj_set_click_obj) }, + { MP_ROM_QSTR(MP_QSTR_set_top), MP_ROM_PTR(&mp_lv_obj_set_top_obj) }, + { MP_ROM_QSTR(MP_QSTR_set_drag), MP_ROM_PTR(&mp_lv_obj_set_drag_obj) }, + { MP_ROM_QSTR(MP_QSTR_set_drag_throw), MP_ROM_PTR(&mp_lv_obj_set_drag_throw_obj) }, + { MP_ROM_QSTR(MP_QSTR_set_drag_parent), MP_ROM_PTR(&mp_lv_obj_set_drag_parent_obj) }, + { MP_ROM_QSTR(MP_QSTR_set_opa_scale_enable), MP_ROM_PTR(&mp_lv_obj_set_opa_scale_enable_obj) }, + { MP_ROM_QSTR(MP_QSTR_set_opa_scale), MP_ROM_PTR(&mp_lv_obj_set_opa_scale_obj) }, + { MP_ROM_QSTR(MP_QSTR_set_protect), MP_ROM_PTR(&mp_lv_obj_set_protect_obj) }, + { MP_ROM_QSTR(MP_QSTR_clear_protect), MP_ROM_PTR(&mp_lv_obj_clear_protect_obj) }, + { MP_ROM_QSTR(MP_QSTR_set_signal_func), MP_ROM_PTR(&mp_lv_obj_set_signal_func_obj) }, + { MP_ROM_QSTR(MP_QSTR_set_design_func), MP_ROM_PTR(&mp_lv_obj_set_design_func_obj) }, + { MP_ROM_QSTR(MP_QSTR_allocate_ext_attr), MP_ROM_PTR(&mp_lv_obj_allocate_ext_attr_obj) }, + { MP_ROM_QSTR(MP_QSTR_refresh_ext_size), MP_ROM_PTR(&mp_lv_obj_refresh_ext_size_obj) }, + { MP_ROM_QSTR(MP_QSTR_set_free_num), MP_ROM_PTR(&mp_lv_obj_set_free_num_obj) }, + { MP_ROM_QSTR(MP_QSTR_set_free_ptr), MP_ROM_PTR(&mp_lv_obj_set_free_ptr_obj) }, + { MP_ROM_QSTR(MP_QSTR_animate), MP_ROM_PTR(&mp_lv_obj_animate_obj) }, + { MP_ROM_QSTR(MP_QSTR_get_screen), MP_ROM_PTR(&mp_lv_obj_get_screen_obj) }, + { MP_ROM_QSTR(MP_QSTR_get_parent), MP_ROM_PTR(&mp_lv_obj_get_parent_obj) }, + { MP_ROM_QSTR(MP_QSTR_get_child), MP_ROM_PTR(&mp_lv_obj_get_child_obj) }, + { MP_ROM_QSTR(MP_QSTR_get_child_back), MP_ROM_PTR(&mp_lv_obj_get_child_back_obj) }, + { MP_ROM_QSTR(MP_QSTR_count_children), MP_ROM_PTR(&mp_lv_obj_count_children_obj) }, + { MP_ROM_QSTR(MP_QSTR_get_coords), MP_ROM_PTR(&mp_lv_obj_get_coords_obj) }, + { MP_ROM_QSTR(MP_QSTR_get_x), MP_ROM_PTR(&mp_lv_obj_get_x_obj) }, + { MP_ROM_QSTR(MP_QSTR_get_y), MP_ROM_PTR(&mp_lv_obj_get_y_obj) }, + { MP_ROM_QSTR(MP_QSTR_get_width), MP_ROM_PTR(&mp_lv_obj_get_width_obj) }, + { MP_ROM_QSTR(MP_QSTR_get_height), MP_ROM_PTR(&mp_lv_obj_get_height_obj) }, + { MP_ROM_QSTR(MP_QSTR_get_ext_size), MP_ROM_PTR(&mp_lv_obj_get_ext_size_obj) }, + { MP_ROM_QSTR(MP_QSTR_get_auto_realign), MP_ROM_PTR(&mp_lv_obj_get_auto_realign_obj) }, + { MP_ROM_QSTR(MP_QSTR_get_style), MP_ROM_PTR(&mp_lv_obj_get_style_obj) }, + { MP_ROM_QSTR(MP_QSTR_get_hidden), MP_ROM_PTR(&mp_lv_obj_get_hidden_obj) }, + { MP_ROM_QSTR(MP_QSTR_get_click), MP_ROM_PTR(&mp_lv_obj_get_click_obj) }, + { MP_ROM_QSTR(MP_QSTR_get_top), MP_ROM_PTR(&mp_lv_obj_get_top_obj) }, + { MP_ROM_QSTR(MP_QSTR_get_drag), MP_ROM_PTR(&mp_lv_obj_get_drag_obj) }, + { MP_ROM_QSTR(MP_QSTR_get_drag_throw), MP_ROM_PTR(&mp_lv_obj_get_drag_throw_obj) }, + { MP_ROM_QSTR(MP_QSTR_get_drag_parent), MP_ROM_PTR(&mp_lv_obj_get_drag_parent_obj) }, + { MP_ROM_QSTR(MP_QSTR_get_opa_scale_enable), MP_ROM_PTR(&mp_lv_obj_get_opa_scale_enable_obj) }, + { MP_ROM_QSTR(MP_QSTR_get_opa_scale), MP_ROM_PTR(&mp_lv_obj_get_opa_scale_obj) }, + { MP_ROM_QSTR(MP_QSTR_get_protect), MP_ROM_PTR(&mp_lv_obj_get_protect_obj) }, + { MP_ROM_QSTR(MP_QSTR_is_protected), MP_ROM_PTR(&mp_lv_obj_is_protected_obj) }, + { MP_ROM_QSTR(MP_QSTR_get_signal_func), MP_ROM_PTR(&mp_lv_obj_get_signal_func_obj) }, + { MP_ROM_QSTR(MP_QSTR_get_design_func), MP_ROM_PTR(&mp_lv_obj_get_design_func_obj) }, + { MP_ROM_QSTR(MP_QSTR_get_ext_attr), MP_ROM_PTR(&mp_lv_obj_get_ext_attr_obj) }, + { MP_ROM_QSTR(MP_QSTR_get_free_num), MP_ROM_PTR(&mp_lv_obj_get_free_num_obj) }, + { MP_ROM_QSTR(MP_QSTR_get_free_ptr), MP_ROM_PTR(&mp_lv_obj_get_free_ptr_obj) }, + { MP_ROM_QSTR(MP_QSTR_get_group), MP_ROM_PTR(&mp_lv_obj_get_group_obj) }, + { MP_ROM_QSTR(MP_QSTR_is_focused), MP_ROM_PTR(&mp_lv_obj_is_focused_obj) }, + { MP_ROM_QSTR(MP_QSTR_STYLE), MP_ROM_PTR(&mp_LV_TABLE_STYLE_type) } +}; + +STATIC MP_DEFINE_CONST_DICT(table_locals_dict, table_locals_dict_table); + +STATIC void table_print(const mp_print_t *print, + mp_obj_t self_in, + mp_print_kind_t kind) +{ + mp_printf(print, "lvgl table"); +} + + +STATIC mp_obj_t table_make_new( + const mp_obj_type_t *type, + size_t n_args, + size_t n_kw, + const mp_obj_t *args) +{ + return make_new(&lv_table_create, type, n_args, n_kw, args); +} + + +STATIC const mp_obj_type_t mp_table_type = { + { &mp_type_type }, + .name = MP_QSTR_table, + .print = table_print, + .make_new = table_make_new, + .locals_dict = (mp_obj_dict_t*)&table_locals_dict, +}; + + +/* + * lvgl extension definition for: + * inline static void lv_cb_set_checked(lv_obj_t *cb, bool checked) + */ + +STATIC mp_obj_t mp_lv_cb_set_checked(size_t n_args, const mp_obj_t *args) +{ + lv_obj_t *cb = mp_to_lv(args[0]); + bool checked = mp_obj_is_true(args[1]); + lv_cb_set_checked(cb, checked); + return mp_const_none; +} + +STATIC MP_DEFINE_CONST_FUN_OBJ_VAR_BETWEEN(mp_lv_cb_set_checked_obj, 2, 2, mp_lv_cb_set_checked); + + + +/* + * lvgl extension definition for: + * inline static void lv_cb_set_inactive(lv_obj_t *cb) + */ + +STATIC mp_obj_t mp_lv_cb_set_inactive(size_t n_args, const mp_obj_t *args) +{ + lv_obj_t *cb = mp_to_lv(args[0]); + lv_cb_set_inactive(cb); + return mp_const_none; +} + +STATIC MP_DEFINE_CONST_FUN_OBJ_VAR_BETWEEN(mp_lv_cb_set_inactive_obj, 1, 1, mp_lv_cb_set_inactive); + + + +/* + * lvgl extension definition for: + * inline static void lv_cb_set_action(lv_obj_t *cb, lv_action_t action) + */ + +STATIC mp_obj_t mp_lv_cb_set_action(size_t n_args, const mp_obj_t *args) +{ + lv_obj_t *cb = mp_to_lv(args[0]); + set_action(args[0], args[1]); + lv_action_t action = &lv_action_t_callback; + lv_cb_set_action(cb, action); + return mp_const_none; +} + +STATIC MP_DEFINE_CONST_FUN_OBJ_VAR_BETWEEN(mp_lv_cb_set_action_obj, 2, 2, mp_lv_cb_set_action); + + + +/* + * lvgl extension definition for: + * inline static bool lv_cb_is_checked(const lv_obj_t *cb) + */ + +STATIC mp_obj_t mp_lv_cb_is_checked(size_t n_args, const mp_obj_t *args) +{ + const lv_obj_t *cb = mp_to_lv(args[0]); + bool res = lv_cb_is_checked(cb); + return convert_to_bool(res); +} + +STATIC MP_DEFINE_CONST_FUN_OBJ_VAR_BETWEEN(mp_lv_cb_is_checked_obj, 1, 1, mp_lv_cb_is_checked); + + + +/* + * lvgl extension definition for: + * inline static lv_action_t lv_cb_get_action(const lv_obj_t *cb) + */ + +STATIC mp_obj_t mp_lv_cb_get_action(size_t n_args, const mp_obj_t *args) +{ + const lv_obj_t *cb = mp_to_lv(args[0]); + lv_action_t res = lv_cb_get_action(cb); + return ptr_to_mp(res); +} + +STATIC MP_DEFINE_CONST_FUN_OBJ_VAR_BETWEEN(mp_lv_cb_get_action_obj, 1, 1, mp_lv_cb_get_action); + + + +/* + * lvgl extension definition for: + * void lv_cb_set_text(lv_obj_t *cb, const char *txt) + */ + +STATIC mp_obj_t mp_lv_cb_set_text(size_t n_args, const mp_obj_t *args) +{ + lv_obj_t *cb = mp_to_lv(args[0]); + const char *txt = (char*)mp_obj_str_get_str(args[1]); + lv_cb_set_text(cb, txt); + return mp_const_none; +} + +STATIC MP_DEFINE_CONST_FUN_OBJ_VAR_BETWEEN(mp_lv_cb_set_text_obj, 2, 2, mp_lv_cb_set_text); + + + +/* + * lvgl extension definition for: + * void lv_cb_set_style(lv_obj_t *cb, lv_cb_style_t type, lv_style_t *style) + */ + +STATIC mp_obj_t mp_lv_cb_set_style(size_t n_args, const mp_obj_t *args) +{ + lv_obj_t *cb = mp_to_lv(args[0]); + lv_cb_style_t type = (uint8_t)mp_obj_get_int(args[1]); + lv_style_t *style = mp_write_ptr_lv_style_t(args[2]); + lv_cb_set_style(cb, type, style); + return mp_const_none; +} + +STATIC MP_DEFINE_CONST_FUN_OBJ_VAR_BETWEEN(mp_lv_cb_set_style_obj, 3, 3, mp_lv_cb_set_style); + + + +/* + * lvgl extension definition for: + * const char *lv_cb_get_text(const lv_obj_t *cb) + */ + +STATIC mp_obj_t mp_lv_cb_get_text(size_t n_args, const mp_obj_t *args) +{ + const lv_obj_t *cb = mp_to_lv(args[0]); + const char* res = lv_cb_get_text(cb); + return convert_to_str((void*)res); +} + +STATIC MP_DEFINE_CONST_FUN_OBJ_VAR_BETWEEN(mp_lv_cb_get_text_obj, 1, 1, mp_lv_cb_get_text); + + + +/* + * lvgl extension definition for: + * lv_style_t *lv_cb_get_style(const lv_obj_t *cb, lv_cb_style_t type) + */ + +STATIC mp_obj_t mp_lv_cb_get_style(size_t n_args, const mp_obj_t *args) +{ + const lv_obj_t *cb = mp_to_lv(args[0]); + lv_cb_style_t type = (uint8_t)mp_obj_get_int(args[1]); + lv_style_t* res = lv_cb_get_style(cb, type); + return mp_read_ptr_lv_style_t((void*)res); +} + +STATIC MP_DEFINE_CONST_FUN_OBJ_VAR_BETWEEN(mp_lv_cb_get_style_obj, 2, 2, mp_lv_cb_get_style); + + + +/* + * lvgl cb object definitions + */ + + +STATIC const mp_rom_map_elem_t cb_locals_dict_table[] = { + { MP_ROM_QSTR(MP_QSTR_set_checked), MP_ROM_PTR(&mp_lv_cb_set_checked_obj) }, + { MP_ROM_QSTR(MP_QSTR_set_inactive), MP_ROM_PTR(&mp_lv_cb_set_inactive_obj) }, + { MP_ROM_QSTR(MP_QSTR_set_action), MP_ROM_PTR(&mp_lv_cb_set_action_obj) }, + { MP_ROM_QSTR(MP_QSTR_is_checked), MP_ROM_PTR(&mp_lv_cb_is_checked_obj) }, + { MP_ROM_QSTR(MP_QSTR_get_action), MP_ROM_PTR(&mp_lv_cb_get_action_obj) }, + { MP_ROM_QSTR(MP_QSTR_set_text), MP_ROM_PTR(&mp_lv_cb_set_text_obj) }, + { MP_ROM_QSTR(MP_QSTR_set_style), MP_ROM_PTR(&mp_lv_cb_set_style_obj) }, + { MP_ROM_QSTR(MP_QSTR_get_text), MP_ROM_PTR(&mp_lv_cb_get_text_obj) }, + { MP_ROM_QSTR(MP_QSTR_get_style), MP_ROM_PTR(&mp_lv_cb_get_style_obj) }, + { MP_ROM_QSTR(MP_QSTR_delete), MP_ROM_PTR(&mp_lv_obj_del_obj) }, + { MP_ROM_QSTR(MP_QSTR_clean), MP_ROM_PTR(&mp_lv_obj_clean_obj) }, + { MP_ROM_QSTR(MP_QSTR_invalidate), MP_ROM_PTR(&mp_lv_obj_invalidate_obj) }, + { MP_ROM_QSTR(MP_QSTR_set_parent), MP_ROM_PTR(&mp_lv_obj_set_parent_obj) }, + { MP_ROM_QSTR(MP_QSTR_set_pos), MP_ROM_PTR(&mp_lv_obj_set_pos_obj) }, + { MP_ROM_QSTR(MP_QSTR_set_x), MP_ROM_PTR(&mp_lv_obj_set_x_obj) }, + { MP_ROM_QSTR(MP_QSTR_set_y), MP_ROM_PTR(&mp_lv_obj_set_y_obj) }, + { MP_ROM_QSTR(MP_QSTR_set_size), MP_ROM_PTR(&mp_lv_obj_set_size_obj) }, + { MP_ROM_QSTR(MP_QSTR_set_width), MP_ROM_PTR(&mp_lv_obj_set_width_obj) }, + { MP_ROM_QSTR(MP_QSTR_set_height), MP_ROM_PTR(&mp_lv_obj_set_height_obj) }, + { MP_ROM_QSTR(MP_QSTR_align), MP_ROM_PTR(&mp_lv_obj_align_obj) }, + { MP_ROM_QSTR(MP_QSTR_align_origo), MP_ROM_PTR(&mp_lv_obj_align_origo_obj) }, + { MP_ROM_QSTR(MP_QSTR_realign), MP_ROM_PTR(&mp_lv_obj_realign_obj) }, + { MP_ROM_QSTR(MP_QSTR_set_auto_realign), MP_ROM_PTR(&mp_lv_obj_set_auto_realign_obj) }, + { MP_ROM_QSTR(MP_QSTR_set_style), MP_ROM_PTR(&mp_lv_obj_set_style_obj) }, + { MP_ROM_QSTR(MP_QSTR_refresh_style), MP_ROM_PTR(&mp_lv_obj_refresh_style_obj) }, + { MP_ROM_QSTR(MP_QSTR_report_style_mod), MP_ROM_PTR(&mp_lv_obj_report_style_mod_obj) }, + { MP_ROM_QSTR(MP_QSTR_set_hidden), MP_ROM_PTR(&mp_lv_obj_set_hidden_obj) }, + { MP_ROM_QSTR(MP_QSTR_set_click), MP_ROM_PTR(&mp_lv_obj_set_click_obj) }, + { MP_ROM_QSTR(MP_QSTR_set_top), MP_ROM_PTR(&mp_lv_obj_set_top_obj) }, + { MP_ROM_QSTR(MP_QSTR_set_drag), MP_ROM_PTR(&mp_lv_obj_set_drag_obj) }, + { MP_ROM_QSTR(MP_QSTR_set_drag_throw), MP_ROM_PTR(&mp_lv_obj_set_drag_throw_obj) }, + { MP_ROM_QSTR(MP_QSTR_set_drag_parent), MP_ROM_PTR(&mp_lv_obj_set_drag_parent_obj) }, + { MP_ROM_QSTR(MP_QSTR_set_opa_scale_enable), MP_ROM_PTR(&mp_lv_obj_set_opa_scale_enable_obj) }, + { MP_ROM_QSTR(MP_QSTR_set_opa_scale), MP_ROM_PTR(&mp_lv_obj_set_opa_scale_obj) }, + { MP_ROM_QSTR(MP_QSTR_set_protect), MP_ROM_PTR(&mp_lv_obj_set_protect_obj) }, + { MP_ROM_QSTR(MP_QSTR_clear_protect), MP_ROM_PTR(&mp_lv_obj_clear_protect_obj) }, + { MP_ROM_QSTR(MP_QSTR_set_signal_func), MP_ROM_PTR(&mp_lv_obj_set_signal_func_obj) }, + { MP_ROM_QSTR(MP_QSTR_set_design_func), MP_ROM_PTR(&mp_lv_obj_set_design_func_obj) }, + { MP_ROM_QSTR(MP_QSTR_allocate_ext_attr), MP_ROM_PTR(&mp_lv_obj_allocate_ext_attr_obj) }, + { MP_ROM_QSTR(MP_QSTR_refresh_ext_size), MP_ROM_PTR(&mp_lv_obj_refresh_ext_size_obj) }, + { MP_ROM_QSTR(MP_QSTR_set_free_num), MP_ROM_PTR(&mp_lv_obj_set_free_num_obj) }, + { MP_ROM_QSTR(MP_QSTR_set_free_ptr), MP_ROM_PTR(&mp_lv_obj_set_free_ptr_obj) }, + { MP_ROM_QSTR(MP_QSTR_animate), MP_ROM_PTR(&mp_lv_obj_animate_obj) }, + { MP_ROM_QSTR(MP_QSTR_get_screen), MP_ROM_PTR(&mp_lv_obj_get_screen_obj) }, + { MP_ROM_QSTR(MP_QSTR_get_parent), MP_ROM_PTR(&mp_lv_obj_get_parent_obj) }, + { MP_ROM_QSTR(MP_QSTR_get_child), MP_ROM_PTR(&mp_lv_obj_get_child_obj) }, + { MP_ROM_QSTR(MP_QSTR_get_child_back), MP_ROM_PTR(&mp_lv_obj_get_child_back_obj) }, + { MP_ROM_QSTR(MP_QSTR_count_children), MP_ROM_PTR(&mp_lv_obj_count_children_obj) }, + { MP_ROM_QSTR(MP_QSTR_get_coords), MP_ROM_PTR(&mp_lv_obj_get_coords_obj) }, + { MP_ROM_QSTR(MP_QSTR_get_x), MP_ROM_PTR(&mp_lv_obj_get_x_obj) }, + { MP_ROM_QSTR(MP_QSTR_get_y), MP_ROM_PTR(&mp_lv_obj_get_y_obj) }, + { MP_ROM_QSTR(MP_QSTR_get_width), MP_ROM_PTR(&mp_lv_obj_get_width_obj) }, + { MP_ROM_QSTR(MP_QSTR_get_height), MP_ROM_PTR(&mp_lv_obj_get_height_obj) }, + { MP_ROM_QSTR(MP_QSTR_get_ext_size), MP_ROM_PTR(&mp_lv_obj_get_ext_size_obj) }, + { MP_ROM_QSTR(MP_QSTR_get_auto_realign), MP_ROM_PTR(&mp_lv_obj_get_auto_realign_obj) }, + { MP_ROM_QSTR(MP_QSTR_get_style), MP_ROM_PTR(&mp_lv_obj_get_style_obj) }, + { MP_ROM_QSTR(MP_QSTR_get_hidden), MP_ROM_PTR(&mp_lv_obj_get_hidden_obj) }, + { MP_ROM_QSTR(MP_QSTR_get_click), MP_ROM_PTR(&mp_lv_obj_get_click_obj) }, + { MP_ROM_QSTR(MP_QSTR_get_top), MP_ROM_PTR(&mp_lv_obj_get_top_obj) }, + { MP_ROM_QSTR(MP_QSTR_get_drag), MP_ROM_PTR(&mp_lv_obj_get_drag_obj) }, + { MP_ROM_QSTR(MP_QSTR_get_drag_throw), MP_ROM_PTR(&mp_lv_obj_get_drag_throw_obj) }, + { MP_ROM_QSTR(MP_QSTR_get_drag_parent), MP_ROM_PTR(&mp_lv_obj_get_drag_parent_obj) }, + { MP_ROM_QSTR(MP_QSTR_get_opa_scale_enable), MP_ROM_PTR(&mp_lv_obj_get_opa_scale_enable_obj) }, + { MP_ROM_QSTR(MP_QSTR_get_opa_scale), MP_ROM_PTR(&mp_lv_obj_get_opa_scale_obj) }, + { MP_ROM_QSTR(MP_QSTR_get_protect), MP_ROM_PTR(&mp_lv_obj_get_protect_obj) }, + { MP_ROM_QSTR(MP_QSTR_is_protected), MP_ROM_PTR(&mp_lv_obj_is_protected_obj) }, + { MP_ROM_QSTR(MP_QSTR_get_signal_func), MP_ROM_PTR(&mp_lv_obj_get_signal_func_obj) }, + { MP_ROM_QSTR(MP_QSTR_get_design_func), MP_ROM_PTR(&mp_lv_obj_get_design_func_obj) }, + { MP_ROM_QSTR(MP_QSTR_get_ext_attr), MP_ROM_PTR(&mp_lv_obj_get_ext_attr_obj) }, + { MP_ROM_QSTR(MP_QSTR_get_free_num), MP_ROM_PTR(&mp_lv_obj_get_free_num_obj) }, + { MP_ROM_QSTR(MP_QSTR_get_free_ptr), MP_ROM_PTR(&mp_lv_obj_get_free_ptr_obj) }, + { MP_ROM_QSTR(MP_QSTR_get_group), MP_ROM_PTR(&mp_lv_obj_get_group_obj) }, + { MP_ROM_QSTR(MP_QSTR_is_focused), MP_ROM_PTR(&mp_lv_obj_is_focused_obj) }, + { MP_ROM_QSTR(MP_QSTR_STYLE), MP_ROM_PTR(&mp_LV_CB_STYLE_type) } +}; + +STATIC MP_DEFINE_CONST_DICT(cb_locals_dict, cb_locals_dict_table); + +STATIC void cb_print(const mp_print_t *print, + mp_obj_t self_in, + mp_print_kind_t kind) +{ + mp_printf(print, "lvgl cb"); +} + + +STATIC mp_obj_t cb_make_new( + const mp_obj_type_t *type, + size_t n_args, + size_t n_kw, + const mp_obj_t *args) +{ + return make_new(&lv_cb_create, type, n_args, n_kw, args); +} + + +STATIC const mp_obj_type_t mp_cb_type = { + { &mp_type_type }, + .name = MP_QSTR_cb, + .print = cb_print, + .make_new = cb_make_new, + .locals_dict = (mp_obj_dict_t*)&cb_locals_dict, +}; + + +/* + * lvgl extension definition for: + * void lv_bar_set_value(lv_obj_t *bar, int16_t value) + */ + +STATIC mp_obj_t mp_lv_bar_set_value(size_t n_args, const mp_obj_t *args) +{ + lv_obj_t *bar = mp_to_lv(args[0]); + int16_t value = (int16_t)mp_obj_get_int(args[1]); + lv_bar_set_value(bar, value); + return mp_const_none; +} + +STATIC MP_DEFINE_CONST_FUN_OBJ_VAR_BETWEEN(mp_lv_bar_set_value_obj, 2, 2, mp_lv_bar_set_value); + + + +/* + * lvgl extension definition for: + * void lv_bar_set_value_anim(lv_obj_t *bar, int16_t value, uint16_t anim_time) + */ + +STATIC mp_obj_t mp_lv_bar_set_value_anim(size_t n_args, const mp_obj_t *args) +{ + lv_obj_t *bar = mp_to_lv(args[0]); + int16_t value = (int16_t)mp_obj_get_int(args[1]); + uint16_t anim_time = (uint16_t)mp_obj_get_int(args[2]); + lv_bar_set_value_anim(bar, value, anim_time); + return mp_const_none; +} + +STATIC MP_DEFINE_CONST_FUN_OBJ_VAR_BETWEEN(mp_lv_bar_set_value_anim_obj, 3, 3, mp_lv_bar_set_value_anim); + + + +/* + * lvgl extension definition for: + * void lv_bar_set_range(lv_obj_t *bar, int16_t min, int16_t max) + */ + +STATIC mp_obj_t mp_lv_bar_set_range(size_t n_args, const mp_obj_t *args) +{ + lv_obj_t *bar = mp_to_lv(args[0]); + int16_t min = (int16_t)mp_obj_get_int(args[1]); + int16_t max = (int16_t)mp_obj_get_int(args[2]); + lv_bar_set_range(bar, min, max); + return mp_const_none; +} + +STATIC MP_DEFINE_CONST_FUN_OBJ_VAR_BETWEEN(mp_lv_bar_set_range_obj, 3, 3, mp_lv_bar_set_range); + + + +/* + * lvgl extension definition for: + * void lv_bar_set_sym(lv_obj_t *bar, bool en) + */ + +STATIC mp_obj_t mp_lv_bar_set_sym(size_t n_args, const mp_obj_t *args) +{ + lv_obj_t *bar = mp_to_lv(args[0]); + bool en = mp_obj_is_true(args[1]); + lv_bar_set_sym(bar, en); + return mp_const_none; +} + +STATIC MP_DEFINE_CONST_FUN_OBJ_VAR_BETWEEN(mp_lv_bar_set_sym_obj, 2, 2, mp_lv_bar_set_sym); + + + +/* + * lvgl extension definition for: + * void lv_bar_set_style(lv_obj_t *bar, lv_bar_style_t type, lv_style_t *style) + */ + +STATIC mp_obj_t mp_lv_bar_set_style(size_t n_args, const mp_obj_t *args) +{ + lv_obj_t *bar = mp_to_lv(args[0]); + lv_bar_style_t type = (uint8_t)mp_obj_get_int(args[1]); + lv_style_t *style = mp_write_ptr_lv_style_t(args[2]); + lv_bar_set_style(bar, type, style); + return mp_const_none; +} + +STATIC MP_DEFINE_CONST_FUN_OBJ_VAR_BETWEEN(mp_lv_bar_set_style_obj, 3, 3, mp_lv_bar_set_style); + + + +/* + * lvgl extension definition for: + * int16_t lv_bar_get_value(const lv_obj_t *bar) + */ + +STATIC mp_obj_t mp_lv_bar_get_value(size_t n_args, const mp_obj_t *args) +{ + const lv_obj_t *bar = mp_to_lv(args[0]); + int16_t res = lv_bar_get_value(bar); + return mp_obj_new_int(res); +} + +STATIC MP_DEFINE_CONST_FUN_OBJ_VAR_BETWEEN(mp_lv_bar_get_value_obj, 1, 1, mp_lv_bar_get_value); + + + +/* + * lvgl extension definition for: + * int16_t lv_bar_get_min_value(const lv_obj_t *bar) + */ + +STATIC mp_obj_t mp_lv_bar_get_min_value(size_t n_args, const mp_obj_t *args) +{ + const lv_obj_t *bar = mp_to_lv(args[0]); + int16_t res = lv_bar_get_min_value(bar); + return mp_obj_new_int(res); +} + +STATIC MP_DEFINE_CONST_FUN_OBJ_VAR_BETWEEN(mp_lv_bar_get_min_value_obj, 1, 1, mp_lv_bar_get_min_value); + + + +/* + * lvgl extension definition for: + * int16_t lv_bar_get_max_value(const lv_obj_t *bar) + */ + +STATIC mp_obj_t mp_lv_bar_get_max_value(size_t n_args, const mp_obj_t *args) +{ + const lv_obj_t *bar = mp_to_lv(args[0]); + int16_t res = lv_bar_get_max_value(bar); + return mp_obj_new_int(res); +} + +STATIC MP_DEFINE_CONST_FUN_OBJ_VAR_BETWEEN(mp_lv_bar_get_max_value_obj, 1, 1, mp_lv_bar_get_max_value); + + + +/* + * lvgl extension definition for: + * bool lv_bar_get_sym(lv_obj_t *bar) + */ + +STATIC mp_obj_t mp_lv_bar_get_sym(size_t n_args, const mp_obj_t *args) +{ + lv_obj_t *bar = mp_to_lv(args[0]); + bool res = lv_bar_get_sym(bar); + return convert_to_bool(res); +} + +STATIC MP_DEFINE_CONST_FUN_OBJ_VAR_BETWEEN(mp_lv_bar_get_sym_obj, 1, 1, mp_lv_bar_get_sym); + + + +/* + * lvgl extension definition for: + * lv_style_t *lv_bar_get_style(const lv_obj_t *bar, lv_bar_style_t type) + */ + +STATIC mp_obj_t mp_lv_bar_get_style(size_t n_args, const mp_obj_t *args) +{ + const lv_obj_t *bar = mp_to_lv(args[0]); + lv_bar_style_t type = (uint8_t)mp_obj_get_int(args[1]); + lv_style_t* res = lv_bar_get_style(bar, type); + return mp_read_ptr_lv_style_t((void*)res); +} + +STATIC MP_DEFINE_CONST_FUN_OBJ_VAR_BETWEEN(mp_lv_bar_get_style_obj, 2, 2, mp_lv_bar_get_style); + + + +/* + * lvgl bar object definitions + */ + + +STATIC const mp_rom_map_elem_t bar_locals_dict_table[] = { + { MP_ROM_QSTR(MP_QSTR_set_value), MP_ROM_PTR(&mp_lv_bar_set_value_obj) }, + { MP_ROM_QSTR(MP_QSTR_set_value_anim), MP_ROM_PTR(&mp_lv_bar_set_value_anim_obj) }, + { MP_ROM_QSTR(MP_QSTR_set_range), MP_ROM_PTR(&mp_lv_bar_set_range_obj) }, + { MP_ROM_QSTR(MP_QSTR_set_sym), MP_ROM_PTR(&mp_lv_bar_set_sym_obj) }, + { MP_ROM_QSTR(MP_QSTR_set_style), MP_ROM_PTR(&mp_lv_bar_set_style_obj) }, + { MP_ROM_QSTR(MP_QSTR_get_value), MP_ROM_PTR(&mp_lv_bar_get_value_obj) }, + { MP_ROM_QSTR(MP_QSTR_get_min_value), MP_ROM_PTR(&mp_lv_bar_get_min_value_obj) }, + { MP_ROM_QSTR(MP_QSTR_get_max_value), MP_ROM_PTR(&mp_lv_bar_get_max_value_obj) }, + { MP_ROM_QSTR(MP_QSTR_get_sym), MP_ROM_PTR(&mp_lv_bar_get_sym_obj) }, + { MP_ROM_QSTR(MP_QSTR_get_style), MP_ROM_PTR(&mp_lv_bar_get_style_obj) }, + { MP_ROM_QSTR(MP_QSTR_delete), MP_ROM_PTR(&mp_lv_obj_del_obj) }, + { MP_ROM_QSTR(MP_QSTR_clean), MP_ROM_PTR(&mp_lv_obj_clean_obj) }, + { MP_ROM_QSTR(MP_QSTR_invalidate), MP_ROM_PTR(&mp_lv_obj_invalidate_obj) }, + { MP_ROM_QSTR(MP_QSTR_set_parent), MP_ROM_PTR(&mp_lv_obj_set_parent_obj) }, + { MP_ROM_QSTR(MP_QSTR_set_pos), MP_ROM_PTR(&mp_lv_obj_set_pos_obj) }, + { MP_ROM_QSTR(MP_QSTR_set_x), MP_ROM_PTR(&mp_lv_obj_set_x_obj) }, + { MP_ROM_QSTR(MP_QSTR_set_y), MP_ROM_PTR(&mp_lv_obj_set_y_obj) }, + { MP_ROM_QSTR(MP_QSTR_set_size), MP_ROM_PTR(&mp_lv_obj_set_size_obj) }, + { MP_ROM_QSTR(MP_QSTR_set_width), MP_ROM_PTR(&mp_lv_obj_set_width_obj) }, + { MP_ROM_QSTR(MP_QSTR_set_height), MP_ROM_PTR(&mp_lv_obj_set_height_obj) }, + { MP_ROM_QSTR(MP_QSTR_align), MP_ROM_PTR(&mp_lv_obj_align_obj) }, + { MP_ROM_QSTR(MP_QSTR_align_origo), MP_ROM_PTR(&mp_lv_obj_align_origo_obj) }, + { MP_ROM_QSTR(MP_QSTR_realign), MP_ROM_PTR(&mp_lv_obj_realign_obj) }, + { MP_ROM_QSTR(MP_QSTR_set_auto_realign), MP_ROM_PTR(&mp_lv_obj_set_auto_realign_obj) }, + { MP_ROM_QSTR(MP_QSTR_set_style), MP_ROM_PTR(&mp_lv_obj_set_style_obj) }, + { MP_ROM_QSTR(MP_QSTR_refresh_style), MP_ROM_PTR(&mp_lv_obj_refresh_style_obj) }, + { MP_ROM_QSTR(MP_QSTR_report_style_mod), MP_ROM_PTR(&mp_lv_obj_report_style_mod_obj) }, + { MP_ROM_QSTR(MP_QSTR_set_hidden), MP_ROM_PTR(&mp_lv_obj_set_hidden_obj) }, + { MP_ROM_QSTR(MP_QSTR_set_click), MP_ROM_PTR(&mp_lv_obj_set_click_obj) }, + { MP_ROM_QSTR(MP_QSTR_set_top), MP_ROM_PTR(&mp_lv_obj_set_top_obj) }, + { MP_ROM_QSTR(MP_QSTR_set_drag), MP_ROM_PTR(&mp_lv_obj_set_drag_obj) }, + { MP_ROM_QSTR(MP_QSTR_set_drag_throw), MP_ROM_PTR(&mp_lv_obj_set_drag_throw_obj) }, + { MP_ROM_QSTR(MP_QSTR_set_drag_parent), MP_ROM_PTR(&mp_lv_obj_set_drag_parent_obj) }, + { MP_ROM_QSTR(MP_QSTR_set_opa_scale_enable), MP_ROM_PTR(&mp_lv_obj_set_opa_scale_enable_obj) }, + { MP_ROM_QSTR(MP_QSTR_set_opa_scale), MP_ROM_PTR(&mp_lv_obj_set_opa_scale_obj) }, + { MP_ROM_QSTR(MP_QSTR_set_protect), MP_ROM_PTR(&mp_lv_obj_set_protect_obj) }, + { MP_ROM_QSTR(MP_QSTR_clear_protect), MP_ROM_PTR(&mp_lv_obj_clear_protect_obj) }, + { MP_ROM_QSTR(MP_QSTR_set_signal_func), MP_ROM_PTR(&mp_lv_obj_set_signal_func_obj) }, + { MP_ROM_QSTR(MP_QSTR_set_design_func), MP_ROM_PTR(&mp_lv_obj_set_design_func_obj) }, + { MP_ROM_QSTR(MP_QSTR_allocate_ext_attr), MP_ROM_PTR(&mp_lv_obj_allocate_ext_attr_obj) }, + { MP_ROM_QSTR(MP_QSTR_refresh_ext_size), MP_ROM_PTR(&mp_lv_obj_refresh_ext_size_obj) }, + { MP_ROM_QSTR(MP_QSTR_set_free_num), MP_ROM_PTR(&mp_lv_obj_set_free_num_obj) }, + { MP_ROM_QSTR(MP_QSTR_set_free_ptr), MP_ROM_PTR(&mp_lv_obj_set_free_ptr_obj) }, + { MP_ROM_QSTR(MP_QSTR_animate), MP_ROM_PTR(&mp_lv_obj_animate_obj) }, + { MP_ROM_QSTR(MP_QSTR_get_screen), MP_ROM_PTR(&mp_lv_obj_get_screen_obj) }, + { MP_ROM_QSTR(MP_QSTR_get_parent), MP_ROM_PTR(&mp_lv_obj_get_parent_obj) }, + { MP_ROM_QSTR(MP_QSTR_get_child), MP_ROM_PTR(&mp_lv_obj_get_child_obj) }, + { MP_ROM_QSTR(MP_QSTR_get_child_back), MP_ROM_PTR(&mp_lv_obj_get_child_back_obj) }, + { MP_ROM_QSTR(MP_QSTR_count_children), MP_ROM_PTR(&mp_lv_obj_count_children_obj) }, + { MP_ROM_QSTR(MP_QSTR_get_coords), MP_ROM_PTR(&mp_lv_obj_get_coords_obj) }, + { MP_ROM_QSTR(MP_QSTR_get_x), MP_ROM_PTR(&mp_lv_obj_get_x_obj) }, + { MP_ROM_QSTR(MP_QSTR_get_y), MP_ROM_PTR(&mp_lv_obj_get_y_obj) }, + { MP_ROM_QSTR(MP_QSTR_get_width), MP_ROM_PTR(&mp_lv_obj_get_width_obj) }, + { MP_ROM_QSTR(MP_QSTR_get_height), MP_ROM_PTR(&mp_lv_obj_get_height_obj) }, + { MP_ROM_QSTR(MP_QSTR_get_ext_size), MP_ROM_PTR(&mp_lv_obj_get_ext_size_obj) }, + { MP_ROM_QSTR(MP_QSTR_get_auto_realign), MP_ROM_PTR(&mp_lv_obj_get_auto_realign_obj) }, + { MP_ROM_QSTR(MP_QSTR_get_style), MP_ROM_PTR(&mp_lv_obj_get_style_obj) }, + { MP_ROM_QSTR(MP_QSTR_get_hidden), MP_ROM_PTR(&mp_lv_obj_get_hidden_obj) }, + { MP_ROM_QSTR(MP_QSTR_get_click), MP_ROM_PTR(&mp_lv_obj_get_click_obj) }, + { MP_ROM_QSTR(MP_QSTR_get_top), MP_ROM_PTR(&mp_lv_obj_get_top_obj) }, + { MP_ROM_QSTR(MP_QSTR_get_drag), MP_ROM_PTR(&mp_lv_obj_get_drag_obj) }, + { MP_ROM_QSTR(MP_QSTR_get_drag_throw), MP_ROM_PTR(&mp_lv_obj_get_drag_throw_obj) }, + { MP_ROM_QSTR(MP_QSTR_get_drag_parent), MP_ROM_PTR(&mp_lv_obj_get_drag_parent_obj) }, + { MP_ROM_QSTR(MP_QSTR_get_opa_scale_enable), MP_ROM_PTR(&mp_lv_obj_get_opa_scale_enable_obj) }, + { MP_ROM_QSTR(MP_QSTR_get_opa_scale), MP_ROM_PTR(&mp_lv_obj_get_opa_scale_obj) }, + { MP_ROM_QSTR(MP_QSTR_get_protect), MP_ROM_PTR(&mp_lv_obj_get_protect_obj) }, + { MP_ROM_QSTR(MP_QSTR_is_protected), MP_ROM_PTR(&mp_lv_obj_is_protected_obj) }, + { MP_ROM_QSTR(MP_QSTR_get_signal_func), MP_ROM_PTR(&mp_lv_obj_get_signal_func_obj) }, + { MP_ROM_QSTR(MP_QSTR_get_design_func), MP_ROM_PTR(&mp_lv_obj_get_design_func_obj) }, + { MP_ROM_QSTR(MP_QSTR_get_ext_attr), MP_ROM_PTR(&mp_lv_obj_get_ext_attr_obj) }, + { MP_ROM_QSTR(MP_QSTR_get_free_num), MP_ROM_PTR(&mp_lv_obj_get_free_num_obj) }, + { MP_ROM_QSTR(MP_QSTR_get_free_ptr), MP_ROM_PTR(&mp_lv_obj_get_free_ptr_obj) }, + { MP_ROM_QSTR(MP_QSTR_get_group), MP_ROM_PTR(&mp_lv_obj_get_group_obj) }, + { MP_ROM_QSTR(MP_QSTR_is_focused), MP_ROM_PTR(&mp_lv_obj_is_focused_obj) }, + { MP_ROM_QSTR(MP_QSTR_STYLE), MP_ROM_PTR(&mp_LV_BAR_STYLE_type) } +}; + +STATIC MP_DEFINE_CONST_DICT(bar_locals_dict, bar_locals_dict_table); + +STATIC void bar_print(const mp_print_t *print, + mp_obj_t self_in, + mp_print_kind_t kind) +{ + mp_printf(print, "lvgl bar"); +} + + +STATIC mp_obj_t bar_make_new( + const mp_obj_type_t *type, + size_t n_args, + size_t n_kw, + const mp_obj_t *args) +{ + return make_new(&lv_bar_create, type, n_args, n_kw, args); +} + + +STATIC const mp_obj_type_t mp_bar_type = { + { &mp_type_type }, + .name = MP_QSTR_bar, + .print = bar_print, + .make_new = bar_make_new, + .locals_dict = (mp_obj_dict_t*)&bar_locals_dict, +}; + + +/* + * lvgl extension definition for: + * inline static void lv_slider_set_value(lv_obj_t *slider, int16_t value) + */ + +STATIC mp_obj_t mp_lv_slider_set_value(size_t n_args, const mp_obj_t *args) +{ + lv_obj_t *slider = mp_to_lv(args[0]); + int16_t value = (int16_t)mp_obj_get_int(args[1]); + lv_slider_set_value(slider, value); + return mp_const_none; +} + +STATIC MP_DEFINE_CONST_FUN_OBJ_VAR_BETWEEN(mp_lv_slider_set_value_obj, 2, 2, mp_lv_slider_set_value); + + + +/* + * lvgl extension definition for: + * inline static void lv_slider_set_value_anim(lv_obj_t *slider, int16_t value, uint16_t anim_time) + */ + +STATIC mp_obj_t mp_lv_slider_set_value_anim(size_t n_args, const mp_obj_t *args) +{ + lv_obj_t *slider = mp_to_lv(args[0]); + int16_t value = (int16_t)mp_obj_get_int(args[1]); + uint16_t anim_time = (uint16_t)mp_obj_get_int(args[2]); + lv_slider_set_value_anim(slider, value, anim_time); + return mp_const_none; +} + +STATIC MP_DEFINE_CONST_FUN_OBJ_VAR_BETWEEN(mp_lv_slider_set_value_anim_obj, 3, 3, mp_lv_slider_set_value_anim); + + + +/* + * lvgl extension definition for: + * inline static void lv_slider_set_range(lv_obj_t *slider, int16_t min, int16_t max) + */ + +STATIC mp_obj_t mp_lv_slider_set_range(size_t n_args, const mp_obj_t *args) +{ + lv_obj_t *slider = mp_to_lv(args[0]); + int16_t min = (int16_t)mp_obj_get_int(args[1]); + int16_t max = (int16_t)mp_obj_get_int(args[2]); + lv_slider_set_range(slider, min, max); + return mp_const_none; +} + +STATIC MP_DEFINE_CONST_FUN_OBJ_VAR_BETWEEN(mp_lv_slider_set_range_obj, 3, 3, mp_lv_slider_set_range); + + + +/* + * lvgl extension definition for: + * inline static int16_t lv_slider_get_min_value(const lv_obj_t *slider) + */ + +STATIC mp_obj_t mp_lv_slider_get_min_value(size_t n_args, const mp_obj_t *args) +{ + const lv_obj_t *slider = mp_to_lv(args[0]); + int16_t res = lv_slider_get_min_value(slider); + return mp_obj_new_int(res); +} + +STATIC MP_DEFINE_CONST_FUN_OBJ_VAR_BETWEEN(mp_lv_slider_get_min_value_obj, 1, 1, mp_lv_slider_get_min_value); + + + +/* + * lvgl extension definition for: + * inline static int16_t lv_slider_get_max_value(const lv_obj_t *slider) + */ + +STATIC mp_obj_t mp_lv_slider_get_max_value(size_t n_args, const mp_obj_t *args) +{ + const lv_obj_t *slider = mp_to_lv(args[0]); + int16_t res = lv_slider_get_max_value(slider); + return mp_obj_new_int(res); +} + +STATIC MP_DEFINE_CONST_FUN_OBJ_VAR_BETWEEN(mp_lv_slider_get_max_value_obj, 1, 1, mp_lv_slider_get_max_value); + + + +/* + * lvgl extension definition for: + * void lv_slider_set_action(lv_obj_t *slider, lv_action_t action) + */ + +STATIC mp_obj_t mp_lv_slider_set_action(size_t n_args, const mp_obj_t *args) +{ + lv_obj_t *slider = mp_to_lv(args[0]); + set_action(args[0], args[1]); + lv_action_t action = &lv_action_t_callback; + lv_slider_set_action(slider, action); + return mp_const_none; +} + +STATIC MP_DEFINE_CONST_FUN_OBJ_VAR_BETWEEN(mp_lv_slider_set_action_obj, 2, 2, mp_lv_slider_set_action); + + + +/* + * lvgl extension definition for: + * void lv_slider_set_knob_in(lv_obj_t *slider, bool in) + */ + +STATIC mp_obj_t mp_lv_slider_set_knob_in(size_t n_args, const mp_obj_t *args) +{ + lv_obj_t *slider = mp_to_lv(args[0]); + bool in = mp_obj_is_true(args[1]); + lv_slider_set_knob_in(slider, in); + return mp_const_none; +} + +STATIC MP_DEFINE_CONST_FUN_OBJ_VAR_BETWEEN(mp_lv_slider_set_knob_in_obj, 2, 2, mp_lv_slider_set_knob_in); + + + +/* + * lvgl extension definition for: + * void lv_slider_set_style(lv_obj_t *slider, lv_slider_style_t type, lv_style_t *style) + */ + +STATIC mp_obj_t mp_lv_slider_set_style(size_t n_args, const mp_obj_t *args) +{ + lv_obj_t *slider = mp_to_lv(args[0]); + lv_slider_style_t type = (uint8_t)mp_obj_get_int(args[1]); + lv_style_t *style = mp_write_ptr_lv_style_t(args[2]); + lv_slider_set_style(slider, type, style); + return mp_const_none; +} + +STATIC MP_DEFINE_CONST_FUN_OBJ_VAR_BETWEEN(mp_lv_slider_set_style_obj, 3, 3, mp_lv_slider_set_style); + + + +/* + * lvgl extension definition for: + * int16_t lv_slider_get_value(const lv_obj_t *slider) + */ + +STATIC mp_obj_t mp_lv_slider_get_value(size_t n_args, const mp_obj_t *args) +{ + const lv_obj_t *slider = mp_to_lv(args[0]); + int16_t res = lv_slider_get_value(slider); + return mp_obj_new_int(res); +} + +STATIC MP_DEFINE_CONST_FUN_OBJ_VAR_BETWEEN(mp_lv_slider_get_value_obj, 1, 1, mp_lv_slider_get_value); + + + +/* + * lvgl extension definition for: + * lv_action_t lv_slider_get_action(const lv_obj_t *slider) + */ + +STATIC mp_obj_t mp_lv_slider_get_action(size_t n_args, const mp_obj_t *args) +{ + const lv_obj_t *slider = mp_to_lv(args[0]); + lv_action_t res = lv_slider_get_action(slider); + return ptr_to_mp(res); +} + +STATIC MP_DEFINE_CONST_FUN_OBJ_VAR_BETWEEN(mp_lv_slider_get_action_obj, 1, 1, mp_lv_slider_get_action); + + + +/* + * lvgl extension definition for: + * bool lv_slider_is_dragged(const lv_obj_t *slider) + */ + +STATIC mp_obj_t mp_lv_slider_is_dragged(size_t n_args, const mp_obj_t *args) +{ + const lv_obj_t *slider = mp_to_lv(args[0]); + bool res = lv_slider_is_dragged(slider); + return convert_to_bool(res); +} + +STATIC MP_DEFINE_CONST_FUN_OBJ_VAR_BETWEEN(mp_lv_slider_is_dragged_obj, 1, 1, mp_lv_slider_is_dragged); + + + +/* + * lvgl extension definition for: + * bool lv_slider_get_knob_in(const lv_obj_t *slider) + */ + +STATIC mp_obj_t mp_lv_slider_get_knob_in(size_t n_args, const mp_obj_t *args) +{ + const lv_obj_t *slider = mp_to_lv(args[0]); + bool res = lv_slider_get_knob_in(slider); + return convert_to_bool(res); +} + +STATIC MP_DEFINE_CONST_FUN_OBJ_VAR_BETWEEN(mp_lv_slider_get_knob_in_obj, 1, 1, mp_lv_slider_get_knob_in); + + + +/* + * lvgl extension definition for: + * lv_style_t *lv_slider_get_style(const lv_obj_t *slider, lv_slider_style_t type) + */ + +STATIC mp_obj_t mp_lv_slider_get_style(size_t n_args, const mp_obj_t *args) +{ + const lv_obj_t *slider = mp_to_lv(args[0]); + lv_slider_style_t type = (uint8_t)mp_obj_get_int(args[1]); + lv_style_t* res = lv_slider_get_style(slider, type); + return mp_read_ptr_lv_style_t((void*)res); +} + +STATIC MP_DEFINE_CONST_FUN_OBJ_VAR_BETWEEN(mp_lv_slider_get_style_obj, 2, 2, mp_lv_slider_get_style); + + + +/* + * lvgl slider object definitions + */ + + +STATIC const mp_rom_map_elem_t slider_locals_dict_table[] = { + { MP_ROM_QSTR(MP_QSTR_set_value), MP_ROM_PTR(&mp_lv_slider_set_value_obj) }, + { MP_ROM_QSTR(MP_QSTR_set_value_anim), MP_ROM_PTR(&mp_lv_slider_set_value_anim_obj) }, + { MP_ROM_QSTR(MP_QSTR_set_range), MP_ROM_PTR(&mp_lv_slider_set_range_obj) }, + { MP_ROM_QSTR(MP_QSTR_get_min_value), MP_ROM_PTR(&mp_lv_slider_get_min_value_obj) }, + { MP_ROM_QSTR(MP_QSTR_get_max_value), MP_ROM_PTR(&mp_lv_slider_get_max_value_obj) }, + { MP_ROM_QSTR(MP_QSTR_set_action), MP_ROM_PTR(&mp_lv_slider_set_action_obj) }, + { MP_ROM_QSTR(MP_QSTR_set_knob_in), MP_ROM_PTR(&mp_lv_slider_set_knob_in_obj) }, + { MP_ROM_QSTR(MP_QSTR_set_style), MP_ROM_PTR(&mp_lv_slider_set_style_obj) }, + { MP_ROM_QSTR(MP_QSTR_get_value), MP_ROM_PTR(&mp_lv_slider_get_value_obj) }, + { MP_ROM_QSTR(MP_QSTR_get_action), MP_ROM_PTR(&mp_lv_slider_get_action_obj) }, + { MP_ROM_QSTR(MP_QSTR_is_dragged), MP_ROM_PTR(&mp_lv_slider_is_dragged_obj) }, + { MP_ROM_QSTR(MP_QSTR_get_knob_in), MP_ROM_PTR(&mp_lv_slider_get_knob_in_obj) }, + { MP_ROM_QSTR(MP_QSTR_get_style), MP_ROM_PTR(&mp_lv_slider_get_style_obj) }, + { MP_ROM_QSTR(MP_QSTR_delete), MP_ROM_PTR(&mp_lv_obj_del_obj) }, + { MP_ROM_QSTR(MP_QSTR_clean), MP_ROM_PTR(&mp_lv_obj_clean_obj) }, + { MP_ROM_QSTR(MP_QSTR_invalidate), MP_ROM_PTR(&mp_lv_obj_invalidate_obj) }, + { MP_ROM_QSTR(MP_QSTR_set_parent), MP_ROM_PTR(&mp_lv_obj_set_parent_obj) }, + { MP_ROM_QSTR(MP_QSTR_set_pos), MP_ROM_PTR(&mp_lv_obj_set_pos_obj) }, + { MP_ROM_QSTR(MP_QSTR_set_x), MP_ROM_PTR(&mp_lv_obj_set_x_obj) }, + { MP_ROM_QSTR(MP_QSTR_set_y), MP_ROM_PTR(&mp_lv_obj_set_y_obj) }, + { MP_ROM_QSTR(MP_QSTR_set_size), MP_ROM_PTR(&mp_lv_obj_set_size_obj) }, + { MP_ROM_QSTR(MP_QSTR_set_width), MP_ROM_PTR(&mp_lv_obj_set_width_obj) }, + { MP_ROM_QSTR(MP_QSTR_set_height), MP_ROM_PTR(&mp_lv_obj_set_height_obj) }, + { MP_ROM_QSTR(MP_QSTR_align), MP_ROM_PTR(&mp_lv_obj_align_obj) }, + { MP_ROM_QSTR(MP_QSTR_align_origo), MP_ROM_PTR(&mp_lv_obj_align_origo_obj) }, + { MP_ROM_QSTR(MP_QSTR_realign), MP_ROM_PTR(&mp_lv_obj_realign_obj) }, + { MP_ROM_QSTR(MP_QSTR_set_auto_realign), MP_ROM_PTR(&mp_lv_obj_set_auto_realign_obj) }, + { MP_ROM_QSTR(MP_QSTR_set_style), MP_ROM_PTR(&mp_lv_obj_set_style_obj) }, + { MP_ROM_QSTR(MP_QSTR_refresh_style), MP_ROM_PTR(&mp_lv_obj_refresh_style_obj) }, + { MP_ROM_QSTR(MP_QSTR_report_style_mod), MP_ROM_PTR(&mp_lv_obj_report_style_mod_obj) }, + { MP_ROM_QSTR(MP_QSTR_set_hidden), MP_ROM_PTR(&mp_lv_obj_set_hidden_obj) }, + { MP_ROM_QSTR(MP_QSTR_set_click), MP_ROM_PTR(&mp_lv_obj_set_click_obj) }, + { MP_ROM_QSTR(MP_QSTR_set_top), MP_ROM_PTR(&mp_lv_obj_set_top_obj) }, + { MP_ROM_QSTR(MP_QSTR_set_drag), MP_ROM_PTR(&mp_lv_obj_set_drag_obj) }, + { MP_ROM_QSTR(MP_QSTR_set_drag_throw), MP_ROM_PTR(&mp_lv_obj_set_drag_throw_obj) }, + { MP_ROM_QSTR(MP_QSTR_set_drag_parent), MP_ROM_PTR(&mp_lv_obj_set_drag_parent_obj) }, + { MP_ROM_QSTR(MP_QSTR_set_opa_scale_enable), MP_ROM_PTR(&mp_lv_obj_set_opa_scale_enable_obj) }, + { MP_ROM_QSTR(MP_QSTR_set_opa_scale), MP_ROM_PTR(&mp_lv_obj_set_opa_scale_obj) }, + { MP_ROM_QSTR(MP_QSTR_set_protect), MP_ROM_PTR(&mp_lv_obj_set_protect_obj) }, + { MP_ROM_QSTR(MP_QSTR_clear_protect), MP_ROM_PTR(&mp_lv_obj_clear_protect_obj) }, + { MP_ROM_QSTR(MP_QSTR_set_signal_func), MP_ROM_PTR(&mp_lv_obj_set_signal_func_obj) }, + { MP_ROM_QSTR(MP_QSTR_set_design_func), MP_ROM_PTR(&mp_lv_obj_set_design_func_obj) }, + { MP_ROM_QSTR(MP_QSTR_allocate_ext_attr), MP_ROM_PTR(&mp_lv_obj_allocate_ext_attr_obj) }, + { MP_ROM_QSTR(MP_QSTR_refresh_ext_size), MP_ROM_PTR(&mp_lv_obj_refresh_ext_size_obj) }, + { MP_ROM_QSTR(MP_QSTR_set_free_num), MP_ROM_PTR(&mp_lv_obj_set_free_num_obj) }, + { MP_ROM_QSTR(MP_QSTR_set_free_ptr), MP_ROM_PTR(&mp_lv_obj_set_free_ptr_obj) }, + { MP_ROM_QSTR(MP_QSTR_animate), MP_ROM_PTR(&mp_lv_obj_animate_obj) }, + { MP_ROM_QSTR(MP_QSTR_get_screen), MP_ROM_PTR(&mp_lv_obj_get_screen_obj) }, + { MP_ROM_QSTR(MP_QSTR_get_parent), MP_ROM_PTR(&mp_lv_obj_get_parent_obj) }, + { MP_ROM_QSTR(MP_QSTR_get_child), MP_ROM_PTR(&mp_lv_obj_get_child_obj) }, + { MP_ROM_QSTR(MP_QSTR_get_child_back), MP_ROM_PTR(&mp_lv_obj_get_child_back_obj) }, + { MP_ROM_QSTR(MP_QSTR_count_children), MP_ROM_PTR(&mp_lv_obj_count_children_obj) }, + { MP_ROM_QSTR(MP_QSTR_get_coords), MP_ROM_PTR(&mp_lv_obj_get_coords_obj) }, + { MP_ROM_QSTR(MP_QSTR_get_x), MP_ROM_PTR(&mp_lv_obj_get_x_obj) }, + { MP_ROM_QSTR(MP_QSTR_get_y), MP_ROM_PTR(&mp_lv_obj_get_y_obj) }, + { MP_ROM_QSTR(MP_QSTR_get_width), MP_ROM_PTR(&mp_lv_obj_get_width_obj) }, + { MP_ROM_QSTR(MP_QSTR_get_height), MP_ROM_PTR(&mp_lv_obj_get_height_obj) }, + { MP_ROM_QSTR(MP_QSTR_get_ext_size), MP_ROM_PTR(&mp_lv_obj_get_ext_size_obj) }, + { MP_ROM_QSTR(MP_QSTR_get_auto_realign), MP_ROM_PTR(&mp_lv_obj_get_auto_realign_obj) }, + { MP_ROM_QSTR(MP_QSTR_get_style), MP_ROM_PTR(&mp_lv_obj_get_style_obj) }, + { MP_ROM_QSTR(MP_QSTR_get_hidden), MP_ROM_PTR(&mp_lv_obj_get_hidden_obj) }, + { MP_ROM_QSTR(MP_QSTR_get_click), MP_ROM_PTR(&mp_lv_obj_get_click_obj) }, + { MP_ROM_QSTR(MP_QSTR_get_top), MP_ROM_PTR(&mp_lv_obj_get_top_obj) }, + { MP_ROM_QSTR(MP_QSTR_get_drag), MP_ROM_PTR(&mp_lv_obj_get_drag_obj) }, + { MP_ROM_QSTR(MP_QSTR_get_drag_throw), MP_ROM_PTR(&mp_lv_obj_get_drag_throw_obj) }, + { MP_ROM_QSTR(MP_QSTR_get_drag_parent), MP_ROM_PTR(&mp_lv_obj_get_drag_parent_obj) }, + { MP_ROM_QSTR(MP_QSTR_get_opa_scale_enable), MP_ROM_PTR(&mp_lv_obj_get_opa_scale_enable_obj) }, + { MP_ROM_QSTR(MP_QSTR_get_opa_scale), MP_ROM_PTR(&mp_lv_obj_get_opa_scale_obj) }, + { MP_ROM_QSTR(MP_QSTR_get_protect), MP_ROM_PTR(&mp_lv_obj_get_protect_obj) }, + { MP_ROM_QSTR(MP_QSTR_is_protected), MP_ROM_PTR(&mp_lv_obj_is_protected_obj) }, + { MP_ROM_QSTR(MP_QSTR_get_signal_func), MP_ROM_PTR(&mp_lv_obj_get_signal_func_obj) }, + { MP_ROM_QSTR(MP_QSTR_get_design_func), MP_ROM_PTR(&mp_lv_obj_get_design_func_obj) }, + { MP_ROM_QSTR(MP_QSTR_get_ext_attr), MP_ROM_PTR(&mp_lv_obj_get_ext_attr_obj) }, + { MP_ROM_QSTR(MP_QSTR_get_free_num), MP_ROM_PTR(&mp_lv_obj_get_free_num_obj) }, + { MP_ROM_QSTR(MP_QSTR_get_free_ptr), MP_ROM_PTR(&mp_lv_obj_get_free_ptr_obj) }, + { MP_ROM_QSTR(MP_QSTR_get_group), MP_ROM_PTR(&mp_lv_obj_get_group_obj) }, + { MP_ROM_QSTR(MP_QSTR_is_focused), MP_ROM_PTR(&mp_lv_obj_is_focused_obj) }, + { MP_ROM_QSTR(MP_QSTR_STYLE), MP_ROM_PTR(&mp_LV_SLIDER_STYLE_type) } +}; + +STATIC MP_DEFINE_CONST_DICT(slider_locals_dict, slider_locals_dict_table); + +STATIC void slider_print(const mp_print_t *print, + mp_obj_t self_in, + mp_print_kind_t kind) +{ + mp_printf(print, "lvgl slider"); +} + + +STATIC mp_obj_t slider_make_new( + const mp_obj_type_t *type, + size_t n_args, + size_t n_kw, + const mp_obj_t *args) +{ + return make_new(&lv_slider_create, type, n_args, n_kw, args); +} + + +STATIC const mp_obj_type_t mp_slider_type = { + { &mp_type_type }, + .name = MP_QSTR_slider, + .print = slider_print, + .make_new = slider_make_new, + .locals_dict = (mp_obj_dict_t*)&slider_locals_dict, +}; + + +/* + * lvgl extension definition for: + * inline static void lv_led_set_style(lv_obj_t *led, lv_style_t *style) + */ + +STATIC mp_obj_t mp_lv_led_set_style(size_t n_args, const mp_obj_t *args) +{ + lv_obj_t *led = mp_to_lv(args[0]); + lv_style_t *style = mp_write_ptr_lv_style_t(args[1]); + lv_led_set_style(led, style); + return mp_const_none; +} + +STATIC MP_DEFINE_CONST_FUN_OBJ_VAR_BETWEEN(mp_lv_led_set_style_obj, 2, 2, mp_lv_led_set_style); + + + +/* + * lvgl extension definition for: + * inline static lv_style_t *lv_led_get_style(const lv_obj_t *led) + */ + +STATIC mp_obj_t mp_lv_led_get_style(size_t n_args, const mp_obj_t *args) +{ + const lv_obj_t *led = mp_to_lv(args[0]); + lv_style_t* res = lv_led_get_style(led); + return mp_read_ptr_lv_style_t((void*)res); +} + +STATIC MP_DEFINE_CONST_FUN_OBJ_VAR_BETWEEN(mp_lv_led_get_style_obj, 1, 1, mp_lv_led_get_style); + + + +/* + * lvgl extension definition for: + * void lv_led_set_bright(lv_obj_t *led, uint8_t bright) + */ + +STATIC mp_obj_t mp_lv_led_set_bright(size_t n_args, const mp_obj_t *args) +{ + lv_obj_t *led = mp_to_lv(args[0]); + uint8_t bright = (uint8_t)mp_obj_get_int(args[1]); + lv_led_set_bright(led, bright); + return mp_const_none; +} + +STATIC MP_DEFINE_CONST_FUN_OBJ_VAR_BETWEEN(mp_lv_led_set_bright_obj, 2, 2, mp_lv_led_set_bright); + + + +/* + * lvgl extension definition for: + * void lv_led_on(lv_obj_t *led) + */ + +STATIC mp_obj_t mp_lv_led_on(size_t n_args, const mp_obj_t *args) +{ + lv_obj_t *led = mp_to_lv(args[0]); + lv_led_on(led); + return mp_const_none; +} + +STATIC MP_DEFINE_CONST_FUN_OBJ_VAR_BETWEEN(mp_lv_led_on_obj, 1, 1, mp_lv_led_on); + + + +/* + * lvgl extension definition for: + * void lv_led_off(lv_obj_t *led) + */ + +STATIC mp_obj_t mp_lv_led_off(size_t n_args, const mp_obj_t *args) +{ + lv_obj_t *led = mp_to_lv(args[0]); + lv_led_off(led); + return mp_const_none; +} + +STATIC MP_DEFINE_CONST_FUN_OBJ_VAR_BETWEEN(mp_lv_led_off_obj, 1, 1, mp_lv_led_off); + + + +/* + * lvgl extension definition for: + * void lv_led_toggle(lv_obj_t *led) + */ + +STATIC mp_obj_t mp_lv_led_toggle(size_t n_args, const mp_obj_t *args) +{ + lv_obj_t *led = mp_to_lv(args[0]); + lv_led_toggle(led); + return mp_const_none; +} + +STATIC MP_DEFINE_CONST_FUN_OBJ_VAR_BETWEEN(mp_lv_led_toggle_obj, 1, 1, mp_lv_led_toggle); + + + +/* + * lvgl extension definition for: + * uint8_t lv_led_get_bright(const lv_obj_t *led) + */ + +STATIC mp_obj_t mp_lv_led_get_bright(size_t n_args, const mp_obj_t *args) +{ + const lv_obj_t *led = mp_to_lv(args[0]); + uint8_t res = lv_led_get_bright(led); + return mp_obj_new_int_from_uint(res); +} + +STATIC MP_DEFINE_CONST_FUN_OBJ_VAR_BETWEEN(mp_lv_led_get_bright_obj, 1, 1, mp_lv_led_get_bright); + + + +/* + * lvgl led object definitions + */ + + +STATIC const mp_rom_map_elem_t led_locals_dict_table[] = { + { MP_ROM_QSTR(MP_QSTR_set_style), MP_ROM_PTR(&mp_lv_led_set_style_obj) }, + { MP_ROM_QSTR(MP_QSTR_get_style), MP_ROM_PTR(&mp_lv_led_get_style_obj) }, + { MP_ROM_QSTR(MP_QSTR_set_bright), MP_ROM_PTR(&mp_lv_led_set_bright_obj) }, + { MP_ROM_QSTR(MP_QSTR_on), MP_ROM_PTR(&mp_lv_led_on_obj) }, + { MP_ROM_QSTR(MP_QSTR_off), MP_ROM_PTR(&mp_lv_led_off_obj) }, + { MP_ROM_QSTR(MP_QSTR_toggle), MP_ROM_PTR(&mp_lv_led_toggle_obj) }, + { MP_ROM_QSTR(MP_QSTR_get_bright), MP_ROM_PTR(&mp_lv_led_get_bright_obj) }, + { MP_ROM_QSTR(MP_QSTR_delete), MP_ROM_PTR(&mp_lv_obj_del_obj) }, + { MP_ROM_QSTR(MP_QSTR_clean), MP_ROM_PTR(&mp_lv_obj_clean_obj) }, + { MP_ROM_QSTR(MP_QSTR_invalidate), MP_ROM_PTR(&mp_lv_obj_invalidate_obj) }, + { MP_ROM_QSTR(MP_QSTR_set_parent), MP_ROM_PTR(&mp_lv_obj_set_parent_obj) }, + { MP_ROM_QSTR(MP_QSTR_set_pos), MP_ROM_PTR(&mp_lv_obj_set_pos_obj) }, + { MP_ROM_QSTR(MP_QSTR_set_x), MP_ROM_PTR(&mp_lv_obj_set_x_obj) }, + { MP_ROM_QSTR(MP_QSTR_set_y), MP_ROM_PTR(&mp_lv_obj_set_y_obj) }, + { MP_ROM_QSTR(MP_QSTR_set_size), MP_ROM_PTR(&mp_lv_obj_set_size_obj) }, + { MP_ROM_QSTR(MP_QSTR_set_width), MP_ROM_PTR(&mp_lv_obj_set_width_obj) }, + { MP_ROM_QSTR(MP_QSTR_set_height), MP_ROM_PTR(&mp_lv_obj_set_height_obj) }, + { MP_ROM_QSTR(MP_QSTR_align), MP_ROM_PTR(&mp_lv_obj_align_obj) }, + { MP_ROM_QSTR(MP_QSTR_align_origo), MP_ROM_PTR(&mp_lv_obj_align_origo_obj) }, + { MP_ROM_QSTR(MP_QSTR_realign), MP_ROM_PTR(&mp_lv_obj_realign_obj) }, + { MP_ROM_QSTR(MP_QSTR_set_auto_realign), MP_ROM_PTR(&mp_lv_obj_set_auto_realign_obj) }, + { MP_ROM_QSTR(MP_QSTR_set_style), MP_ROM_PTR(&mp_lv_obj_set_style_obj) }, + { MP_ROM_QSTR(MP_QSTR_refresh_style), MP_ROM_PTR(&mp_lv_obj_refresh_style_obj) }, + { MP_ROM_QSTR(MP_QSTR_report_style_mod), MP_ROM_PTR(&mp_lv_obj_report_style_mod_obj) }, + { MP_ROM_QSTR(MP_QSTR_set_hidden), MP_ROM_PTR(&mp_lv_obj_set_hidden_obj) }, + { MP_ROM_QSTR(MP_QSTR_set_click), MP_ROM_PTR(&mp_lv_obj_set_click_obj) }, + { MP_ROM_QSTR(MP_QSTR_set_top), MP_ROM_PTR(&mp_lv_obj_set_top_obj) }, + { MP_ROM_QSTR(MP_QSTR_set_drag), MP_ROM_PTR(&mp_lv_obj_set_drag_obj) }, + { MP_ROM_QSTR(MP_QSTR_set_drag_throw), MP_ROM_PTR(&mp_lv_obj_set_drag_throw_obj) }, + { MP_ROM_QSTR(MP_QSTR_set_drag_parent), MP_ROM_PTR(&mp_lv_obj_set_drag_parent_obj) }, + { MP_ROM_QSTR(MP_QSTR_set_opa_scale_enable), MP_ROM_PTR(&mp_lv_obj_set_opa_scale_enable_obj) }, + { MP_ROM_QSTR(MP_QSTR_set_opa_scale), MP_ROM_PTR(&mp_lv_obj_set_opa_scale_obj) }, + { MP_ROM_QSTR(MP_QSTR_set_protect), MP_ROM_PTR(&mp_lv_obj_set_protect_obj) }, + { MP_ROM_QSTR(MP_QSTR_clear_protect), MP_ROM_PTR(&mp_lv_obj_clear_protect_obj) }, + { MP_ROM_QSTR(MP_QSTR_set_signal_func), MP_ROM_PTR(&mp_lv_obj_set_signal_func_obj) }, + { MP_ROM_QSTR(MP_QSTR_set_design_func), MP_ROM_PTR(&mp_lv_obj_set_design_func_obj) }, + { MP_ROM_QSTR(MP_QSTR_allocate_ext_attr), MP_ROM_PTR(&mp_lv_obj_allocate_ext_attr_obj) }, + { MP_ROM_QSTR(MP_QSTR_refresh_ext_size), MP_ROM_PTR(&mp_lv_obj_refresh_ext_size_obj) }, + { MP_ROM_QSTR(MP_QSTR_set_free_num), MP_ROM_PTR(&mp_lv_obj_set_free_num_obj) }, + { MP_ROM_QSTR(MP_QSTR_set_free_ptr), MP_ROM_PTR(&mp_lv_obj_set_free_ptr_obj) }, + { MP_ROM_QSTR(MP_QSTR_animate), MP_ROM_PTR(&mp_lv_obj_animate_obj) }, + { MP_ROM_QSTR(MP_QSTR_get_screen), MP_ROM_PTR(&mp_lv_obj_get_screen_obj) }, + { MP_ROM_QSTR(MP_QSTR_get_parent), MP_ROM_PTR(&mp_lv_obj_get_parent_obj) }, + { MP_ROM_QSTR(MP_QSTR_get_child), MP_ROM_PTR(&mp_lv_obj_get_child_obj) }, + { MP_ROM_QSTR(MP_QSTR_get_child_back), MP_ROM_PTR(&mp_lv_obj_get_child_back_obj) }, + { MP_ROM_QSTR(MP_QSTR_count_children), MP_ROM_PTR(&mp_lv_obj_count_children_obj) }, + { MP_ROM_QSTR(MP_QSTR_get_coords), MP_ROM_PTR(&mp_lv_obj_get_coords_obj) }, + { MP_ROM_QSTR(MP_QSTR_get_x), MP_ROM_PTR(&mp_lv_obj_get_x_obj) }, + { MP_ROM_QSTR(MP_QSTR_get_y), MP_ROM_PTR(&mp_lv_obj_get_y_obj) }, + { MP_ROM_QSTR(MP_QSTR_get_width), MP_ROM_PTR(&mp_lv_obj_get_width_obj) }, + { MP_ROM_QSTR(MP_QSTR_get_height), MP_ROM_PTR(&mp_lv_obj_get_height_obj) }, + { MP_ROM_QSTR(MP_QSTR_get_ext_size), MP_ROM_PTR(&mp_lv_obj_get_ext_size_obj) }, + { MP_ROM_QSTR(MP_QSTR_get_auto_realign), MP_ROM_PTR(&mp_lv_obj_get_auto_realign_obj) }, + { MP_ROM_QSTR(MP_QSTR_get_style), MP_ROM_PTR(&mp_lv_obj_get_style_obj) }, + { MP_ROM_QSTR(MP_QSTR_get_hidden), MP_ROM_PTR(&mp_lv_obj_get_hidden_obj) }, + { MP_ROM_QSTR(MP_QSTR_get_click), MP_ROM_PTR(&mp_lv_obj_get_click_obj) }, + { MP_ROM_QSTR(MP_QSTR_get_top), MP_ROM_PTR(&mp_lv_obj_get_top_obj) }, + { MP_ROM_QSTR(MP_QSTR_get_drag), MP_ROM_PTR(&mp_lv_obj_get_drag_obj) }, + { MP_ROM_QSTR(MP_QSTR_get_drag_throw), MP_ROM_PTR(&mp_lv_obj_get_drag_throw_obj) }, + { MP_ROM_QSTR(MP_QSTR_get_drag_parent), MP_ROM_PTR(&mp_lv_obj_get_drag_parent_obj) }, + { MP_ROM_QSTR(MP_QSTR_get_opa_scale_enable), MP_ROM_PTR(&mp_lv_obj_get_opa_scale_enable_obj) }, + { MP_ROM_QSTR(MP_QSTR_get_opa_scale), MP_ROM_PTR(&mp_lv_obj_get_opa_scale_obj) }, + { MP_ROM_QSTR(MP_QSTR_get_protect), MP_ROM_PTR(&mp_lv_obj_get_protect_obj) }, + { MP_ROM_QSTR(MP_QSTR_is_protected), MP_ROM_PTR(&mp_lv_obj_is_protected_obj) }, + { MP_ROM_QSTR(MP_QSTR_get_signal_func), MP_ROM_PTR(&mp_lv_obj_get_signal_func_obj) }, + { MP_ROM_QSTR(MP_QSTR_get_design_func), MP_ROM_PTR(&mp_lv_obj_get_design_func_obj) }, + { MP_ROM_QSTR(MP_QSTR_get_ext_attr), MP_ROM_PTR(&mp_lv_obj_get_ext_attr_obj) }, + { MP_ROM_QSTR(MP_QSTR_get_free_num), MP_ROM_PTR(&mp_lv_obj_get_free_num_obj) }, + { MP_ROM_QSTR(MP_QSTR_get_free_ptr), MP_ROM_PTR(&mp_lv_obj_get_free_ptr_obj) }, + { MP_ROM_QSTR(MP_QSTR_get_group), MP_ROM_PTR(&mp_lv_obj_get_group_obj) }, + { MP_ROM_QSTR(MP_QSTR_is_focused), MP_ROM_PTR(&mp_lv_obj_is_focused_obj) } +}; + +STATIC MP_DEFINE_CONST_DICT(led_locals_dict, led_locals_dict_table); + +STATIC void led_print(const mp_print_t *print, + mp_obj_t self_in, + mp_print_kind_t kind) +{ + mp_printf(print, "lvgl led"); +} + + +STATIC mp_obj_t led_make_new( + const mp_obj_type_t *type, + size_t n_args, + size_t n_kw, + const mp_obj_t *args) +{ + return make_new(&lv_led_create, type, n_args, n_kw, args); +} + + +STATIC const mp_obj_type_t mp_led_type = { + { &mp_type_type }, + .name = MP_QSTR_led, + .print = led_print, + .make_new = led_make_new, + .locals_dict = (mp_obj_dict_t*)&led_locals_dict, +}; + + +/* + * lvgl extension definition for: + * void lv_btnm_set_map(lv_obj_t *btnm, const char **map) + */ + +STATIC mp_obj_t mp_lv_btnm_set_map(size_t n_args, const mp_obj_t *args) +{ + lv_obj_t *btnm = mp_to_lv(args[0]); + const char **map = mp_to_ptr(args[1]); + lv_btnm_set_map(btnm, map); + return mp_const_none; +} + +STATIC MP_DEFINE_CONST_FUN_OBJ_VAR_BETWEEN(mp_lv_btnm_set_map_obj, 2, 2, mp_lv_btnm_set_map); + + + +/* + * lvgl extension definition for: + * void lv_btnm_set_action(lv_obj_t *btnm, lv_btnm_action_t action) + */ + +STATIC mp_obj_t mp_lv_btnm_set_action(size_t n_args, const mp_obj_t *args) +{ + lv_obj_t *btnm = mp_to_lv(args[0]); + set_action(args[0], args[1]); + lv_btnm_action_t action = &lv_btnm_action_t_callback; + lv_btnm_set_action(btnm, action); + return mp_const_none; +} + +STATIC MP_DEFINE_CONST_FUN_OBJ_VAR_BETWEEN(mp_lv_btnm_set_action_obj, 2, 2, mp_lv_btnm_set_action); + + + +/* + * lvgl extension definition for: + * void lv_btnm_set_toggle(lv_obj_t *btnm, bool en, uint16_t id) + */ + +STATIC mp_obj_t mp_lv_btnm_set_toggle(size_t n_args, const mp_obj_t *args) +{ + lv_obj_t *btnm = mp_to_lv(args[0]); + bool en = mp_obj_is_true(args[1]); + uint16_t id = (uint16_t)mp_obj_get_int(args[2]); + lv_btnm_set_toggle(btnm, en, id); + return mp_const_none; +} + +STATIC MP_DEFINE_CONST_FUN_OBJ_VAR_BETWEEN(mp_lv_btnm_set_toggle_obj, 3, 3, mp_lv_btnm_set_toggle); + + + +/* + * lvgl extension definition for: + * void lv_btnm_set_style(lv_obj_t *btnm, lv_btnm_style_t type, lv_style_t *style) + */ + +STATIC mp_obj_t mp_lv_btnm_set_style(size_t n_args, const mp_obj_t *args) +{ + lv_obj_t *btnm = mp_to_lv(args[0]); + lv_btnm_style_t type = (uint8_t)mp_obj_get_int(args[1]); + lv_style_t *style = mp_write_ptr_lv_style_t(args[2]); + lv_btnm_set_style(btnm, type, style); + return mp_const_none; +} + +STATIC MP_DEFINE_CONST_FUN_OBJ_VAR_BETWEEN(mp_lv_btnm_set_style_obj, 3, 3, mp_lv_btnm_set_style); + + + +/* + * lvgl extension definition for: + * void lv_btnm_set_recolor(const lv_obj_t *btnm, bool en) + */ + +STATIC mp_obj_t mp_lv_btnm_set_recolor(size_t n_args, const mp_obj_t *args) +{ + const lv_obj_t *btnm = mp_to_lv(args[0]); + bool en = mp_obj_is_true(args[1]); + lv_btnm_set_recolor(btnm, en); + return mp_const_none; +} + +STATIC MP_DEFINE_CONST_FUN_OBJ_VAR_BETWEEN(mp_lv_btnm_set_recolor_obj, 2, 2, mp_lv_btnm_set_recolor); + + + +/* + * lvgl extension definition for: + * const char **lv_btnm_get_map(const lv_obj_t *btnm) + */ + +STATIC mp_obj_t mp_lv_btnm_get_map(size_t n_args, const mp_obj_t *args) +{ + const lv_obj_t *btnm = mp_to_lv(args[0]); + const char** res = lv_btnm_get_map(btnm); + return ptr_to_mp((void*)res); +} + +STATIC MP_DEFINE_CONST_FUN_OBJ_VAR_BETWEEN(mp_lv_btnm_get_map_obj, 1, 1, mp_lv_btnm_get_map); + + + +/* + * lvgl extension definition for: + * lv_btnm_action_t lv_btnm_get_action(const lv_obj_t *btnm) + */ + +STATIC mp_obj_t mp_lv_btnm_get_action(size_t n_args, const mp_obj_t *args) +{ + const lv_obj_t *btnm = mp_to_lv(args[0]); + lv_btnm_action_t res = lv_btnm_get_action(btnm); + return ptr_to_mp(res); +} + +STATIC MP_DEFINE_CONST_FUN_OBJ_VAR_BETWEEN(mp_lv_btnm_get_action_obj, 1, 1, mp_lv_btnm_get_action); + + + +/* + * lvgl extension definition for: + * uint16_t lv_btnm_get_pressed(const lv_obj_t *btnm) + */ + +STATIC mp_obj_t mp_lv_btnm_get_pressed(size_t n_args, const mp_obj_t *args) +{ + const lv_obj_t *btnm = mp_to_lv(args[0]); + uint16_t res = lv_btnm_get_pressed(btnm); + return mp_obj_new_int_from_uint(res); +} + +STATIC MP_DEFINE_CONST_FUN_OBJ_VAR_BETWEEN(mp_lv_btnm_get_pressed_obj, 1, 1, mp_lv_btnm_get_pressed); + + + +/* + * lvgl extension definition for: + * uint16_t lv_btnm_get_toggled(const lv_obj_t *btnm) + */ + +STATIC mp_obj_t mp_lv_btnm_get_toggled(size_t n_args, const mp_obj_t *args) +{ + const lv_obj_t *btnm = mp_to_lv(args[0]); + uint16_t res = lv_btnm_get_toggled(btnm); + return mp_obj_new_int_from_uint(res); +} + +STATIC MP_DEFINE_CONST_FUN_OBJ_VAR_BETWEEN(mp_lv_btnm_get_toggled_obj, 1, 1, mp_lv_btnm_get_toggled); + + + +/* + * lvgl extension definition for: + * lv_style_t *lv_btnm_get_style(const lv_obj_t *btnm, lv_btnm_style_t type) + */ + +STATIC mp_obj_t mp_lv_btnm_get_style(size_t n_args, const mp_obj_t *args) +{ + const lv_obj_t *btnm = mp_to_lv(args[0]); + lv_btnm_style_t type = (uint8_t)mp_obj_get_int(args[1]); + lv_style_t* res = lv_btnm_get_style(btnm, type); + return mp_read_ptr_lv_style_t((void*)res); +} + +STATIC MP_DEFINE_CONST_FUN_OBJ_VAR_BETWEEN(mp_lv_btnm_get_style_obj, 2, 2, mp_lv_btnm_get_style); + + + +/* + * lvgl extension definition for: + * bool lv_btnm_get_recolor(const lv_obj_t *btnm) + */ + +STATIC mp_obj_t mp_lv_btnm_get_recolor(size_t n_args, const mp_obj_t *args) +{ + const lv_obj_t *btnm = mp_to_lv(args[0]); + bool res = lv_btnm_get_recolor(btnm); + return convert_to_bool(res); +} + +STATIC MP_DEFINE_CONST_FUN_OBJ_VAR_BETWEEN(mp_lv_btnm_get_recolor_obj, 1, 1, mp_lv_btnm_get_recolor); + + + +/* + * lvgl btnm object definitions + */ + + +STATIC const mp_rom_map_elem_t btnm_locals_dict_table[] = { + { MP_ROM_QSTR(MP_QSTR_set_map), MP_ROM_PTR(&mp_lv_btnm_set_map_obj) }, + { MP_ROM_QSTR(MP_QSTR_set_action), MP_ROM_PTR(&mp_lv_btnm_set_action_obj) }, + { MP_ROM_QSTR(MP_QSTR_set_toggle), MP_ROM_PTR(&mp_lv_btnm_set_toggle_obj) }, + { MP_ROM_QSTR(MP_QSTR_set_style), MP_ROM_PTR(&mp_lv_btnm_set_style_obj) }, + { MP_ROM_QSTR(MP_QSTR_set_recolor), MP_ROM_PTR(&mp_lv_btnm_set_recolor_obj) }, + { MP_ROM_QSTR(MP_QSTR_get_map), MP_ROM_PTR(&mp_lv_btnm_get_map_obj) }, + { MP_ROM_QSTR(MP_QSTR_get_action), MP_ROM_PTR(&mp_lv_btnm_get_action_obj) }, + { MP_ROM_QSTR(MP_QSTR_get_pressed), MP_ROM_PTR(&mp_lv_btnm_get_pressed_obj) }, + { MP_ROM_QSTR(MP_QSTR_get_toggled), MP_ROM_PTR(&mp_lv_btnm_get_toggled_obj) }, + { MP_ROM_QSTR(MP_QSTR_get_style), MP_ROM_PTR(&mp_lv_btnm_get_style_obj) }, + { MP_ROM_QSTR(MP_QSTR_get_recolor), MP_ROM_PTR(&mp_lv_btnm_get_recolor_obj) }, + { MP_ROM_QSTR(MP_QSTR_delete), MP_ROM_PTR(&mp_lv_obj_del_obj) }, + { MP_ROM_QSTR(MP_QSTR_clean), MP_ROM_PTR(&mp_lv_obj_clean_obj) }, + { MP_ROM_QSTR(MP_QSTR_invalidate), MP_ROM_PTR(&mp_lv_obj_invalidate_obj) }, + { MP_ROM_QSTR(MP_QSTR_set_parent), MP_ROM_PTR(&mp_lv_obj_set_parent_obj) }, + { MP_ROM_QSTR(MP_QSTR_set_pos), MP_ROM_PTR(&mp_lv_obj_set_pos_obj) }, + { MP_ROM_QSTR(MP_QSTR_set_x), MP_ROM_PTR(&mp_lv_obj_set_x_obj) }, + { MP_ROM_QSTR(MP_QSTR_set_y), MP_ROM_PTR(&mp_lv_obj_set_y_obj) }, + { MP_ROM_QSTR(MP_QSTR_set_size), MP_ROM_PTR(&mp_lv_obj_set_size_obj) }, + { MP_ROM_QSTR(MP_QSTR_set_width), MP_ROM_PTR(&mp_lv_obj_set_width_obj) }, + { MP_ROM_QSTR(MP_QSTR_set_height), MP_ROM_PTR(&mp_lv_obj_set_height_obj) }, + { MP_ROM_QSTR(MP_QSTR_align), MP_ROM_PTR(&mp_lv_obj_align_obj) }, + { MP_ROM_QSTR(MP_QSTR_align_origo), MP_ROM_PTR(&mp_lv_obj_align_origo_obj) }, + { MP_ROM_QSTR(MP_QSTR_realign), MP_ROM_PTR(&mp_lv_obj_realign_obj) }, + { MP_ROM_QSTR(MP_QSTR_set_auto_realign), MP_ROM_PTR(&mp_lv_obj_set_auto_realign_obj) }, + { MP_ROM_QSTR(MP_QSTR_set_style), MP_ROM_PTR(&mp_lv_obj_set_style_obj) }, + { MP_ROM_QSTR(MP_QSTR_refresh_style), MP_ROM_PTR(&mp_lv_obj_refresh_style_obj) }, + { MP_ROM_QSTR(MP_QSTR_report_style_mod), MP_ROM_PTR(&mp_lv_obj_report_style_mod_obj) }, + { MP_ROM_QSTR(MP_QSTR_set_hidden), MP_ROM_PTR(&mp_lv_obj_set_hidden_obj) }, + { MP_ROM_QSTR(MP_QSTR_set_click), MP_ROM_PTR(&mp_lv_obj_set_click_obj) }, + { MP_ROM_QSTR(MP_QSTR_set_top), MP_ROM_PTR(&mp_lv_obj_set_top_obj) }, + { MP_ROM_QSTR(MP_QSTR_set_drag), MP_ROM_PTR(&mp_lv_obj_set_drag_obj) }, + { MP_ROM_QSTR(MP_QSTR_set_drag_throw), MP_ROM_PTR(&mp_lv_obj_set_drag_throw_obj) }, + { MP_ROM_QSTR(MP_QSTR_set_drag_parent), MP_ROM_PTR(&mp_lv_obj_set_drag_parent_obj) }, + { MP_ROM_QSTR(MP_QSTR_set_opa_scale_enable), MP_ROM_PTR(&mp_lv_obj_set_opa_scale_enable_obj) }, + { MP_ROM_QSTR(MP_QSTR_set_opa_scale), MP_ROM_PTR(&mp_lv_obj_set_opa_scale_obj) }, + { MP_ROM_QSTR(MP_QSTR_set_protect), MP_ROM_PTR(&mp_lv_obj_set_protect_obj) }, + { MP_ROM_QSTR(MP_QSTR_clear_protect), MP_ROM_PTR(&mp_lv_obj_clear_protect_obj) }, + { MP_ROM_QSTR(MP_QSTR_set_signal_func), MP_ROM_PTR(&mp_lv_obj_set_signal_func_obj) }, + { MP_ROM_QSTR(MP_QSTR_set_design_func), MP_ROM_PTR(&mp_lv_obj_set_design_func_obj) }, + { MP_ROM_QSTR(MP_QSTR_allocate_ext_attr), MP_ROM_PTR(&mp_lv_obj_allocate_ext_attr_obj) }, + { MP_ROM_QSTR(MP_QSTR_refresh_ext_size), MP_ROM_PTR(&mp_lv_obj_refresh_ext_size_obj) }, + { MP_ROM_QSTR(MP_QSTR_set_free_num), MP_ROM_PTR(&mp_lv_obj_set_free_num_obj) }, + { MP_ROM_QSTR(MP_QSTR_set_free_ptr), MP_ROM_PTR(&mp_lv_obj_set_free_ptr_obj) }, + { MP_ROM_QSTR(MP_QSTR_animate), MP_ROM_PTR(&mp_lv_obj_animate_obj) }, + { MP_ROM_QSTR(MP_QSTR_get_screen), MP_ROM_PTR(&mp_lv_obj_get_screen_obj) }, + { MP_ROM_QSTR(MP_QSTR_get_parent), MP_ROM_PTR(&mp_lv_obj_get_parent_obj) }, + { MP_ROM_QSTR(MP_QSTR_get_child), MP_ROM_PTR(&mp_lv_obj_get_child_obj) }, + { MP_ROM_QSTR(MP_QSTR_get_child_back), MP_ROM_PTR(&mp_lv_obj_get_child_back_obj) }, + { MP_ROM_QSTR(MP_QSTR_count_children), MP_ROM_PTR(&mp_lv_obj_count_children_obj) }, + { MP_ROM_QSTR(MP_QSTR_get_coords), MP_ROM_PTR(&mp_lv_obj_get_coords_obj) }, + { MP_ROM_QSTR(MP_QSTR_get_x), MP_ROM_PTR(&mp_lv_obj_get_x_obj) }, + { MP_ROM_QSTR(MP_QSTR_get_y), MP_ROM_PTR(&mp_lv_obj_get_y_obj) }, + { MP_ROM_QSTR(MP_QSTR_get_width), MP_ROM_PTR(&mp_lv_obj_get_width_obj) }, + { MP_ROM_QSTR(MP_QSTR_get_height), MP_ROM_PTR(&mp_lv_obj_get_height_obj) }, + { MP_ROM_QSTR(MP_QSTR_get_ext_size), MP_ROM_PTR(&mp_lv_obj_get_ext_size_obj) }, + { MP_ROM_QSTR(MP_QSTR_get_auto_realign), MP_ROM_PTR(&mp_lv_obj_get_auto_realign_obj) }, + { MP_ROM_QSTR(MP_QSTR_get_style), MP_ROM_PTR(&mp_lv_obj_get_style_obj) }, + { MP_ROM_QSTR(MP_QSTR_get_hidden), MP_ROM_PTR(&mp_lv_obj_get_hidden_obj) }, + { MP_ROM_QSTR(MP_QSTR_get_click), MP_ROM_PTR(&mp_lv_obj_get_click_obj) }, + { MP_ROM_QSTR(MP_QSTR_get_top), MP_ROM_PTR(&mp_lv_obj_get_top_obj) }, + { MP_ROM_QSTR(MP_QSTR_get_drag), MP_ROM_PTR(&mp_lv_obj_get_drag_obj) }, + { MP_ROM_QSTR(MP_QSTR_get_drag_throw), MP_ROM_PTR(&mp_lv_obj_get_drag_throw_obj) }, + { MP_ROM_QSTR(MP_QSTR_get_drag_parent), MP_ROM_PTR(&mp_lv_obj_get_drag_parent_obj) }, + { MP_ROM_QSTR(MP_QSTR_get_opa_scale_enable), MP_ROM_PTR(&mp_lv_obj_get_opa_scale_enable_obj) }, + { MP_ROM_QSTR(MP_QSTR_get_opa_scale), MP_ROM_PTR(&mp_lv_obj_get_opa_scale_obj) }, + { MP_ROM_QSTR(MP_QSTR_get_protect), MP_ROM_PTR(&mp_lv_obj_get_protect_obj) }, + { MP_ROM_QSTR(MP_QSTR_is_protected), MP_ROM_PTR(&mp_lv_obj_is_protected_obj) }, + { MP_ROM_QSTR(MP_QSTR_get_signal_func), MP_ROM_PTR(&mp_lv_obj_get_signal_func_obj) }, + { MP_ROM_QSTR(MP_QSTR_get_design_func), MP_ROM_PTR(&mp_lv_obj_get_design_func_obj) }, + { MP_ROM_QSTR(MP_QSTR_get_ext_attr), MP_ROM_PTR(&mp_lv_obj_get_ext_attr_obj) }, + { MP_ROM_QSTR(MP_QSTR_get_free_num), MP_ROM_PTR(&mp_lv_obj_get_free_num_obj) }, + { MP_ROM_QSTR(MP_QSTR_get_free_ptr), MP_ROM_PTR(&mp_lv_obj_get_free_ptr_obj) }, + { MP_ROM_QSTR(MP_QSTR_get_group), MP_ROM_PTR(&mp_lv_obj_get_group_obj) }, + { MP_ROM_QSTR(MP_QSTR_is_focused), MP_ROM_PTR(&mp_lv_obj_is_focused_obj) }, + { MP_ROM_QSTR(MP_QSTR_STYLE), MP_ROM_PTR(&mp_LV_BTNM_STYLE_type) } +}; + +STATIC MP_DEFINE_CONST_DICT(btnm_locals_dict, btnm_locals_dict_table); + +STATIC void btnm_print(const mp_print_t *print, + mp_obj_t self_in, + mp_print_kind_t kind) +{ + mp_printf(print, "lvgl btnm"); +} + + +STATIC mp_obj_t btnm_make_new( + const mp_obj_type_t *type, + size_t n_args, + size_t n_kw, + const mp_obj_t *args) +{ + return make_new(&lv_btnm_create, type, n_args, n_kw, args); +} + + +STATIC const mp_obj_type_t mp_btnm_type = { + { &mp_type_type }, + .name = MP_QSTR_btnm, + .print = btnm_print, + .make_new = btnm_make_new, + .locals_dict = (mp_obj_dict_t*)&btnm_locals_dict, +}; + + +/* + * lvgl extension definition for: + * inline static void lv_kb_set_map(lv_obj_t *kb, const char **map) + */ + +STATIC mp_obj_t mp_lv_kb_set_map(size_t n_args, const mp_obj_t *args) +{ + lv_obj_t *kb = mp_to_lv(args[0]); + const char **map = mp_to_ptr(args[1]); + lv_kb_set_map(kb, map); + return mp_const_none; +} + +STATIC MP_DEFINE_CONST_FUN_OBJ_VAR_BETWEEN(mp_lv_kb_set_map_obj, 2, 2, mp_lv_kb_set_map); + + + +/* + * lvgl extension definition for: + * void lv_kb_set_ta(lv_obj_t *kb, lv_obj_t *ta) + */ + +STATIC mp_obj_t mp_lv_kb_set_ta(size_t n_args, const mp_obj_t *args) +{ + lv_obj_t *kb = mp_to_lv(args[0]); + lv_obj_t *ta = mp_to_lv(args[1]); + lv_kb_set_ta(kb, ta); + return mp_const_none; +} + +STATIC MP_DEFINE_CONST_FUN_OBJ_VAR_BETWEEN(mp_lv_kb_set_ta_obj, 2, 2, mp_lv_kb_set_ta); + + + +/* + * lvgl extension definition for: + * void lv_kb_set_mode(lv_obj_t *kb, lv_kb_mode_t mode) + */ + +STATIC mp_obj_t mp_lv_kb_set_mode(size_t n_args, const mp_obj_t *args) +{ + lv_obj_t *kb = mp_to_lv(args[0]); + lv_kb_mode_t mode = (uint8_t)mp_obj_get_int(args[1]); + lv_kb_set_mode(kb, mode); + return mp_const_none; +} + +STATIC MP_DEFINE_CONST_FUN_OBJ_VAR_BETWEEN(mp_lv_kb_set_mode_obj, 2, 2, mp_lv_kb_set_mode); + + + +/* + * lvgl extension definition for: + * void lv_kb_set_cursor_manage(lv_obj_t *kb, bool en) + */ + +STATIC mp_obj_t mp_lv_kb_set_cursor_manage(size_t n_args, const mp_obj_t *args) +{ + lv_obj_t *kb = mp_to_lv(args[0]); + bool en = mp_obj_is_true(args[1]); + lv_kb_set_cursor_manage(kb, en); + return mp_const_none; +} + +STATIC MP_DEFINE_CONST_FUN_OBJ_VAR_BETWEEN(mp_lv_kb_set_cursor_manage_obj, 2, 2, mp_lv_kb_set_cursor_manage); + + + +/* + * lvgl extension definition for: + * void lv_kb_set_ok_action(lv_obj_t *kb, lv_action_t action) + */ + +STATIC mp_obj_t mp_lv_kb_set_ok_action(size_t n_args, const mp_obj_t *args) +{ + lv_obj_t *kb = mp_to_lv(args[0]); + set_action(args[0], args[1]); + lv_action_t action = &lv_action_t_callback; + lv_kb_set_ok_action(kb, action); + return mp_const_none; +} + +STATIC MP_DEFINE_CONST_FUN_OBJ_VAR_BETWEEN(mp_lv_kb_set_ok_action_obj, 2, 2, mp_lv_kb_set_ok_action); + + + +/* + * lvgl extension definition for: + * void lv_kb_set_hide_action(lv_obj_t *kb, lv_action_t action) + */ + +STATIC mp_obj_t mp_lv_kb_set_hide_action(size_t n_args, const mp_obj_t *args) +{ + lv_obj_t *kb = mp_to_lv(args[0]); + set_action(args[0], args[1]); + lv_action_t action = &lv_action_t_callback; + lv_kb_set_hide_action(kb, action); + return mp_const_none; +} + +STATIC MP_DEFINE_CONST_FUN_OBJ_VAR_BETWEEN(mp_lv_kb_set_hide_action_obj, 2, 2, mp_lv_kb_set_hide_action); + + + +/* + * lvgl extension definition for: + * void lv_kb_set_style(lv_obj_t *kb, lv_kb_style_t type, lv_style_t *style) + */ + +STATIC mp_obj_t mp_lv_kb_set_style(size_t n_args, const mp_obj_t *args) +{ + lv_obj_t *kb = mp_to_lv(args[0]); + lv_kb_style_t type = (uint8_t)mp_obj_get_int(args[1]); + lv_style_t *style = mp_write_ptr_lv_style_t(args[2]); + lv_kb_set_style(kb, type, style); + return mp_const_none; +} + +STATIC MP_DEFINE_CONST_FUN_OBJ_VAR_BETWEEN(mp_lv_kb_set_style_obj, 3, 3, mp_lv_kb_set_style); + + + +/* + * lvgl extension definition for: + * lv_obj_t *lv_kb_get_ta(const lv_obj_t *kb) + */ + +STATIC mp_obj_t mp_lv_kb_get_ta(size_t n_args, const mp_obj_t *args) +{ + const lv_obj_t *kb = mp_to_lv(args[0]); + lv_obj_t* res = lv_kb_get_ta(kb); + return lv_to_mp((void*)res); +} + +STATIC MP_DEFINE_CONST_FUN_OBJ_VAR_BETWEEN(mp_lv_kb_get_ta_obj, 1, 1, mp_lv_kb_get_ta); + + + +/* + * lvgl extension definition for: + * lv_kb_mode_t lv_kb_get_mode(const lv_obj_t *kb) + */ + +STATIC mp_obj_t mp_lv_kb_get_mode(size_t n_args, const mp_obj_t *args) +{ + const lv_obj_t *kb = mp_to_lv(args[0]); + lv_kb_mode_t res = lv_kb_get_mode(kb); + return mp_obj_new_int_from_uint(res); +} + +STATIC MP_DEFINE_CONST_FUN_OBJ_VAR_BETWEEN(mp_lv_kb_get_mode_obj, 1, 1, mp_lv_kb_get_mode); + + + +/* + * lvgl extension definition for: + * bool lv_kb_get_cursor_manage(const lv_obj_t *kb) + */ + +STATIC mp_obj_t mp_lv_kb_get_cursor_manage(size_t n_args, const mp_obj_t *args) +{ + const lv_obj_t *kb = mp_to_lv(args[0]); + bool res = lv_kb_get_cursor_manage(kb); + return convert_to_bool(res); +} + +STATIC MP_DEFINE_CONST_FUN_OBJ_VAR_BETWEEN(mp_lv_kb_get_cursor_manage_obj, 1, 1, mp_lv_kb_get_cursor_manage); + + + +/* + * lvgl extension definition for: + * lv_action_t lv_kb_get_ok_action(const lv_obj_t *kb) + */ + +STATIC mp_obj_t mp_lv_kb_get_ok_action(size_t n_args, const mp_obj_t *args) +{ + const lv_obj_t *kb = mp_to_lv(args[0]); + lv_action_t res = lv_kb_get_ok_action(kb); + return ptr_to_mp(res); +} + +STATIC MP_DEFINE_CONST_FUN_OBJ_VAR_BETWEEN(mp_lv_kb_get_ok_action_obj, 1, 1, mp_lv_kb_get_ok_action); + + + +/* + * lvgl extension definition for: + * lv_action_t lv_kb_get_hide_action(const lv_obj_t *kb) + */ + +STATIC mp_obj_t mp_lv_kb_get_hide_action(size_t n_args, const mp_obj_t *args) +{ + const lv_obj_t *kb = mp_to_lv(args[0]); + lv_action_t res = lv_kb_get_hide_action(kb); + return ptr_to_mp(res); +} + +STATIC MP_DEFINE_CONST_FUN_OBJ_VAR_BETWEEN(mp_lv_kb_get_hide_action_obj, 1, 1, mp_lv_kb_get_hide_action); + + + +/* + * lvgl extension definition for: + * lv_style_t *lv_kb_get_style(const lv_obj_t *kb, lv_kb_style_t type) + */ + +STATIC mp_obj_t mp_lv_kb_get_style(size_t n_args, const mp_obj_t *args) +{ + const lv_obj_t *kb = mp_to_lv(args[0]); + lv_kb_style_t type = (uint8_t)mp_obj_get_int(args[1]); + lv_style_t* res = lv_kb_get_style(kb, type); + return mp_read_ptr_lv_style_t((void*)res); +} + +STATIC MP_DEFINE_CONST_FUN_OBJ_VAR_BETWEEN(mp_lv_kb_get_style_obj, 2, 2, mp_lv_kb_get_style); + + + +/* + * lvgl kb object definitions + */ + + +STATIC const mp_rom_map_elem_t kb_locals_dict_table[] = { + { MP_ROM_QSTR(MP_QSTR_set_map), MP_ROM_PTR(&mp_lv_kb_set_map_obj) }, + { MP_ROM_QSTR(MP_QSTR_set_ta), MP_ROM_PTR(&mp_lv_kb_set_ta_obj) }, + { MP_ROM_QSTR(MP_QSTR_set_mode), MP_ROM_PTR(&mp_lv_kb_set_mode_obj) }, + { MP_ROM_QSTR(MP_QSTR_set_cursor_manage), MP_ROM_PTR(&mp_lv_kb_set_cursor_manage_obj) }, + { MP_ROM_QSTR(MP_QSTR_set_ok_action), MP_ROM_PTR(&mp_lv_kb_set_ok_action_obj) }, + { MP_ROM_QSTR(MP_QSTR_set_hide_action), MP_ROM_PTR(&mp_lv_kb_set_hide_action_obj) }, + { MP_ROM_QSTR(MP_QSTR_set_style), MP_ROM_PTR(&mp_lv_kb_set_style_obj) }, + { MP_ROM_QSTR(MP_QSTR_get_ta), MP_ROM_PTR(&mp_lv_kb_get_ta_obj) }, + { MP_ROM_QSTR(MP_QSTR_get_mode), MP_ROM_PTR(&mp_lv_kb_get_mode_obj) }, + { MP_ROM_QSTR(MP_QSTR_get_cursor_manage), MP_ROM_PTR(&mp_lv_kb_get_cursor_manage_obj) }, + { MP_ROM_QSTR(MP_QSTR_get_ok_action), MP_ROM_PTR(&mp_lv_kb_get_ok_action_obj) }, + { MP_ROM_QSTR(MP_QSTR_get_hide_action), MP_ROM_PTR(&mp_lv_kb_get_hide_action_obj) }, + { MP_ROM_QSTR(MP_QSTR_get_style), MP_ROM_PTR(&mp_lv_kb_get_style_obj) }, + { MP_ROM_QSTR(MP_QSTR_delete), MP_ROM_PTR(&mp_lv_obj_del_obj) }, + { MP_ROM_QSTR(MP_QSTR_clean), MP_ROM_PTR(&mp_lv_obj_clean_obj) }, + { MP_ROM_QSTR(MP_QSTR_invalidate), MP_ROM_PTR(&mp_lv_obj_invalidate_obj) }, + { MP_ROM_QSTR(MP_QSTR_set_parent), MP_ROM_PTR(&mp_lv_obj_set_parent_obj) }, + { MP_ROM_QSTR(MP_QSTR_set_pos), MP_ROM_PTR(&mp_lv_obj_set_pos_obj) }, + { MP_ROM_QSTR(MP_QSTR_set_x), MP_ROM_PTR(&mp_lv_obj_set_x_obj) }, + { MP_ROM_QSTR(MP_QSTR_set_y), MP_ROM_PTR(&mp_lv_obj_set_y_obj) }, + { MP_ROM_QSTR(MP_QSTR_set_size), MP_ROM_PTR(&mp_lv_obj_set_size_obj) }, + { MP_ROM_QSTR(MP_QSTR_set_width), MP_ROM_PTR(&mp_lv_obj_set_width_obj) }, + { MP_ROM_QSTR(MP_QSTR_set_height), MP_ROM_PTR(&mp_lv_obj_set_height_obj) }, + { MP_ROM_QSTR(MP_QSTR_align), MP_ROM_PTR(&mp_lv_obj_align_obj) }, + { MP_ROM_QSTR(MP_QSTR_align_origo), MP_ROM_PTR(&mp_lv_obj_align_origo_obj) }, + { MP_ROM_QSTR(MP_QSTR_realign), MP_ROM_PTR(&mp_lv_obj_realign_obj) }, + { MP_ROM_QSTR(MP_QSTR_set_auto_realign), MP_ROM_PTR(&mp_lv_obj_set_auto_realign_obj) }, + { MP_ROM_QSTR(MP_QSTR_set_style), MP_ROM_PTR(&mp_lv_obj_set_style_obj) }, + { MP_ROM_QSTR(MP_QSTR_refresh_style), MP_ROM_PTR(&mp_lv_obj_refresh_style_obj) }, + { MP_ROM_QSTR(MP_QSTR_report_style_mod), MP_ROM_PTR(&mp_lv_obj_report_style_mod_obj) }, + { MP_ROM_QSTR(MP_QSTR_set_hidden), MP_ROM_PTR(&mp_lv_obj_set_hidden_obj) }, + { MP_ROM_QSTR(MP_QSTR_set_click), MP_ROM_PTR(&mp_lv_obj_set_click_obj) }, + { MP_ROM_QSTR(MP_QSTR_set_top), MP_ROM_PTR(&mp_lv_obj_set_top_obj) }, + { MP_ROM_QSTR(MP_QSTR_set_drag), MP_ROM_PTR(&mp_lv_obj_set_drag_obj) }, + { MP_ROM_QSTR(MP_QSTR_set_drag_throw), MP_ROM_PTR(&mp_lv_obj_set_drag_throw_obj) }, + { MP_ROM_QSTR(MP_QSTR_set_drag_parent), MP_ROM_PTR(&mp_lv_obj_set_drag_parent_obj) }, + { MP_ROM_QSTR(MP_QSTR_set_opa_scale_enable), MP_ROM_PTR(&mp_lv_obj_set_opa_scale_enable_obj) }, + { MP_ROM_QSTR(MP_QSTR_set_opa_scale), MP_ROM_PTR(&mp_lv_obj_set_opa_scale_obj) }, + { MP_ROM_QSTR(MP_QSTR_set_protect), MP_ROM_PTR(&mp_lv_obj_set_protect_obj) }, + { MP_ROM_QSTR(MP_QSTR_clear_protect), MP_ROM_PTR(&mp_lv_obj_clear_protect_obj) }, + { MP_ROM_QSTR(MP_QSTR_set_signal_func), MP_ROM_PTR(&mp_lv_obj_set_signal_func_obj) }, + { MP_ROM_QSTR(MP_QSTR_set_design_func), MP_ROM_PTR(&mp_lv_obj_set_design_func_obj) }, + { MP_ROM_QSTR(MP_QSTR_allocate_ext_attr), MP_ROM_PTR(&mp_lv_obj_allocate_ext_attr_obj) }, + { MP_ROM_QSTR(MP_QSTR_refresh_ext_size), MP_ROM_PTR(&mp_lv_obj_refresh_ext_size_obj) }, + { MP_ROM_QSTR(MP_QSTR_set_free_num), MP_ROM_PTR(&mp_lv_obj_set_free_num_obj) }, + { MP_ROM_QSTR(MP_QSTR_set_free_ptr), MP_ROM_PTR(&mp_lv_obj_set_free_ptr_obj) }, + { MP_ROM_QSTR(MP_QSTR_animate), MP_ROM_PTR(&mp_lv_obj_animate_obj) }, + { MP_ROM_QSTR(MP_QSTR_get_screen), MP_ROM_PTR(&mp_lv_obj_get_screen_obj) }, + { MP_ROM_QSTR(MP_QSTR_get_parent), MP_ROM_PTR(&mp_lv_obj_get_parent_obj) }, + { MP_ROM_QSTR(MP_QSTR_get_child), MP_ROM_PTR(&mp_lv_obj_get_child_obj) }, + { MP_ROM_QSTR(MP_QSTR_get_child_back), MP_ROM_PTR(&mp_lv_obj_get_child_back_obj) }, + { MP_ROM_QSTR(MP_QSTR_count_children), MP_ROM_PTR(&mp_lv_obj_count_children_obj) }, + { MP_ROM_QSTR(MP_QSTR_get_coords), MP_ROM_PTR(&mp_lv_obj_get_coords_obj) }, + { MP_ROM_QSTR(MP_QSTR_get_x), MP_ROM_PTR(&mp_lv_obj_get_x_obj) }, + { MP_ROM_QSTR(MP_QSTR_get_y), MP_ROM_PTR(&mp_lv_obj_get_y_obj) }, + { MP_ROM_QSTR(MP_QSTR_get_width), MP_ROM_PTR(&mp_lv_obj_get_width_obj) }, + { MP_ROM_QSTR(MP_QSTR_get_height), MP_ROM_PTR(&mp_lv_obj_get_height_obj) }, + { MP_ROM_QSTR(MP_QSTR_get_ext_size), MP_ROM_PTR(&mp_lv_obj_get_ext_size_obj) }, + { MP_ROM_QSTR(MP_QSTR_get_auto_realign), MP_ROM_PTR(&mp_lv_obj_get_auto_realign_obj) }, + { MP_ROM_QSTR(MP_QSTR_get_style), MP_ROM_PTR(&mp_lv_obj_get_style_obj) }, + { MP_ROM_QSTR(MP_QSTR_get_hidden), MP_ROM_PTR(&mp_lv_obj_get_hidden_obj) }, + { MP_ROM_QSTR(MP_QSTR_get_click), MP_ROM_PTR(&mp_lv_obj_get_click_obj) }, + { MP_ROM_QSTR(MP_QSTR_get_top), MP_ROM_PTR(&mp_lv_obj_get_top_obj) }, + { MP_ROM_QSTR(MP_QSTR_get_drag), MP_ROM_PTR(&mp_lv_obj_get_drag_obj) }, + { MP_ROM_QSTR(MP_QSTR_get_drag_throw), MP_ROM_PTR(&mp_lv_obj_get_drag_throw_obj) }, + { MP_ROM_QSTR(MP_QSTR_get_drag_parent), MP_ROM_PTR(&mp_lv_obj_get_drag_parent_obj) }, + { MP_ROM_QSTR(MP_QSTR_get_opa_scale_enable), MP_ROM_PTR(&mp_lv_obj_get_opa_scale_enable_obj) }, + { MP_ROM_QSTR(MP_QSTR_get_opa_scale), MP_ROM_PTR(&mp_lv_obj_get_opa_scale_obj) }, + { MP_ROM_QSTR(MP_QSTR_get_protect), MP_ROM_PTR(&mp_lv_obj_get_protect_obj) }, + { MP_ROM_QSTR(MP_QSTR_is_protected), MP_ROM_PTR(&mp_lv_obj_is_protected_obj) }, + { MP_ROM_QSTR(MP_QSTR_get_signal_func), MP_ROM_PTR(&mp_lv_obj_get_signal_func_obj) }, + { MP_ROM_QSTR(MP_QSTR_get_design_func), MP_ROM_PTR(&mp_lv_obj_get_design_func_obj) }, + { MP_ROM_QSTR(MP_QSTR_get_ext_attr), MP_ROM_PTR(&mp_lv_obj_get_ext_attr_obj) }, + { MP_ROM_QSTR(MP_QSTR_get_free_num), MP_ROM_PTR(&mp_lv_obj_get_free_num_obj) }, + { MP_ROM_QSTR(MP_QSTR_get_free_ptr), MP_ROM_PTR(&mp_lv_obj_get_free_ptr_obj) }, + { MP_ROM_QSTR(MP_QSTR_get_group), MP_ROM_PTR(&mp_lv_obj_get_group_obj) }, + { MP_ROM_QSTR(MP_QSTR_is_focused), MP_ROM_PTR(&mp_lv_obj_is_focused_obj) }, + { MP_ROM_QSTR(MP_QSTR_MODE), MP_ROM_PTR(&mp_LV_KB_MODE_type) }, + { MP_ROM_QSTR(MP_QSTR_STYLE), MP_ROM_PTR(&mp_LV_KB_STYLE_type) } +}; + +STATIC MP_DEFINE_CONST_DICT(kb_locals_dict, kb_locals_dict_table); + +STATIC void kb_print(const mp_print_t *print, + mp_obj_t self_in, + mp_print_kind_t kind) +{ + mp_printf(print, "lvgl kb"); +} + + +STATIC mp_obj_t kb_make_new( + const mp_obj_type_t *type, + size_t n_args, + size_t n_kw, + const mp_obj_t *args) +{ + return make_new(&lv_kb_create, type, n_args, n_kw, args); +} + + +STATIC const mp_obj_type_t mp_kb_type = { + { &mp_type_type }, + .name = MP_QSTR_kb, + .print = kb_print, + .make_new = kb_make_new, + .locals_dict = (mp_obj_dict_t*)&kb_locals_dict, +}; + + +/* + * lvgl extension definition for: + * inline static void lv_ddlist_set_sb_mode(lv_obj_t *ddlist, lv_sb_mode_t mode) + */ + +STATIC mp_obj_t mp_lv_ddlist_set_sb_mode(size_t n_args, const mp_obj_t *args) +{ + lv_obj_t *ddlist = mp_to_lv(args[0]); + lv_sb_mode_t mode = (uint8_t)mp_obj_get_int(args[1]); + lv_ddlist_set_sb_mode(ddlist, mode); + return mp_const_none; +} + +STATIC MP_DEFINE_CONST_FUN_OBJ_VAR_BETWEEN(mp_lv_ddlist_set_sb_mode_obj, 2, 2, mp_lv_ddlist_set_sb_mode); + + + +/* + * lvgl extension definition for: + * inline static lv_sb_mode_t lv_ddlist_get_sb_mode(const lv_obj_t *ddlist) + */ + +STATIC mp_obj_t mp_lv_ddlist_get_sb_mode(size_t n_args, const mp_obj_t *args) +{ + const lv_obj_t *ddlist = mp_to_lv(args[0]); + lv_sb_mode_t res = lv_ddlist_get_sb_mode(ddlist); + return mp_obj_new_int_from_uint(res); +} + +STATIC MP_DEFINE_CONST_FUN_OBJ_VAR_BETWEEN(mp_lv_ddlist_get_sb_mode_obj, 1, 1, mp_lv_ddlist_get_sb_mode); + + + +/* + * lvgl extension definition for: + * void lv_ddlist_set_draw_arrow(lv_obj_t *ddlist, bool en) + */ + +STATIC mp_obj_t mp_lv_ddlist_set_draw_arrow(size_t n_args, const mp_obj_t *args) +{ + lv_obj_t *ddlist = mp_to_lv(args[0]); + bool en = mp_obj_is_true(args[1]); + lv_ddlist_set_draw_arrow(ddlist, en); + return mp_const_none; +} + +STATIC MP_DEFINE_CONST_FUN_OBJ_VAR_BETWEEN(mp_lv_ddlist_set_draw_arrow_obj, 2, 2, mp_lv_ddlist_set_draw_arrow); + + + +/* + * lvgl extension definition for: + * void lv_ddlist_set_options(lv_obj_t *ddlist, const char *options) + */ + +STATIC mp_obj_t mp_lv_ddlist_set_options(size_t n_args, const mp_obj_t *args) +{ + lv_obj_t *ddlist = mp_to_lv(args[0]); + const char *options = (char*)mp_obj_str_get_str(args[1]); + lv_ddlist_set_options(ddlist, options); + return mp_const_none; +} + +STATIC MP_DEFINE_CONST_FUN_OBJ_VAR_BETWEEN(mp_lv_ddlist_set_options_obj, 2, 2, mp_lv_ddlist_set_options); + + + +/* + * lvgl extension definition for: + * void lv_ddlist_set_selected(lv_obj_t *ddlist, uint16_t sel_opt) + */ + +STATIC mp_obj_t mp_lv_ddlist_set_selected(size_t n_args, const mp_obj_t *args) +{ + lv_obj_t *ddlist = mp_to_lv(args[0]); + uint16_t sel_opt = (uint16_t)mp_obj_get_int(args[1]); + lv_ddlist_set_selected(ddlist, sel_opt); + return mp_const_none; +} + +STATIC MP_DEFINE_CONST_FUN_OBJ_VAR_BETWEEN(mp_lv_ddlist_set_selected_obj, 2, 2, mp_lv_ddlist_set_selected); + + + +/* + * lvgl extension definition for: + * void lv_ddlist_set_action(lv_obj_t *ddlist, lv_action_t action) + */ + +STATIC mp_obj_t mp_lv_ddlist_set_action(size_t n_args, const mp_obj_t *args) +{ + lv_obj_t *ddlist = mp_to_lv(args[0]); + set_action(args[0], args[1]); + lv_action_t action = &lv_action_t_callback; + lv_ddlist_set_action(ddlist, action); + return mp_const_none; +} + +STATIC MP_DEFINE_CONST_FUN_OBJ_VAR_BETWEEN(mp_lv_ddlist_set_action_obj, 2, 2, mp_lv_ddlist_set_action); + + + +/* + * lvgl extension definition for: + * void lv_ddlist_set_fix_height(lv_obj_t *ddlist, lv_coord_t h) + */ + +STATIC mp_obj_t mp_lv_ddlist_set_fix_height(size_t n_args, const mp_obj_t *args) +{ + lv_obj_t *ddlist = mp_to_lv(args[0]); + lv_coord_t h = (int16_t)mp_obj_get_int(args[1]); + lv_ddlist_set_fix_height(ddlist, h); + return mp_const_none; +} + +STATIC MP_DEFINE_CONST_FUN_OBJ_VAR_BETWEEN(mp_lv_ddlist_set_fix_height_obj, 2, 2, mp_lv_ddlist_set_fix_height); + + + +/* + * lvgl extension definition for: + * void lv_ddlist_set_hor_fit(lv_obj_t *ddlist, bool en) + */ + +STATIC mp_obj_t mp_lv_ddlist_set_hor_fit(size_t n_args, const mp_obj_t *args) +{ + lv_obj_t *ddlist = mp_to_lv(args[0]); + bool en = mp_obj_is_true(args[1]); + lv_ddlist_set_hor_fit(ddlist, en); + return mp_const_none; +} + +STATIC MP_DEFINE_CONST_FUN_OBJ_VAR_BETWEEN(mp_lv_ddlist_set_hor_fit_obj, 2, 2, mp_lv_ddlist_set_hor_fit); + + + +/* + * lvgl extension definition for: + * void lv_ddlist_set_anim_time(lv_obj_t *ddlist, uint16_t anim_time) + */ + +STATIC mp_obj_t mp_lv_ddlist_set_anim_time(size_t n_args, const mp_obj_t *args) +{ + lv_obj_t *ddlist = mp_to_lv(args[0]); + uint16_t anim_time = (uint16_t)mp_obj_get_int(args[1]); + lv_ddlist_set_anim_time(ddlist, anim_time); + return mp_const_none; +} + +STATIC MP_DEFINE_CONST_FUN_OBJ_VAR_BETWEEN(mp_lv_ddlist_set_anim_time_obj, 2, 2, mp_lv_ddlist_set_anim_time); + + + +/* + * lvgl extension definition for: + * void lv_ddlist_set_style(lv_obj_t *ddlist, lv_ddlist_style_t type, lv_style_t *style) + */ + +STATIC mp_obj_t mp_lv_ddlist_set_style(size_t n_args, const mp_obj_t *args) +{ + lv_obj_t *ddlist = mp_to_lv(args[0]); + lv_ddlist_style_t type = (uint8_t)mp_obj_get_int(args[1]); + lv_style_t *style = mp_write_ptr_lv_style_t(args[2]); + lv_ddlist_set_style(ddlist, type, style); + return mp_const_none; +} + +STATIC MP_DEFINE_CONST_FUN_OBJ_VAR_BETWEEN(mp_lv_ddlist_set_style_obj, 3, 3, mp_lv_ddlist_set_style); + + + +/* + * lvgl extension definition for: + * void lv_ddlist_set_align(lv_obj_t *ddlist, lv_label_align_t align) + */ + +STATIC mp_obj_t mp_lv_ddlist_set_align(size_t n_args, const mp_obj_t *args) +{ + lv_obj_t *ddlist = mp_to_lv(args[0]); + lv_label_align_t align = (uint8_t)mp_obj_get_int(args[1]); + lv_ddlist_set_align(ddlist, align); + return mp_const_none; +} + +STATIC MP_DEFINE_CONST_FUN_OBJ_VAR_BETWEEN(mp_lv_ddlist_set_align_obj, 2, 2, mp_lv_ddlist_set_align); + + + +/* + * lvgl extension definition for: + * bool lv_ddlist_get_draw_arrow(lv_obj_t *ddlist) + */ + +STATIC mp_obj_t mp_lv_ddlist_get_draw_arrow(size_t n_args, const mp_obj_t *args) +{ + lv_obj_t *ddlist = mp_to_lv(args[0]); + bool res = lv_ddlist_get_draw_arrow(ddlist); + return convert_to_bool(res); +} + +STATIC MP_DEFINE_CONST_FUN_OBJ_VAR_BETWEEN(mp_lv_ddlist_get_draw_arrow_obj, 1, 1, mp_lv_ddlist_get_draw_arrow); + + + +/* + * lvgl extension definition for: + * const char *lv_ddlist_get_options(const lv_obj_t *ddlist) + */ + +STATIC mp_obj_t mp_lv_ddlist_get_options(size_t n_args, const mp_obj_t *args) +{ + const lv_obj_t *ddlist = mp_to_lv(args[0]); + const char* res = lv_ddlist_get_options(ddlist); + return convert_to_str((void*)res); +} + +STATIC MP_DEFINE_CONST_FUN_OBJ_VAR_BETWEEN(mp_lv_ddlist_get_options_obj, 1, 1, mp_lv_ddlist_get_options); + + + +/* + * lvgl extension definition for: + * uint16_t lv_ddlist_get_selected(const lv_obj_t *ddlist) + */ + +STATIC mp_obj_t mp_lv_ddlist_get_selected(size_t n_args, const mp_obj_t *args) +{ + const lv_obj_t *ddlist = mp_to_lv(args[0]); + uint16_t res = lv_ddlist_get_selected(ddlist); + return mp_obj_new_int_from_uint(res); +} + +STATIC MP_DEFINE_CONST_FUN_OBJ_VAR_BETWEEN(mp_lv_ddlist_get_selected_obj, 1, 1, mp_lv_ddlist_get_selected); + + + +/* + * lvgl extension definition for: + * void lv_ddlist_get_selected_str(const lv_obj_t *ddlist, char *buf) + */ + +STATIC mp_obj_t mp_lv_ddlist_get_selected_str(size_t n_args, const mp_obj_t *args) +{ + const lv_obj_t *ddlist = mp_to_lv(args[0]); + char *buf = (char*)mp_obj_str_get_str(args[1]); + lv_ddlist_get_selected_str(ddlist, buf); + return mp_const_none; +} + +STATIC MP_DEFINE_CONST_FUN_OBJ_VAR_BETWEEN(mp_lv_ddlist_get_selected_str_obj, 2, 2, mp_lv_ddlist_get_selected_str); + + + +/* + * lvgl extension definition for: + * lv_action_t lv_ddlist_get_action(const lv_obj_t *ddlist) + */ + +STATIC mp_obj_t mp_lv_ddlist_get_action(size_t n_args, const mp_obj_t *args) +{ + const lv_obj_t *ddlist = mp_to_lv(args[0]); + lv_action_t res = lv_ddlist_get_action(ddlist); + return ptr_to_mp(res); +} + +STATIC MP_DEFINE_CONST_FUN_OBJ_VAR_BETWEEN(mp_lv_ddlist_get_action_obj, 1, 1, mp_lv_ddlist_get_action); + + + +/* + * lvgl extension definition for: + * lv_coord_t lv_ddlist_get_fix_height(const lv_obj_t *ddlist) + */ + +STATIC mp_obj_t mp_lv_ddlist_get_fix_height(size_t n_args, const mp_obj_t *args) +{ + const lv_obj_t *ddlist = mp_to_lv(args[0]); + lv_coord_t res = lv_ddlist_get_fix_height(ddlist); + return mp_obj_new_int(res); +} + +STATIC MP_DEFINE_CONST_FUN_OBJ_VAR_BETWEEN(mp_lv_ddlist_get_fix_height_obj, 1, 1, mp_lv_ddlist_get_fix_height); + + + +/* + * lvgl extension definition for: + * uint16_t lv_ddlist_get_anim_time(const lv_obj_t *ddlist) + */ + +STATIC mp_obj_t mp_lv_ddlist_get_anim_time(size_t n_args, const mp_obj_t *args) +{ + const lv_obj_t *ddlist = mp_to_lv(args[0]); + uint16_t res = lv_ddlist_get_anim_time(ddlist); + return mp_obj_new_int_from_uint(res); +} + +STATIC MP_DEFINE_CONST_FUN_OBJ_VAR_BETWEEN(mp_lv_ddlist_get_anim_time_obj, 1, 1, mp_lv_ddlist_get_anim_time); + + + +/* + * lvgl extension definition for: + * lv_style_t *lv_ddlist_get_style(const lv_obj_t *ddlist, lv_ddlist_style_t type) + */ + +STATIC mp_obj_t mp_lv_ddlist_get_style(size_t n_args, const mp_obj_t *args) +{ + const lv_obj_t *ddlist = mp_to_lv(args[0]); + lv_ddlist_style_t type = (uint8_t)mp_obj_get_int(args[1]); + lv_style_t* res = lv_ddlist_get_style(ddlist, type); + return mp_read_ptr_lv_style_t((void*)res); +} + +STATIC MP_DEFINE_CONST_FUN_OBJ_VAR_BETWEEN(mp_lv_ddlist_get_style_obj, 2, 2, mp_lv_ddlist_get_style); + + + +/* + * lvgl extension definition for: + * lv_label_align_t lv_ddlist_get_align(const lv_obj_t *ddlist) + */ + +STATIC mp_obj_t mp_lv_ddlist_get_align(size_t n_args, const mp_obj_t *args) +{ + const lv_obj_t *ddlist = mp_to_lv(args[0]); + lv_label_align_t res = lv_ddlist_get_align(ddlist); + return mp_obj_new_int_from_uint(res); +} + +STATIC MP_DEFINE_CONST_FUN_OBJ_VAR_BETWEEN(mp_lv_ddlist_get_align_obj, 1, 1, mp_lv_ddlist_get_align); + + + +/* + * lvgl extension definition for: + * void lv_ddlist_open(lv_obj_t *ddlist, bool anim_en) + */ + +STATIC mp_obj_t mp_lv_ddlist_open(size_t n_args, const mp_obj_t *args) +{ + lv_obj_t *ddlist = mp_to_lv(args[0]); + bool anim_en = mp_obj_is_true(args[1]); + lv_ddlist_open(ddlist, anim_en); + return mp_const_none; +} + +STATIC MP_DEFINE_CONST_FUN_OBJ_VAR_BETWEEN(mp_lv_ddlist_open_obj, 2, 2, mp_lv_ddlist_open); + + + +/* + * lvgl extension definition for: + * void lv_ddlist_close(lv_obj_t *ddlist, bool anim_en) + */ + +STATIC mp_obj_t mp_lv_ddlist_close(size_t n_args, const mp_obj_t *args) +{ + lv_obj_t *ddlist = mp_to_lv(args[0]); + bool anim_en = mp_obj_is_true(args[1]); + lv_ddlist_close(ddlist, anim_en); + return mp_const_none; +} + +STATIC MP_DEFINE_CONST_FUN_OBJ_VAR_BETWEEN(mp_lv_ddlist_close_obj, 2, 2, mp_lv_ddlist_close); + + + +/* + * lvgl ddlist object definitions + */ + + +STATIC const mp_rom_map_elem_t ddlist_locals_dict_table[] = { + { MP_ROM_QSTR(MP_QSTR_set_sb_mode), MP_ROM_PTR(&mp_lv_ddlist_set_sb_mode_obj) }, + { MP_ROM_QSTR(MP_QSTR_get_sb_mode), MP_ROM_PTR(&mp_lv_ddlist_get_sb_mode_obj) }, + { MP_ROM_QSTR(MP_QSTR_set_draw_arrow), MP_ROM_PTR(&mp_lv_ddlist_set_draw_arrow_obj) }, + { MP_ROM_QSTR(MP_QSTR_set_options), MP_ROM_PTR(&mp_lv_ddlist_set_options_obj) }, + { MP_ROM_QSTR(MP_QSTR_set_selected), MP_ROM_PTR(&mp_lv_ddlist_set_selected_obj) }, + { MP_ROM_QSTR(MP_QSTR_set_action), MP_ROM_PTR(&mp_lv_ddlist_set_action_obj) }, + { MP_ROM_QSTR(MP_QSTR_set_fix_height), MP_ROM_PTR(&mp_lv_ddlist_set_fix_height_obj) }, + { MP_ROM_QSTR(MP_QSTR_set_hor_fit), MP_ROM_PTR(&mp_lv_ddlist_set_hor_fit_obj) }, + { MP_ROM_QSTR(MP_QSTR_set_anim_time), MP_ROM_PTR(&mp_lv_ddlist_set_anim_time_obj) }, + { MP_ROM_QSTR(MP_QSTR_set_style), MP_ROM_PTR(&mp_lv_ddlist_set_style_obj) }, + { MP_ROM_QSTR(MP_QSTR_set_align), MP_ROM_PTR(&mp_lv_ddlist_set_align_obj) }, + { MP_ROM_QSTR(MP_QSTR_get_draw_arrow), MP_ROM_PTR(&mp_lv_ddlist_get_draw_arrow_obj) }, + { MP_ROM_QSTR(MP_QSTR_get_options), MP_ROM_PTR(&mp_lv_ddlist_get_options_obj) }, + { MP_ROM_QSTR(MP_QSTR_get_selected), MP_ROM_PTR(&mp_lv_ddlist_get_selected_obj) }, + { MP_ROM_QSTR(MP_QSTR_get_selected_str), MP_ROM_PTR(&mp_lv_ddlist_get_selected_str_obj) }, + { MP_ROM_QSTR(MP_QSTR_get_action), MP_ROM_PTR(&mp_lv_ddlist_get_action_obj) }, + { MP_ROM_QSTR(MP_QSTR_get_fix_height), MP_ROM_PTR(&mp_lv_ddlist_get_fix_height_obj) }, + { MP_ROM_QSTR(MP_QSTR_get_anim_time), MP_ROM_PTR(&mp_lv_ddlist_get_anim_time_obj) }, + { MP_ROM_QSTR(MP_QSTR_get_style), MP_ROM_PTR(&mp_lv_ddlist_get_style_obj) }, + { MP_ROM_QSTR(MP_QSTR_get_align), MP_ROM_PTR(&mp_lv_ddlist_get_align_obj) }, + { MP_ROM_QSTR(MP_QSTR_open), MP_ROM_PTR(&mp_lv_ddlist_open_obj) }, + { MP_ROM_QSTR(MP_QSTR_close), MP_ROM_PTR(&mp_lv_ddlist_close_obj) }, + { MP_ROM_QSTR(MP_QSTR_delete), MP_ROM_PTR(&mp_lv_obj_del_obj) }, + { MP_ROM_QSTR(MP_QSTR_clean), MP_ROM_PTR(&mp_lv_obj_clean_obj) }, + { MP_ROM_QSTR(MP_QSTR_invalidate), MP_ROM_PTR(&mp_lv_obj_invalidate_obj) }, + { MP_ROM_QSTR(MP_QSTR_set_parent), MP_ROM_PTR(&mp_lv_obj_set_parent_obj) }, + { MP_ROM_QSTR(MP_QSTR_set_pos), MP_ROM_PTR(&mp_lv_obj_set_pos_obj) }, + { MP_ROM_QSTR(MP_QSTR_set_x), MP_ROM_PTR(&mp_lv_obj_set_x_obj) }, + { MP_ROM_QSTR(MP_QSTR_set_y), MP_ROM_PTR(&mp_lv_obj_set_y_obj) }, + { MP_ROM_QSTR(MP_QSTR_set_size), MP_ROM_PTR(&mp_lv_obj_set_size_obj) }, + { MP_ROM_QSTR(MP_QSTR_set_width), MP_ROM_PTR(&mp_lv_obj_set_width_obj) }, + { MP_ROM_QSTR(MP_QSTR_set_height), MP_ROM_PTR(&mp_lv_obj_set_height_obj) }, + { MP_ROM_QSTR(MP_QSTR_align), MP_ROM_PTR(&mp_lv_obj_align_obj) }, + { MP_ROM_QSTR(MP_QSTR_align_origo), MP_ROM_PTR(&mp_lv_obj_align_origo_obj) }, + { MP_ROM_QSTR(MP_QSTR_realign), MP_ROM_PTR(&mp_lv_obj_realign_obj) }, + { MP_ROM_QSTR(MP_QSTR_set_auto_realign), MP_ROM_PTR(&mp_lv_obj_set_auto_realign_obj) }, + { MP_ROM_QSTR(MP_QSTR_set_style), MP_ROM_PTR(&mp_lv_obj_set_style_obj) }, + { MP_ROM_QSTR(MP_QSTR_refresh_style), MP_ROM_PTR(&mp_lv_obj_refresh_style_obj) }, + { MP_ROM_QSTR(MP_QSTR_report_style_mod), MP_ROM_PTR(&mp_lv_obj_report_style_mod_obj) }, + { MP_ROM_QSTR(MP_QSTR_set_hidden), MP_ROM_PTR(&mp_lv_obj_set_hidden_obj) }, + { MP_ROM_QSTR(MP_QSTR_set_click), MP_ROM_PTR(&mp_lv_obj_set_click_obj) }, + { MP_ROM_QSTR(MP_QSTR_set_top), MP_ROM_PTR(&mp_lv_obj_set_top_obj) }, + { MP_ROM_QSTR(MP_QSTR_set_drag), MP_ROM_PTR(&mp_lv_obj_set_drag_obj) }, + { MP_ROM_QSTR(MP_QSTR_set_drag_throw), MP_ROM_PTR(&mp_lv_obj_set_drag_throw_obj) }, + { MP_ROM_QSTR(MP_QSTR_set_drag_parent), MP_ROM_PTR(&mp_lv_obj_set_drag_parent_obj) }, + { MP_ROM_QSTR(MP_QSTR_set_opa_scale_enable), MP_ROM_PTR(&mp_lv_obj_set_opa_scale_enable_obj) }, + { MP_ROM_QSTR(MP_QSTR_set_opa_scale), MP_ROM_PTR(&mp_lv_obj_set_opa_scale_obj) }, + { MP_ROM_QSTR(MP_QSTR_set_protect), MP_ROM_PTR(&mp_lv_obj_set_protect_obj) }, + { MP_ROM_QSTR(MP_QSTR_clear_protect), MP_ROM_PTR(&mp_lv_obj_clear_protect_obj) }, + { MP_ROM_QSTR(MP_QSTR_set_signal_func), MP_ROM_PTR(&mp_lv_obj_set_signal_func_obj) }, + { MP_ROM_QSTR(MP_QSTR_set_design_func), MP_ROM_PTR(&mp_lv_obj_set_design_func_obj) }, + { MP_ROM_QSTR(MP_QSTR_allocate_ext_attr), MP_ROM_PTR(&mp_lv_obj_allocate_ext_attr_obj) }, + { MP_ROM_QSTR(MP_QSTR_refresh_ext_size), MP_ROM_PTR(&mp_lv_obj_refresh_ext_size_obj) }, + { MP_ROM_QSTR(MP_QSTR_set_free_num), MP_ROM_PTR(&mp_lv_obj_set_free_num_obj) }, + { MP_ROM_QSTR(MP_QSTR_set_free_ptr), MP_ROM_PTR(&mp_lv_obj_set_free_ptr_obj) }, + { MP_ROM_QSTR(MP_QSTR_animate), MP_ROM_PTR(&mp_lv_obj_animate_obj) }, + { MP_ROM_QSTR(MP_QSTR_get_screen), MP_ROM_PTR(&mp_lv_obj_get_screen_obj) }, + { MP_ROM_QSTR(MP_QSTR_get_parent), MP_ROM_PTR(&mp_lv_obj_get_parent_obj) }, + { MP_ROM_QSTR(MP_QSTR_get_child), MP_ROM_PTR(&mp_lv_obj_get_child_obj) }, + { MP_ROM_QSTR(MP_QSTR_get_child_back), MP_ROM_PTR(&mp_lv_obj_get_child_back_obj) }, + { MP_ROM_QSTR(MP_QSTR_count_children), MP_ROM_PTR(&mp_lv_obj_count_children_obj) }, + { MP_ROM_QSTR(MP_QSTR_get_coords), MP_ROM_PTR(&mp_lv_obj_get_coords_obj) }, + { MP_ROM_QSTR(MP_QSTR_get_x), MP_ROM_PTR(&mp_lv_obj_get_x_obj) }, + { MP_ROM_QSTR(MP_QSTR_get_y), MP_ROM_PTR(&mp_lv_obj_get_y_obj) }, + { MP_ROM_QSTR(MP_QSTR_get_width), MP_ROM_PTR(&mp_lv_obj_get_width_obj) }, + { MP_ROM_QSTR(MP_QSTR_get_height), MP_ROM_PTR(&mp_lv_obj_get_height_obj) }, + { MP_ROM_QSTR(MP_QSTR_get_ext_size), MP_ROM_PTR(&mp_lv_obj_get_ext_size_obj) }, + { MP_ROM_QSTR(MP_QSTR_get_auto_realign), MP_ROM_PTR(&mp_lv_obj_get_auto_realign_obj) }, + { MP_ROM_QSTR(MP_QSTR_get_style), MP_ROM_PTR(&mp_lv_obj_get_style_obj) }, + { MP_ROM_QSTR(MP_QSTR_get_hidden), MP_ROM_PTR(&mp_lv_obj_get_hidden_obj) }, + { MP_ROM_QSTR(MP_QSTR_get_click), MP_ROM_PTR(&mp_lv_obj_get_click_obj) }, + { MP_ROM_QSTR(MP_QSTR_get_top), MP_ROM_PTR(&mp_lv_obj_get_top_obj) }, + { MP_ROM_QSTR(MP_QSTR_get_drag), MP_ROM_PTR(&mp_lv_obj_get_drag_obj) }, + { MP_ROM_QSTR(MP_QSTR_get_drag_throw), MP_ROM_PTR(&mp_lv_obj_get_drag_throw_obj) }, + { MP_ROM_QSTR(MP_QSTR_get_drag_parent), MP_ROM_PTR(&mp_lv_obj_get_drag_parent_obj) }, + { MP_ROM_QSTR(MP_QSTR_get_opa_scale_enable), MP_ROM_PTR(&mp_lv_obj_get_opa_scale_enable_obj) }, + { MP_ROM_QSTR(MP_QSTR_get_opa_scale), MP_ROM_PTR(&mp_lv_obj_get_opa_scale_obj) }, + { MP_ROM_QSTR(MP_QSTR_get_protect), MP_ROM_PTR(&mp_lv_obj_get_protect_obj) }, + { MP_ROM_QSTR(MP_QSTR_is_protected), MP_ROM_PTR(&mp_lv_obj_is_protected_obj) }, + { MP_ROM_QSTR(MP_QSTR_get_signal_func), MP_ROM_PTR(&mp_lv_obj_get_signal_func_obj) }, + { MP_ROM_QSTR(MP_QSTR_get_design_func), MP_ROM_PTR(&mp_lv_obj_get_design_func_obj) }, + { MP_ROM_QSTR(MP_QSTR_get_ext_attr), MP_ROM_PTR(&mp_lv_obj_get_ext_attr_obj) }, + { MP_ROM_QSTR(MP_QSTR_get_free_num), MP_ROM_PTR(&mp_lv_obj_get_free_num_obj) }, + { MP_ROM_QSTR(MP_QSTR_get_free_ptr), MP_ROM_PTR(&mp_lv_obj_get_free_ptr_obj) }, + { MP_ROM_QSTR(MP_QSTR_get_group), MP_ROM_PTR(&mp_lv_obj_get_group_obj) }, + { MP_ROM_QSTR(MP_QSTR_is_focused), MP_ROM_PTR(&mp_lv_obj_is_focused_obj) }, + { MP_ROM_QSTR(MP_QSTR_STYLE), MP_ROM_PTR(&mp_LV_DDLIST_STYLE_type) } +}; + +STATIC MP_DEFINE_CONST_DICT(ddlist_locals_dict, ddlist_locals_dict_table); + +STATIC void ddlist_print(const mp_print_t *print, + mp_obj_t self_in, + mp_print_kind_t kind) +{ + mp_printf(print, "lvgl ddlist"); +} + + +STATIC mp_obj_t ddlist_make_new( + const mp_obj_type_t *type, + size_t n_args, + size_t n_kw, + const mp_obj_t *args) +{ + return make_new(&lv_ddlist_create, type, n_args, n_kw, args); +} + + +STATIC const mp_obj_type_t mp_ddlist_type = { + { &mp_type_type }, + .name = MP_QSTR_ddlist, + .print = ddlist_print, + .make_new = ddlist_make_new, + .locals_dict = (mp_obj_dict_t*)&ddlist_locals_dict, +}; + + +/* + * lvgl extension definition for: + * inline static void lv_roller_set_options(lv_obj_t *roller, const char *options) + */ + +STATIC mp_obj_t mp_lv_roller_set_options(size_t n_args, const mp_obj_t *args) +{ + lv_obj_t *roller = mp_to_lv(args[0]); + const char *options = (char*)mp_obj_str_get_str(args[1]); + lv_roller_set_options(roller, options); + return mp_const_none; +} + +STATIC MP_DEFINE_CONST_FUN_OBJ_VAR_BETWEEN(mp_lv_roller_set_options_obj, 2, 2, mp_lv_roller_set_options); + + + +/* + * lvgl extension definition for: + * inline static void lv_roller_set_action(lv_obj_t *roller, lv_action_t action) + */ + +STATIC mp_obj_t mp_lv_roller_set_action(size_t n_args, const mp_obj_t *args) +{ + lv_obj_t *roller = mp_to_lv(args[0]); + set_action(args[0], args[1]); + lv_action_t action = &lv_action_t_callback; + lv_roller_set_action(roller, action); + return mp_const_none; +} + +STATIC MP_DEFINE_CONST_FUN_OBJ_VAR_BETWEEN(mp_lv_roller_set_action_obj, 2, 2, mp_lv_roller_set_action); + + + +/* + * lvgl extension definition for: + * inline static void lv_roller_set_hor_fit(lv_obj_t *roller, bool en) + */ + +STATIC mp_obj_t mp_lv_roller_set_hor_fit(size_t n_args, const mp_obj_t *args) +{ + lv_obj_t *roller = mp_to_lv(args[0]); + bool en = mp_obj_is_true(args[1]); + lv_roller_set_hor_fit(roller, en); + return mp_const_none; +} + +STATIC MP_DEFINE_CONST_FUN_OBJ_VAR_BETWEEN(mp_lv_roller_set_hor_fit_obj, 2, 2, mp_lv_roller_set_hor_fit); + + + +/* + * lvgl extension definition for: + * inline static void lv_roller_set_anim_time(lv_obj_t *roller, uint16_t anim_time) + */ + +STATIC mp_obj_t mp_lv_roller_set_anim_time(size_t n_args, const mp_obj_t *args) +{ + lv_obj_t *roller = mp_to_lv(args[0]); + uint16_t anim_time = (uint16_t)mp_obj_get_int(args[1]); + lv_roller_set_anim_time(roller, anim_time); + return mp_const_none; +} + +STATIC MP_DEFINE_CONST_FUN_OBJ_VAR_BETWEEN(mp_lv_roller_set_anim_time_obj, 2, 2, mp_lv_roller_set_anim_time); + + + +/* + * lvgl extension definition for: + * inline static const char *lv_roller_get_options(const lv_obj_t *roller) + */ + +STATIC mp_obj_t mp_lv_roller_get_options(size_t n_args, const mp_obj_t *args) +{ + const lv_obj_t *roller = mp_to_lv(args[0]); + const char* res = lv_roller_get_options(roller); + return convert_to_str((void*)res); +} + +STATIC MP_DEFINE_CONST_FUN_OBJ_VAR_BETWEEN(mp_lv_roller_get_options_obj, 1, 1, mp_lv_roller_get_options); + + + +/* + * lvgl extension definition for: + * inline static uint16_t lv_roller_get_selected(const lv_obj_t *roller) + */ + +STATIC mp_obj_t mp_lv_roller_get_selected(size_t n_args, const mp_obj_t *args) +{ + const lv_obj_t *roller = mp_to_lv(args[0]); + uint16_t res = lv_roller_get_selected(roller); + return mp_obj_new_int_from_uint(res); +} + +STATIC MP_DEFINE_CONST_FUN_OBJ_VAR_BETWEEN(mp_lv_roller_get_selected_obj, 1, 1, mp_lv_roller_get_selected); + + + +/* + * lvgl extension definition for: + * inline static void lv_roller_get_selected_str(const lv_obj_t *roller, char *buf) + */ + +STATIC mp_obj_t mp_lv_roller_get_selected_str(size_t n_args, const mp_obj_t *args) +{ + const lv_obj_t *roller = mp_to_lv(args[0]); + char *buf = (char*)mp_obj_str_get_str(args[1]); + lv_roller_get_selected_str(roller, buf); + return mp_const_none; +} + +STATIC MP_DEFINE_CONST_FUN_OBJ_VAR_BETWEEN(mp_lv_roller_get_selected_str_obj, 2, 2, mp_lv_roller_get_selected_str); + + + +/* + * lvgl extension definition for: + * inline static lv_action_t lv_roller_get_action(const lv_obj_t *roller) + */ + +STATIC mp_obj_t mp_lv_roller_get_action(size_t n_args, const mp_obj_t *args) +{ + const lv_obj_t *roller = mp_to_lv(args[0]); + lv_action_t res = lv_roller_get_action(roller); + return ptr_to_mp(res); +} + +STATIC MP_DEFINE_CONST_FUN_OBJ_VAR_BETWEEN(mp_lv_roller_get_action_obj, 1, 1, mp_lv_roller_get_action); + + + +/* + * lvgl extension definition for: + * inline static uint16_t lv_roller_get_anim_time(const lv_obj_t *roller) + */ + +STATIC mp_obj_t mp_lv_roller_get_anim_time(size_t n_args, const mp_obj_t *args) +{ + const lv_obj_t *roller = mp_to_lv(args[0]); + uint16_t res = lv_roller_get_anim_time(roller); + return mp_obj_new_int_from_uint(res); +} + +STATIC MP_DEFINE_CONST_FUN_OBJ_VAR_BETWEEN(mp_lv_roller_get_anim_time_obj, 1, 1, mp_lv_roller_get_anim_time); + + + +/* + * lvgl extension definition for: + * void lv_roller_set_align(lv_obj_t *roller, lv_label_align_t align) + */ + +STATIC mp_obj_t mp_lv_roller_set_align(size_t n_args, const mp_obj_t *args) +{ + lv_obj_t *roller = mp_to_lv(args[0]); + lv_label_align_t align = (uint8_t)mp_obj_get_int(args[1]); + lv_roller_set_align(roller, align); + return mp_const_none; +} + +STATIC MP_DEFINE_CONST_FUN_OBJ_VAR_BETWEEN(mp_lv_roller_set_align_obj, 2, 2, mp_lv_roller_set_align); + + + +/* + * lvgl extension definition for: + * void lv_roller_set_selected(lv_obj_t *roller, uint16_t sel_opt, bool anim_en) + */ + +STATIC mp_obj_t mp_lv_roller_set_selected(size_t n_args, const mp_obj_t *args) +{ + lv_obj_t *roller = mp_to_lv(args[0]); + uint16_t sel_opt = (uint16_t)mp_obj_get_int(args[1]); + bool anim_en = mp_obj_is_true(args[2]); + lv_roller_set_selected(roller, sel_opt, anim_en); + return mp_const_none; +} + +STATIC MP_DEFINE_CONST_FUN_OBJ_VAR_BETWEEN(mp_lv_roller_set_selected_obj, 3, 3, mp_lv_roller_set_selected); + + + +/* + * lvgl extension definition for: + * void lv_roller_set_visible_row_count(lv_obj_t *roller, uint8_t row_cnt) + */ + +STATIC mp_obj_t mp_lv_roller_set_visible_row_count(size_t n_args, const mp_obj_t *args) +{ + lv_obj_t *roller = mp_to_lv(args[0]); + uint8_t row_cnt = (uint8_t)mp_obj_get_int(args[1]); + lv_roller_set_visible_row_count(roller, row_cnt); + return mp_const_none; +} + +STATIC MP_DEFINE_CONST_FUN_OBJ_VAR_BETWEEN(mp_lv_roller_set_visible_row_count_obj, 2, 2, mp_lv_roller_set_visible_row_count); + + + +/* + * lvgl extension definition for: + * void lv_roller_set_style(lv_obj_t *roller, lv_roller_style_t type, lv_style_t *style) + */ + +STATIC mp_obj_t mp_lv_roller_set_style(size_t n_args, const mp_obj_t *args) +{ + lv_obj_t *roller = mp_to_lv(args[0]); + lv_roller_style_t type = (uint8_t)mp_obj_get_int(args[1]); + lv_style_t *style = mp_write_ptr_lv_style_t(args[2]); + lv_roller_set_style(roller, type, style); + return mp_const_none; +} + +STATIC MP_DEFINE_CONST_FUN_OBJ_VAR_BETWEEN(mp_lv_roller_set_style_obj, 3, 3, mp_lv_roller_set_style); + + + +/* + * lvgl extension definition for: + * lv_label_align_t lv_roller_get_align(const lv_obj_t *roller) + */ + +STATIC mp_obj_t mp_lv_roller_get_align(size_t n_args, const mp_obj_t *args) +{ + const lv_obj_t *roller = mp_to_lv(args[0]); + lv_label_align_t res = lv_roller_get_align(roller); + return mp_obj_new_int_from_uint(res); +} + +STATIC MP_DEFINE_CONST_FUN_OBJ_VAR_BETWEEN(mp_lv_roller_get_align_obj, 1, 1, mp_lv_roller_get_align); + + + +/* + * lvgl extension definition for: + * bool lv_roller_get_hor_fit(const lv_obj_t *roller) + */ + +STATIC mp_obj_t mp_lv_roller_get_hor_fit(size_t n_args, const mp_obj_t *args) +{ + const lv_obj_t *roller = mp_to_lv(args[0]); + bool res = lv_roller_get_hor_fit(roller); + return convert_to_bool(res); +} + +STATIC MP_DEFINE_CONST_FUN_OBJ_VAR_BETWEEN(mp_lv_roller_get_hor_fit_obj, 1, 1, mp_lv_roller_get_hor_fit); + + + +/* + * lvgl extension definition for: + * lv_style_t *lv_roller_get_style(const lv_obj_t *roller, lv_roller_style_t type) + */ + +STATIC mp_obj_t mp_lv_roller_get_style(size_t n_args, const mp_obj_t *args) +{ + const lv_obj_t *roller = mp_to_lv(args[0]); + lv_roller_style_t type = (uint8_t)mp_obj_get_int(args[1]); + lv_style_t* res = lv_roller_get_style(roller, type); + return mp_read_ptr_lv_style_t((void*)res); +} + +STATIC MP_DEFINE_CONST_FUN_OBJ_VAR_BETWEEN(mp_lv_roller_get_style_obj, 2, 2, mp_lv_roller_get_style); + + + +/* + * lvgl roller object definitions + */ + + +STATIC const mp_rom_map_elem_t roller_locals_dict_table[] = { + { MP_ROM_QSTR(MP_QSTR_set_options), MP_ROM_PTR(&mp_lv_roller_set_options_obj) }, + { MP_ROM_QSTR(MP_QSTR_set_action), MP_ROM_PTR(&mp_lv_roller_set_action_obj) }, + { MP_ROM_QSTR(MP_QSTR_set_hor_fit), MP_ROM_PTR(&mp_lv_roller_set_hor_fit_obj) }, + { MP_ROM_QSTR(MP_QSTR_set_anim_time), MP_ROM_PTR(&mp_lv_roller_set_anim_time_obj) }, + { MP_ROM_QSTR(MP_QSTR_get_options), MP_ROM_PTR(&mp_lv_roller_get_options_obj) }, + { MP_ROM_QSTR(MP_QSTR_get_selected), MP_ROM_PTR(&mp_lv_roller_get_selected_obj) }, + { MP_ROM_QSTR(MP_QSTR_get_selected_str), MP_ROM_PTR(&mp_lv_roller_get_selected_str_obj) }, + { MP_ROM_QSTR(MP_QSTR_get_action), MP_ROM_PTR(&mp_lv_roller_get_action_obj) }, + { MP_ROM_QSTR(MP_QSTR_get_anim_time), MP_ROM_PTR(&mp_lv_roller_get_anim_time_obj) }, + { MP_ROM_QSTR(MP_QSTR_set_align), MP_ROM_PTR(&mp_lv_roller_set_align_obj) }, + { MP_ROM_QSTR(MP_QSTR_set_selected), MP_ROM_PTR(&mp_lv_roller_set_selected_obj) }, + { MP_ROM_QSTR(MP_QSTR_set_visible_row_count), MP_ROM_PTR(&mp_lv_roller_set_visible_row_count_obj) }, + { MP_ROM_QSTR(MP_QSTR_set_style), MP_ROM_PTR(&mp_lv_roller_set_style_obj) }, + { MP_ROM_QSTR(MP_QSTR_get_align), MP_ROM_PTR(&mp_lv_roller_get_align_obj) }, + { MP_ROM_QSTR(MP_QSTR_get_hor_fit), MP_ROM_PTR(&mp_lv_roller_get_hor_fit_obj) }, + { MP_ROM_QSTR(MP_QSTR_get_style), MP_ROM_PTR(&mp_lv_roller_get_style_obj) }, + { MP_ROM_QSTR(MP_QSTR_delete), MP_ROM_PTR(&mp_lv_obj_del_obj) }, + { MP_ROM_QSTR(MP_QSTR_clean), MP_ROM_PTR(&mp_lv_obj_clean_obj) }, + { MP_ROM_QSTR(MP_QSTR_invalidate), MP_ROM_PTR(&mp_lv_obj_invalidate_obj) }, + { MP_ROM_QSTR(MP_QSTR_set_parent), MP_ROM_PTR(&mp_lv_obj_set_parent_obj) }, + { MP_ROM_QSTR(MP_QSTR_set_pos), MP_ROM_PTR(&mp_lv_obj_set_pos_obj) }, + { MP_ROM_QSTR(MP_QSTR_set_x), MP_ROM_PTR(&mp_lv_obj_set_x_obj) }, + { MP_ROM_QSTR(MP_QSTR_set_y), MP_ROM_PTR(&mp_lv_obj_set_y_obj) }, + { MP_ROM_QSTR(MP_QSTR_set_size), MP_ROM_PTR(&mp_lv_obj_set_size_obj) }, + { MP_ROM_QSTR(MP_QSTR_set_width), MP_ROM_PTR(&mp_lv_obj_set_width_obj) }, + { MP_ROM_QSTR(MP_QSTR_set_height), MP_ROM_PTR(&mp_lv_obj_set_height_obj) }, + { MP_ROM_QSTR(MP_QSTR_align), MP_ROM_PTR(&mp_lv_obj_align_obj) }, + { MP_ROM_QSTR(MP_QSTR_align_origo), MP_ROM_PTR(&mp_lv_obj_align_origo_obj) }, + { MP_ROM_QSTR(MP_QSTR_realign), MP_ROM_PTR(&mp_lv_obj_realign_obj) }, + { MP_ROM_QSTR(MP_QSTR_set_auto_realign), MP_ROM_PTR(&mp_lv_obj_set_auto_realign_obj) }, + { MP_ROM_QSTR(MP_QSTR_set_style), MP_ROM_PTR(&mp_lv_obj_set_style_obj) }, + { MP_ROM_QSTR(MP_QSTR_refresh_style), MP_ROM_PTR(&mp_lv_obj_refresh_style_obj) }, + { MP_ROM_QSTR(MP_QSTR_report_style_mod), MP_ROM_PTR(&mp_lv_obj_report_style_mod_obj) }, + { MP_ROM_QSTR(MP_QSTR_set_hidden), MP_ROM_PTR(&mp_lv_obj_set_hidden_obj) }, + { MP_ROM_QSTR(MP_QSTR_set_click), MP_ROM_PTR(&mp_lv_obj_set_click_obj) }, + { MP_ROM_QSTR(MP_QSTR_set_top), MP_ROM_PTR(&mp_lv_obj_set_top_obj) }, + { MP_ROM_QSTR(MP_QSTR_set_drag), MP_ROM_PTR(&mp_lv_obj_set_drag_obj) }, + { MP_ROM_QSTR(MP_QSTR_set_drag_throw), MP_ROM_PTR(&mp_lv_obj_set_drag_throw_obj) }, + { MP_ROM_QSTR(MP_QSTR_set_drag_parent), MP_ROM_PTR(&mp_lv_obj_set_drag_parent_obj) }, + { MP_ROM_QSTR(MP_QSTR_set_opa_scale_enable), MP_ROM_PTR(&mp_lv_obj_set_opa_scale_enable_obj) }, + { MP_ROM_QSTR(MP_QSTR_set_opa_scale), MP_ROM_PTR(&mp_lv_obj_set_opa_scale_obj) }, + { MP_ROM_QSTR(MP_QSTR_set_protect), MP_ROM_PTR(&mp_lv_obj_set_protect_obj) }, + { MP_ROM_QSTR(MP_QSTR_clear_protect), MP_ROM_PTR(&mp_lv_obj_clear_protect_obj) }, + { MP_ROM_QSTR(MP_QSTR_set_signal_func), MP_ROM_PTR(&mp_lv_obj_set_signal_func_obj) }, + { MP_ROM_QSTR(MP_QSTR_set_design_func), MP_ROM_PTR(&mp_lv_obj_set_design_func_obj) }, + { MP_ROM_QSTR(MP_QSTR_allocate_ext_attr), MP_ROM_PTR(&mp_lv_obj_allocate_ext_attr_obj) }, + { MP_ROM_QSTR(MP_QSTR_refresh_ext_size), MP_ROM_PTR(&mp_lv_obj_refresh_ext_size_obj) }, + { MP_ROM_QSTR(MP_QSTR_set_free_num), MP_ROM_PTR(&mp_lv_obj_set_free_num_obj) }, + { MP_ROM_QSTR(MP_QSTR_set_free_ptr), MP_ROM_PTR(&mp_lv_obj_set_free_ptr_obj) }, + { MP_ROM_QSTR(MP_QSTR_animate), MP_ROM_PTR(&mp_lv_obj_animate_obj) }, + { MP_ROM_QSTR(MP_QSTR_get_screen), MP_ROM_PTR(&mp_lv_obj_get_screen_obj) }, + { MP_ROM_QSTR(MP_QSTR_get_parent), MP_ROM_PTR(&mp_lv_obj_get_parent_obj) }, + { MP_ROM_QSTR(MP_QSTR_get_child), MP_ROM_PTR(&mp_lv_obj_get_child_obj) }, + { MP_ROM_QSTR(MP_QSTR_get_child_back), MP_ROM_PTR(&mp_lv_obj_get_child_back_obj) }, + { MP_ROM_QSTR(MP_QSTR_count_children), MP_ROM_PTR(&mp_lv_obj_count_children_obj) }, + { MP_ROM_QSTR(MP_QSTR_get_coords), MP_ROM_PTR(&mp_lv_obj_get_coords_obj) }, + { MP_ROM_QSTR(MP_QSTR_get_x), MP_ROM_PTR(&mp_lv_obj_get_x_obj) }, + { MP_ROM_QSTR(MP_QSTR_get_y), MP_ROM_PTR(&mp_lv_obj_get_y_obj) }, + { MP_ROM_QSTR(MP_QSTR_get_width), MP_ROM_PTR(&mp_lv_obj_get_width_obj) }, + { MP_ROM_QSTR(MP_QSTR_get_height), MP_ROM_PTR(&mp_lv_obj_get_height_obj) }, + { MP_ROM_QSTR(MP_QSTR_get_ext_size), MP_ROM_PTR(&mp_lv_obj_get_ext_size_obj) }, + { MP_ROM_QSTR(MP_QSTR_get_auto_realign), MP_ROM_PTR(&mp_lv_obj_get_auto_realign_obj) }, + { MP_ROM_QSTR(MP_QSTR_get_style), MP_ROM_PTR(&mp_lv_obj_get_style_obj) }, + { MP_ROM_QSTR(MP_QSTR_get_hidden), MP_ROM_PTR(&mp_lv_obj_get_hidden_obj) }, + { MP_ROM_QSTR(MP_QSTR_get_click), MP_ROM_PTR(&mp_lv_obj_get_click_obj) }, + { MP_ROM_QSTR(MP_QSTR_get_top), MP_ROM_PTR(&mp_lv_obj_get_top_obj) }, + { MP_ROM_QSTR(MP_QSTR_get_drag), MP_ROM_PTR(&mp_lv_obj_get_drag_obj) }, + { MP_ROM_QSTR(MP_QSTR_get_drag_throw), MP_ROM_PTR(&mp_lv_obj_get_drag_throw_obj) }, + { MP_ROM_QSTR(MP_QSTR_get_drag_parent), MP_ROM_PTR(&mp_lv_obj_get_drag_parent_obj) }, + { MP_ROM_QSTR(MP_QSTR_get_opa_scale_enable), MP_ROM_PTR(&mp_lv_obj_get_opa_scale_enable_obj) }, + { MP_ROM_QSTR(MP_QSTR_get_opa_scale), MP_ROM_PTR(&mp_lv_obj_get_opa_scale_obj) }, + { MP_ROM_QSTR(MP_QSTR_get_protect), MP_ROM_PTR(&mp_lv_obj_get_protect_obj) }, + { MP_ROM_QSTR(MP_QSTR_is_protected), MP_ROM_PTR(&mp_lv_obj_is_protected_obj) }, + { MP_ROM_QSTR(MP_QSTR_get_signal_func), MP_ROM_PTR(&mp_lv_obj_get_signal_func_obj) }, + { MP_ROM_QSTR(MP_QSTR_get_design_func), MP_ROM_PTR(&mp_lv_obj_get_design_func_obj) }, + { MP_ROM_QSTR(MP_QSTR_get_ext_attr), MP_ROM_PTR(&mp_lv_obj_get_ext_attr_obj) }, + { MP_ROM_QSTR(MP_QSTR_get_free_num), MP_ROM_PTR(&mp_lv_obj_get_free_num_obj) }, + { MP_ROM_QSTR(MP_QSTR_get_free_ptr), MP_ROM_PTR(&mp_lv_obj_get_free_ptr_obj) }, + { MP_ROM_QSTR(MP_QSTR_get_group), MP_ROM_PTR(&mp_lv_obj_get_group_obj) }, + { MP_ROM_QSTR(MP_QSTR_is_focused), MP_ROM_PTR(&mp_lv_obj_is_focused_obj) }, + { MP_ROM_QSTR(MP_QSTR_STYLE), MP_ROM_PTR(&mp_LV_ROLLER_STYLE_type) } +}; + +STATIC MP_DEFINE_CONST_DICT(roller_locals_dict, roller_locals_dict_table); + +STATIC void roller_print(const mp_print_t *print, + mp_obj_t self_in, + mp_print_kind_t kind) +{ + mp_printf(print, "lvgl roller"); +} + + +STATIC mp_obj_t roller_make_new( + const mp_obj_type_t *type, + size_t n_args, + size_t n_kw, + const mp_obj_t *args) +{ + return make_new(&lv_roller_create, type, n_args, n_kw, args); +} + + +STATIC const mp_obj_type_t mp_roller_type = { + { &mp_type_type }, + .name = MP_QSTR_roller, + .print = roller_print, + .make_new = roller_make_new, + .locals_dict = (mp_obj_dict_t*)&roller_locals_dict, +}; + + +/* + * lvgl extension definition for: + * inline static void lv_ta_set_action(lv_obj_t *ta, lv_action_t action) + */ + +STATIC mp_obj_t mp_lv_ta_set_action(size_t n_args, const mp_obj_t *args) +{ + lv_obj_t *ta = mp_to_lv(args[0]); + set_action(args[0], args[1]); + lv_action_t action = &lv_action_t_callback; + lv_ta_set_action(ta, action); + return mp_const_none; +} + +STATIC MP_DEFINE_CONST_FUN_OBJ_VAR_BETWEEN(mp_lv_ta_set_action_obj, 2, 2, mp_lv_ta_set_action); + + + +/* + * lvgl extension definition for: + * inline static void lv_ta_set_sb_mode(lv_obj_t *ta, lv_sb_mode_t mode) + */ + +STATIC mp_obj_t mp_lv_ta_set_sb_mode(size_t n_args, const mp_obj_t *args) +{ + lv_obj_t *ta = mp_to_lv(args[0]); + lv_sb_mode_t mode = (uint8_t)mp_obj_get_int(args[1]); + lv_ta_set_sb_mode(ta, mode); + return mp_const_none; +} + +STATIC MP_DEFINE_CONST_FUN_OBJ_VAR_BETWEEN(mp_lv_ta_set_sb_mode_obj, 2, 2, mp_lv_ta_set_sb_mode); + + + +/* + * lvgl extension definition for: + * inline static void lv_ta_set_scroll_propagation(lv_obj_t *ta, bool en) + */ + +STATIC mp_obj_t mp_lv_ta_set_scroll_propagation(size_t n_args, const mp_obj_t *args) +{ + lv_obj_t *ta = mp_to_lv(args[0]); + bool en = mp_obj_is_true(args[1]); + lv_ta_set_scroll_propagation(ta, en); + return mp_const_none; +} + +STATIC MP_DEFINE_CONST_FUN_OBJ_VAR_BETWEEN(mp_lv_ta_set_scroll_propagation_obj, 2, 2, mp_lv_ta_set_scroll_propagation); + + + +/* + * lvgl extension definition for: + * inline static void lv_ta_set_edge_flash(lv_obj_t *ta, bool en) + */ + +STATIC mp_obj_t mp_lv_ta_set_edge_flash(size_t n_args, const mp_obj_t *args) +{ + lv_obj_t *ta = mp_to_lv(args[0]); + bool en = mp_obj_is_true(args[1]); + lv_ta_set_edge_flash(ta, en); + return mp_const_none; +} + +STATIC MP_DEFINE_CONST_FUN_OBJ_VAR_BETWEEN(mp_lv_ta_set_edge_flash_obj, 2, 2, mp_lv_ta_set_edge_flash); + + + +/* + * lvgl extension definition for: + * inline static lv_action_t lv_ta_get_action(lv_obj_t *ta) + */ + +STATIC mp_obj_t mp_lv_ta_get_action(size_t n_args, const mp_obj_t *args) +{ + lv_obj_t *ta = mp_to_lv(args[0]); + lv_action_t res = lv_ta_get_action(ta); + return ptr_to_mp(res); +} + +STATIC MP_DEFINE_CONST_FUN_OBJ_VAR_BETWEEN(mp_lv_ta_get_action_obj, 1, 1, mp_lv_ta_get_action); + + + +/* + * lvgl extension definition for: + * inline static lv_sb_mode_t lv_ta_get_sb_mode(const lv_obj_t *ta) + */ + +STATIC mp_obj_t mp_lv_ta_get_sb_mode(size_t n_args, const mp_obj_t *args) +{ + const lv_obj_t *ta = mp_to_lv(args[0]); + lv_sb_mode_t res = lv_ta_get_sb_mode(ta); + return mp_obj_new_int_from_uint(res); +} + +STATIC MP_DEFINE_CONST_FUN_OBJ_VAR_BETWEEN(mp_lv_ta_get_sb_mode_obj, 1, 1, mp_lv_ta_get_sb_mode); + + + +/* + * lvgl extension definition for: + * inline static bool lv_ta_get_scroll_propagation(lv_obj_t *ta) + */ + +STATIC mp_obj_t mp_lv_ta_get_scroll_propagation(size_t n_args, const mp_obj_t *args) +{ + lv_obj_t *ta = mp_to_lv(args[0]); + bool res = lv_ta_get_scroll_propagation(ta); + return convert_to_bool(res); +} + +STATIC MP_DEFINE_CONST_FUN_OBJ_VAR_BETWEEN(mp_lv_ta_get_scroll_propagation_obj, 1, 1, mp_lv_ta_get_scroll_propagation); + + + +/* + * lvgl extension definition for: + * inline static bool lv_ta_get_edge_flash(lv_obj_t *ta) + */ + +STATIC mp_obj_t mp_lv_ta_get_edge_flash(size_t n_args, const mp_obj_t *args) +{ + lv_obj_t *ta = mp_to_lv(args[0]); + bool res = lv_ta_get_edge_flash(ta); + return convert_to_bool(res); +} + +STATIC MP_DEFINE_CONST_FUN_OBJ_VAR_BETWEEN(mp_lv_ta_get_edge_flash_obj, 1, 1, mp_lv_ta_get_edge_flash); + + + +/* + * lvgl extension definition for: + * void lv_ta_add_char(lv_obj_t *ta, uint32_t c) + */ + +STATIC mp_obj_t mp_lv_ta_add_char(size_t n_args, const mp_obj_t *args) +{ + lv_obj_t *ta = mp_to_lv(args[0]); + uint32_t c = (uint32_t)mp_obj_get_int(args[1]); + lv_ta_add_char(ta, c); + return mp_const_none; +} + +STATIC MP_DEFINE_CONST_FUN_OBJ_VAR_BETWEEN(mp_lv_ta_add_char_obj, 2, 2, mp_lv_ta_add_char); + + + +/* + * lvgl extension definition for: + * void lv_ta_add_text(lv_obj_t *ta, const char *txt) + */ + +STATIC mp_obj_t mp_lv_ta_add_text(size_t n_args, const mp_obj_t *args) +{ + lv_obj_t *ta = mp_to_lv(args[0]); + const char *txt = (char*)mp_obj_str_get_str(args[1]); + lv_ta_add_text(ta, txt); + return mp_const_none; +} + +STATIC MP_DEFINE_CONST_FUN_OBJ_VAR_BETWEEN(mp_lv_ta_add_text_obj, 2, 2, mp_lv_ta_add_text); + + + +/* + * lvgl extension definition for: + * void lv_ta_del_char(lv_obj_t *ta) + */ + +STATIC mp_obj_t mp_lv_ta_del_char(size_t n_args, const mp_obj_t *args) +{ + lv_obj_t *ta = mp_to_lv(args[0]); + lv_ta_del_char(ta); + return mp_const_none; +} + +STATIC MP_DEFINE_CONST_FUN_OBJ_VAR_BETWEEN(mp_lv_ta_del_char_obj, 1, 1, mp_lv_ta_del_char); + + + +/* + * lvgl extension definition for: + * void lv_ta_set_text(lv_obj_t *ta, const char *txt) + */ + +STATIC mp_obj_t mp_lv_ta_set_text(size_t n_args, const mp_obj_t *args) +{ + lv_obj_t *ta = mp_to_lv(args[0]); + const char *txt = (char*)mp_obj_str_get_str(args[1]); + lv_ta_set_text(ta, txt); + return mp_const_none; +} + +STATIC MP_DEFINE_CONST_FUN_OBJ_VAR_BETWEEN(mp_lv_ta_set_text_obj, 2, 2, mp_lv_ta_set_text); + + + +/* + * lvgl extension definition for: + * void lv_ta_set_cursor_pos(lv_obj_t *ta, int16_t pos) + */ + +STATIC mp_obj_t mp_lv_ta_set_cursor_pos(size_t n_args, const mp_obj_t *args) +{ + lv_obj_t *ta = mp_to_lv(args[0]); + int16_t pos = (int16_t)mp_obj_get_int(args[1]); + lv_ta_set_cursor_pos(ta, pos); + return mp_const_none; +} + +STATIC MP_DEFINE_CONST_FUN_OBJ_VAR_BETWEEN(mp_lv_ta_set_cursor_pos_obj, 2, 2, mp_lv_ta_set_cursor_pos); + + + +/* + * lvgl extension definition for: + * void lv_ta_set_cursor_type(lv_obj_t *ta, lv_cursor_type_t cur_type) + */ + +STATIC mp_obj_t mp_lv_ta_set_cursor_type(size_t n_args, const mp_obj_t *args) +{ + lv_obj_t *ta = mp_to_lv(args[0]); + lv_cursor_type_t cur_type = (uint8_t)mp_obj_get_int(args[1]); + lv_ta_set_cursor_type(ta, cur_type); + return mp_const_none; +} + +STATIC MP_DEFINE_CONST_FUN_OBJ_VAR_BETWEEN(mp_lv_ta_set_cursor_type_obj, 2, 2, mp_lv_ta_set_cursor_type); + + + +/* + * lvgl extension definition for: + * void lv_ta_set_pwd_mode(lv_obj_t *ta, bool en) + */ + +STATIC mp_obj_t mp_lv_ta_set_pwd_mode(size_t n_args, const mp_obj_t *args) +{ + lv_obj_t *ta = mp_to_lv(args[0]); + bool en = mp_obj_is_true(args[1]); + lv_ta_set_pwd_mode(ta, en); + return mp_const_none; +} + +STATIC MP_DEFINE_CONST_FUN_OBJ_VAR_BETWEEN(mp_lv_ta_set_pwd_mode_obj, 2, 2, mp_lv_ta_set_pwd_mode); + + + +/* + * lvgl extension definition for: + * void lv_ta_set_one_line(lv_obj_t *ta, bool en) + */ + +STATIC mp_obj_t mp_lv_ta_set_one_line(size_t n_args, const mp_obj_t *args) +{ + lv_obj_t *ta = mp_to_lv(args[0]); + bool en = mp_obj_is_true(args[1]); + lv_ta_set_one_line(ta, en); + return mp_const_none; +} + +STATIC MP_DEFINE_CONST_FUN_OBJ_VAR_BETWEEN(mp_lv_ta_set_one_line_obj, 2, 2, mp_lv_ta_set_one_line); + + + +/* + * lvgl extension definition for: + * void lv_ta_set_text_align(lv_obj_t *ta, lv_label_align_t align) + */ + +STATIC mp_obj_t mp_lv_ta_set_text_align(size_t n_args, const mp_obj_t *args) +{ + lv_obj_t *ta = mp_to_lv(args[0]); + lv_label_align_t align = (uint8_t)mp_obj_get_int(args[1]); + lv_ta_set_text_align(ta, align); + return mp_const_none; +} + +STATIC MP_DEFINE_CONST_FUN_OBJ_VAR_BETWEEN(mp_lv_ta_set_text_align_obj, 2, 2, mp_lv_ta_set_text_align); + + + +/* + * lvgl extension definition for: + * void lv_ta_set_accepted_chars(lv_obj_t *ta, const char *list) + */ + +STATIC mp_obj_t mp_lv_ta_set_accepted_chars(size_t n_args, const mp_obj_t *args) +{ + lv_obj_t *ta = mp_to_lv(args[0]); + const char *list = (char*)mp_obj_str_get_str(args[1]); + lv_ta_set_accepted_chars(ta, list); + return mp_const_none; +} + +STATIC MP_DEFINE_CONST_FUN_OBJ_VAR_BETWEEN(mp_lv_ta_set_accepted_chars_obj, 2, 2, mp_lv_ta_set_accepted_chars); + + + +/* + * lvgl extension definition for: + * void lv_ta_set_max_length(lv_obj_t *ta, uint16_t num) + */ + +STATIC mp_obj_t mp_lv_ta_set_max_length(size_t n_args, const mp_obj_t *args) +{ + lv_obj_t *ta = mp_to_lv(args[0]); + uint16_t num = (uint16_t)mp_obj_get_int(args[1]); + lv_ta_set_max_length(ta, num); + return mp_const_none; +} + +STATIC MP_DEFINE_CONST_FUN_OBJ_VAR_BETWEEN(mp_lv_ta_set_max_length_obj, 2, 2, mp_lv_ta_set_max_length); + + + +/* + * lvgl extension definition for: + * void lv_ta_set_style(lv_obj_t *ta, lv_ta_style_t type, lv_style_t *style) + */ + +STATIC mp_obj_t mp_lv_ta_set_style(size_t n_args, const mp_obj_t *args) +{ + lv_obj_t *ta = mp_to_lv(args[0]); + lv_ta_style_t type = (uint8_t)mp_obj_get_int(args[1]); + lv_style_t *style = mp_write_ptr_lv_style_t(args[2]); + lv_ta_set_style(ta, type, style); + return mp_const_none; +} + +STATIC MP_DEFINE_CONST_FUN_OBJ_VAR_BETWEEN(mp_lv_ta_set_style_obj, 3, 3, mp_lv_ta_set_style); + + + +/* + * lvgl extension definition for: + * const char *lv_ta_get_text(const lv_obj_t *ta) + */ + +STATIC mp_obj_t mp_lv_ta_get_text(size_t n_args, const mp_obj_t *args) +{ + const lv_obj_t *ta = mp_to_lv(args[0]); + const char* res = lv_ta_get_text(ta); + return convert_to_str((void*)res); +} + +STATIC MP_DEFINE_CONST_FUN_OBJ_VAR_BETWEEN(mp_lv_ta_get_text_obj, 1, 1, mp_lv_ta_get_text); + + + +/* + * lvgl extension definition for: + * lv_obj_t *lv_ta_get_label(const lv_obj_t *ta) + */ + +STATIC mp_obj_t mp_lv_ta_get_label(size_t n_args, const mp_obj_t *args) +{ + const lv_obj_t *ta = mp_to_lv(args[0]); + lv_obj_t* res = lv_ta_get_label(ta); + return lv_to_mp((void*)res); +} + +STATIC MP_DEFINE_CONST_FUN_OBJ_VAR_BETWEEN(mp_lv_ta_get_label_obj, 1, 1, mp_lv_ta_get_label); + + + +/* + * lvgl extension definition for: + * uint16_t lv_ta_get_cursor_pos(const lv_obj_t *ta) + */ + +STATIC mp_obj_t mp_lv_ta_get_cursor_pos(size_t n_args, const mp_obj_t *args) +{ + const lv_obj_t *ta = mp_to_lv(args[0]); + uint16_t res = lv_ta_get_cursor_pos(ta); + return mp_obj_new_int_from_uint(res); +} + +STATIC MP_DEFINE_CONST_FUN_OBJ_VAR_BETWEEN(mp_lv_ta_get_cursor_pos_obj, 1, 1, mp_lv_ta_get_cursor_pos); + + + +/* + * lvgl extension definition for: + * lv_cursor_type_t lv_ta_get_cursor_type(const lv_obj_t *ta) + */ + +STATIC mp_obj_t mp_lv_ta_get_cursor_type(size_t n_args, const mp_obj_t *args) +{ + const lv_obj_t *ta = mp_to_lv(args[0]); + lv_cursor_type_t res = lv_ta_get_cursor_type(ta); + return mp_obj_new_int_from_uint(res); +} + +STATIC MP_DEFINE_CONST_FUN_OBJ_VAR_BETWEEN(mp_lv_ta_get_cursor_type_obj, 1, 1, mp_lv_ta_get_cursor_type); + + + +/* + * lvgl extension definition for: + * bool lv_ta_get_pwd_mode(const lv_obj_t *ta) + */ + +STATIC mp_obj_t mp_lv_ta_get_pwd_mode(size_t n_args, const mp_obj_t *args) +{ + const lv_obj_t *ta = mp_to_lv(args[0]); + bool res = lv_ta_get_pwd_mode(ta); + return convert_to_bool(res); +} + +STATIC MP_DEFINE_CONST_FUN_OBJ_VAR_BETWEEN(mp_lv_ta_get_pwd_mode_obj, 1, 1, mp_lv_ta_get_pwd_mode); + + + +/* + * lvgl extension definition for: + * bool lv_ta_get_one_line(const lv_obj_t *ta) + */ + +STATIC mp_obj_t mp_lv_ta_get_one_line(size_t n_args, const mp_obj_t *args) +{ + const lv_obj_t *ta = mp_to_lv(args[0]); + bool res = lv_ta_get_one_line(ta); + return convert_to_bool(res); +} + +STATIC MP_DEFINE_CONST_FUN_OBJ_VAR_BETWEEN(mp_lv_ta_get_one_line_obj, 1, 1, mp_lv_ta_get_one_line); + + + +/* + * lvgl extension definition for: + * const char *lv_ta_get_accepted_chars(lv_obj_t *ta) + */ + +STATIC mp_obj_t mp_lv_ta_get_accepted_chars(size_t n_args, const mp_obj_t *args) +{ + lv_obj_t *ta = mp_to_lv(args[0]); + const char* res = lv_ta_get_accepted_chars(ta); + return convert_to_str((void*)res); +} + +STATIC MP_DEFINE_CONST_FUN_OBJ_VAR_BETWEEN(mp_lv_ta_get_accepted_chars_obj, 1, 1, mp_lv_ta_get_accepted_chars); + + + +/* + * lvgl extension definition for: + * uint16_t lv_ta_get_max_length(lv_obj_t *ta) + */ + +STATIC mp_obj_t mp_lv_ta_get_max_length(size_t n_args, const mp_obj_t *args) +{ + lv_obj_t *ta = mp_to_lv(args[0]); + uint16_t res = lv_ta_get_max_length(ta); + return mp_obj_new_int_from_uint(res); +} + +STATIC MP_DEFINE_CONST_FUN_OBJ_VAR_BETWEEN(mp_lv_ta_get_max_length_obj, 1, 1, mp_lv_ta_get_max_length); + + + +/* + * lvgl extension definition for: + * lv_style_t *lv_ta_get_style(const lv_obj_t *ta, lv_ta_style_t type) + */ + +STATIC mp_obj_t mp_lv_ta_get_style(size_t n_args, const mp_obj_t *args) +{ + const lv_obj_t *ta = mp_to_lv(args[0]); + lv_ta_style_t type = (uint8_t)mp_obj_get_int(args[1]); + lv_style_t* res = lv_ta_get_style(ta, type); + return mp_read_ptr_lv_style_t((void*)res); +} + +STATIC MP_DEFINE_CONST_FUN_OBJ_VAR_BETWEEN(mp_lv_ta_get_style_obj, 2, 2, mp_lv_ta_get_style); + + + +/* + * lvgl extension definition for: + * void lv_ta_cursor_right(lv_obj_t *ta) + */ + +STATIC mp_obj_t mp_lv_ta_cursor_right(size_t n_args, const mp_obj_t *args) +{ + lv_obj_t *ta = mp_to_lv(args[0]); + lv_ta_cursor_right(ta); + return mp_const_none; +} + +STATIC MP_DEFINE_CONST_FUN_OBJ_VAR_BETWEEN(mp_lv_ta_cursor_right_obj, 1, 1, mp_lv_ta_cursor_right); + + + +/* + * lvgl extension definition for: + * void lv_ta_cursor_left(lv_obj_t *ta) + */ + +STATIC mp_obj_t mp_lv_ta_cursor_left(size_t n_args, const mp_obj_t *args) +{ + lv_obj_t *ta = mp_to_lv(args[0]); + lv_ta_cursor_left(ta); + return mp_const_none; +} + +STATIC MP_DEFINE_CONST_FUN_OBJ_VAR_BETWEEN(mp_lv_ta_cursor_left_obj, 1, 1, mp_lv_ta_cursor_left); + + + +/* + * lvgl extension definition for: + * void lv_ta_cursor_down(lv_obj_t *ta) + */ + +STATIC mp_obj_t mp_lv_ta_cursor_down(size_t n_args, const mp_obj_t *args) +{ + lv_obj_t *ta = mp_to_lv(args[0]); + lv_ta_cursor_down(ta); + return mp_const_none; +} + +STATIC MP_DEFINE_CONST_FUN_OBJ_VAR_BETWEEN(mp_lv_ta_cursor_down_obj, 1, 1, mp_lv_ta_cursor_down); + + + +/* + * lvgl extension definition for: + * void lv_ta_cursor_up(lv_obj_t *ta) + */ + +STATIC mp_obj_t mp_lv_ta_cursor_up(size_t n_args, const mp_obj_t *args) +{ + lv_obj_t *ta = mp_to_lv(args[0]); + lv_ta_cursor_up(ta); + return mp_const_none; +} + +STATIC MP_DEFINE_CONST_FUN_OBJ_VAR_BETWEEN(mp_lv_ta_cursor_up_obj, 1, 1, mp_lv_ta_cursor_up); + + + +/* + * lvgl ta object definitions + */ + + +STATIC const mp_rom_map_elem_t ta_locals_dict_table[] = { + { MP_ROM_QSTR(MP_QSTR_set_action), MP_ROM_PTR(&mp_lv_ta_set_action_obj) }, + { MP_ROM_QSTR(MP_QSTR_set_sb_mode), MP_ROM_PTR(&mp_lv_ta_set_sb_mode_obj) }, + { MP_ROM_QSTR(MP_QSTR_set_scroll_propagation), MP_ROM_PTR(&mp_lv_ta_set_scroll_propagation_obj) }, + { MP_ROM_QSTR(MP_QSTR_set_edge_flash), MP_ROM_PTR(&mp_lv_ta_set_edge_flash_obj) }, + { MP_ROM_QSTR(MP_QSTR_get_action), MP_ROM_PTR(&mp_lv_ta_get_action_obj) }, + { MP_ROM_QSTR(MP_QSTR_get_sb_mode), MP_ROM_PTR(&mp_lv_ta_get_sb_mode_obj) }, + { MP_ROM_QSTR(MP_QSTR_get_scroll_propagation), MP_ROM_PTR(&mp_lv_ta_get_scroll_propagation_obj) }, + { MP_ROM_QSTR(MP_QSTR_get_edge_flash), MP_ROM_PTR(&mp_lv_ta_get_edge_flash_obj) }, + { MP_ROM_QSTR(MP_QSTR_add_char), MP_ROM_PTR(&mp_lv_ta_add_char_obj) }, + { MP_ROM_QSTR(MP_QSTR_add_text), MP_ROM_PTR(&mp_lv_ta_add_text_obj) }, + { MP_ROM_QSTR(MP_QSTR_del_char), MP_ROM_PTR(&mp_lv_ta_del_char_obj) }, + { MP_ROM_QSTR(MP_QSTR_set_text), MP_ROM_PTR(&mp_lv_ta_set_text_obj) }, + { MP_ROM_QSTR(MP_QSTR_set_cursor_pos), MP_ROM_PTR(&mp_lv_ta_set_cursor_pos_obj) }, + { MP_ROM_QSTR(MP_QSTR_set_cursor_type), MP_ROM_PTR(&mp_lv_ta_set_cursor_type_obj) }, + { MP_ROM_QSTR(MP_QSTR_set_pwd_mode), MP_ROM_PTR(&mp_lv_ta_set_pwd_mode_obj) }, + { MP_ROM_QSTR(MP_QSTR_set_one_line), MP_ROM_PTR(&mp_lv_ta_set_one_line_obj) }, + { MP_ROM_QSTR(MP_QSTR_set_text_align), MP_ROM_PTR(&mp_lv_ta_set_text_align_obj) }, + { MP_ROM_QSTR(MP_QSTR_set_accepted_chars), MP_ROM_PTR(&mp_lv_ta_set_accepted_chars_obj) }, + { MP_ROM_QSTR(MP_QSTR_set_max_length), MP_ROM_PTR(&mp_lv_ta_set_max_length_obj) }, + { MP_ROM_QSTR(MP_QSTR_set_style), MP_ROM_PTR(&mp_lv_ta_set_style_obj) }, + { MP_ROM_QSTR(MP_QSTR_get_text), MP_ROM_PTR(&mp_lv_ta_get_text_obj) }, + { MP_ROM_QSTR(MP_QSTR_get_label), MP_ROM_PTR(&mp_lv_ta_get_label_obj) }, + { MP_ROM_QSTR(MP_QSTR_get_cursor_pos), MP_ROM_PTR(&mp_lv_ta_get_cursor_pos_obj) }, + { MP_ROM_QSTR(MP_QSTR_get_cursor_type), MP_ROM_PTR(&mp_lv_ta_get_cursor_type_obj) }, + { MP_ROM_QSTR(MP_QSTR_get_pwd_mode), MP_ROM_PTR(&mp_lv_ta_get_pwd_mode_obj) }, + { MP_ROM_QSTR(MP_QSTR_get_one_line), MP_ROM_PTR(&mp_lv_ta_get_one_line_obj) }, + { MP_ROM_QSTR(MP_QSTR_get_accepted_chars), MP_ROM_PTR(&mp_lv_ta_get_accepted_chars_obj) }, + { MP_ROM_QSTR(MP_QSTR_get_max_length), MP_ROM_PTR(&mp_lv_ta_get_max_length_obj) }, + { MP_ROM_QSTR(MP_QSTR_get_style), MP_ROM_PTR(&mp_lv_ta_get_style_obj) }, + { MP_ROM_QSTR(MP_QSTR_cursor_right), MP_ROM_PTR(&mp_lv_ta_cursor_right_obj) }, + { MP_ROM_QSTR(MP_QSTR_cursor_left), MP_ROM_PTR(&mp_lv_ta_cursor_left_obj) }, + { MP_ROM_QSTR(MP_QSTR_cursor_down), MP_ROM_PTR(&mp_lv_ta_cursor_down_obj) }, + { MP_ROM_QSTR(MP_QSTR_cursor_up), MP_ROM_PTR(&mp_lv_ta_cursor_up_obj) }, + { MP_ROM_QSTR(MP_QSTR_delete), MP_ROM_PTR(&mp_lv_obj_del_obj) }, + { MP_ROM_QSTR(MP_QSTR_clean), MP_ROM_PTR(&mp_lv_obj_clean_obj) }, + { MP_ROM_QSTR(MP_QSTR_invalidate), MP_ROM_PTR(&mp_lv_obj_invalidate_obj) }, + { MP_ROM_QSTR(MP_QSTR_set_parent), MP_ROM_PTR(&mp_lv_obj_set_parent_obj) }, + { MP_ROM_QSTR(MP_QSTR_set_pos), MP_ROM_PTR(&mp_lv_obj_set_pos_obj) }, + { MP_ROM_QSTR(MP_QSTR_set_x), MP_ROM_PTR(&mp_lv_obj_set_x_obj) }, + { MP_ROM_QSTR(MP_QSTR_set_y), MP_ROM_PTR(&mp_lv_obj_set_y_obj) }, + { MP_ROM_QSTR(MP_QSTR_set_size), MP_ROM_PTR(&mp_lv_obj_set_size_obj) }, + { MP_ROM_QSTR(MP_QSTR_set_width), MP_ROM_PTR(&mp_lv_obj_set_width_obj) }, + { MP_ROM_QSTR(MP_QSTR_set_height), MP_ROM_PTR(&mp_lv_obj_set_height_obj) }, + { MP_ROM_QSTR(MP_QSTR_align), MP_ROM_PTR(&mp_lv_obj_align_obj) }, + { MP_ROM_QSTR(MP_QSTR_align_origo), MP_ROM_PTR(&mp_lv_obj_align_origo_obj) }, + { MP_ROM_QSTR(MP_QSTR_realign), MP_ROM_PTR(&mp_lv_obj_realign_obj) }, + { MP_ROM_QSTR(MP_QSTR_set_auto_realign), MP_ROM_PTR(&mp_lv_obj_set_auto_realign_obj) }, + { MP_ROM_QSTR(MP_QSTR_set_style), MP_ROM_PTR(&mp_lv_obj_set_style_obj) }, + { MP_ROM_QSTR(MP_QSTR_refresh_style), MP_ROM_PTR(&mp_lv_obj_refresh_style_obj) }, + { MP_ROM_QSTR(MP_QSTR_report_style_mod), MP_ROM_PTR(&mp_lv_obj_report_style_mod_obj) }, + { MP_ROM_QSTR(MP_QSTR_set_hidden), MP_ROM_PTR(&mp_lv_obj_set_hidden_obj) }, + { MP_ROM_QSTR(MP_QSTR_set_click), MP_ROM_PTR(&mp_lv_obj_set_click_obj) }, + { MP_ROM_QSTR(MP_QSTR_set_top), MP_ROM_PTR(&mp_lv_obj_set_top_obj) }, + { MP_ROM_QSTR(MP_QSTR_set_drag), MP_ROM_PTR(&mp_lv_obj_set_drag_obj) }, + { MP_ROM_QSTR(MP_QSTR_set_drag_throw), MP_ROM_PTR(&mp_lv_obj_set_drag_throw_obj) }, + { MP_ROM_QSTR(MP_QSTR_set_drag_parent), MP_ROM_PTR(&mp_lv_obj_set_drag_parent_obj) }, + { MP_ROM_QSTR(MP_QSTR_set_opa_scale_enable), MP_ROM_PTR(&mp_lv_obj_set_opa_scale_enable_obj) }, + { MP_ROM_QSTR(MP_QSTR_set_opa_scale), MP_ROM_PTR(&mp_lv_obj_set_opa_scale_obj) }, + { MP_ROM_QSTR(MP_QSTR_set_protect), MP_ROM_PTR(&mp_lv_obj_set_protect_obj) }, + { MP_ROM_QSTR(MP_QSTR_clear_protect), MP_ROM_PTR(&mp_lv_obj_clear_protect_obj) }, + { MP_ROM_QSTR(MP_QSTR_set_signal_func), MP_ROM_PTR(&mp_lv_obj_set_signal_func_obj) }, + { MP_ROM_QSTR(MP_QSTR_set_design_func), MP_ROM_PTR(&mp_lv_obj_set_design_func_obj) }, + { MP_ROM_QSTR(MP_QSTR_allocate_ext_attr), MP_ROM_PTR(&mp_lv_obj_allocate_ext_attr_obj) }, + { MP_ROM_QSTR(MP_QSTR_refresh_ext_size), MP_ROM_PTR(&mp_lv_obj_refresh_ext_size_obj) }, + { MP_ROM_QSTR(MP_QSTR_set_free_num), MP_ROM_PTR(&mp_lv_obj_set_free_num_obj) }, + { MP_ROM_QSTR(MP_QSTR_set_free_ptr), MP_ROM_PTR(&mp_lv_obj_set_free_ptr_obj) }, + { MP_ROM_QSTR(MP_QSTR_animate), MP_ROM_PTR(&mp_lv_obj_animate_obj) }, + { MP_ROM_QSTR(MP_QSTR_get_screen), MP_ROM_PTR(&mp_lv_obj_get_screen_obj) }, + { MP_ROM_QSTR(MP_QSTR_get_parent), MP_ROM_PTR(&mp_lv_obj_get_parent_obj) }, + { MP_ROM_QSTR(MP_QSTR_get_child), MP_ROM_PTR(&mp_lv_obj_get_child_obj) }, + { MP_ROM_QSTR(MP_QSTR_get_child_back), MP_ROM_PTR(&mp_lv_obj_get_child_back_obj) }, + { MP_ROM_QSTR(MP_QSTR_count_children), MP_ROM_PTR(&mp_lv_obj_count_children_obj) }, + { MP_ROM_QSTR(MP_QSTR_get_coords), MP_ROM_PTR(&mp_lv_obj_get_coords_obj) }, + { MP_ROM_QSTR(MP_QSTR_get_x), MP_ROM_PTR(&mp_lv_obj_get_x_obj) }, + { MP_ROM_QSTR(MP_QSTR_get_y), MP_ROM_PTR(&mp_lv_obj_get_y_obj) }, + { MP_ROM_QSTR(MP_QSTR_get_width), MP_ROM_PTR(&mp_lv_obj_get_width_obj) }, + { MP_ROM_QSTR(MP_QSTR_get_height), MP_ROM_PTR(&mp_lv_obj_get_height_obj) }, + { MP_ROM_QSTR(MP_QSTR_get_ext_size), MP_ROM_PTR(&mp_lv_obj_get_ext_size_obj) }, + { MP_ROM_QSTR(MP_QSTR_get_auto_realign), MP_ROM_PTR(&mp_lv_obj_get_auto_realign_obj) }, + { MP_ROM_QSTR(MP_QSTR_get_style), MP_ROM_PTR(&mp_lv_obj_get_style_obj) }, + { MP_ROM_QSTR(MP_QSTR_get_hidden), MP_ROM_PTR(&mp_lv_obj_get_hidden_obj) }, + { MP_ROM_QSTR(MP_QSTR_get_click), MP_ROM_PTR(&mp_lv_obj_get_click_obj) }, + { MP_ROM_QSTR(MP_QSTR_get_top), MP_ROM_PTR(&mp_lv_obj_get_top_obj) }, + { MP_ROM_QSTR(MP_QSTR_get_drag), MP_ROM_PTR(&mp_lv_obj_get_drag_obj) }, + { MP_ROM_QSTR(MP_QSTR_get_drag_throw), MP_ROM_PTR(&mp_lv_obj_get_drag_throw_obj) }, + { MP_ROM_QSTR(MP_QSTR_get_drag_parent), MP_ROM_PTR(&mp_lv_obj_get_drag_parent_obj) }, + { MP_ROM_QSTR(MP_QSTR_get_opa_scale_enable), MP_ROM_PTR(&mp_lv_obj_get_opa_scale_enable_obj) }, + { MP_ROM_QSTR(MP_QSTR_get_opa_scale), MP_ROM_PTR(&mp_lv_obj_get_opa_scale_obj) }, + { MP_ROM_QSTR(MP_QSTR_get_protect), MP_ROM_PTR(&mp_lv_obj_get_protect_obj) }, + { MP_ROM_QSTR(MP_QSTR_is_protected), MP_ROM_PTR(&mp_lv_obj_is_protected_obj) }, + { MP_ROM_QSTR(MP_QSTR_get_signal_func), MP_ROM_PTR(&mp_lv_obj_get_signal_func_obj) }, + { MP_ROM_QSTR(MP_QSTR_get_design_func), MP_ROM_PTR(&mp_lv_obj_get_design_func_obj) }, + { MP_ROM_QSTR(MP_QSTR_get_ext_attr), MP_ROM_PTR(&mp_lv_obj_get_ext_attr_obj) }, + { MP_ROM_QSTR(MP_QSTR_get_free_num), MP_ROM_PTR(&mp_lv_obj_get_free_num_obj) }, + { MP_ROM_QSTR(MP_QSTR_get_free_ptr), MP_ROM_PTR(&mp_lv_obj_get_free_ptr_obj) }, + { MP_ROM_QSTR(MP_QSTR_get_group), MP_ROM_PTR(&mp_lv_obj_get_group_obj) }, + { MP_ROM_QSTR(MP_QSTR_is_focused), MP_ROM_PTR(&mp_lv_obj_is_focused_obj) }, + { MP_ROM_QSTR(MP_QSTR_STYLE), MP_ROM_PTR(&mp_LV_TA_STYLE_type) } +}; + +STATIC MP_DEFINE_CONST_DICT(ta_locals_dict, ta_locals_dict_table); + +STATIC void ta_print(const mp_print_t *print, + mp_obj_t self_in, + mp_print_kind_t kind) +{ + mp_printf(print, "lvgl ta"); +} + + +STATIC mp_obj_t ta_make_new( + const mp_obj_type_t *type, + size_t n_args, + size_t n_kw, + const mp_obj_t *args) +{ + return make_new(&lv_ta_create, type, n_args, n_kw, args); +} + + +STATIC const mp_obj_type_t mp_ta_type = { + { &mp_type_type }, + .name = MP_QSTR_ta, + .print = ta_print, + .make_new = ta_make_new, + .locals_dict = (mp_obj_dict_t*)&ta_locals_dict, +}; + + +/* + * lvgl extension definition for: + * void lv_canvas_set_buffer(lv_obj_t *canvas, void *buf, lv_coord_t w, lv_coord_t h, lv_img_cf_t cf) + */ + +STATIC mp_obj_t mp_lv_canvas_set_buffer(size_t n_args, const mp_obj_t *args) +{ + lv_obj_t *canvas = mp_to_lv(args[0]); + void *buf = mp_to_ptr(args[1]); + lv_coord_t w = (int16_t)mp_obj_get_int(args[2]); + lv_coord_t h = (int16_t)mp_obj_get_int(args[3]); + lv_img_cf_t cf = (uint8_t)mp_obj_get_int(args[4]); + lv_canvas_set_buffer(canvas, buf, w, h, cf); + return mp_const_none; +} + +STATIC MP_DEFINE_CONST_FUN_OBJ_VAR_BETWEEN(mp_lv_canvas_set_buffer_obj, 5, 5, mp_lv_canvas_set_buffer); + + + +/* + * lvgl extension definition for: + * void lv_canvas_set_px(lv_obj_t *canvas, lv_coord_t x, lv_coord_t y, lv_color_t c) + */ + +STATIC mp_obj_t mp_lv_canvas_set_px(size_t n_args, const mp_obj_t *args) +{ + lv_obj_t *canvas = mp_to_lv(args[0]); + lv_coord_t x = (int16_t)mp_obj_get_int(args[1]); + lv_coord_t y = (int16_t)mp_obj_get_int(args[2]); + lv_color_t c = mp_write_lv_color16_t(args[3]); + lv_canvas_set_px(canvas, x, y, c); + return mp_const_none; +} + +STATIC MP_DEFINE_CONST_FUN_OBJ_VAR_BETWEEN(mp_lv_canvas_set_px_obj, 4, 4, mp_lv_canvas_set_px); + + + +/* + * lvgl extension definition for: + * void lv_canvas_set_style(lv_obj_t *canvas, lv_canvas_style_t type, lv_style_t *style) + */ + +STATIC mp_obj_t mp_lv_canvas_set_style(size_t n_args, const mp_obj_t *args) +{ + lv_obj_t *canvas = mp_to_lv(args[0]); + lv_canvas_style_t type = (uint8_t)mp_obj_get_int(args[1]); + lv_style_t *style = mp_write_ptr_lv_style_t(args[2]); + lv_canvas_set_style(canvas, type, style); + return mp_const_none; +} + +STATIC MP_DEFINE_CONST_FUN_OBJ_VAR_BETWEEN(mp_lv_canvas_set_style_obj, 3, 3, mp_lv_canvas_set_style); + + + +/* + * lvgl extension definition for: + * lv_color_t lv_canvas_get_px(lv_obj_t *canvas, lv_coord_t x, lv_coord_t y) + */ + +STATIC mp_obj_t mp_lv_canvas_get_px(size_t n_args, const mp_obj_t *args) +{ + lv_obj_t *canvas = mp_to_lv(args[0]); + lv_coord_t x = (int16_t)mp_obj_get_int(args[1]); + lv_coord_t y = (int16_t)mp_obj_get_int(args[2]); + lv_color_t res = lv_canvas_get_px(canvas, x, y); + return mp_read_lv_color16_t(res); +} + +STATIC MP_DEFINE_CONST_FUN_OBJ_VAR_BETWEEN(mp_lv_canvas_get_px_obj, 3, 3, mp_lv_canvas_get_px); + + + +/* + * lvgl extension definition for: + * lv_style_t *lv_canvas_get_style(const lv_obj_t *canvas, lv_canvas_style_t type) + */ + +STATIC mp_obj_t mp_lv_canvas_get_style(size_t n_args, const mp_obj_t *args) +{ + const lv_obj_t *canvas = mp_to_lv(args[0]); + lv_canvas_style_t type = (uint8_t)mp_obj_get_int(args[1]); + lv_style_t* res = lv_canvas_get_style(canvas, type); + return mp_read_ptr_lv_style_t((void*)res); +} + +STATIC MP_DEFINE_CONST_FUN_OBJ_VAR_BETWEEN(mp_lv_canvas_get_style_obj, 2, 2, mp_lv_canvas_get_style); + + + +/* + * lvgl extension definition for: + * void lv_canvas_copy_buf(lv_obj_t *canvas, const void *to_copy, lv_coord_t w, lv_coord_t h, lv_coord_t x, lv_coord_t y) + */ + +STATIC mp_obj_t mp_lv_canvas_copy_buf(size_t n_args, const mp_obj_t *args) +{ + lv_obj_t *canvas = mp_to_lv(args[0]); + const void *to_copy = mp_to_ptr(args[1]); + lv_coord_t w = (int16_t)mp_obj_get_int(args[2]); + lv_coord_t h = (int16_t)mp_obj_get_int(args[3]); + lv_coord_t x = (int16_t)mp_obj_get_int(args[4]); + lv_coord_t y = (int16_t)mp_obj_get_int(args[5]); + lv_canvas_copy_buf(canvas, to_copy, w, h, x, y); + return mp_const_none; +} + +STATIC MP_DEFINE_CONST_FUN_OBJ_VAR_BETWEEN(mp_lv_canvas_copy_buf_obj, 6, 6, mp_lv_canvas_copy_buf); + + + +/* + * lvgl extension definition for: + * void lv_canvas_mult_buf(lv_obj_t *canvas, void *to_copy, lv_coord_t w, lv_coord_t h, lv_coord_t x, lv_coord_t y) + */ + +STATIC mp_obj_t mp_lv_canvas_mult_buf(size_t n_args, const mp_obj_t *args) +{ + lv_obj_t *canvas = mp_to_lv(args[0]); + void *to_copy = mp_to_ptr(args[1]); + lv_coord_t w = (int16_t)mp_obj_get_int(args[2]); + lv_coord_t h = (int16_t)mp_obj_get_int(args[3]); + lv_coord_t x = (int16_t)mp_obj_get_int(args[4]); + lv_coord_t y = (int16_t)mp_obj_get_int(args[5]); + lv_canvas_mult_buf(canvas, to_copy, w, h, x, y); + return mp_const_none; +} + +STATIC MP_DEFINE_CONST_FUN_OBJ_VAR_BETWEEN(mp_lv_canvas_mult_buf_obj, 6, 6, mp_lv_canvas_mult_buf); + + + +/* + * lvgl extension definition for: + * void lv_canvas_draw_circle(lv_obj_t *canvas, lv_coord_t x0, lv_coord_t y0, lv_coord_t radius, lv_color_t color) + */ + +STATIC mp_obj_t mp_lv_canvas_draw_circle(size_t n_args, const mp_obj_t *args) +{ + lv_obj_t *canvas = mp_to_lv(args[0]); + lv_coord_t x0 = (int16_t)mp_obj_get_int(args[1]); + lv_coord_t y0 = (int16_t)mp_obj_get_int(args[2]); + lv_coord_t radius = (int16_t)mp_obj_get_int(args[3]); + lv_color_t color = mp_write_lv_color16_t(args[4]); + lv_canvas_draw_circle(canvas, x0, y0, radius, color); + return mp_const_none; +} + +STATIC MP_DEFINE_CONST_FUN_OBJ_VAR_BETWEEN(mp_lv_canvas_draw_circle_obj, 5, 5, mp_lv_canvas_draw_circle); + + + +/* + * lvgl extension definition for: + * void lv_canvas_draw_line(lv_obj_t *canvas, lv_point_t point1, lv_point_t point2, lv_color_t color) + */ + +STATIC mp_obj_t mp_lv_canvas_draw_line(size_t n_args, const mp_obj_t *args) +{ + lv_obj_t *canvas = mp_to_lv(args[0]); + lv_point_t point1 = mp_write_lv_point_t(args[1]); + lv_point_t point2 = mp_write_lv_point_t(args[2]); + lv_color_t color = mp_write_lv_color16_t(args[3]); + lv_canvas_draw_line(canvas, point1, point2, color); + return mp_const_none; +} + +STATIC MP_DEFINE_CONST_FUN_OBJ_VAR_BETWEEN(mp_lv_canvas_draw_line_obj, 4, 4, mp_lv_canvas_draw_line); + + + +/* + * lvgl extension definition for: + * void lv_canvas_draw_triangle(lv_obj_t *canvas, lv_point_t *points, lv_color_t color) + */ + +STATIC mp_obj_t mp_lv_canvas_draw_triangle(size_t n_args, const mp_obj_t *args) +{ + lv_obj_t *canvas = mp_to_lv(args[0]); + lv_point_t *points = mp_write_ptr_lv_point_t(args[1]); + lv_color_t color = mp_write_lv_color16_t(args[2]); + lv_canvas_draw_triangle(canvas, points, color); + return mp_const_none; +} + +STATIC MP_DEFINE_CONST_FUN_OBJ_VAR_BETWEEN(mp_lv_canvas_draw_triangle_obj, 3, 3, mp_lv_canvas_draw_triangle); + + + +/* + * lvgl extension definition for: + * void lv_canvas_draw_rect(lv_obj_t *canvas, lv_point_t *points, lv_color_t color) + */ + +STATIC mp_obj_t mp_lv_canvas_draw_rect(size_t n_args, const mp_obj_t *args) +{ + lv_obj_t *canvas = mp_to_lv(args[0]); + lv_point_t *points = mp_write_ptr_lv_point_t(args[1]); + lv_color_t color = mp_write_lv_color16_t(args[2]); + lv_canvas_draw_rect(canvas, points, color); + return mp_const_none; +} + +STATIC MP_DEFINE_CONST_FUN_OBJ_VAR_BETWEEN(mp_lv_canvas_draw_rect_obj, 3, 3, mp_lv_canvas_draw_rect); + + + +/* + * lvgl extension definition for: + * void lv_canvas_draw_polygon(lv_obj_t *canvas, lv_point_t *points, size_t size, lv_color_t color) + */ + +STATIC mp_obj_t mp_lv_canvas_draw_polygon(size_t n_args, const mp_obj_t *args) +{ + lv_obj_t *canvas = mp_to_lv(args[0]); + lv_point_t *points = mp_write_ptr_lv_point_t(args[1]); + size_t size = (size_t)mp_obj_get_int(args[2]); + lv_color_t color = mp_write_lv_color16_t(args[3]); + lv_canvas_draw_polygon(canvas, points, size, color); + return mp_const_none; +} + +STATIC MP_DEFINE_CONST_FUN_OBJ_VAR_BETWEEN(mp_lv_canvas_draw_polygon_obj, 4, 4, mp_lv_canvas_draw_polygon); + + + +/* + * lvgl extension definition for: + * void lv_canvas_fill_polygon(lv_obj_t *canvas, lv_point_t *points, size_t size, lv_color_t boundary_color, lv_color_t fill_color) + */ + +STATIC mp_obj_t mp_lv_canvas_fill_polygon(size_t n_args, const mp_obj_t *args) +{ + lv_obj_t *canvas = mp_to_lv(args[0]); + lv_point_t *points = mp_write_ptr_lv_point_t(args[1]); + size_t size = (size_t)mp_obj_get_int(args[2]); + lv_color_t boundary_color = mp_write_lv_color16_t(args[3]); + lv_color_t fill_color = mp_write_lv_color16_t(args[4]); + lv_canvas_fill_polygon(canvas, points, size, boundary_color, fill_color); + return mp_const_none; +} + +STATIC MP_DEFINE_CONST_FUN_OBJ_VAR_BETWEEN(mp_lv_canvas_fill_polygon_obj, 5, 5, mp_lv_canvas_fill_polygon); + + + +/* + * lvgl extension definition for: + * void lv_canvas_boundary_fill4(lv_obj_t *canvas, lv_coord_t x, lv_coord_t y, lv_color_t boundary_color, lv_color_t fill_color) + */ + +STATIC mp_obj_t mp_lv_canvas_boundary_fill4(size_t n_args, const mp_obj_t *args) +{ + lv_obj_t *canvas = mp_to_lv(args[0]); + lv_coord_t x = (int16_t)mp_obj_get_int(args[1]); + lv_coord_t y = (int16_t)mp_obj_get_int(args[2]); + lv_color_t boundary_color = mp_write_lv_color16_t(args[3]); + lv_color_t fill_color = mp_write_lv_color16_t(args[4]); + lv_canvas_boundary_fill4(canvas, x, y, boundary_color, fill_color); + return mp_const_none; +} + +STATIC MP_DEFINE_CONST_FUN_OBJ_VAR_BETWEEN(mp_lv_canvas_boundary_fill4_obj, 5, 5, mp_lv_canvas_boundary_fill4); + + + +/* + * lvgl extension definition for: + * void lv_canvas_flood_fill(lv_obj_t *canvas, lv_coord_t x, lv_coord_t y, lv_color_t fill_color, lv_color_t bg_color) + */ + +STATIC mp_obj_t mp_lv_canvas_flood_fill(size_t n_args, const mp_obj_t *args) +{ + lv_obj_t *canvas = mp_to_lv(args[0]); + lv_coord_t x = (int16_t)mp_obj_get_int(args[1]); + lv_coord_t y = (int16_t)mp_obj_get_int(args[2]); + lv_color_t fill_color = mp_write_lv_color16_t(args[3]); + lv_color_t bg_color = mp_write_lv_color16_t(args[4]); + lv_canvas_flood_fill(canvas, x, y, fill_color, bg_color); + return mp_const_none; +} + +STATIC MP_DEFINE_CONST_FUN_OBJ_VAR_BETWEEN(mp_lv_canvas_flood_fill_obj, 5, 5, mp_lv_canvas_flood_fill); + + + +/* + * lvgl canvas object definitions + */ + + +STATIC const mp_rom_map_elem_t canvas_locals_dict_table[] = { + { MP_ROM_QSTR(MP_QSTR_set_buffer), MP_ROM_PTR(&mp_lv_canvas_set_buffer_obj) }, + { MP_ROM_QSTR(MP_QSTR_set_px), MP_ROM_PTR(&mp_lv_canvas_set_px_obj) }, + { MP_ROM_QSTR(MP_QSTR_set_style), MP_ROM_PTR(&mp_lv_canvas_set_style_obj) }, + { MP_ROM_QSTR(MP_QSTR_get_px), MP_ROM_PTR(&mp_lv_canvas_get_px_obj) }, + { MP_ROM_QSTR(MP_QSTR_get_style), MP_ROM_PTR(&mp_lv_canvas_get_style_obj) }, + { MP_ROM_QSTR(MP_QSTR_copy_buf), MP_ROM_PTR(&mp_lv_canvas_copy_buf_obj) }, + { MP_ROM_QSTR(MP_QSTR_mult_buf), MP_ROM_PTR(&mp_lv_canvas_mult_buf_obj) }, + { MP_ROM_QSTR(MP_QSTR_draw_circle), MP_ROM_PTR(&mp_lv_canvas_draw_circle_obj) }, + { MP_ROM_QSTR(MP_QSTR_draw_line), MP_ROM_PTR(&mp_lv_canvas_draw_line_obj) }, + { MP_ROM_QSTR(MP_QSTR_draw_triangle), MP_ROM_PTR(&mp_lv_canvas_draw_triangle_obj) }, + { MP_ROM_QSTR(MP_QSTR_draw_rect), MP_ROM_PTR(&mp_lv_canvas_draw_rect_obj) }, + { MP_ROM_QSTR(MP_QSTR_draw_polygon), MP_ROM_PTR(&mp_lv_canvas_draw_polygon_obj) }, + { MP_ROM_QSTR(MP_QSTR_fill_polygon), MP_ROM_PTR(&mp_lv_canvas_fill_polygon_obj) }, + { MP_ROM_QSTR(MP_QSTR_boundary_fill4), MP_ROM_PTR(&mp_lv_canvas_boundary_fill4_obj) }, + { MP_ROM_QSTR(MP_QSTR_flood_fill), MP_ROM_PTR(&mp_lv_canvas_flood_fill_obj) }, + { MP_ROM_QSTR(MP_QSTR_delete), MP_ROM_PTR(&mp_lv_obj_del_obj) }, + { MP_ROM_QSTR(MP_QSTR_clean), MP_ROM_PTR(&mp_lv_obj_clean_obj) }, + { MP_ROM_QSTR(MP_QSTR_invalidate), MP_ROM_PTR(&mp_lv_obj_invalidate_obj) }, + { MP_ROM_QSTR(MP_QSTR_set_parent), MP_ROM_PTR(&mp_lv_obj_set_parent_obj) }, + { MP_ROM_QSTR(MP_QSTR_set_pos), MP_ROM_PTR(&mp_lv_obj_set_pos_obj) }, + { MP_ROM_QSTR(MP_QSTR_set_x), MP_ROM_PTR(&mp_lv_obj_set_x_obj) }, + { MP_ROM_QSTR(MP_QSTR_set_y), MP_ROM_PTR(&mp_lv_obj_set_y_obj) }, + { MP_ROM_QSTR(MP_QSTR_set_size), MP_ROM_PTR(&mp_lv_obj_set_size_obj) }, + { MP_ROM_QSTR(MP_QSTR_set_width), MP_ROM_PTR(&mp_lv_obj_set_width_obj) }, + { MP_ROM_QSTR(MP_QSTR_set_height), MP_ROM_PTR(&mp_lv_obj_set_height_obj) }, + { MP_ROM_QSTR(MP_QSTR_align), MP_ROM_PTR(&mp_lv_obj_align_obj) }, + { MP_ROM_QSTR(MP_QSTR_align_origo), MP_ROM_PTR(&mp_lv_obj_align_origo_obj) }, + { MP_ROM_QSTR(MP_QSTR_realign), MP_ROM_PTR(&mp_lv_obj_realign_obj) }, + { MP_ROM_QSTR(MP_QSTR_set_auto_realign), MP_ROM_PTR(&mp_lv_obj_set_auto_realign_obj) }, + { MP_ROM_QSTR(MP_QSTR_set_style), MP_ROM_PTR(&mp_lv_obj_set_style_obj) }, + { MP_ROM_QSTR(MP_QSTR_refresh_style), MP_ROM_PTR(&mp_lv_obj_refresh_style_obj) }, + { MP_ROM_QSTR(MP_QSTR_report_style_mod), MP_ROM_PTR(&mp_lv_obj_report_style_mod_obj) }, + { MP_ROM_QSTR(MP_QSTR_set_hidden), MP_ROM_PTR(&mp_lv_obj_set_hidden_obj) }, + { MP_ROM_QSTR(MP_QSTR_set_click), MP_ROM_PTR(&mp_lv_obj_set_click_obj) }, + { MP_ROM_QSTR(MP_QSTR_set_top), MP_ROM_PTR(&mp_lv_obj_set_top_obj) }, + { MP_ROM_QSTR(MP_QSTR_set_drag), MP_ROM_PTR(&mp_lv_obj_set_drag_obj) }, + { MP_ROM_QSTR(MP_QSTR_set_drag_throw), MP_ROM_PTR(&mp_lv_obj_set_drag_throw_obj) }, + { MP_ROM_QSTR(MP_QSTR_set_drag_parent), MP_ROM_PTR(&mp_lv_obj_set_drag_parent_obj) }, + { MP_ROM_QSTR(MP_QSTR_set_opa_scale_enable), MP_ROM_PTR(&mp_lv_obj_set_opa_scale_enable_obj) }, + { MP_ROM_QSTR(MP_QSTR_set_opa_scale), MP_ROM_PTR(&mp_lv_obj_set_opa_scale_obj) }, + { MP_ROM_QSTR(MP_QSTR_set_protect), MP_ROM_PTR(&mp_lv_obj_set_protect_obj) }, + { MP_ROM_QSTR(MP_QSTR_clear_protect), MP_ROM_PTR(&mp_lv_obj_clear_protect_obj) }, + { MP_ROM_QSTR(MP_QSTR_set_signal_func), MP_ROM_PTR(&mp_lv_obj_set_signal_func_obj) }, + { MP_ROM_QSTR(MP_QSTR_set_design_func), MP_ROM_PTR(&mp_lv_obj_set_design_func_obj) }, + { MP_ROM_QSTR(MP_QSTR_allocate_ext_attr), MP_ROM_PTR(&mp_lv_obj_allocate_ext_attr_obj) }, + { MP_ROM_QSTR(MP_QSTR_refresh_ext_size), MP_ROM_PTR(&mp_lv_obj_refresh_ext_size_obj) }, + { MP_ROM_QSTR(MP_QSTR_set_free_num), MP_ROM_PTR(&mp_lv_obj_set_free_num_obj) }, + { MP_ROM_QSTR(MP_QSTR_set_free_ptr), MP_ROM_PTR(&mp_lv_obj_set_free_ptr_obj) }, + { MP_ROM_QSTR(MP_QSTR_animate), MP_ROM_PTR(&mp_lv_obj_animate_obj) }, + { MP_ROM_QSTR(MP_QSTR_get_screen), MP_ROM_PTR(&mp_lv_obj_get_screen_obj) }, + { MP_ROM_QSTR(MP_QSTR_get_parent), MP_ROM_PTR(&mp_lv_obj_get_parent_obj) }, + { MP_ROM_QSTR(MP_QSTR_get_child), MP_ROM_PTR(&mp_lv_obj_get_child_obj) }, + { MP_ROM_QSTR(MP_QSTR_get_child_back), MP_ROM_PTR(&mp_lv_obj_get_child_back_obj) }, + { MP_ROM_QSTR(MP_QSTR_count_children), MP_ROM_PTR(&mp_lv_obj_count_children_obj) }, + { MP_ROM_QSTR(MP_QSTR_get_coords), MP_ROM_PTR(&mp_lv_obj_get_coords_obj) }, + { MP_ROM_QSTR(MP_QSTR_get_x), MP_ROM_PTR(&mp_lv_obj_get_x_obj) }, + { MP_ROM_QSTR(MP_QSTR_get_y), MP_ROM_PTR(&mp_lv_obj_get_y_obj) }, + { MP_ROM_QSTR(MP_QSTR_get_width), MP_ROM_PTR(&mp_lv_obj_get_width_obj) }, + { MP_ROM_QSTR(MP_QSTR_get_height), MP_ROM_PTR(&mp_lv_obj_get_height_obj) }, + { MP_ROM_QSTR(MP_QSTR_get_ext_size), MP_ROM_PTR(&mp_lv_obj_get_ext_size_obj) }, + { MP_ROM_QSTR(MP_QSTR_get_auto_realign), MP_ROM_PTR(&mp_lv_obj_get_auto_realign_obj) }, + { MP_ROM_QSTR(MP_QSTR_get_style), MP_ROM_PTR(&mp_lv_obj_get_style_obj) }, + { MP_ROM_QSTR(MP_QSTR_get_hidden), MP_ROM_PTR(&mp_lv_obj_get_hidden_obj) }, + { MP_ROM_QSTR(MP_QSTR_get_click), MP_ROM_PTR(&mp_lv_obj_get_click_obj) }, + { MP_ROM_QSTR(MP_QSTR_get_top), MP_ROM_PTR(&mp_lv_obj_get_top_obj) }, + { MP_ROM_QSTR(MP_QSTR_get_drag), MP_ROM_PTR(&mp_lv_obj_get_drag_obj) }, + { MP_ROM_QSTR(MP_QSTR_get_drag_throw), MP_ROM_PTR(&mp_lv_obj_get_drag_throw_obj) }, + { MP_ROM_QSTR(MP_QSTR_get_drag_parent), MP_ROM_PTR(&mp_lv_obj_get_drag_parent_obj) }, + { MP_ROM_QSTR(MP_QSTR_get_opa_scale_enable), MP_ROM_PTR(&mp_lv_obj_get_opa_scale_enable_obj) }, + { MP_ROM_QSTR(MP_QSTR_get_opa_scale), MP_ROM_PTR(&mp_lv_obj_get_opa_scale_obj) }, + { MP_ROM_QSTR(MP_QSTR_get_protect), MP_ROM_PTR(&mp_lv_obj_get_protect_obj) }, + { MP_ROM_QSTR(MP_QSTR_is_protected), MP_ROM_PTR(&mp_lv_obj_is_protected_obj) }, + { MP_ROM_QSTR(MP_QSTR_get_signal_func), MP_ROM_PTR(&mp_lv_obj_get_signal_func_obj) }, + { MP_ROM_QSTR(MP_QSTR_get_design_func), MP_ROM_PTR(&mp_lv_obj_get_design_func_obj) }, + { MP_ROM_QSTR(MP_QSTR_get_ext_attr), MP_ROM_PTR(&mp_lv_obj_get_ext_attr_obj) }, + { MP_ROM_QSTR(MP_QSTR_get_free_num), MP_ROM_PTR(&mp_lv_obj_get_free_num_obj) }, + { MP_ROM_QSTR(MP_QSTR_get_free_ptr), MP_ROM_PTR(&mp_lv_obj_get_free_ptr_obj) }, + { MP_ROM_QSTR(MP_QSTR_get_group), MP_ROM_PTR(&mp_lv_obj_get_group_obj) }, + { MP_ROM_QSTR(MP_QSTR_is_focused), MP_ROM_PTR(&mp_lv_obj_is_focused_obj) }, + { MP_ROM_QSTR(MP_QSTR_STYLE), MP_ROM_PTR(&mp_LV_CANVAS_STYLE_type) } +}; + +STATIC MP_DEFINE_CONST_DICT(canvas_locals_dict, canvas_locals_dict_table); + +STATIC void canvas_print(const mp_print_t *print, + mp_obj_t self_in, + mp_print_kind_t kind) +{ + mp_printf(print, "lvgl canvas"); +} + + +STATIC mp_obj_t canvas_make_new( + const mp_obj_type_t *type, + size_t n_args, + size_t n_kw, + const mp_obj_t *args) +{ + return make_new(&lv_canvas_create, type, n_args, n_kw, args); +} + + +STATIC const mp_obj_type_t mp_canvas_type = { + { &mp_type_type }, + .name = MP_QSTR_canvas, + .print = canvas_print, + .make_new = canvas_make_new, + .locals_dict = (mp_obj_dict_t*)&canvas_locals_dict, +}; + + +/* + * lvgl extension definition for: + * inline static bool lv_win_get_drag(const lv_obj_t *win) + */ + +STATIC mp_obj_t mp_lv_win_get_drag(size_t n_args, const mp_obj_t *args) +{ + const lv_obj_t *win = mp_to_lv(args[0]); + bool res = lv_win_get_drag(win); + return convert_to_bool(res); +} + +STATIC MP_DEFINE_CONST_FUN_OBJ_VAR_BETWEEN(mp_lv_win_get_drag_obj, 1, 1, mp_lv_win_get_drag); + + + +/* + * lvgl extension definition for: + * inline static void lv_win_scroll_hor(lv_obj_t *win, lv_coord_t dist) + */ + +STATIC mp_obj_t mp_lv_win_scroll_hor(size_t n_args, const mp_obj_t *args) +{ + lv_obj_t *win = mp_to_lv(args[0]); + lv_coord_t dist = (int16_t)mp_obj_get_int(args[1]); + lv_win_scroll_hor(win, dist); + return mp_const_none; +} + +STATIC MP_DEFINE_CONST_FUN_OBJ_VAR_BETWEEN(mp_lv_win_scroll_hor_obj, 2, 2, mp_lv_win_scroll_hor); + + + +/* + * lvgl extension definition for: + * inline static void lv_win_scroll_ver(lv_obj_t *win, lv_coord_t dist) + */ + +STATIC mp_obj_t mp_lv_win_scroll_ver(size_t n_args, const mp_obj_t *args) +{ + lv_obj_t *win = mp_to_lv(args[0]); + lv_coord_t dist = (int16_t)mp_obj_get_int(args[1]); + lv_win_scroll_ver(win, dist); + return mp_const_none; +} + +STATIC MP_DEFINE_CONST_FUN_OBJ_VAR_BETWEEN(mp_lv_win_scroll_ver_obj, 2, 2, mp_lv_win_scroll_ver); + + + +/* + * lvgl extension definition for: + * void lv_win_clean(lv_obj_t *obj) + */ + +STATIC mp_obj_t mp_lv_win_clean(size_t n_args, const mp_obj_t *args) +{ + lv_obj_t *obj = mp_to_lv(args[0]); + lv_win_clean(obj); + return mp_const_none; +} + +STATIC MP_DEFINE_CONST_FUN_OBJ_VAR_BETWEEN(mp_lv_win_clean_obj, 1, 1, mp_lv_win_clean); + + + +/* + * lvgl extension definition for: + * lv_obj_t *lv_win_add_btn(lv_obj_t *win, const void *img_src, lv_action_t rel_action) + */ + +STATIC mp_obj_t mp_lv_win_add_btn(size_t n_args, const mp_obj_t *args) +{ + lv_obj_t *win = mp_to_lv(args[0]); + const void *img_src = mp_to_ptr(args[1]); + set_action(args[0], args[2]); + lv_action_t rel_action = &lv_action_t_callback; + lv_obj_t* res = lv_win_add_btn(win, img_src, rel_action); + return lv_to_mp((void*)res); +} + +STATIC MP_DEFINE_CONST_FUN_OBJ_VAR_BETWEEN(mp_lv_win_add_btn_obj, 3, 3, mp_lv_win_add_btn); + + + +/* + * lvgl extension definition for: + * lv_res_t lv_win_close_action(lv_obj_t *btn) + */ + +STATIC mp_obj_t mp_lv_win_close_action(size_t n_args, const mp_obj_t *args) +{ + lv_obj_t *btn = mp_to_lv(args[0]); + lv_res_t res = lv_win_close_action(btn); + return mp_obj_new_int_from_uint(res); +} + +STATIC MP_DEFINE_CONST_FUN_OBJ_VAR_BETWEEN(mp_lv_win_close_action_obj, 1, 1, mp_lv_win_close_action); + + + +/* + * lvgl extension definition for: + * void lv_win_set_title(lv_obj_t *win, const char *title) + */ + +STATIC mp_obj_t mp_lv_win_set_title(size_t n_args, const mp_obj_t *args) +{ + lv_obj_t *win = mp_to_lv(args[0]); + const char *title = (char*)mp_obj_str_get_str(args[1]); + lv_win_set_title(win, title); + return mp_const_none; +} + +STATIC MP_DEFINE_CONST_FUN_OBJ_VAR_BETWEEN(mp_lv_win_set_title_obj, 2, 2, mp_lv_win_set_title); + + + +/* + * lvgl extension definition for: + * void lv_win_set_btn_size(lv_obj_t *win, lv_coord_t size) + */ + +STATIC mp_obj_t mp_lv_win_set_btn_size(size_t n_args, const mp_obj_t *args) +{ + lv_obj_t *win = mp_to_lv(args[0]); + lv_coord_t size = (int16_t)mp_obj_get_int(args[1]); + lv_win_set_btn_size(win, size); + return mp_const_none; +} + +STATIC MP_DEFINE_CONST_FUN_OBJ_VAR_BETWEEN(mp_lv_win_set_btn_size_obj, 2, 2, mp_lv_win_set_btn_size); + + + +/* + * lvgl extension definition for: + * void lv_win_set_layout(lv_obj_t *win, lv_layout_t layout) + */ + +STATIC mp_obj_t mp_lv_win_set_layout(size_t n_args, const mp_obj_t *args) +{ + lv_obj_t *win = mp_to_lv(args[0]); + lv_layout_t layout = (uint8_t)mp_obj_get_int(args[1]); + lv_win_set_layout(win, layout); + return mp_const_none; +} + +STATIC MP_DEFINE_CONST_FUN_OBJ_VAR_BETWEEN(mp_lv_win_set_layout_obj, 2, 2, mp_lv_win_set_layout); + + + +/* + * lvgl extension definition for: + * void lv_win_set_sb_mode(lv_obj_t *win, lv_sb_mode_t sb_mode) + */ + +STATIC mp_obj_t mp_lv_win_set_sb_mode(size_t n_args, const mp_obj_t *args) +{ + lv_obj_t *win = mp_to_lv(args[0]); + lv_sb_mode_t sb_mode = (uint8_t)mp_obj_get_int(args[1]); + lv_win_set_sb_mode(win, sb_mode); + return mp_const_none; +} + +STATIC MP_DEFINE_CONST_FUN_OBJ_VAR_BETWEEN(mp_lv_win_set_sb_mode_obj, 2, 2, mp_lv_win_set_sb_mode); + + + +/* + * lvgl extension definition for: + * void lv_win_set_style(lv_obj_t *win, lv_win_style_t type, lv_style_t *style) + */ + +STATIC mp_obj_t mp_lv_win_set_style(size_t n_args, const mp_obj_t *args) +{ + lv_obj_t *win = mp_to_lv(args[0]); + lv_win_style_t type = (uint8_t)mp_obj_get_int(args[1]); + lv_style_t *style = mp_write_ptr_lv_style_t(args[2]); + lv_win_set_style(win, type, style); + return mp_const_none; +} + +STATIC MP_DEFINE_CONST_FUN_OBJ_VAR_BETWEEN(mp_lv_win_set_style_obj, 3, 3, mp_lv_win_set_style); + + + +/* + * lvgl extension definition for: + * void lv_win_set_drag(lv_obj_t *win, bool en) + */ + +STATIC mp_obj_t mp_lv_win_set_drag(size_t n_args, const mp_obj_t *args) +{ + lv_obj_t *win = mp_to_lv(args[0]); + bool en = mp_obj_is_true(args[1]); + lv_win_set_drag(win, en); + return mp_const_none; +} + +STATIC MP_DEFINE_CONST_FUN_OBJ_VAR_BETWEEN(mp_lv_win_set_drag_obj, 2, 2, mp_lv_win_set_drag); + + + +/* + * lvgl extension definition for: + * const char *lv_win_get_title(const lv_obj_t *win) + */ + +STATIC mp_obj_t mp_lv_win_get_title(size_t n_args, const mp_obj_t *args) +{ + const lv_obj_t *win = mp_to_lv(args[0]); + const char* res = lv_win_get_title(win); + return convert_to_str((void*)res); +} + +STATIC MP_DEFINE_CONST_FUN_OBJ_VAR_BETWEEN(mp_lv_win_get_title_obj, 1, 1, mp_lv_win_get_title); + + + +/* + * lvgl extension definition for: + * lv_obj_t *lv_win_get_content(const lv_obj_t *win) + */ + +STATIC mp_obj_t mp_lv_win_get_content(size_t n_args, const mp_obj_t *args) +{ + const lv_obj_t *win = mp_to_lv(args[0]); + lv_obj_t* res = lv_win_get_content(win); + return lv_to_mp((void*)res); +} + +STATIC MP_DEFINE_CONST_FUN_OBJ_VAR_BETWEEN(mp_lv_win_get_content_obj, 1, 1, mp_lv_win_get_content); + + + +/* + * lvgl extension definition for: + * lv_coord_t lv_win_get_btn_size(const lv_obj_t *win) + */ + +STATIC mp_obj_t mp_lv_win_get_btn_size(size_t n_args, const mp_obj_t *args) +{ + const lv_obj_t *win = mp_to_lv(args[0]); + lv_coord_t res = lv_win_get_btn_size(win); + return mp_obj_new_int(res); +} + +STATIC MP_DEFINE_CONST_FUN_OBJ_VAR_BETWEEN(mp_lv_win_get_btn_size_obj, 1, 1, mp_lv_win_get_btn_size); + + + +/* + * lvgl extension definition for: + * lv_obj_t *lv_win_get_from_btn(const lv_obj_t *ctrl_btn) + */ + +STATIC mp_obj_t mp_lv_win_get_from_btn(size_t n_args, const mp_obj_t *args) +{ + const lv_obj_t *ctrl_btn = mp_to_lv(args[0]); + lv_obj_t* res = lv_win_get_from_btn(ctrl_btn); + return lv_to_mp((void*)res); +} + +STATIC MP_DEFINE_CONST_FUN_OBJ_VAR_BETWEEN(mp_lv_win_get_from_btn_obj, 1, 1, mp_lv_win_get_from_btn); + + + +/* + * lvgl extension definition for: + * lv_layout_t lv_win_get_layout(lv_obj_t *win) + */ + +STATIC mp_obj_t mp_lv_win_get_layout(size_t n_args, const mp_obj_t *args) +{ + lv_obj_t *win = mp_to_lv(args[0]); + lv_layout_t res = lv_win_get_layout(win); + return mp_obj_new_int_from_uint(res); +} + +STATIC MP_DEFINE_CONST_FUN_OBJ_VAR_BETWEEN(mp_lv_win_get_layout_obj, 1, 1, mp_lv_win_get_layout); + + + +/* + * lvgl extension definition for: + * lv_sb_mode_t lv_win_get_sb_mode(lv_obj_t *win) + */ + +STATIC mp_obj_t mp_lv_win_get_sb_mode(size_t n_args, const mp_obj_t *args) +{ + lv_obj_t *win = mp_to_lv(args[0]); + lv_sb_mode_t res = lv_win_get_sb_mode(win); + return mp_obj_new_int_from_uint(res); +} + +STATIC MP_DEFINE_CONST_FUN_OBJ_VAR_BETWEEN(mp_lv_win_get_sb_mode_obj, 1, 1, mp_lv_win_get_sb_mode); + + + +/* + * lvgl extension definition for: + * lv_coord_t lv_win_get_width(lv_obj_t *win) + */ + +STATIC mp_obj_t mp_lv_win_get_width(size_t n_args, const mp_obj_t *args) +{ + lv_obj_t *win = mp_to_lv(args[0]); + lv_coord_t res = lv_win_get_width(win); + return mp_obj_new_int(res); +} + +STATIC MP_DEFINE_CONST_FUN_OBJ_VAR_BETWEEN(mp_lv_win_get_width_obj, 1, 1, mp_lv_win_get_width); + + + +/* + * lvgl extension definition for: + * lv_style_t *lv_win_get_style(const lv_obj_t *win, lv_win_style_t type) + */ + +STATIC mp_obj_t mp_lv_win_get_style(size_t n_args, const mp_obj_t *args) +{ + const lv_obj_t *win = mp_to_lv(args[0]); + lv_win_style_t type = (uint8_t)mp_obj_get_int(args[1]); + lv_style_t* res = lv_win_get_style(win, type); + return mp_read_ptr_lv_style_t((void*)res); +} + +STATIC MP_DEFINE_CONST_FUN_OBJ_VAR_BETWEEN(mp_lv_win_get_style_obj, 2, 2, mp_lv_win_get_style); + + + +/* + * lvgl extension definition for: + * void lv_win_focus(lv_obj_t *win, lv_obj_t *obj, uint16_t anim_time) + */ + +STATIC mp_obj_t mp_lv_win_focus(size_t n_args, const mp_obj_t *args) +{ + lv_obj_t *win = mp_to_lv(args[0]); + lv_obj_t *obj = mp_to_lv(args[1]); + uint16_t anim_time = (uint16_t)mp_obj_get_int(args[2]); + lv_win_focus(win, obj, anim_time); + return mp_const_none; +} + +STATIC MP_DEFINE_CONST_FUN_OBJ_VAR_BETWEEN(mp_lv_win_focus_obj, 3, 3, mp_lv_win_focus); + + + +/* + * lvgl win object definitions + */ + + +STATIC const mp_rom_map_elem_t win_locals_dict_table[] = { + { MP_ROM_QSTR(MP_QSTR_get_drag), MP_ROM_PTR(&mp_lv_win_get_drag_obj) }, + { MP_ROM_QSTR(MP_QSTR_scroll_hor), MP_ROM_PTR(&mp_lv_win_scroll_hor_obj) }, + { MP_ROM_QSTR(MP_QSTR_scroll_ver), MP_ROM_PTR(&mp_lv_win_scroll_ver_obj) }, + { MP_ROM_QSTR(MP_QSTR_clean), MP_ROM_PTR(&mp_lv_win_clean_obj) }, + { MP_ROM_QSTR(MP_QSTR_add_btn), MP_ROM_PTR(&mp_lv_win_add_btn_obj) }, + { MP_ROM_QSTR(MP_QSTR_close_action), MP_ROM_PTR(&mp_lv_win_close_action_obj) }, + { MP_ROM_QSTR(MP_QSTR_set_title), MP_ROM_PTR(&mp_lv_win_set_title_obj) }, + { MP_ROM_QSTR(MP_QSTR_set_btn_size), MP_ROM_PTR(&mp_lv_win_set_btn_size_obj) }, + { MP_ROM_QSTR(MP_QSTR_set_layout), MP_ROM_PTR(&mp_lv_win_set_layout_obj) }, + { MP_ROM_QSTR(MP_QSTR_set_sb_mode), MP_ROM_PTR(&mp_lv_win_set_sb_mode_obj) }, + { MP_ROM_QSTR(MP_QSTR_set_style), MP_ROM_PTR(&mp_lv_win_set_style_obj) }, + { MP_ROM_QSTR(MP_QSTR_set_drag), MP_ROM_PTR(&mp_lv_win_set_drag_obj) }, + { MP_ROM_QSTR(MP_QSTR_get_title), MP_ROM_PTR(&mp_lv_win_get_title_obj) }, + { MP_ROM_QSTR(MP_QSTR_get_content), MP_ROM_PTR(&mp_lv_win_get_content_obj) }, + { MP_ROM_QSTR(MP_QSTR_get_btn_size), MP_ROM_PTR(&mp_lv_win_get_btn_size_obj) }, + { MP_ROM_QSTR(MP_QSTR_get_from_btn), MP_ROM_PTR(&mp_lv_win_get_from_btn_obj) }, + { MP_ROM_QSTR(MP_QSTR_get_layout), MP_ROM_PTR(&mp_lv_win_get_layout_obj) }, + { MP_ROM_QSTR(MP_QSTR_get_sb_mode), MP_ROM_PTR(&mp_lv_win_get_sb_mode_obj) }, + { MP_ROM_QSTR(MP_QSTR_get_width), MP_ROM_PTR(&mp_lv_win_get_width_obj) }, + { MP_ROM_QSTR(MP_QSTR_get_style), MP_ROM_PTR(&mp_lv_win_get_style_obj) }, + { MP_ROM_QSTR(MP_QSTR_focus), MP_ROM_PTR(&mp_lv_win_focus_obj) }, + { MP_ROM_QSTR(MP_QSTR_delete), MP_ROM_PTR(&mp_lv_obj_del_obj) }, + { MP_ROM_QSTR(MP_QSTR_clean), MP_ROM_PTR(&mp_lv_obj_clean_obj) }, + { MP_ROM_QSTR(MP_QSTR_invalidate), MP_ROM_PTR(&mp_lv_obj_invalidate_obj) }, + { MP_ROM_QSTR(MP_QSTR_set_parent), MP_ROM_PTR(&mp_lv_obj_set_parent_obj) }, + { MP_ROM_QSTR(MP_QSTR_set_pos), MP_ROM_PTR(&mp_lv_obj_set_pos_obj) }, + { MP_ROM_QSTR(MP_QSTR_set_x), MP_ROM_PTR(&mp_lv_obj_set_x_obj) }, + { MP_ROM_QSTR(MP_QSTR_set_y), MP_ROM_PTR(&mp_lv_obj_set_y_obj) }, + { MP_ROM_QSTR(MP_QSTR_set_size), MP_ROM_PTR(&mp_lv_obj_set_size_obj) }, + { MP_ROM_QSTR(MP_QSTR_set_width), MP_ROM_PTR(&mp_lv_obj_set_width_obj) }, + { MP_ROM_QSTR(MP_QSTR_set_height), MP_ROM_PTR(&mp_lv_obj_set_height_obj) }, + { MP_ROM_QSTR(MP_QSTR_align), MP_ROM_PTR(&mp_lv_obj_align_obj) }, + { MP_ROM_QSTR(MP_QSTR_align_origo), MP_ROM_PTR(&mp_lv_obj_align_origo_obj) }, + { MP_ROM_QSTR(MP_QSTR_realign), MP_ROM_PTR(&mp_lv_obj_realign_obj) }, + { MP_ROM_QSTR(MP_QSTR_set_auto_realign), MP_ROM_PTR(&mp_lv_obj_set_auto_realign_obj) }, + { MP_ROM_QSTR(MP_QSTR_set_style), MP_ROM_PTR(&mp_lv_obj_set_style_obj) }, + { MP_ROM_QSTR(MP_QSTR_refresh_style), MP_ROM_PTR(&mp_lv_obj_refresh_style_obj) }, + { MP_ROM_QSTR(MP_QSTR_report_style_mod), MP_ROM_PTR(&mp_lv_obj_report_style_mod_obj) }, + { MP_ROM_QSTR(MP_QSTR_set_hidden), MP_ROM_PTR(&mp_lv_obj_set_hidden_obj) }, + { MP_ROM_QSTR(MP_QSTR_set_click), MP_ROM_PTR(&mp_lv_obj_set_click_obj) }, + { MP_ROM_QSTR(MP_QSTR_set_top), MP_ROM_PTR(&mp_lv_obj_set_top_obj) }, + { MP_ROM_QSTR(MP_QSTR_set_drag), MP_ROM_PTR(&mp_lv_obj_set_drag_obj) }, + { MP_ROM_QSTR(MP_QSTR_set_drag_throw), MP_ROM_PTR(&mp_lv_obj_set_drag_throw_obj) }, + { MP_ROM_QSTR(MP_QSTR_set_drag_parent), MP_ROM_PTR(&mp_lv_obj_set_drag_parent_obj) }, + { MP_ROM_QSTR(MP_QSTR_set_opa_scale_enable), MP_ROM_PTR(&mp_lv_obj_set_opa_scale_enable_obj) }, + { MP_ROM_QSTR(MP_QSTR_set_opa_scale), MP_ROM_PTR(&mp_lv_obj_set_opa_scale_obj) }, + { MP_ROM_QSTR(MP_QSTR_set_protect), MP_ROM_PTR(&mp_lv_obj_set_protect_obj) }, + { MP_ROM_QSTR(MP_QSTR_clear_protect), MP_ROM_PTR(&mp_lv_obj_clear_protect_obj) }, + { MP_ROM_QSTR(MP_QSTR_set_signal_func), MP_ROM_PTR(&mp_lv_obj_set_signal_func_obj) }, + { MP_ROM_QSTR(MP_QSTR_set_design_func), MP_ROM_PTR(&mp_lv_obj_set_design_func_obj) }, + { MP_ROM_QSTR(MP_QSTR_allocate_ext_attr), MP_ROM_PTR(&mp_lv_obj_allocate_ext_attr_obj) }, + { MP_ROM_QSTR(MP_QSTR_refresh_ext_size), MP_ROM_PTR(&mp_lv_obj_refresh_ext_size_obj) }, + { MP_ROM_QSTR(MP_QSTR_set_free_num), MP_ROM_PTR(&mp_lv_obj_set_free_num_obj) }, + { MP_ROM_QSTR(MP_QSTR_set_free_ptr), MP_ROM_PTR(&mp_lv_obj_set_free_ptr_obj) }, + { MP_ROM_QSTR(MP_QSTR_animate), MP_ROM_PTR(&mp_lv_obj_animate_obj) }, + { MP_ROM_QSTR(MP_QSTR_get_screen), MP_ROM_PTR(&mp_lv_obj_get_screen_obj) }, + { MP_ROM_QSTR(MP_QSTR_get_parent), MP_ROM_PTR(&mp_lv_obj_get_parent_obj) }, + { MP_ROM_QSTR(MP_QSTR_get_child), MP_ROM_PTR(&mp_lv_obj_get_child_obj) }, + { MP_ROM_QSTR(MP_QSTR_get_child_back), MP_ROM_PTR(&mp_lv_obj_get_child_back_obj) }, + { MP_ROM_QSTR(MP_QSTR_count_children), MP_ROM_PTR(&mp_lv_obj_count_children_obj) }, + { MP_ROM_QSTR(MP_QSTR_get_coords), MP_ROM_PTR(&mp_lv_obj_get_coords_obj) }, + { MP_ROM_QSTR(MP_QSTR_get_x), MP_ROM_PTR(&mp_lv_obj_get_x_obj) }, + { MP_ROM_QSTR(MP_QSTR_get_y), MP_ROM_PTR(&mp_lv_obj_get_y_obj) }, + { MP_ROM_QSTR(MP_QSTR_get_width), MP_ROM_PTR(&mp_lv_obj_get_width_obj) }, + { MP_ROM_QSTR(MP_QSTR_get_height), MP_ROM_PTR(&mp_lv_obj_get_height_obj) }, + { MP_ROM_QSTR(MP_QSTR_get_ext_size), MP_ROM_PTR(&mp_lv_obj_get_ext_size_obj) }, + { MP_ROM_QSTR(MP_QSTR_get_auto_realign), MP_ROM_PTR(&mp_lv_obj_get_auto_realign_obj) }, + { MP_ROM_QSTR(MP_QSTR_get_style), MP_ROM_PTR(&mp_lv_obj_get_style_obj) }, + { MP_ROM_QSTR(MP_QSTR_get_hidden), MP_ROM_PTR(&mp_lv_obj_get_hidden_obj) }, + { MP_ROM_QSTR(MP_QSTR_get_click), MP_ROM_PTR(&mp_lv_obj_get_click_obj) }, + { MP_ROM_QSTR(MP_QSTR_get_top), MP_ROM_PTR(&mp_lv_obj_get_top_obj) }, + { MP_ROM_QSTR(MP_QSTR_get_drag), MP_ROM_PTR(&mp_lv_obj_get_drag_obj) }, + { MP_ROM_QSTR(MP_QSTR_get_drag_throw), MP_ROM_PTR(&mp_lv_obj_get_drag_throw_obj) }, + { MP_ROM_QSTR(MP_QSTR_get_drag_parent), MP_ROM_PTR(&mp_lv_obj_get_drag_parent_obj) }, + { MP_ROM_QSTR(MP_QSTR_get_opa_scale_enable), MP_ROM_PTR(&mp_lv_obj_get_opa_scale_enable_obj) }, + { MP_ROM_QSTR(MP_QSTR_get_opa_scale), MP_ROM_PTR(&mp_lv_obj_get_opa_scale_obj) }, + { MP_ROM_QSTR(MP_QSTR_get_protect), MP_ROM_PTR(&mp_lv_obj_get_protect_obj) }, + { MP_ROM_QSTR(MP_QSTR_is_protected), MP_ROM_PTR(&mp_lv_obj_is_protected_obj) }, + { MP_ROM_QSTR(MP_QSTR_get_signal_func), MP_ROM_PTR(&mp_lv_obj_get_signal_func_obj) }, + { MP_ROM_QSTR(MP_QSTR_get_design_func), MP_ROM_PTR(&mp_lv_obj_get_design_func_obj) }, + { MP_ROM_QSTR(MP_QSTR_get_ext_attr), MP_ROM_PTR(&mp_lv_obj_get_ext_attr_obj) }, + { MP_ROM_QSTR(MP_QSTR_get_free_num), MP_ROM_PTR(&mp_lv_obj_get_free_num_obj) }, + { MP_ROM_QSTR(MP_QSTR_get_free_ptr), MP_ROM_PTR(&mp_lv_obj_get_free_ptr_obj) }, + { MP_ROM_QSTR(MP_QSTR_get_group), MP_ROM_PTR(&mp_lv_obj_get_group_obj) }, + { MP_ROM_QSTR(MP_QSTR_is_focused), MP_ROM_PTR(&mp_lv_obj_is_focused_obj) }, + { MP_ROM_QSTR(MP_QSTR_STYLE), MP_ROM_PTR(&mp_LV_WIN_STYLE_type) } +}; + +STATIC MP_DEFINE_CONST_DICT(win_locals_dict, win_locals_dict_table); + +STATIC void win_print(const mp_print_t *print, + mp_obj_t self_in, + mp_print_kind_t kind) +{ + mp_printf(print, "lvgl win"); +} + + +STATIC mp_obj_t win_make_new( + const mp_obj_type_t *type, + size_t n_args, + size_t n_kw, + const mp_obj_t *args) +{ + return make_new(&lv_win_create, type, n_args, n_kw, args); +} + + +STATIC const mp_obj_type_t mp_win_type = { + { &mp_type_type }, + .name = MP_QSTR_win, + .print = win_print, + .make_new = win_make_new, + .locals_dict = (mp_obj_dict_t*)&win_locals_dict, +}; + + +/* + * lvgl extension definition for: + * void lv_tabview_clean(lv_obj_t *obj) + */ + +STATIC mp_obj_t mp_lv_tabview_clean(size_t n_args, const mp_obj_t *args) +{ + lv_obj_t *obj = mp_to_lv(args[0]); + lv_tabview_clean(obj); + return mp_const_none; +} + +STATIC MP_DEFINE_CONST_FUN_OBJ_VAR_BETWEEN(mp_lv_tabview_clean_obj, 1, 1, mp_lv_tabview_clean); + + + +/* + * lvgl extension definition for: + * lv_obj_t *lv_tabview_add_tab(lv_obj_t *tabview, const char *name) + */ + +STATIC mp_obj_t mp_lv_tabview_add_tab(size_t n_args, const mp_obj_t *args) +{ + lv_obj_t *tabview = mp_to_lv(args[0]); + const char *name = (char*)mp_obj_str_get_str(args[1]); + lv_obj_t* res = lv_tabview_add_tab(tabview, name); + return lv_to_mp((void*)res); +} + +STATIC MP_DEFINE_CONST_FUN_OBJ_VAR_BETWEEN(mp_lv_tabview_add_tab_obj, 2, 2, mp_lv_tabview_add_tab); + + + +/* + * lvgl extension definition for: + * void lv_tabview_set_tab_act(lv_obj_t *tabview, uint16_t id, bool anim_en) + */ + +STATIC mp_obj_t mp_lv_tabview_set_tab_act(size_t n_args, const mp_obj_t *args) +{ + lv_obj_t *tabview = mp_to_lv(args[0]); + uint16_t id = (uint16_t)mp_obj_get_int(args[1]); + bool anim_en = mp_obj_is_true(args[2]); + lv_tabview_set_tab_act(tabview, id, anim_en); + return mp_const_none; +} + +STATIC MP_DEFINE_CONST_FUN_OBJ_VAR_BETWEEN(mp_lv_tabview_set_tab_act_obj, 3, 3, mp_lv_tabview_set_tab_act); + + + +/* + * lvgl extension definition for: + * void lv_tabview_set_tab_load_action(lv_obj_t *tabview, lv_tabview_action_t action) + */ + +STATIC mp_obj_t mp_lv_tabview_set_tab_load_action(size_t n_args, const mp_obj_t *args) +{ + lv_obj_t *tabview = mp_to_lv(args[0]); + set_action(args[0], args[1]); + lv_tabview_action_t action = &lv_tabview_action_t_callback; + lv_tabview_set_tab_load_action(tabview, action); + return mp_const_none; +} + +STATIC MP_DEFINE_CONST_FUN_OBJ_VAR_BETWEEN(mp_lv_tabview_set_tab_load_action_obj, 2, 2, mp_lv_tabview_set_tab_load_action); + + + +/* + * lvgl extension definition for: + * void lv_tabview_set_sliding(lv_obj_t *tabview, bool en) + */ + +STATIC mp_obj_t mp_lv_tabview_set_sliding(size_t n_args, const mp_obj_t *args) +{ + lv_obj_t *tabview = mp_to_lv(args[0]); + bool en = mp_obj_is_true(args[1]); + lv_tabview_set_sliding(tabview, en); + return mp_const_none; +} + +STATIC MP_DEFINE_CONST_FUN_OBJ_VAR_BETWEEN(mp_lv_tabview_set_sliding_obj, 2, 2, mp_lv_tabview_set_sliding); + + + +/* + * lvgl extension definition for: + * void lv_tabview_set_anim_time(lv_obj_t *tabview, uint16_t anim_time) + */ + +STATIC mp_obj_t mp_lv_tabview_set_anim_time(size_t n_args, const mp_obj_t *args) +{ + lv_obj_t *tabview = mp_to_lv(args[0]); + uint16_t anim_time = (uint16_t)mp_obj_get_int(args[1]); + lv_tabview_set_anim_time(tabview, anim_time); + return mp_const_none; +} + +STATIC MP_DEFINE_CONST_FUN_OBJ_VAR_BETWEEN(mp_lv_tabview_set_anim_time_obj, 2, 2, mp_lv_tabview_set_anim_time); + + + +/* + * lvgl extension definition for: + * void lv_tabview_set_style(lv_obj_t *tabview, lv_tabview_style_t type, lv_style_t *style) + */ + +STATIC mp_obj_t mp_lv_tabview_set_style(size_t n_args, const mp_obj_t *args) +{ + lv_obj_t *tabview = mp_to_lv(args[0]); + lv_tabview_style_t type = (uint8_t)mp_obj_get_int(args[1]); + lv_style_t *style = mp_write_ptr_lv_style_t(args[2]); + lv_tabview_set_style(tabview, type, style); + return mp_const_none; +} + +STATIC MP_DEFINE_CONST_FUN_OBJ_VAR_BETWEEN(mp_lv_tabview_set_style_obj, 3, 3, mp_lv_tabview_set_style); + + + +/* + * lvgl extension definition for: + * void lv_tabview_set_btns_pos(lv_obj_t *tabview, lv_tabview_btns_pos_t btns_pos) + */ + +STATIC mp_obj_t mp_lv_tabview_set_btns_pos(size_t n_args, const mp_obj_t *args) +{ + lv_obj_t *tabview = mp_to_lv(args[0]); + lv_tabview_btns_pos_t btns_pos = (uint8_t)mp_obj_get_int(args[1]); + lv_tabview_set_btns_pos(tabview, btns_pos); + return mp_const_none; +} + +STATIC MP_DEFINE_CONST_FUN_OBJ_VAR_BETWEEN(mp_lv_tabview_set_btns_pos_obj, 2, 2, mp_lv_tabview_set_btns_pos); + + + +/* + * lvgl extension definition for: + * void lv_tabview_set_btns_hidden(lv_obj_t *tabview, bool en) + */ + +STATIC mp_obj_t mp_lv_tabview_set_btns_hidden(size_t n_args, const mp_obj_t *args) +{ + lv_obj_t *tabview = mp_to_lv(args[0]); + bool en = mp_obj_is_true(args[1]); + lv_tabview_set_btns_hidden(tabview, en); + return mp_const_none; +} + +STATIC MP_DEFINE_CONST_FUN_OBJ_VAR_BETWEEN(mp_lv_tabview_set_btns_hidden_obj, 2, 2, mp_lv_tabview_set_btns_hidden); + + + +/* + * lvgl extension definition for: + * uint16_t lv_tabview_get_tab_act(const lv_obj_t *tabview) + */ + +STATIC mp_obj_t mp_lv_tabview_get_tab_act(size_t n_args, const mp_obj_t *args) +{ + const lv_obj_t *tabview = mp_to_lv(args[0]); + uint16_t res = lv_tabview_get_tab_act(tabview); + return mp_obj_new_int_from_uint(res); +} + +STATIC MP_DEFINE_CONST_FUN_OBJ_VAR_BETWEEN(mp_lv_tabview_get_tab_act_obj, 1, 1, mp_lv_tabview_get_tab_act); + + + +/* + * lvgl extension definition for: + * uint16_t lv_tabview_get_tab_count(const lv_obj_t *tabview) + */ + +STATIC mp_obj_t mp_lv_tabview_get_tab_count(size_t n_args, const mp_obj_t *args) +{ + const lv_obj_t *tabview = mp_to_lv(args[0]); + uint16_t res = lv_tabview_get_tab_count(tabview); + return mp_obj_new_int_from_uint(res); +} + +STATIC MP_DEFINE_CONST_FUN_OBJ_VAR_BETWEEN(mp_lv_tabview_get_tab_count_obj, 1, 1, mp_lv_tabview_get_tab_count); + + + +/* + * lvgl extension definition for: + * lv_obj_t *lv_tabview_get_tab(const lv_obj_t *tabview, uint16_t id) + */ + +STATIC mp_obj_t mp_lv_tabview_get_tab(size_t n_args, const mp_obj_t *args) +{ + const lv_obj_t *tabview = mp_to_lv(args[0]); + uint16_t id = (uint16_t)mp_obj_get_int(args[1]); + lv_obj_t* res = lv_tabview_get_tab(tabview, id); + return lv_to_mp((void*)res); +} + +STATIC MP_DEFINE_CONST_FUN_OBJ_VAR_BETWEEN(mp_lv_tabview_get_tab_obj, 2, 2, mp_lv_tabview_get_tab); + + + +/* + * lvgl extension definition for: + * lv_tabview_action_t lv_tabview_get_tab_load_action(const lv_obj_t *tabview) + */ + +STATIC mp_obj_t mp_lv_tabview_get_tab_load_action(size_t n_args, const mp_obj_t *args) +{ + const lv_obj_t *tabview = mp_to_lv(args[0]); + lv_tabview_action_t res = lv_tabview_get_tab_load_action(tabview); + return ptr_to_mp(res); +} + +STATIC MP_DEFINE_CONST_FUN_OBJ_VAR_BETWEEN(mp_lv_tabview_get_tab_load_action_obj, 1, 1, mp_lv_tabview_get_tab_load_action); + + + +/* + * lvgl extension definition for: + * bool lv_tabview_get_sliding(const lv_obj_t *tabview) + */ + +STATIC mp_obj_t mp_lv_tabview_get_sliding(size_t n_args, const mp_obj_t *args) +{ + const lv_obj_t *tabview = mp_to_lv(args[0]); + bool res = lv_tabview_get_sliding(tabview); + return convert_to_bool(res); +} + +STATIC MP_DEFINE_CONST_FUN_OBJ_VAR_BETWEEN(mp_lv_tabview_get_sliding_obj, 1, 1, mp_lv_tabview_get_sliding); + + + +/* + * lvgl extension definition for: + * uint16_t lv_tabview_get_anim_time(const lv_obj_t *tabview) + */ + +STATIC mp_obj_t mp_lv_tabview_get_anim_time(size_t n_args, const mp_obj_t *args) +{ + const lv_obj_t *tabview = mp_to_lv(args[0]); + uint16_t res = lv_tabview_get_anim_time(tabview); + return mp_obj_new_int_from_uint(res); +} + +STATIC MP_DEFINE_CONST_FUN_OBJ_VAR_BETWEEN(mp_lv_tabview_get_anim_time_obj, 1, 1, mp_lv_tabview_get_anim_time); + + + +/* + * lvgl extension definition for: + * lv_style_t *lv_tabview_get_style(const lv_obj_t *tabview, lv_tabview_style_t type) + */ + +STATIC mp_obj_t mp_lv_tabview_get_style(size_t n_args, const mp_obj_t *args) +{ + const lv_obj_t *tabview = mp_to_lv(args[0]); + lv_tabview_style_t type = (uint8_t)mp_obj_get_int(args[1]); + lv_style_t* res = lv_tabview_get_style(tabview, type); + return mp_read_ptr_lv_style_t((void*)res); +} + +STATIC MP_DEFINE_CONST_FUN_OBJ_VAR_BETWEEN(mp_lv_tabview_get_style_obj, 2, 2, mp_lv_tabview_get_style); + + + +/* + * lvgl extension definition for: + * lv_tabview_btns_pos_t lv_tabview_get_btns_pos(const lv_obj_t *tabview) + */ + +STATIC mp_obj_t mp_lv_tabview_get_btns_pos(size_t n_args, const mp_obj_t *args) +{ + const lv_obj_t *tabview = mp_to_lv(args[0]); + lv_tabview_btns_pos_t res = lv_tabview_get_btns_pos(tabview); + return mp_obj_new_int_from_uint(res); +} + +STATIC MP_DEFINE_CONST_FUN_OBJ_VAR_BETWEEN(mp_lv_tabview_get_btns_pos_obj, 1, 1, mp_lv_tabview_get_btns_pos); + + + +/* + * lvgl extension definition for: + * bool lv_tabview_get_btns_hidden(const lv_obj_t *tabview) + */ + +STATIC mp_obj_t mp_lv_tabview_get_btns_hidden(size_t n_args, const mp_obj_t *args) +{ + const lv_obj_t *tabview = mp_to_lv(args[0]); + bool res = lv_tabview_get_btns_hidden(tabview); + return convert_to_bool(res); +} + +STATIC MP_DEFINE_CONST_FUN_OBJ_VAR_BETWEEN(mp_lv_tabview_get_btns_hidden_obj, 1, 1, mp_lv_tabview_get_btns_hidden); + + + +/* + * lvgl tabview object definitions + */ + + +STATIC const mp_rom_map_elem_t tabview_locals_dict_table[] = { + { MP_ROM_QSTR(MP_QSTR_clean), MP_ROM_PTR(&mp_lv_tabview_clean_obj) }, + { MP_ROM_QSTR(MP_QSTR_add_tab), MP_ROM_PTR(&mp_lv_tabview_add_tab_obj) }, + { MP_ROM_QSTR(MP_QSTR_set_tab_act), MP_ROM_PTR(&mp_lv_tabview_set_tab_act_obj) }, + { MP_ROM_QSTR(MP_QSTR_set_tab_load_action), MP_ROM_PTR(&mp_lv_tabview_set_tab_load_action_obj) }, + { MP_ROM_QSTR(MP_QSTR_set_sliding), MP_ROM_PTR(&mp_lv_tabview_set_sliding_obj) }, + { MP_ROM_QSTR(MP_QSTR_set_anim_time), MP_ROM_PTR(&mp_lv_tabview_set_anim_time_obj) }, + { MP_ROM_QSTR(MP_QSTR_set_style), MP_ROM_PTR(&mp_lv_tabview_set_style_obj) }, + { MP_ROM_QSTR(MP_QSTR_set_btns_pos), MP_ROM_PTR(&mp_lv_tabview_set_btns_pos_obj) }, + { MP_ROM_QSTR(MP_QSTR_set_btns_hidden), MP_ROM_PTR(&mp_lv_tabview_set_btns_hidden_obj) }, + { MP_ROM_QSTR(MP_QSTR_get_tab_act), MP_ROM_PTR(&mp_lv_tabview_get_tab_act_obj) }, + { MP_ROM_QSTR(MP_QSTR_get_tab_count), MP_ROM_PTR(&mp_lv_tabview_get_tab_count_obj) }, + { MP_ROM_QSTR(MP_QSTR_get_tab), MP_ROM_PTR(&mp_lv_tabview_get_tab_obj) }, + { MP_ROM_QSTR(MP_QSTR_get_tab_load_action), MP_ROM_PTR(&mp_lv_tabview_get_tab_load_action_obj) }, + { MP_ROM_QSTR(MP_QSTR_get_sliding), MP_ROM_PTR(&mp_lv_tabview_get_sliding_obj) }, + { MP_ROM_QSTR(MP_QSTR_get_anim_time), MP_ROM_PTR(&mp_lv_tabview_get_anim_time_obj) }, + { MP_ROM_QSTR(MP_QSTR_get_style), MP_ROM_PTR(&mp_lv_tabview_get_style_obj) }, + { MP_ROM_QSTR(MP_QSTR_get_btns_pos), MP_ROM_PTR(&mp_lv_tabview_get_btns_pos_obj) }, + { MP_ROM_QSTR(MP_QSTR_get_btns_hidden), MP_ROM_PTR(&mp_lv_tabview_get_btns_hidden_obj) }, + { MP_ROM_QSTR(MP_QSTR_delete), MP_ROM_PTR(&mp_lv_obj_del_obj) }, + { MP_ROM_QSTR(MP_QSTR_clean), MP_ROM_PTR(&mp_lv_obj_clean_obj) }, + { MP_ROM_QSTR(MP_QSTR_invalidate), MP_ROM_PTR(&mp_lv_obj_invalidate_obj) }, + { MP_ROM_QSTR(MP_QSTR_set_parent), MP_ROM_PTR(&mp_lv_obj_set_parent_obj) }, + { MP_ROM_QSTR(MP_QSTR_set_pos), MP_ROM_PTR(&mp_lv_obj_set_pos_obj) }, + { MP_ROM_QSTR(MP_QSTR_set_x), MP_ROM_PTR(&mp_lv_obj_set_x_obj) }, + { MP_ROM_QSTR(MP_QSTR_set_y), MP_ROM_PTR(&mp_lv_obj_set_y_obj) }, + { MP_ROM_QSTR(MP_QSTR_set_size), MP_ROM_PTR(&mp_lv_obj_set_size_obj) }, + { MP_ROM_QSTR(MP_QSTR_set_width), MP_ROM_PTR(&mp_lv_obj_set_width_obj) }, + { MP_ROM_QSTR(MP_QSTR_set_height), MP_ROM_PTR(&mp_lv_obj_set_height_obj) }, + { MP_ROM_QSTR(MP_QSTR_align), MP_ROM_PTR(&mp_lv_obj_align_obj) }, + { MP_ROM_QSTR(MP_QSTR_align_origo), MP_ROM_PTR(&mp_lv_obj_align_origo_obj) }, + { MP_ROM_QSTR(MP_QSTR_realign), MP_ROM_PTR(&mp_lv_obj_realign_obj) }, + { MP_ROM_QSTR(MP_QSTR_set_auto_realign), MP_ROM_PTR(&mp_lv_obj_set_auto_realign_obj) }, + { MP_ROM_QSTR(MP_QSTR_set_style), MP_ROM_PTR(&mp_lv_obj_set_style_obj) }, + { MP_ROM_QSTR(MP_QSTR_refresh_style), MP_ROM_PTR(&mp_lv_obj_refresh_style_obj) }, + { MP_ROM_QSTR(MP_QSTR_report_style_mod), MP_ROM_PTR(&mp_lv_obj_report_style_mod_obj) }, + { MP_ROM_QSTR(MP_QSTR_set_hidden), MP_ROM_PTR(&mp_lv_obj_set_hidden_obj) }, + { MP_ROM_QSTR(MP_QSTR_set_click), MP_ROM_PTR(&mp_lv_obj_set_click_obj) }, + { MP_ROM_QSTR(MP_QSTR_set_top), MP_ROM_PTR(&mp_lv_obj_set_top_obj) }, + { MP_ROM_QSTR(MP_QSTR_set_drag), MP_ROM_PTR(&mp_lv_obj_set_drag_obj) }, + { MP_ROM_QSTR(MP_QSTR_set_drag_throw), MP_ROM_PTR(&mp_lv_obj_set_drag_throw_obj) }, + { MP_ROM_QSTR(MP_QSTR_set_drag_parent), MP_ROM_PTR(&mp_lv_obj_set_drag_parent_obj) }, + { MP_ROM_QSTR(MP_QSTR_set_opa_scale_enable), MP_ROM_PTR(&mp_lv_obj_set_opa_scale_enable_obj) }, + { MP_ROM_QSTR(MP_QSTR_set_opa_scale), MP_ROM_PTR(&mp_lv_obj_set_opa_scale_obj) }, + { MP_ROM_QSTR(MP_QSTR_set_protect), MP_ROM_PTR(&mp_lv_obj_set_protect_obj) }, + { MP_ROM_QSTR(MP_QSTR_clear_protect), MP_ROM_PTR(&mp_lv_obj_clear_protect_obj) }, + { MP_ROM_QSTR(MP_QSTR_set_signal_func), MP_ROM_PTR(&mp_lv_obj_set_signal_func_obj) }, + { MP_ROM_QSTR(MP_QSTR_set_design_func), MP_ROM_PTR(&mp_lv_obj_set_design_func_obj) }, + { MP_ROM_QSTR(MP_QSTR_allocate_ext_attr), MP_ROM_PTR(&mp_lv_obj_allocate_ext_attr_obj) }, + { MP_ROM_QSTR(MP_QSTR_refresh_ext_size), MP_ROM_PTR(&mp_lv_obj_refresh_ext_size_obj) }, + { MP_ROM_QSTR(MP_QSTR_set_free_num), MP_ROM_PTR(&mp_lv_obj_set_free_num_obj) }, + { MP_ROM_QSTR(MP_QSTR_set_free_ptr), MP_ROM_PTR(&mp_lv_obj_set_free_ptr_obj) }, + { MP_ROM_QSTR(MP_QSTR_animate), MP_ROM_PTR(&mp_lv_obj_animate_obj) }, + { MP_ROM_QSTR(MP_QSTR_get_screen), MP_ROM_PTR(&mp_lv_obj_get_screen_obj) }, + { MP_ROM_QSTR(MP_QSTR_get_parent), MP_ROM_PTR(&mp_lv_obj_get_parent_obj) }, + { MP_ROM_QSTR(MP_QSTR_get_child), MP_ROM_PTR(&mp_lv_obj_get_child_obj) }, + { MP_ROM_QSTR(MP_QSTR_get_child_back), MP_ROM_PTR(&mp_lv_obj_get_child_back_obj) }, + { MP_ROM_QSTR(MP_QSTR_count_children), MP_ROM_PTR(&mp_lv_obj_count_children_obj) }, + { MP_ROM_QSTR(MP_QSTR_get_coords), MP_ROM_PTR(&mp_lv_obj_get_coords_obj) }, + { MP_ROM_QSTR(MP_QSTR_get_x), MP_ROM_PTR(&mp_lv_obj_get_x_obj) }, + { MP_ROM_QSTR(MP_QSTR_get_y), MP_ROM_PTR(&mp_lv_obj_get_y_obj) }, + { MP_ROM_QSTR(MP_QSTR_get_width), MP_ROM_PTR(&mp_lv_obj_get_width_obj) }, + { MP_ROM_QSTR(MP_QSTR_get_height), MP_ROM_PTR(&mp_lv_obj_get_height_obj) }, + { MP_ROM_QSTR(MP_QSTR_get_ext_size), MP_ROM_PTR(&mp_lv_obj_get_ext_size_obj) }, + { MP_ROM_QSTR(MP_QSTR_get_auto_realign), MP_ROM_PTR(&mp_lv_obj_get_auto_realign_obj) }, + { MP_ROM_QSTR(MP_QSTR_get_style), MP_ROM_PTR(&mp_lv_obj_get_style_obj) }, + { MP_ROM_QSTR(MP_QSTR_get_hidden), MP_ROM_PTR(&mp_lv_obj_get_hidden_obj) }, + { MP_ROM_QSTR(MP_QSTR_get_click), MP_ROM_PTR(&mp_lv_obj_get_click_obj) }, + { MP_ROM_QSTR(MP_QSTR_get_top), MP_ROM_PTR(&mp_lv_obj_get_top_obj) }, + { MP_ROM_QSTR(MP_QSTR_get_drag), MP_ROM_PTR(&mp_lv_obj_get_drag_obj) }, + { MP_ROM_QSTR(MP_QSTR_get_drag_throw), MP_ROM_PTR(&mp_lv_obj_get_drag_throw_obj) }, + { MP_ROM_QSTR(MP_QSTR_get_drag_parent), MP_ROM_PTR(&mp_lv_obj_get_drag_parent_obj) }, + { MP_ROM_QSTR(MP_QSTR_get_opa_scale_enable), MP_ROM_PTR(&mp_lv_obj_get_opa_scale_enable_obj) }, + { MP_ROM_QSTR(MP_QSTR_get_opa_scale), MP_ROM_PTR(&mp_lv_obj_get_opa_scale_obj) }, + { MP_ROM_QSTR(MP_QSTR_get_protect), MP_ROM_PTR(&mp_lv_obj_get_protect_obj) }, + { MP_ROM_QSTR(MP_QSTR_is_protected), MP_ROM_PTR(&mp_lv_obj_is_protected_obj) }, + { MP_ROM_QSTR(MP_QSTR_get_signal_func), MP_ROM_PTR(&mp_lv_obj_get_signal_func_obj) }, + { MP_ROM_QSTR(MP_QSTR_get_design_func), MP_ROM_PTR(&mp_lv_obj_get_design_func_obj) }, + { MP_ROM_QSTR(MP_QSTR_get_ext_attr), MP_ROM_PTR(&mp_lv_obj_get_ext_attr_obj) }, + { MP_ROM_QSTR(MP_QSTR_get_free_num), MP_ROM_PTR(&mp_lv_obj_get_free_num_obj) }, + { MP_ROM_QSTR(MP_QSTR_get_free_ptr), MP_ROM_PTR(&mp_lv_obj_get_free_ptr_obj) }, + { MP_ROM_QSTR(MP_QSTR_get_group), MP_ROM_PTR(&mp_lv_obj_get_group_obj) }, + { MP_ROM_QSTR(MP_QSTR_is_focused), MP_ROM_PTR(&mp_lv_obj_is_focused_obj) }, + { MP_ROM_QSTR(MP_QSTR_BTNS_POS), MP_ROM_PTR(&mp_LV_TABVIEW_BTNS_POS_type) }, + { MP_ROM_QSTR(MP_QSTR_STYLE), MP_ROM_PTR(&mp_LV_TABVIEW_STYLE_type) } +}; + +STATIC MP_DEFINE_CONST_DICT(tabview_locals_dict, tabview_locals_dict_table); + +STATIC void tabview_print(const mp_print_t *print, + mp_obj_t self_in, + mp_print_kind_t kind) +{ + mp_printf(print, "lvgl tabview"); +} + + +STATIC mp_obj_t tabview_make_new( + const mp_obj_type_t *type, + size_t n_args, + size_t n_kw, + const mp_obj_t *args) +{ + return make_new(&lv_tabview_create, type, n_args, n_kw, args); +} + + +STATIC const mp_obj_type_t mp_tabview_type = { + { &mp_type_type }, + .name = MP_QSTR_tabview, + .print = tabview_print, + .make_new = tabview_make_new, + .locals_dict = (mp_obj_dict_t*)&tabview_locals_dict, +}; + + +/* + * lvgl extension definition for: + * inline static void lv_tileview_set_edge_flash(lv_obj_t *tileview, bool en) + */ + +STATIC mp_obj_t mp_lv_tileview_set_edge_flash(size_t n_args, const mp_obj_t *args) +{ + lv_obj_t *tileview = mp_to_lv(args[0]); + bool en = mp_obj_is_true(args[1]); + lv_tileview_set_edge_flash(tileview, en); + return mp_const_none; +} + +STATIC MP_DEFINE_CONST_FUN_OBJ_VAR_BETWEEN(mp_lv_tileview_set_edge_flash_obj, 2, 2, mp_lv_tileview_set_edge_flash); + + + +/* + * lvgl extension definition for: + * inline static bool lv_tileview_get_edge_flash(lv_obj_t *tileview) + */ + +STATIC mp_obj_t mp_lv_tileview_get_edge_flash(size_t n_args, const mp_obj_t *args) +{ + lv_obj_t *tileview = mp_to_lv(args[0]); + bool res = lv_tileview_get_edge_flash(tileview); + return convert_to_bool(res); +} + +STATIC MP_DEFINE_CONST_FUN_OBJ_VAR_BETWEEN(mp_lv_tileview_get_edge_flash_obj, 1, 1, mp_lv_tileview_get_edge_flash); + + + +/* + * lvgl extension definition for: + * void lv_tileview_add_element(lv_obj_t *element) + */ + +STATIC mp_obj_t mp_lv_tileview_add_element(size_t n_args, const mp_obj_t *args) +{ + lv_obj_t *element = mp_to_lv(args[0]); + lv_tileview_add_element(element); + return mp_const_none; +} + +STATIC MP_DEFINE_CONST_FUN_OBJ_VAR_BETWEEN(mp_lv_tileview_add_element_obj, 1, 1, mp_lv_tileview_add_element); + + + +/* + * lvgl extension definition for: + * void lv_tileview_set_valid_positions(lv_obj_t *tileview, const lv_point_t *valid_pos) + */ + +STATIC mp_obj_t mp_lv_tileview_set_valid_positions(size_t n_args, const mp_obj_t *args) +{ + lv_obj_t *tileview = mp_to_lv(args[0]); + const lv_point_t *valid_pos = mp_write_ptr_lv_point_t(args[1]); + lv_tileview_set_valid_positions(tileview, valid_pos); + return mp_const_none; +} + +STATIC MP_DEFINE_CONST_FUN_OBJ_VAR_BETWEEN(mp_lv_tileview_set_valid_positions_obj, 2, 2, mp_lv_tileview_set_valid_positions); + + + +/* + * lvgl extension definition for: + * void lv_tileview_set_tile_act(lv_obj_t *tileview, lv_coord_t x, lv_coord_t y, bool anim_en) + */ + +STATIC mp_obj_t mp_lv_tileview_set_tile_act(size_t n_args, const mp_obj_t *args) +{ + lv_obj_t *tileview = mp_to_lv(args[0]); + lv_coord_t x = (int16_t)mp_obj_get_int(args[1]); + lv_coord_t y = (int16_t)mp_obj_get_int(args[2]); + bool anim_en = mp_obj_is_true(args[3]); + lv_tileview_set_tile_act(tileview, x, y, anim_en); + return mp_const_none; +} + +STATIC MP_DEFINE_CONST_FUN_OBJ_VAR_BETWEEN(mp_lv_tileview_set_tile_act_obj, 4, 4, mp_lv_tileview_set_tile_act); + + + +/* + * lvgl extension definition for: + * void lv_tileview_set_style(lv_obj_t *tileview, lv_tileview_style_t type, lv_style_t *style) + */ + +STATIC mp_obj_t mp_lv_tileview_set_style(size_t n_args, const mp_obj_t *args) +{ + lv_obj_t *tileview = mp_to_lv(args[0]); + lv_tileview_style_t type = (uint8_t)mp_obj_get_int(args[1]); + lv_style_t *style = mp_write_ptr_lv_style_t(args[2]); + lv_tileview_set_style(tileview, type, style); + return mp_const_none; +} + +STATIC MP_DEFINE_CONST_FUN_OBJ_VAR_BETWEEN(mp_lv_tileview_set_style_obj, 3, 3, mp_lv_tileview_set_style); + + + +/* + * lvgl extension definition for: + * lv_style_t *lv_tileview_get_style(const lv_obj_t *tileview, lv_tileview_style_t type) + */ + +STATIC mp_obj_t mp_lv_tileview_get_style(size_t n_args, const mp_obj_t *args) +{ + const lv_obj_t *tileview = mp_to_lv(args[0]); + lv_tileview_style_t type = (uint8_t)mp_obj_get_int(args[1]); + lv_style_t* res = lv_tileview_get_style(tileview, type); + return mp_read_ptr_lv_style_t((void*)res); +} + +STATIC MP_DEFINE_CONST_FUN_OBJ_VAR_BETWEEN(mp_lv_tileview_get_style_obj, 2, 2, mp_lv_tileview_get_style); + + + +/* + * lvgl tileview object definitions + */ + + +STATIC const mp_rom_map_elem_t tileview_locals_dict_table[] = { + { MP_ROM_QSTR(MP_QSTR_set_edge_flash), MP_ROM_PTR(&mp_lv_tileview_set_edge_flash_obj) }, + { MP_ROM_QSTR(MP_QSTR_get_edge_flash), MP_ROM_PTR(&mp_lv_tileview_get_edge_flash_obj) }, + { MP_ROM_QSTR(MP_QSTR_add_element), MP_ROM_PTR(&mp_lv_tileview_add_element_obj) }, + { MP_ROM_QSTR(MP_QSTR_set_valid_positions), MP_ROM_PTR(&mp_lv_tileview_set_valid_positions_obj) }, + { MP_ROM_QSTR(MP_QSTR_set_tile_act), MP_ROM_PTR(&mp_lv_tileview_set_tile_act_obj) }, + { MP_ROM_QSTR(MP_QSTR_set_style), MP_ROM_PTR(&mp_lv_tileview_set_style_obj) }, + { MP_ROM_QSTR(MP_QSTR_get_style), MP_ROM_PTR(&mp_lv_tileview_get_style_obj) }, + { MP_ROM_QSTR(MP_QSTR_delete), MP_ROM_PTR(&mp_lv_obj_del_obj) }, + { MP_ROM_QSTR(MP_QSTR_clean), MP_ROM_PTR(&mp_lv_obj_clean_obj) }, + { MP_ROM_QSTR(MP_QSTR_invalidate), MP_ROM_PTR(&mp_lv_obj_invalidate_obj) }, + { MP_ROM_QSTR(MP_QSTR_set_parent), MP_ROM_PTR(&mp_lv_obj_set_parent_obj) }, + { MP_ROM_QSTR(MP_QSTR_set_pos), MP_ROM_PTR(&mp_lv_obj_set_pos_obj) }, + { MP_ROM_QSTR(MP_QSTR_set_x), MP_ROM_PTR(&mp_lv_obj_set_x_obj) }, + { MP_ROM_QSTR(MP_QSTR_set_y), MP_ROM_PTR(&mp_lv_obj_set_y_obj) }, + { MP_ROM_QSTR(MP_QSTR_set_size), MP_ROM_PTR(&mp_lv_obj_set_size_obj) }, + { MP_ROM_QSTR(MP_QSTR_set_width), MP_ROM_PTR(&mp_lv_obj_set_width_obj) }, + { MP_ROM_QSTR(MP_QSTR_set_height), MP_ROM_PTR(&mp_lv_obj_set_height_obj) }, + { MP_ROM_QSTR(MP_QSTR_align), MP_ROM_PTR(&mp_lv_obj_align_obj) }, + { MP_ROM_QSTR(MP_QSTR_align_origo), MP_ROM_PTR(&mp_lv_obj_align_origo_obj) }, + { MP_ROM_QSTR(MP_QSTR_realign), MP_ROM_PTR(&mp_lv_obj_realign_obj) }, + { MP_ROM_QSTR(MP_QSTR_set_auto_realign), MP_ROM_PTR(&mp_lv_obj_set_auto_realign_obj) }, + { MP_ROM_QSTR(MP_QSTR_set_style), MP_ROM_PTR(&mp_lv_obj_set_style_obj) }, + { MP_ROM_QSTR(MP_QSTR_refresh_style), MP_ROM_PTR(&mp_lv_obj_refresh_style_obj) }, + { MP_ROM_QSTR(MP_QSTR_report_style_mod), MP_ROM_PTR(&mp_lv_obj_report_style_mod_obj) }, + { MP_ROM_QSTR(MP_QSTR_set_hidden), MP_ROM_PTR(&mp_lv_obj_set_hidden_obj) }, + { MP_ROM_QSTR(MP_QSTR_set_click), MP_ROM_PTR(&mp_lv_obj_set_click_obj) }, + { MP_ROM_QSTR(MP_QSTR_set_top), MP_ROM_PTR(&mp_lv_obj_set_top_obj) }, + { MP_ROM_QSTR(MP_QSTR_set_drag), MP_ROM_PTR(&mp_lv_obj_set_drag_obj) }, + { MP_ROM_QSTR(MP_QSTR_set_drag_throw), MP_ROM_PTR(&mp_lv_obj_set_drag_throw_obj) }, + { MP_ROM_QSTR(MP_QSTR_set_drag_parent), MP_ROM_PTR(&mp_lv_obj_set_drag_parent_obj) }, + { MP_ROM_QSTR(MP_QSTR_set_opa_scale_enable), MP_ROM_PTR(&mp_lv_obj_set_opa_scale_enable_obj) }, + { MP_ROM_QSTR(MP_QSTR_set_opa_scale), MP_ROM_PTR(&mp_lv_obj_set_opa_scale_obj) }, + { MP_ROM_QSTR(MP_QSTR_set_protect), MP_ROM_PTR(&mp_lv_obj_set_protect_obj) }, + { MP_ROM_QSTR(MP_QSTR_clear_protect), MP_ROM_PTR(&mp_lv_obj_clear_protect_obj) }, + { MP_ROM_QSTR(MP_QSTR_set_signal_func), MP_ROM_PTR(&mp_lv_obj_set_signal_func_obj) }, + { MP_ROM_QSTR(MP_QSTR_set_design_func), MP_ROM_PTR(&mp_lv_obj_set_design_func_obj) }, + { MP_ROM_QSTR(MP_QSTR_allocate_ext_attr), MP_ROM_PTR(&mp_lv_obj_allocate_ext_attr_obj) }, + { MP_ROM_QSTR(MP_QSTR_refresh_ext_size), MP_ROM_PTR(&mp_lv_obj_refresh_ext_size_obj) }, + { MP_ROM_QSTR(MP_QSTR_set_free_num), MP_ROM_PTR(&mp_lv_obj_set_free_num_obj) }, + { MP_ROM_QSTR(MP_QSTR_set_free_ptr), MP_ROM_PTR(&mp_lv_obj_set_free_ptr_obj) }, + { MP_ROM_QSTR(MP_QSTR_animate), MP_ROM_PTR(&mp_lv_obj_animate_obj) }, + { MP_ROM_QSTR(MP_QSTR_get_screen), MP_ROM_PTR(&mp_lv_obj_get_screen_obj) }, + { MP_ROM_QSTR(MP_QSTR_get_parent), MP_ROM_PTR(&mp_lv_obj_get_parent_obj) }, + { MP_ROM_QSTR(MP_QSTR_get_child), MP_ROM_PTR(&mp_lv_obj_get_child_obj) }, + { MP_ROM_QSTR(MP_QSTR_get_child_back), MP_ROM_PTR(&mp_lv_obj_get_child_back_obj) }, + { MP_ROM_QSTR(MP_QSTR_count_children), MP_ROM_PTR(&mp_lv_obj_count_children_obj) }, + { MP_ROM_QSTR(MP_QSTR_get_coords), MP_ROM_PTR(&mp_lv_obj_get_coords_obj) }, + { MP_ROM_QSTR(MP_QSTR_get_x), MP_ROM_PTR(&mp_lv_obj_get_x_obj) }, + { MP_ROM_QSTR(MP_QSTR_get_y), MP_ROM_PTR(&mp_lv_obj_get_y_obj) }, + { MP_ROM_QSTR(MP_QSTR_get_width), MP_ROM_PTR(&mp_lv_obj_get_width_obj) }, + { MP_ROM_QSTR(MP_QSTR_get_height), MP_ROM_PTR(&mp_lv_obj_get_height_obj) }, + { MP_ROM_QSTR(MP_QSTR_get_ext_size), MP_ROM_PTR(&mp_lv_obj_get_ext_size_obj) }, + { MP_ROM_QSTR(MP_QSTR_get_auto_realign), MP_ROM_PTR(&mp_lv_obj_get_auto_realign_obj) }, + { MP_ROM_QSTR(MP_QSTR_get_style), MP_ROM_PTR(&mp_lv_obj_get_style_obj) }, + { MP_ROM_QSTR(MP_QSTR_get_hidden), MP_ROM_PTR(&mp_lv_obj_get_hidden_obj) }, + { MP_ROM_QSTR(MP_QSTR_get_click), MP_ROM_PTR(&mp_lv_obj_get_click_obj) }, + { MP_ROM_QSTR(MP_QSTR_get_top), MP_ROM_PTR(&mp_lv_obj_get_top_obj) }, + { MP_ROM_QSTR(MP_QSTR_get_drag), MP_ROM_PTR(&mp_lv_obj_get_drag_obj) }, + { MP_ROM_QSTR(MP_QSTR_get_drag_throw), MP_ROM_PTR(&mp_lv_obj_get_drag_throw_obj) }, + { MP_ROM_QSTR(MP_QSTR_get_drag_parent), MP_ROM_PTR(&mp_lv_obj_get_drag_parent_obj) }, + { MP_ROM_QSTR(MP_QSTR_get_opa_scale_enable), MP_ROM_PTR(&mp_lv_obj_get_opa_scale_enable_obj) }, + { MP_ROM_QSTR(MP_QSTR_get_opa_scale), MP_ROM_PTR(&mp_lv_obj_get_opa_scale_obj) }, + { MP_ROM_QSTR(MP_QSTR_get_protect), MP_ROM_PTR(&mp_lv_obj_get_protect_obj) }, + { MP_ROM_QSTR(MP_QSTR_is_protected), MP_ROM_PTR(&mp_lv_obj_is_protected_obj) }, + { MP_ROM_QSTR(MP_QSTR_get_signal_func), MP_ROM_PTR(&mp_lv_obj_get_signal_func_obj) }, + { MP_ROM_QSTR(MP_QSTR_get_design_func), MP_ROM_PTR(&mp_lv_obj_get_design_func_obj) }, + { MP_ROM_QSTR(MP_QSTR_get_ext_attr), MP_ROM_PTR(&mp_lv_obj_get_ext_attr_obj) }, + { MP_ROM_QSTR(MP_QSTR_get_free_num), MP_ROM_PTR(&mp_lv_obj_get_free_num_obj) }, + { MP_ROM_QSTR(MP_QSTR_get_free_ptr), MP_ROM_PTR(&mp_lv_obj_get_free_ptr_obj) }, + { MP_ROM_QSTR(MP_QSTR_get_group), MP_ROM_PTR(&mp_lv_obj_get_group_obj) }, + { MP_ROM_QSTR(MP_QSTR_is_focused), MP_ROM_PTR(&mp_lv_obj_is_focused_obj) }, + { MP_ROM_QSTR(MP_QSTR_STYLE), MP_ROM_PTR(&mp_LV_TILEVIEW_STYLE_type) } +}; + +STATIC MP_DEFINE_CONST_DICT(tileview_locals_dict, tileview_locals_dict_table); + +STATIC void tileview_print(const mp_print_t *print, + mp_obj_t self_in, + mp_print_kind_t kind) +{ + mp_printf(print, "lvgl tileview"); +} + + +STATIC mp_obj_t tileview_make_new( + const mp_obj_type_t *type, + size_t n_args, + size_t n_kw, + const mp_obj_t *args) +{ + return make_new(&lv_tileview_create, type, n_args, n_kw, args); +} + + +STATIC const mp_obj_type_t mp_tileview_type = { + { &mp_type_type }, + .name = MP_QSTR_tileview, + .print = tileview_print, + .make_new = tileview_make_new, + .locals_dict = (mp_obj_dict_t*)&tileview_locals_dict, +}; + + +/* + * lvgl extension definition for: + * void lv_mbox_add_btns(lv_obj_t *mbox, const char **btn_map, lv_btnm_action_t action) + */ + +STATIC mp_obj_t mp_lv_mbox_add_btns(size_t n_args, const mp_obj_t *args) +{ + lv_obj_t *mbox = mp_to_lv(args[0]); + const char **btn_map = mp_to_ptr(args[1]); + set_action(args[0], args[2]); + lv_btnm_action_t action = &lv_btnm_action_t_callback; + lv_mbox_add_btns(mbox, btn_map, action); + return mp_const_none; +} + +STATIC MP_DEFINE_CONST_FUN_OBJ_VAR_BETWEEN(mp_lv_mbox_add_btns_obj, 3, 3, mp_lv_mbox_add_btns); + + + +/* + * lvgl extension definition for: + * void lv_mbox_set_text(lv_obj_t *mbox, const char *txt) + */ + +STATIC mp_obj_t mp_lv_mbox_set_text(size_t n_args, const mp_obj_t *args) +{ + lv_obj_t *mbox = mp_to_lv(args[0]); + const char *txt = (char*)mp_obj_str_get_str(args[1]); + lv_mbox_set_text(mbox, txt); + return mp_const_none; +} + +STATIC MP_DEFINE_CONST_FUN_OBJ_VAR_BETWEEN(mp_lv_mbox_set_text_obj, 2, 2, mp_lv_mbox_set_text); + + + +/* + * lvgl extension definition for: + * void lv_mbox_set_action(lv_obj_t *mbox, lv_btnm_action_t action) + */ + +STATIC mp_obj_t mp_lv_mbox_set_action(size_t n_args, const mp_obj_t *args) +{ + lv_obj_t *mbox = mp_to_lv(args[0]); + set_action(args[0], args[1]); + lv_btnm_action_t action = &lv_btnm_action_t_callback; + lv_mbox_set_action(mbox, action); + return mp_const_none; +} + +STATIC MP_DEFINE_CONST_FUN_OBJ_VAR_BETWEEN(mp_lv_mbox_set_action_obj, 2, 2, mp_lv_mbox_set_action); + + + +/* + * lvgl extension definition for: + * void lv_mbox_set_anim_time(lv_obj_t *mbox, uint16_t anim_time) + */ + +STATIC mp_obj_t mp_lv_mbox_set_anim_time(size_t n_args, const mp_obj_t *args) +{ + lv_obj_t *mbox = mp_to_lv(args[0]); + uint16_t anim_time = (uint16_t)mp_obj_get_int(args[1]); + lv_mbox_set_anim_time(mbox, anim_time); + return mp_const_none; +} + +STATIC MP_DEFINE_CONST_FUN_OBJ_VAR_BETWEEN(mp_lv_mbox_set_anim_time_obj, 2, 2, mp_lv_mbox_set_anim_time); + + + +/* + * lvgl extension definition for: + * void lv_mbox_start_auto_close(lv_obj_t *mbox, uint16_t delay) + */ + +STATIC mp_obj_t mp_lv_mbox_start_auto_close(size_t n_args, const mp_obj_t *args) +{ + lv_obj_t *mbox = mp_to_lv(args[0]); + uint16_t delay = (uint16_t)mp_obj_get_int(args[1]); + lv_mbox_start_auto_close(mbox, delay); + return mp_const_none; +} + +STATIC MP_DEFINE_CONST_FUN_OBJ_VAR_BETWEEN(mp_lv_mbox_start_auto_close_obj, 2, 2, mp_lv_mbox_start_auto_close); + + + +/* + * lvgl extension definition for: + * void lv_mbox_stop_auto_close(lv_obj_t *mbox) + */ + +STATIC mp_obj_t mp_lv_mbox_stop_auto_close(size_t n_args, const mp_obj_t *args) +{ + lv_obj_t *mbox = mp_to_lv(args[0]); + lv_mbox_stop_auto_close(mbox); + return mp_const_none; +} + +STATIC MP_DEFINE_CONST_FUN_OBJ_VAR_BETWEEN(mp_lv_mbox_stop_auto_close_obj, 1, 1, mp_lv_mbox_stop_auto_close); + + + +/* + * lvgl extension definition for: + * void lv_mbox_set_style(lv_obj_t *mbox, lv_mbox_style_t type, lv_style_t *style) + */ + +STATIC mp_obj_t mp_lv_mbox_set_style(size_t n_args, const mp_obj_t *args) +{ + lv_obj_t *mbox = mp_to_lv(args[0]); + lv_mbox_style_t type = (uint8_t)mp_obj_get_int(args[1]); + lv_style_t *style = mp_write_ptr_lv_style_t(args[2]); + lv_mbox_set_style(mbox, type, style); + return mp_const_none; +} + +STATIC MP_DEFINE_CONST_FUN_OBJ_VAR_BETWEEN(mp_lv_mbox_set_style_obj, 3, 3, mp_lv_mbox_set_style); + + + +/* + * lvgl extension definition for: + * void lv_mbox_set_recolor(lv_obj_t *mbox, bool en) + */ + +STATIC mp_obj_t mp_lv_mbox_set_recolor(size_t n_args, const mp_obj_t *args) +{ + lv_obj_t *mbox = mp_to_lv(args[0]); + bool en = mp_obj_is_true(args[1]); + lv_mbox_set_recolor(mbox, en); + return mp_const_none; +} + +STATIC MP_DEFINE_CONST_FUN_OBJ_VAR_BETWEEN(mp_lv_mbox_set_recolor_obj, 2, 2, mp_lv_mbox_set_recolor); + + + +/* + * lvgl extension definition for: + * const char *lv_mbox_get_text(const lv_obj_t *mbox) + */ + +STATIC mp_obj_t mp_lv_mbox_get_text(size_t n_args, const mp_obj_t *args) +{ + const lv_obj_t *mbox = mp_to_lv(args[0]); + const char* res = lv_mbox_get_text(mbox); + return convert_to_str((void*)res); +} + +STATIC MP_DEFINE_CONST_FUN_OBJ_VAR_BETWEEN(mp_lv_mbox_get_text_obj, 1, 1, mp_lv_mbox_get_text); + + + +/* + * lvgl extension definition for: + * lv_obj_t *lv_mbox_get_from_btn(const lv_obj_t *btn) + */ + +STATIC mp_obj_t mp_lv_mbox_get_from_btn(size_t n_args, const mp_obj_t *args) +{ + const lv_obj_t *btn = mp_to_lv(args[0]); + lv_obj_t* res = lv_mbox_get_from_btn(btn); + return lv_to_mp((void*)res); +} + +STATIC MP_DEFINE_CONST_FUN_OBJ_VAR_BETWEEN(mp_lv_mbox_get_from_btn_obj, 1, 1, mp_lv_mbox_get_from_btn); + + + +/* + * lvgl extension definition for: + * uint16_t lv_mbox_get_anim_time(const lv_obj_t *mbox) + */ + +STATIC mp_obj_t mp_lv_mbox_get_anim_time(size_t n_args, const mp_obj_t *args) +{ + const lv_obj_t *mbox = mp_to_lv(args[0]); + uint16_t res = lv_mbox_get_anim_time(mbox); + return mp_obj_new_int_from_uint(res); +} + +STATIC MP_DEFINE_CONST_FUN_OBJ_VAR_BETWEEN(mp_lv_mbox_get_anim_time_obj, 1, 1, mp_lv_mbox_get_anim_time); + + + +/* + * lvgl extension definition for: + * lv_style_t *lv_mbox_get_style(const lv_obj_t *mbox, lv_mbox_style_t type) + */ + +STATIC mp_obj_t mp_lv_mbox_get_style(size_t n_args, const mp_obj_t *args) +{ + const lv_obj_t *mbox = mp_to_lv(args[0]); + lv_mbox_style_t type = (uint8_t)mp_obj_get_int(args[1]); + lv_style_t* res = lv_mbox_get_style(mbox, type); + return mp_read_ptr_lv_style_t((void*)res); +} + +STATIC MP_DEFINE_CONST_FUN_OBJ_VAR_BETWEEN(mp_lv_mbox_get_style_obj, 2, 2, mp_lv_mbox_get_style); + + + +/* + * lvgl extension definition for: + * bool lv_mbox_get_recolor(const lv_obj_t *mbox) + */ + +STATIC mp_obj_t mp_lv_mbox_get_recolor(size_t n_args, const mp_obj_t *args) +{ + const lv_obj_t *mbox = mp_to_lv(args[0]); + bool res = lv_mbox_get_recolor(mbox); + return convert_to_bool(res); +} + +STATIC MP_DEFINE_CONST_FUN_OBJ_VAR_BETWEEN(mp_lv_mbox_get_recolor_obj, 1, 1, mp_lv_mbox_get_recolor); + + + +/* + * lvgl mbox object definitions + */ + + +STATIC const mp_rom_map_elem_t mbox_locals_dict_table[] = { + { MP_ROM_QSTR(MP_QSTR_add_btns), MP_ROM_PTR(&mp_lv_mbox_add_btns_obj) }, + { MP_ROM_QSTR(MP_QSTR_set_text), MP_ROM_PTR(&mp_lv_mbox_set_text_obj) }, + { MP_ROM_QSTR(MP_QSTR_set_action), MP_ROM_PTR(&mp_lv_mbox_set_action_obj) }, + { MP_ROM_QSTR(MP_QSTR_set_anim_time), MP_ROM_PTR(&mp_lv_mbox_set_anim_time_obj) }, + { MP_ROM_QSTR(MP_QSTR_start_auto_close), MP_ROM_PTR(&mp_lv_mbox_start_auto_close_obj) }, + { MP_ROM_QSTR(MP_QSTR_stop_auto_close), MP_ROM_PTR(&mp_lv_mbox_stop_auto_close_obj) }, + { MP_ROM_QSTR(MP_QSTR_set_style), MP_ROM_PTR(&mp_lv_mbox_set_style_obj) }, + { MP_ROM_QSTR(MP_QSTR_set_recolor), MP_ROM_PTR(&mp_lv_mbox_set_recolor_obj) }, + { MP_ROM_QSTR(MP_QSTR_get_text), MP_ROM_PTR(&mp_lv_mbox_get_text_obj) }, + { MP_ROM_QSTR(MP_QSTR_get_from_btn), MP_ROM_PTR(&mp_lv_mbox_get_from_btn_obj) }, + { MP_ROM_QSTR(MP_QSTR_get_anim_time), MP_ROM_PTR(&mp_lv_mbox_get_anim_time_obj) }, + { MP_ROM_QSTR(MP_QSTR_get_style), MP_ROM_PTR(&mp_lv_mbox_get_style_obj) }, + { MP_ROM_QSTR(MP_QSTR_get_recolor), MP_ROM_PTR(&mp_lv_mbox_get_recolor_obj) }, + { MP_ROM_QSTR(MP_QSTR_delete), MP_ROM_PTR(&mp_lv_obj_del_obj) }, + { MP_ROM_QSTR(MP_QSTR_clean), MP_ROM_PTR(&mp_lv_obj_clean_obj) }, + { MP_ROM_QSTR(MP_QSTR_invalidate), MP_ROM_PTR(&mp_lv_obj_invalidate_obj) }, + { MP_ROM_QSTR(MP_QSTR_set_parent), MP_ROM_PTR(&mp_lv_obj_set_parent_obj) }, + { MP_ROM_QSTR(MP_QSTR_set_pos), MP_ROM_PTR(&mp_lv_obj_set_pos_obj) }, + { MP_ROM_QSTR(MP_QSTR_set_x), MP_ROM_PTR(&mp_lv_obj_set_x_obj) }, + { MP_ROM_QSTR(MP_QSTR_set_y), MP_ROM_PTR(&mp_lv_obj_set_y_obj) }, + { MP_ROM_QSTR(MP_QSTR_set_size), MP_ROM_PTR(&mp_lv_obj_set_size_obj) }, + { MP_ROM_QSTR(MP_QSTR_set_width), MP_ROM_PTR(&mp_lv_obj_set_width_obj) }, + { MP_ROM_QSTR(MP_QSTR_set_height), MP_ROM_PTR(&mp_lv_obj_set_height_obj) }, + { MP_ROM_QSTR(MP_QSTR_align), MP_ROM_PTR(&mp_lv_obj_align_obj) }, + { MP_ROM_QSTR(MP_QSTR_align_origo), MP_ROM_PTR(&mp_lv_obj_align_origo_obj) }, + { MP_ROM_QSTR(MP_QSTR_realign), MP_ROM_PTR(&mp_lv_obj_realign_obj) }, + { MP_ROM_QSTR(MP_QSTR_set_auto_realign), MP_ROM_PTR(&mp_lv_obj_set_auto_realign_obj) }, + { MP_ROM_QSTR(MP_QSTR_set_style), MP_ROM_PTR(&mp_lv_obj_set_style_obj) }, + { MP_ROM_QSTR(MP_QSTR_refresh_style), MP_ROM_PTR(&mp_lv_obj_refresh_style_obj) }, + { MP_ROM_QSTR(MP_QSTR_report_style_mod), MP_ROM_PTR(&mp_lv_obj_report_style_mod_obj) }, + { MP_ROM_QSTR(MP_QSTR_set_hidden), MP_ROM_PTR(&mp_lv_obj_set_hidden_obj) }, + { MP_ROM_QSTR(MP_QSTR_set_click), MP_ROM_PTR(&mp_lv_obj_set_click_obj) }, + { MP_ROM_QSTR(MP_QSTR_set_top), MP_ROM_PTR(&mp_lv_obj_set_top_obj) }, + { MP_ROM_QSTR(MP_QSTR_set_drag), MP_ROM_PTR(&mp_lv_obj_set_drag_obj) }, + { MP_ROM_QSTR(MP_QSTR_set_drag_throw), MP_ROM_PTR(&mp_lv_obj_set_drag_throw_obj) }, + { MP_ROM_QSTR(MP_QSTR_set_drag_parent), MP_ROM_PTR(&mp_lv_obj_set_drag_parent_obj) }, + { MP_ROM_QSTR(MP_QSTR_set_opa_scale_enable), MP_ROM_PTR(&mp_lv_obj_set_opa_scale_enable_obj) }, + { MP_ROM_QSTR(MP_QSTR_set_opa_scale), MP_ROM_PTR(&mp_lv_obj_set_opa_scale_obj) }, + { MP_ROM_QSTR(MP_QSTR_set_protect), MP_ROM_PTR(&mp_lv_obj_set_protect_obj) }, + { MP_ROM_QSTR(MP_QSTR_clear_protect), MP_ROM_PTR(&mp_lv_obj_clear_protect_obj) }, + { MP_ROM_QSTR(MP_QSTR_set_signal_func), MP_ROM_PTR(&mp_lv_obj_set_signal_func_obj) }, + { MP_ROM_QSTR(MP_QSTR_set_design_func), MP_ROM_PTR(&mp_lv_obj_set_design_func_obj) }, + { MP_ROM_QSTR(MP_QSTR_allocate_ext_attr), MP_ROM_PTR(&mp_lv_obj_allocate_ext_attr_obj) }, + { MP_ROM_QSTR(MP_QSTR_refresh_ext_size), MP_ROM_PTR(&mp_lv_obj_refresh_ext_size_obj) }, + { MP_ROM_QSTR(MP_QSTR_set_free_num), MP_ROM_PTR(&mp_lv_obj_set_free_num_obj) }, + { MP_ROM_QSTR(MP_QSTR_set_free_ptr), MP_ROM_PTR(&mp_lv_obj_set_free_ptr_obj) }, + { MP_ROM_QSTR(MP_QSTR_animate), MP_ROM_PTR(&mp_lv_obj_animate_obj) }, + { MP_ROM_QSTR(MP_QSTR_get_screen), MP_ROM_PTR(&mp_lv_obj_get_screen_obj) }, + { MP_ROM_QSTR(MP_QSTR_get_parent), MP_ROM_PTR(&mp_lv_obj_get_parent_obj) }, + { MP_ROM_QSTR(MP_QSTR_get_child), MP_ROM_PTR(&mp_lv_obj_get_child_obj) }, + { MP_ROM_QSTR(MP_QSTR_get_child_back), MP_ROM_PTR(&mp_lv_obj_get_child_back_obj) }, + { MP_ROM_QSTR(MP_QSTR_count_children), MP_ROM_PTR(&mp_lv_obj_count_children_obj) }, + { MP_ROM_QSTR(MP_QSTR_get_coords), MP_ROM_PTR(&mp_lv_obj_get_coords_obj) }, + { MP_ROM_QSTR(MP_QSTR_get_x), MP_ROM_PTR(&mp_lv_obj_get_x_obj) }, + { MP_ROM_QSTR(MP_QSTR_get_y), MP_ROM_PTR(&mp_lv_obj_get_y_obj) }, + { MP_ROM_QSTR(MP_QSTR_get_width), MP_ROM_PTR(&mp_lv_obj_get_width_obj) }, + { MP_ROM_QSTR(MP_QSTR_get_height), MP_ROM_PTR(&mp_lv_obj_get_height_obj) }, + { MP_ROM_QSTR(MP_QSTR_get_ext_size), MP_ROM_PTR(&mp_lv_obj_get_ext_size_obj) }, + { MP_ROM_QSTR(MP_QSTR_get_auto_realign), MP_ROM_PTR(&mp_lv_obj_get_auto_realign_obj) }, + { MP_ROM_QSTR(MP_QSTR_get_style), MP_ROM_PTR(&mp_lv_obj_get_style_obj) }, + { MP_ROM_QSTR(MP_QSTR_get_hidden), MP_ROM_PTR(&mp_lv_obj_get_hidden_obj) }, + { MP_ROM_QSTR(MP_QSTR_get_click), MP_ROM_PTR(&mp_lv_obj_get_click_obj) }, + { MP_ROM_QSTR(MP_QSTR_get_top), MP_ROM_PTR(&mp_lv_obj_get_top_obj) }, + { MP_ROM_QSTR(MP_QSTR_get_drag), MP_ROM_PTR(&mp_lv_obj_get_drag_obj) }, + { MP_ROM_QSTR(MP_QSTR_get_drag_throw), MP_ROM_PTR(&mp_lv_obj_get_drag_throw_obj) }, + { MP_ROM_QSTR(MP_QSTR_get_drag_parent), MP_ROM_PTR(&mp_lv_obj_get_drag_parent_obj) }, + { MP_ROM_QSTR(MP_QSTR_get_opa_scale_enable), MP_ROM_PTR(&mp_lv_obj_get_opa_scale_enable_obj) }, + { MP_ROM_QSTR(MP_QSTR_get_opa_scale), MP_ROM_PTR(&mp_lv_obj_get_opa_scale_obj) }, + { MP_ROM_QSTR(MP_QSTR_get_protect), MP_ROM_PTR(&mp_lv_obj_get_protect_obj) }, + { MP_ROM_QSTR(MP_QSTR_is_protected), MP_ROM_PTR(&mp_lv_obj_is_protected_obj) }, + { MP_ROM_QSTR(MP_QSTR_get_signal_func), MP_ROM_PTR(&mp_lv_obj_get_signal_func_obj) }, + { MP_ROM_QSTR(MP_QSTR_get_design_func), MP_ROM_PTR(&mp_lv_obj_get_design_func_obj) }, + { MP_ROM_QSTR(MP_QSTR_get_ext_attr), MP_ROM_PTR(&mp_lv_obj_get_ext_attr_obj) }, + { MP_ROM_QSTR(MP_QSTR_get_free_num), MP_ROM_PTR(&mp_lv_obj_get_free_num_obj) }, + { MP_ROM_QSTR(MP_QSTR_get_free_ptr), MP_ROM_PTR(&mp_lv_obj_get_free_ptr_obj) }, + { MP_ROM_QSTR(MP_QSTR_get_group), MP_ROM_PTR(&mp_lv_obj_get_group_obj) }, + { MP_ROM_QSTR(MP_QSTR_is_focused), MP_ROM_PTR(&mp_lv_obj_is_focused_obj) }, + { MP_ROM_QSTR(MP_QSTR_STYLE), MP_ROM_PTR(&mp_LV_MBOX_STYLE_type) } +}; + +STATIC MP_DEFINE_CONST_DICT(mbox_locals_dict, mbox_locals_dict_table); + +STATIC void mbox_print(const mp_print_t *print, + mp_obj_t self_in, + mp_print_kind_t kind) +{ + mp_printf(print, "lvgl mbox"); +} + + +STATIC mp_obj_t mbox_make_new( + const mp_obj_type_t *type, + size_t n_args, + size_t n_kw, + const mp_obj_t *args) +{ + return make_new(&lv_mbox_create, type, n_args, n_kw, args); +} + + +STATIC const mp_obj_type_t mp_mbox_type = { + { &mp_type_type }, + .name = MP_QSTR_mbox, + .print = mbox_print, + .make_new = mbox_make_new, + .locals_dict = (mp_obj_dict_t*)&mbox_locals_dict, +}; + + +/* + * lvgl extension definition for: + * inline static void lv_lmeter_set_style(lv_obj_t *lmeter, lv_style_t *bg) + */ + +STATIC mp_obj_t mp_lv_lmeter_set_style(size_t n_args, const mp_obj_t *args) +{ + lv_obj_t *lmeter = mp_to_lv(args[0]); + lv_style_t *bg = mp_write_ptr_lv_style_t(args[1]); + lv_lmeter_set_style(lmeter, bg); + return mp_const_none; +} + +STATIC MP_DEFINE_CONST_FUN_OBJ_VAR_BETWEEN(mp_lv_lmeter_set_style_obj, 2, 2, mp_lv_lmeter_set_style); + + + +/* + * lvgl extension definition for: + * inline static lv_style_t *lv_lmeter_get_style(const lv_obj_t *lmeter) + */ + +STATIC mp_obj_t mp_lv_lmeter_get_style(size_t n_args, const mp_obj_t *args) +{ + const lv_obj_t *lmeter = mp_to_lv(args[0]); + lv_style_t* res = lv_lmeter_get_style(lmeter); + return mp_read_ptr_lv_style_t((void*)res); +} + +STATIC MP_DEFINE_CONST_FUN_OBJ_VAR_BETWEEN(mp_lv_lmeter_get_style_obj, 1, 1, mp_lv_lmeter_get_style); + + + +/* + * lvgl extension definition for: + * void lv_lmeter_set_value(lv_obj_t *lmeter, int16_t value) + */ + +STATIC mp_obj_t mp_lv_lmeter_set_value(size_t n_args, const mp_obj_t *args) +{ + lv_obj_t *lmeter = mp_to_lv(args[0]); + int16_t value = (int16_t)mp_obj_get_int(args[1]); + lv_lmeter_set_value(lmeter, value); + return mp_const_none; +} + +STATIC MP_DEFINE_CONST_FUN_OBJ_VAR_BETWEEN(mp_lv_lmeter_set_value_obj, 2, 2, mp_lv_lmeter_set_value); + + + +/* + * lvgl extension definition for: + * void lv_lmeter_set_range(lv_obj_t *lmeter, int16_t min, int16_t max) + */ + +STATIC mp_obj_t mp_lv_lmeter_set_range(size_t n_args, const mp_obj_t *args) +{ + lv_obj_t *lmeter = mp_to_lv(args[0]); + int16_t min = (int16_t)mp_obj_get_int(args[1]); + int16_t max = (int16_t)mp_obj_get_int(args[2]); + lv_lmeter_set_range(lmeter, min, max); + return mp_const_none; +} + +STATIC MP_DEFINE_CONST_FUN_OBJ_VAR_BETWEEN(mp_lv_lmeter_set_range_obj, 3, 3, mp_lv_lmeter_set_range); + + + +/* + * lvgl extension definition for: + * void lv_lmeter_set_scale(lv_obj_t *lmeter, uint16_t angle, uint8_t line_cnt) + */ + +STATIC mp_obj_t mp_lv_lmeter_set_scale(size_t n_args, const mp_obj_t *args) +{ + lv_obj_t *lmeter = mp_to_lv(args[0]); + uint16_t angle = (uint16_t)mp_obj_get_int(args[1]); + uint8_t line_cnt = (uint8_t)mp_obj_get_int(args[2]); + lv_lmeter_set_scale(lmeter, angle, line_cnt); + return mp_const_none; +} + +STATIC MP_DEFINE_CONST_FUN_OBJ_VAR_BETWEEN(mp_lv_lmeter_set_scale_obj, 3, 3, mp_lv_lmeter_set_scale); + + + +/* + * lvgl extension definition for: + * int16_t lv_lmeter_get_value(const lv_obj_t *lmeter) + */ + +STATIC mp_obj_t mp_lv_lmeter_get_value(size_t n_args, const mp_obj_t *args) +{ + const lv_obj_t *lmeter = mp_to_lv(args[0]); + int16_t res = lv_lmeter_get_value(lmeter); + return mp_obj_new_int(res); +} + +STATIC MP_DEFINE_CONST_FUN_OBJ_VAR_BETWEEN(mp_lv_lmeter_get_value_obj, 1, 1, mp_lv_lmeter_get_value); + + + +/* + * lvgl extension definition for: + * int16_t lv_lmeter_get_min_value(const lv_obj_t *lmeter) + */ + +STATIC mp_obj_t mp_lv_lmeter_get_min_value(size_t n_args, const mp_obj_t *args) +{ + const lv_obj_t *lmeter = mp_to_lv(args[0]); + int16_t res = lv_lmeter_get_min_value(lmeter); + return mp_obj_new_int(res); +} + +STATIC MP_DEFINE_CONST_FUN_OBJ_VAR_BETWEEN(mp_lv_lmeter_get_min_value_obj, 1, 1, mp_lv_lmeter_get_min_value); + + + +/* + * lvgl extension definition for: + * int16_t lv_lmeter_get_max_value(const lv_obj_t *lmeter) + */ + +STATIC mp_obj_t mp_lv_lmeter_get_max_value(size_t n_args, const mp_obj_t *args) +{ + const lv_obj_t *lmeter = mp_to_lv(args[0]); + int16_t res = lv_lmeter_get_max_value(lmeter); + return mp_obj_new_int(res); +} + +STATIC MP_DEFINE_CONST_FUN_OBJ_VAR_BETWEEN(mp_lv_lmeter_get_max_value_obj, 1, 1, mp_lv_lmeter_get_max_value); + + + +/* + * lvgl extension definition for: + * uint8_t lv_lmeter_get_line_count(const lv_obj_t *lmeter) + */ + +STATIC mp_obj_t mp_lv_lmeter_get_line_count(size_t n_args, const mp_obj_t *args) +{ + const lv_obj_t *lmeter = mp_to_lv(args[0]); + uint8_t res = lv_lmeter_get_line_count(lmeter); + return mp_obj_new_int_from_uint(res); +} + +STATIC MP_DEFINE_CONST_FUN_OBJ_VAR_BETWEEN(mp_lv_lmeter_get_line_count_obj, 1, 1, mp_lv_lmeter_get_line_count); + + + +/* + * lvgl extension definition for: + * uint16_t lv_lmeter_get_scale_angle(const lv_obj_t *lmeter) + */ + +STATIC mp_obj_t mp_lv_lmeter_get_scale_angle(size_t n_args, const mp_obj_t *args) +{ + const lv_obj_t *lmeter = mp_to_lv(args[0]); + uint16_t res = lv_lmeter_get_scale_angle(lmeter); + return mp_obj_new_int_from_uint(res); +} + +STATIC MP_DEFINE_CONST_FUN_OBJ_VAR_BETWEEN(mp_lv_lmeter_get_scale_angle_obj, 1, 1, mp_lv_lmeter_get_scale_angle); + + + +/* + * lvgl lmeter object definitions + */ + + +STATIC const mp_rom_map_elem_t lmeter_locals_dict_table[] = { + { MP_ROM_QSTR(MP_QSTR_set_style), MP_ROM_PTR(&mp_lv_lmeter_set_style_obj) }, + { MP_ROM_QSTR(MP_QSTR_get_style), MP_ROM_PTR(&mp_lv_lmeter_get_style_obj) }, + { MP_ROM_QSTR(MP_QSTR_set_value), MP_ROM_PTR(&mp_lv_lmeter_set_value_obj) }, + { MP_ROM_QSTR(MP_QSTR_set_range), MP_ROM_PTR(&mp_lv_lmeter_set_range_obj) }, + { MP_ROM_QSTR(MP_QSTR_set_scale), MP_ROM_PTR(&mp_lv_lmeter_set_scale_obj) }, + { MP_ROM_QSTR(MP_QSTR_get_value), MP_ROM_PTR(&mp_lv_lmeter_get_value_obj) }, + { MP_ROM_QSTR(MP_QSTR_get_min_value), MP_ROM_PTR(&mp_lv_lmeter_get_min_value_obj) }, + { MP_ROM_QSTR(MP_QSTR_get_max_value), MP_ROM_PTR(&mp_lv_lmeter_get_max_value_obj) }, + { MP_ROM_QSTR(MP_QSTR_get_line_count), MP_ROM_PTR(&mp_lv_lmeter_get_line_count_obj) }, + { MP_ROM_QSTR(MP_QSTR_get_scale_angle), MP_ROM_PTR(&mp_lv_lmeter_get_scale_angle_obj) }, + { MP_ROM_QSTR(MP_QSTR_delete), MP_ROM_PTR(&mp_lv_obj_del_obj) }, + { MP_ROM_QSTR(MP_QSTR_clean), MP_ROM_PTR(&mp_lv_obj_clean_obj) }, + { MP_ROM_QSTR(MP_QSTR_invalidate), MP_ROM_PTR(&mp_lv_obj_invalidate_obj) }, + { MP_ROM_QSTR(MP_QSTR_set_parent), MP_ROM_PTR(&mp_lv_obj_set_parent_obj) }, + { MP_ROM_QSTR(MP_QSTR_set_pos), MP_ROM_PTR(&mp_lv_obj_set_pos_obj) }, + { MP_ROM_QSTR(MP_QSTR_set_x), MP_ROM_PTR(&mp_lv_obj_set_x_obj) }, + { MP_ROM_QSTR(MP_QSTR_set_y), MP_ROM_PTR(&mp_lv_obj_set_y_obj) }, + { MP_ROM_QSTR(MP_QSTR_set_size), MP_ROM_PTR(&mp_lv_obj_set_size_obj) }, + { MP_ROM_QSTR(MP_QSTR_set_width), MP_ROM_PTR(&mp_lv_obj_set_width_obj) }, + { MP_ROM_QSTR(MP_QSTR_set_height), MP_ROM_PTR(&mp_lv_obj_set_height_obj) }, + { MP_ROM_QSTR(MP_QSTR_align), MP_ROM_PTR(&mp_lv_obj_align_obj) }, + { MP_ROM_QSTR(MP_QSTR_align_origo), MP_ROM_PTR(&mp_lv_obj_align_origo_obj) }, + { MP_ROM_QSTR(MP_QSTR_realign), MP_ROM_PTR(&mp_lv_obj_realign_obj) }, + { MP_ROM_QSTR(MP_QSTR_set_auto_realign), MP_ROM_PTR(&mp_lv_obj_set_auto_realign_obj) }, + { MP_ROM_QSTR(MP_QSTR_set_style), MP_ROM_PTR(&mp_lv_obj_set_style_obj) }, + { MP_ROM_QSTR(MP_QSTR_refresh_style), MP_ROM_PTR(&mp_lv_obj_refresh_style_obj) }, + { MP_ROM_QSTR(MP_QSTR_report_style_mod), MP_ROM_PTR(&mp_lv_obj_report_style_mod_obj) }, + { MP_ROM_QSTR(MP_QSTR_set_hidden), MP_ROM_PTR(&mp_lv_obj_set_hidden_obj) }, + { MP_ROM_QSTR(MP_QSTR_set_click), MP_ROM_PTR(&mp_lv_obj_set_click_obj) }, + { MP_ROM_QSTR(MP_QSTR_set_top), MP_ROM_PTR(&mp_lv_obj_set_top_obj) }, + { MP_ROM_QSTR(MP_QSTR_set_drag), MP_ROM_PTR(&mp_lv_obj_set_drag_obj) }, + { MP_ROM_QSTR(MP_QSTR_set_drag_throw), MP_ROM_PTR(&mp_lv_obj_set_drag_throw_obj) }, + { MP_ROM_QSTR(MP_QSTR_set_drag_parent), MP_ROM_PTR(&mp_lv_obj_set_drag_parent_obj) }, + { MP_ROM_QSTR(MP_QSTR_set_opa_scale_enable), MP_ROM_PTR(&mp_lv_obj_set_opa_scale_enable_obj) }, + { MP_ROM_QSTR(MP_QSTR_set_opa_scale), MP_ROM_PTR(&mp_lv_obj_set_opa_scale_obj) }, + { MP_ROM_QSTR(MP_QSTR_set_protect), MP_ROM_PTR(&mp_lv_obj_set_protect_obj) }, + { MP_ROM_QSTR(MP_QSTR_clear_protect), MP_ROM_PTR(&mp_lv_obj_clear_protect_obj) }, + { MP_ROM_QSTR(MP_QSTR_set_signal_func), MP_ROM_PTR(&mp_lv_obj_set_signal_func_obj) }, + { MP_ROM_QSTR(MP_QSTR_set_design_func), MP_ROM_PTR(&mp_lv_obj_set_design_func_obj) }, + { MP_ROM_QSTR(MP_QSTR_allocate_ext_attr), MP_ROM_PTR(&mp_lv_obj_allocate_ext_attr_obj) }, + { MP_ROM_QSTR(MP_QSTR_refresh_ext_size), MP_ROM_PTR(&mp_lv_obj_refresh_ext_size_obj) }, + { MP_ROM_QSTR(MP_QSTR_set_free_num), MP_ROM_PTR(&mp_lv_obj_set_free_num_obj) }, + { MP_ROM_QSTR(MP_QSTR_set_free_ptr), MP_ROM_PTR(&mp_lv_obj_set_free_ptr_obj) }, + { MP_ROM_QSTR(MP_QSTR_animate), MP_ROM_PTR(&mp_lv_obj_animate_obj) }, + { MP_ROM_QSTR(MP_QSTR_get_screen), MP_ROM_PTR(&mp_lv_obj_get_screen_obj) }, + { MP_ROM_QSTR(MP_QSTR_get_parent), MP_ROM_PTR(&mp_lv_obj_get_parent_obj) }, + { MP_ROM_QSTR(MP_QSTR_get_child), MP_ROM_PTR(&mp_lv_obj_get_child_obj) }, + { MP_ROM_QSTR(MP_QSTR_get_child_back), MP_ROM_PTR(&mp_lv_obj_get_child_back_obj) }, + { MP_ROM_QSTR(MP_QSTR_count_children), MP_ROM_PTR(&mp_lv_obj_count_children_obj) }, + { MP_ROM_QSTR(MP_QSTR_get_coords), MP_ROM_PTR(&mp_lv_obj_get_coords_obj) }, + { MP_ROM_QSTR(MP_QSTR_get_x), MP_ROM_PTR(&mp_lv_obj_get_x_obj) }, + { MP_ROM_QSTR(MP_QSTR_get_y), MP_ROM_PTR(&mp_lv_obj_get_y_obj) }, + { MP_ROM_QSTR(MP_QSTR_get_width), MP_ROM_PTR(&mp_lv_obj_get_width_obj) }, + { MP_ROM_QSTR(MP_QSTR_get_height), MP_ROM_PTR(&mp_lv_obj_get_height_obj) }, + { MP_ROM_QSTR(MP_QSTR_get_ext_size), MP_ROM_PTR(&mp_lv_obj_get_ext_size_obj) }, + { MP_ROM_QSTR(MP_QSTR_get_auto_realign), MP_ROM_PTR(&mp_lv_obj_get_auto_realign_obj) }, + { MP_ROM_QSTR(MP_QSTR_get_style), MP_ROM_PTR(&mp_lv_obj_get_style_obj) }, + { MP_ROM_QSTR(MP_QSTR_get_hidden), MP_ROM_PTR(&mp_lv_obj_get_hidden_obj) }, + { MP_ROM_QSTR(MP_QSTR_get_click), MP_ROM_PTR(&mp_lv_obj_get_click_obj) }, + { MP_ROM_QSTR(MP_QSTR_get_top), MP_ROM_PTR(&mp_lv_obj_get_top_obj) }, + { MP_ROM_QSTR(MP_QSTR_get_drag), MP_ROM_PTR(&mp_lv_obj_get_drag_obj) }, + { MP_ROM_QSTR(MP_QSTR_get_drag_throw), MP_ROM_PTR(&mp_lv_obj_get_drag_throw_obj) }, + { MP_ROM_QSTR(MP_QSTR_get_drag_parent), MP_ROM_PTR(&mp_lv_obj_get_drag_parent_obj) }, + { MP_ROM_QSTR(MP_QSTR_get_opa_scale_enable), MP_ROM_PTR(&mp_lv_obj_get_opa_scale_enable_obj) }, + { MP_ROM_QSTR(MP_QSTR_get_opa_scale), MP_ROM_PTR(&mp_lv_obj_get_opa_scale_obj) }, + { MP_ROM_QSTR(MP_QSTR_get_protect), MP_ROM_PTR(&mp_lv_obj_get_protect_obj) }, + { MP_ROM_QSTR(MP_QSTR_is_protected), MP_ROM_PTR(&mp_lv_obj_is_protected_obj) }, + { MP_ROM_QSTR(MP_QSTR_get_signal_func), MP_ROM_PTR(&mp_lv_obj_get_signal_func_obj) }, + { MP_ROM_QSTR(MP_QSTR_get_design_func), MP_ROM_PTR(&mp_lv_obj_get_design_func_obj) }, + { MP_ROM_QSTR(MP_QSTR_get_ext_attr), MP_ROM_PTR(&mp_lv_obj_get_ext_attr_obj) }, + { MP_ROM_QSTR(MP_QSTR_get_free_num), MP_ROM_PTR(&mp_lv_obj_get_free_num_obj) }, + { MP_ROM_QSTR(MP_QSTR_get_free_ptr), MP_ROM_PTR(&mp_lv_obj_get_free_ptr_obj) }, + { MP_ROM_QSTR(MP_QSTR_get_group), MP_ROM_PTR(&mp_lv_obj_get_group_obj) }, + { MP_ROM_QSTR(MP_QSTR_is_focused), MP_ROM_PTR(&mp_lv_obj_is_focused_obj) } +}; + +STATIC MP_DEFINE_CONST_DICT(lmeter_locals_dict, lmeter_locals_dict_table); + +STATIC void lmeter_print(const mp_print_t *print, + mp_obj_t self_in, + mp_print_kind_t kind) +{ + mp_printf(print, "lvgl lmeter"); +} + + +STATIC mp_obj_t lmeter_make_new( + const mp_obj_type_t *type, + size_t n_args, + size_t n_kw, + const mp_obj_t *args) +{ + return make_new(&lv_lmeter_create, type, n_args, n_kw, args); +} + + +STATIC const mp_obj_type_t mp_lmeter_type = { + { &mp_type_type }, + .name = MP_QSTR_lmeter, + .print = lmeter_print, + .make_new = lmeter_make_new, + .locals_dict = (mp_obj_dict_t*)&lmeter_locals_dict, +}; + + +/* + * lvgl extension definition for: + * inline static void lv_gauge_set_range(lv_obj_t *gauge, int16_t min, int16_t max) + */ + +STATIC mp_obj_t mp_lv_gauge_set_range(size_t n_args, const mp_obj_t *args) +{ + lv_obj_t *gauge = mp_to_lv(args[0]); + int16_t min = (int16_t)mp_obj_get_int(args[1]); + int16_t max = (int16_t)mp_obj_get_int(args[2]); + lv_gauge_set_range(gauge, min, max); + return mp_const_none; +} + +STATIC MP_DEFINE_CONST_FUN_OBJ_VAR_BETWEEN(mp_lv_gauge_set_range_obj, 3, 3, mp_lv_gauge_set_range); + + + +/* + * lvgl extension definition for: + * inline static void lv_gauge_set_critical_value(lv_obj_t *gauge, int16_t value) + */ + +STATIC mp_obj_t mp_lv_gauge_set_critical_value(size_t n_args, const mp_obj_t *args) +{ + lv_obj_t *gauge = mp_to_lv(args[0]); + int16_t value = (int16_t)mp_obj_get_int(args[1]); + lv_gauge_set_critical_value(gauge, value); + return mp_const_none; +} + +STATIC MP_DEFINE_CONST_FUN_OBJ_VAR_BETWEEN(mp_lv_gauge_set_critical_value_obj, 2, 2, mp_lv_gauge_set_critical_value); + + + +/* + * lvgl extension definition for: + * inline static void lv_gauge_set_style(lv_obj_t *gauge, lv_style_t *bg) + */ + +STATIC mp_obj_t mp_lv_gauge_set_style(size_t n_args, const mp_obj_t *args) +{ + lv_obj_t *gauge = mp_to_lv(args[0]); + lv_style_t *bg = mp_write_ptr_lv_style_t(args[1]); + lv_gauge_set_style(gauge, bg); + return mp_const_none; +} + +STATIC MP_DEFINE_CONST_FUN_OBJ_VAR_BETWEEN(mp_lv_gauge_set_style_obj, 2, 2, mp_lv_gauge_set_style); + + + +/* + * lvgl extension definition for: + * inline static int16_t lv_gauge_get_min_value(const lv_obj_t *lmeter) + */ + +STATIC mp_obj_t mp_lv_gauge_get_min_value(size_t n_args, const mp_obj_t *args) +{ + const lv_obj_t *lmeter = mp_to_lv(args[0]); + int16_t res = lv_gauge_get_min_value(lmeter); + return mp_obj_new_int(res); +} + +STATIC MP_DEFINE_CONST_FUN_OBJ_VAR_BETWEEN(mp_lv_gauge_get_min_value_obj, 1, 1, mp_lv_gauge_get_min_value); + + + +/* + * lvgl extension definition for: + * inline static int16_t lv_gauge_get_max_value(const lv_obj_t *lmeter) + */ + +STATIC mp_obj_t mp_lv_gauge_get_max_value(size_t n_args, const mp_obj_t *args) +{ + const lv_obj_t *lmeter = mp_to_lv(args[0]); + int16_t res = lv_gauge_get_max_value(lmeter); + return mp_obj_new_int(res); +} + +STATIC MP_DEFINE_CONST_FUN_OBJ_VAR_BETWEEN(mp_lv_gauge_get_max_value_obj, 1, 1, mp_lv_gauge_get_max_value); + + + +/* + * lvgl extension definition for: + * inline static int16_t lv_gauge_get_critical_value(const lv_obj_t *gauge) + */ + +STATIC mp_obj_t mp_lv_gauge_get_critical_value(size_t n_args, const mp_obj_t *args) +{ + const lv_obj_t *gauge = mp_to_lv(args[0]); + int16_t res = lv_gauge_get_critical_value(gauge); + return mp_obj_new_int(res); +} + +STATIC MP_DEFINE_CONST_FUN_OBJ_VAR_BETWEEN(mp_lv_gauge_get_critical_value_obj, 1, 1, mp_lv_gauge_get_critical_value); + + + +/* + * lvgl extension definition for: + * inline static uint8_t lv_gauge_get_line_count(const lv_obj_t *gauge) + */ + +STATIC mp_obj_t mp_lv_gauge_get_line_count(size_t n_args, const mp_obj_t *args) +{ + const lv_obj_t *gauge = mp_to_lv(args[0]); + uint8_t res = lv_gauge_get_line_count(gauge); + return mp_obj_new_int_from_uint(res); +} + +STATIC MP_DEFINE_CONST_FUN_OBJ_VAR_BETWEEN(mp_lv_gauge_get_line_count_obj, 1, 1, mp_lv_gauge_get_line_count); + + + +/* + * lvgl extension definition for: + * inline static uint16_t lv_gauge_get_scale_angle(const lv_obj_t *gauge) + */ + +STATIC mp_obj_t mp_lv_gauge_get_scale_angle(size_t n_args, const mp_obj_t *args) +{ + const lv_obj_t *gauge = mp_to_lv(args[0]); + uint16_t res = lv_gauge_get_scale_angle(gauge); + return mp_obj_new_int_from_uint(res); +} + +STATIC MP_DEFINE_CONST_FUN_OBJ_VAR_BETWEEN(mp_lv_gauge_get_scale_angle_obj, 1, 1, mp_lv_gauge_get_scale_angle); + + + +/* + * lvgl extension definition for: + * inline static lv_style_t *lv_gauge_get_style(const lv_obj_t *gauge) + */ + +STATIC mp_obj_t mp_lv_gauge_get_style(size_t n_args, const mp_obj_t *args) +{ + const lv_obj_t *gauge = mp_to_lv(args[0]); + lv_style_t* res = lv_gauge_get_style(gauge); + return mp_read_ptr_lv_style_t((void*)res); +} + +STATIC MP_DEFINE_CONST_FUN_OBJ_VAR_BETWEEN(mp_lv_gauge_get_style_obj, 1, 1, mp_lv_gauge_get_style); + + + +/* + * lvgl extension definition for: + * void lv_gauge_set_needle_count(lv_obj_t *gauge, uint8_t needle_cnt, const lv_color_t *colors) + */ + +STATIC mp_obj_t mp_lv_gauge_set_needle_count(size_t n_args, const mp_obj_t *args) +{ + lv_obj_t *gauge = mp_to_lv(args[0]); + uint8_t needle_cnt = (uint8_t)mp_obj_get_int(args[1]); + const lv_color_t *colors = mp_write_ptr_lv_color16_t(args[2]); + lv_gauge_set_needle_count(gauge, needle_cnt, colors); + return mp_const_none; +} + +STATIC MP_DEFINE_CONST_FUN_OBJ_VAR_BETWEEN(mp_lv_gauge_set_needle_count_obj, 3, 3, mp_lv_gauge_set_needle_count); + + + +/* + * lvgl extension definition for: + * void lv_gauge_set_value(lv_obj_t *gauge, uint8_t needle_id, int16_t value) + */ + +STATIC mp_obj_t mp_lv_gauge_set_value(size_t n_args, const mp_obj_t *args) +{ + lv_obj_t *gauge = mp_to_lv(args[0]); + uint8_t needle_id = (uint8_t)mp_obj_get_int(args[1]); + int16_t value = (int16_t)mp_obj_get_int(args[2]); + lv_gauge_set_value(gauge, needle_id, value); + return mp_const_none; +} + +STATIC MP_DEFINE_CONST_FUN_OBJ_VAR_BETWEEN(mp_lv_gauge_set_value_obj, 3, 3, mp_lv_gauge_set_value); + + + +/* + * lvgl extension definition for: + * void lv_gauge_set_scale(lv_obj_t *gauge, uint16_t angle, uint8_t line_cnt, uint8_t label_cnt) + */ + +STATIC mp_obj_t mp_lv_gauge_set_scale(size_t n_args, const mp_obj_t *args) +{ + lv_obj_t *gauge = mp_to_lv(args[0]); + uint16_t angle = (uint16_t)mp_obj_get_int(args[1]); + uint8_t line_cnt = (uint8_t)mp_obj_get_int(args[2]); + uint8_t label_cnt = (uint8_t)mp_obj_get_int(args[3]); + lv_gauge_set_scale(gauge, angle, line_cnt, label_cnt); + return mp_const_none; +} + +STATIC MP_DEFINE_CONST_FUN_OBJ_VAR_BETWEEN(mp_lv_gauge_set_scale_obj, 4, 4, mp_lv_gauge_set_scale); + + + +/* + * lvgl extension definition for: + * int16_t lv_gauge_get_value(const lv_obj_t *gauge, uint8_t needle) + */ + +STATIC mp_obj_t mp_lv_gauge_get_value(size_t n_args, const mp_obj_t *args) +{ + const lv_obj_t *gauge = mp_to_lv(args[0]); + uint8_t needle = (uint8_t)mp_obj_get_int(args[1]); + int16_t res = lv_gauge_get_value(gauge, needle); + return mp_obj_new_int(res); +} + +STATIC MP_DEFINE_CONST_FUN_OBJ_VAR_BETWEEN(mp_lv_gauge_get_value_obj, 2, 2, mp_lv_gauge_get_value); + + + +/* + * lvgl extension definition for: + * uint8_t lv_gauge_get_needle_count(const lv_obj_t *gauge) + */ + +STATIC mp_obj_t mp_lv_gauge_get_needle_count(size_t n_args, const mp_obj_t *args) +{ + const lv_obj_t *gauge = mp_to_lv(args[0]); + uint8_t res = lv_gauge_get_needle_count(gauge); + return mp_obj_new_int_from_uint(res); +} + +STATIC MP_DEFINE_CONST_FUN_OBJ_VAR_BETWEEN(mp_lv_gauge_get_needle_count_obj, 1, 1, mp_lv_gauge_get_needle_count); + + + +/* + * lvgl extension definition for: + * uint8_t lv_gauge_get_label_count(const lv_obj_t *gauge) + */ + +STATIC mp_obj_t mp_lv_gauge_get_label_count(size_t n_args, const mp_obj_t *args) +{ + const lv_obj_t *gauge = mp_to_lv(args[0]); + uint8_t res = lv_gauge_get_label_count(gauge); + return mp_obj_new_int_from_uint(res); +} + +STATIC MP_DEFINE_CONST_FUN_OBJ_VAR_BETWEEN(mp_lv_gauge_get_label_count_obj, 1, 1, mp_lv_gauge_get_label_count); + + + +/* + * lvgl gauge object definitions + */ + + +STATIC const mp_rom_map_elem_t gauge_locals_dict_table[] = { + { MP_ROM_QSTR(MP_QSTR_set_range), MP_ROM_PTR(&mp_lv_gauge_set_range_obj) }, + { MP_ROM_QSTR(MP_QSTR_set_critical_value), MP_ROM_PTR(&mp_lv_gauge_set_critical_value_obj) }, + { MP_ROM_QSTR(MP_QSTR_set_style), MP_ROM_PTR(&mp_lv_gauge_set_style_obj) }, + { MP_ROM_QSTR(MP_QSTR_get_min_value), MP_ROM_PTR(&mp_lv_gauge_get_min_value_obj) }, + { MP_ROM_QSTR(MP_QSTR_get_max_value), MP_ROM_PTR(&mp_lv_gauge_get_max_value_obj) }, + { MP_ROM_QSTR(MP_QSTR_get_critical_value), MP_ROM_PTR(&mp_lv_gauge_get_critical_value_obj) }, + { MP_ROM_QSTR(MP_QSTR_get_line_count), MP_ROM_PTR(&mp_lv_gauge_get_line_count_obj) }, + { MP_ROM_QSTR(MP_QSTR_get_scale_angle), MP_ROM_PTR(&mp_lv_gauge_get_scale_angle_obj) }, + { MP_ROM_QSTR(MP_QSTR_get_style), MP_ROM_PTR(&mp_lv_gauge_get_style_obj) }, + { MP_ROM_QSTR(MP_QSTR_set_needle_count), MP_ROM_PTR(&mp_lv_gauge_set_needle_count_obj) }, + { MP_ROM_QSTR(MP_QSTR_set_value), MP_ROM_PTR(&mp_lv_gauge_set_value_obj) }, + { MP_ROM_QSTR(MP_QSTR_set_scale), MP_ROM_PTR(&mp_lv_gauge_set_scale_obj) }, + { MP_ROM_QSTR(MP_QSTR_get_value), MP_ROM_PTR(&mp_lv_gauge_get_value_obj) }, + { MP_ROM_QSTR(MP_QSTR_get_needle_count), MP_ROM_PTR(&mp_lv_gauge_get_needle_count_obj) }, + { MP_ROM_QSTR(MP_QSTR_get_label_count), MP_ROM_PTR(&mp_lv_gauge_get_label_count_obj) }, + { MP_ROM_QSTR(MP_QSTR_delete), MP_ROM_PTR(&mp_lv_obj_del_obj) }, + { MP_ROM_QSTR(MP_QSTR_clean), MP_ROM_PTR(&mp_lv_obj_clean_obj) }, + { MP_ROM_QSTR(MP_QSTR_invalidate), MP_ROM_PTR(&mp_lv_obj_invalidate_obj) }, + { MP_ROM_QSTR(MP_QSTR_set_parent), MP_ROM_PTR(&mp_lv_obj_set_parent_obj) }, + { MP_ROM_QSTR(MP_QSTR_set_pos), MP_ROM_PTR(&mp_lv_obj_set_pos_obj) }, + { MP_ROM_QSTR(MP_QSTR_set_x), MP_ROM_PTR(&mp_lv_obj_set_x_obj) }, + { MP_ROM_QSTR(MP_QSTR_set_y), MP_ROM_PTR(&mp_lv_obj_set_y_obj) }, + { MP_ROM_QSTR(MP_QSTR_set_size), MP_ROM_PTR(&mp_lv_obj_set_size_obj) }, + { MP_ROM_QSTR(MP_QSTR_set_width), MP_ROM_PTR(&mp_lv_obj_set_width_obj) }, + { MP_ROM_QSTR(MP_QSTR_set_height), MP_ROM_PTR(&mp_lv_obj_set_height_obj) }, + { MP_ROM_QSTR(MP_QSTR_align), MP_ROM_PTR(&mp_lv_obj_align_obj) }, + { MP_ROM_QSTR(MP_QSTR_align_origo), MP_ROM_PTR(&mp_lv_obj_align_origo_obj) }, + { MP_ROM_QSTR(MP_QSTR_realign), MP_ROM_PTR(&mp_lv_obj_realign_obj) }, + { MP_ROM_QSTR(MP_QSTR_set_auto_realign), MP_ROM_PTR(&mp_lv_obj_set_auto_realign_obj) }, + { MP_ROM_QSTR(MP_QSTR_set_style), MP_ROM_PTR(&mp_lv_obj_set_style_obj) }, + { MP_ROM_QSTR(MP_QSTR_refresh_style), MP_ROM_PTR(&mp_lv_obj_refresh_style_obj) }, + { MP_ROM_QSTR(MP_QSTR_report_style_mod), MP_ROM_PTR(&mp_lv_obj_report_style_mod_obj) }, + { MP_ROM_QSTR(MP_QSTR_set_hidden), MP_ROM_PTR(&mp_lv_obj_set_hidden_obj) }, + { MP_ROM_QSTR(MP_QSTR_set_click), MP_ROM_PTR(&mp_lv_obj_set_click_obj) }, + { MP_ROM_QSTR(MP_QSTR_set_top), MP_ROM_PTR(&mp_lv_obj_set_top_obj) }, + { MP_ROM_QSTR(MP_QSTR_set_drag), MP_ROM_PTR(&mp_lv_obj_set_drag_obj) }, + { MP_ROM_QSTR(MP_QSTR_set_drag_throw), MP_ROM_PTR(&mp_lv_obj_set_drag_throw_obj) }, + { MP_ROM_QSTR(MP_QSTR_set_drag_parent), MP_ROM_PTR(&mp_lv_obj_set_drag_parent_obj) }, + { MP_ROM_QSTR(MP_QSTR_set_opa_scale_enable), MP_ROM_PTR(&mp_lv_obj_set_opa_scale_enable_obj) }, + { MP_ROM_QSTR(MP_QSTR_set_opa_scale), MP_ROM_PTR(&mp_lv_obj_set_opa_scale_obj) }, + { MP_ROM_QSTR(MP_QSTR_set_protect), MP_ROM_PTR(&mp_lv_obj_set_protect_obj) }, + { MP_ROM_QSTR(MP_QSTR_clear_protect), MP_ROM_PTR(&mp_lv_obj_clear_protect_obj) }, + { MP_ROM_QSTR(MP_QSTR_set_signal_func), MP_ROM_PTR(&mp_lv_obj_set_signal_func_obj) }, + { MP_ROM_QSTR(MP_QSTR_set_design_func), MP_ROM_PTR(&mp_lv_obj_set_design_func_obj) }, + { MP_ROM_QSTR(MP_QSTR_allocate_ext_attr), MP_ROM_PTR(&mp_lv_obj_allocate_ext_attr_obj) }, + { MP_ROM_QSTR(MP_QSTR_refresh_ext_size), MP_ROM_PTR(&mp_lv_obj_refresh_ext_size_obj) }, + { MP_ROM_QSTR(MP_QSTR_set_free_num), MP_ROM_PTR(&mp_lv_obj_set_free_num_obj) }, + { MP_ROM_QSTR(MP_QSTR_set_free_ptr), MP_ROM_PTR(&mp_lv_obj_set_free_ptr_obj) }, + { MP_ROM_QSTR(MP_QSTR_animate), MP_ROM_PTR(&mp_lv_obj_animate_obj) }, + { MP_ROM_QSTR(MP_QSTR_get_screen), MP_ROM_PTR(&mp_lv_obj_get_screen_obj) }, + { MP_ROM_QSTR(MP_QSTR_get_parent), MP_ROM_PTR(&mp_lv_obj_get_parent_obj) }, + { MP_ROM_QSTR(MP_QSTR_get_child), MP_ROM_PTR(&mp_lv_obj_get_child_obj) }, + { MP_ROM_QSTR(MP_QSTR_get_child_back), MP_ROM_PTR(&mp_lv_obj_get_child_back_obj) }, + { MP_ROM_QSTR(MP_QSTR_count_children), MP_ROM_PTR(&mp_lv_obj_count_children_obj) }, + { MP_ROM_QSTR(MP_QSTR_get_coords), MP_ROM_PTR(&mp_lv_obj_get_coords_obj) }, + { MP_ROM_QSTR(MP_QSTR_get_x), MP_ROM_PTR(&mp_lv_obj_get_x_obj) }, + { MP_ROM_QSTR(MP_QSTR_get_y), MP_ROM_PTR(&mp_lv_obj_get_y_obj) }, + { MP_ROM_QSTR(MP_QSTR_get_width), MP_ROM_PTR(&mp_lv_obj_get_width_obj) }, + { MP_ROM_QSTR(MP_QSTR_get_height), MP_ROM_PTR(&mp_lv_obj_get_height_obj) }, + { MP_ROM_QSTR(MP_QSTR_get_ext_size), MP_ROM_PTR(&mp_lv_obj_get_ext_size_obj) }, + { MP_ROM_QSTR(MP_QSTR_get_auto_realign), MP_ROM_PTR(&mp_lv_obj_get_auto_realign_obj) }, + { MP_ROM_QSTR(MP_QSTR_get_style), MP_ROM_PTR(&mp_lv_obj_get_style_obj) }, + { MP_ROM_QSTR(MP_QSTR_get_hidden), MP_ROM_PTR(&mp_lv_obj_get_hidden_obj) }, + { MP_ROM_QSTR(MP_QSTR_get_click), MP_ROM_PTR(&mp_lv_obj_get_click_obj) }, + { MP_ROM_QSTR(MP_QSTR_get_top), MP_ROM_PTR(&mp_lv_obj_get_top_obj) }, + { MP_ROM_QSTR(MP_QSTR_get_drag), MP_ROM_PTR(&mp_lv_obj_get_drag_obj) }, + { MP_ROM_QSTR(MP_QSTR_get_drag_throw), MP_ROM_PTR(&mp_lv_obj_get_drag_throw_obj) }, + { MP_ROM_QSTR(MP_QSTR_get_drag_parent), MP_ROM_PTR(&mp_lv_obj_get_drag_parent_obj) }, + { MP_ROM_QSTR(MP_QSTR_get_opa_scale_enable), MP_ROM_PTR(&mp_lv_obj_get_opa_scale_enable_obj) }, + { MP_ROM_QSTR(MP_QSTR_get_opa_scale), MP_ROM_PTR(&mp_lv_obj_get_opa_scale_obj) }, + { MP_ROM_QSTR(MP_QSTR_get_protect), MP_ROM_PTR(&mp_lv_obj_get_protect_obj) }, + { MP_ROM_QSTR(MP_QSTR_is_protected), MP_ROM_PTR(&mp_lv_obj_is_protected_obj) }, + { MP_ROM_QSTR(MP_QSTR_get_signal_func), MP_ROM_PTR(&mp_lv_obj_get_signal_func_obj) }, + { MP_ROM_QSTR(MP_QSTR_get_design_func), MP_ROM_PTR(&mp_lv_obj_get_design_func_obj) }, + { MP_ROM_QSTR(MP_QSTR_get_ext_attr), MP_ROM_PTR(&mp_lv_obj_get_ext_attr_obj) }, + { MP_ROM_QSTR(MP_QSTR_get_free_num), MP_ROM_PTR(&mp_lv_obj_get_free_num_obj) }, + { MP_ROM_QSTR(MP_QSTR_get_free_ptr), MP_ROM_PTR(&mp_lv_obj_get_free_ptr_obj) }, + { MP_ROM_QSTR(MP_QSTR_get_group), MP_ROM_PTR(&mp_lv_obj_get_group_obj) }, + { MP_ROM_QSTR(MP_QSTR_is_focused), MP_ROM_PTR(&mp_lv_obj_is_focused_obj) } +}; + +STATIC MP_DEFINE_CONST_DICT(gauge_locals_dict, gauge_locals_dict_table); + +STATIC void gauge_print(const mp_print_t *print, + mp_obj_t self_in, + mp_print_kind_t kind) +{ + mp_printf(print, "lvgl gauge"); +} + + +STATIC mp_obj_t gauge_make_new( + const mp_obj_type_t *type, + size_t n_args, + size_t n_kw, + const mp_obj_t *args) +{ + return make_new(&lv_gauge_create, type, n_args, n_kw, args); +} + + +STATIC const mp_obj_type_t mp_gauge_type = { + { &mp_type_type }, + .name = MP_QSTR_gauge, + .print = gauge_print, + .make_new = gauge_make_new, + .locals_dict = (mp_obj_dict_t*)&gauge_locals_dict, +}; + + +/* + * lvgl extension definition for: + * inline static void lv_sw_set_action(lv_obj_t *sw, lv_action_t action) + */ + +STATIC mp_obj_t mp_lv_sw_set_action(size_t n_args, const mp_obj_t *args) +{ + lv_obj_t *sw = mp_to_lv(args[0]); + set_action(args[0], args[1]); + lv_action_t action = &lv_action_t_callback; + lv_sw_set_action(sw, action); + return mp_const_none; +} + +STATIC MP_DEFINE_CONST_FUN_OBJ_VAR_BETWEEN(mp_lv_sw_set_action_obj, 2, 2, mp_lv_sw_set_action); + + + +/* + * lvgl extension definition for: + * inline static bool lv_sw_get_state(const lv_obj_t *sw) + */ + +STATIC mp_obj_t mp_lv_sw_get_state(size_t n_args, const mp_obj_t *args) +{ + const lv_obj_t *sw = mp_to_lv(args[0]); + bool res = lv_sw_get_state(sw); + return convert_to_bool(res); +} + +STATIC MP_DEFINE_CONST_FUN_OBJ_VAR_BETWEEN(mp_lv_sw_get_state_obj, 1, 1, mp_lv_sw_get_state); + + + +/* + * lvgl extension definition for: + * inline static lv_action_t lv_sw_get_action(const lv_obj_t *slider) + */ + +STATIC mp_obj_t mp_lv_sw_get_action(size_t n_args, const mp_obj_t *args) +{ + const lv_obj_t *slider = mp_to_lv(args[0]); + lv_action_t res = lv_sw_get_action(slider); + return ptr_to_mp(res); +} + +STATIC MP_DEFINE_CONST_FUN_OBJ_VAR_BETWEEN(mp_lv_sw_get_action_obj, 1, 1, mp_lv_sw_get_action); + + + +/* + * lvgl extension definition for: + * void lv_sw_on(lv_obj_t *sw) + */ + +STATIC mp_obj_t mp_lv_sw_on(size_t n_args, const mp_obj_t *args) +{ + lv_obj_t *sw = mp_to_lv(args[0]); + lv_sw_on(sw); + return mp_const_none; +} + +STATIC MP_DEFINE_CONST_FUN_OBJ_VAR_BETWEEN(mp_lv_sw_on_obj, 1, 1, mp_lv_sw_on); + + + +/* + * lvgl extension definition for: + * void lv_sw_off(lv_obj_t *sw) + */ + +STATIC mp_obj_t mp_lv_sw_off(size_t n_args, const mp_obj_t *args) +{ + lv_obj_t *sw = mp_to_lv(args[0]); + lv_sw_off(sw); + return mp_const_none; +} + +STATIC MP_DEFINE_CONST_FUN_OBJ_VAR_BETWEEN(mp_lv_sw_off_obj, 1, 1, mp_lv_sw_off); + + + +/* + * lvgl extension definition for: + * bool lv_sw_toggle(lv_obj_t *sw) + */ + +STATIC mp_obj_t mp_lv_sw_toggle(size_t n_args, const mp_obj_t *args) +{ + lv_obj_t *sw = mp_to_lv(args[0]); + bool res = lv_sw_toggle(sw); + return convert_to_bool(res); +} + +STATIC MP_DEFINE_CONST_FUN_OBJ_VAR_BETWEEN(mp_lv_sw_toggle_obj, 1, 1, mp_lv_sw_toggle); + + + +/* + * lvgl extension definition for: + * void lv_sw_on_anim(lv_obj_t *sw) + */ + +STATIC mp_obj_t mp_lv_sw_on_anim(size_t n_args, const mp_obj_t *args) +{ + lv_obj_t *sw = mp_to_lv(args[0]); + lv_sw_on_anim(sw); + return mp_const_none; +} + +STATIC MP_DEFINE_CONST_FUN_OBJ_VAR_BETWEEN(mp_lv_sw_on_anim_obj, 1, 1, mp_lv_sw_on_anim); + + + +/* + * lvgl extension definition for: + * void lv_sw_off_anim(lv_obj_t *sw) + */ + +STATIC mp_obj_t mp_lv_sw_off_anim(size_t n_args, const mp_obj_t *args) +{ + lv_obj_t *sw = mp_to_lv(args[0]); + lv_sw_off_anim(sw); + return mp_const_none; +} + +STATIC MP_DEFINE_CONST_FUN_OBJ_VAR_BETWEEN(mp_lv_sw_off_anim_obj, 1, 1, mp_lv_sw_off_anim); + + + +/* + * lvgl extension definition for: + * bool lv_sw_toggle_anim(lv_obj_t *sw) + */ + +STATIC mp_obj_t mp_lv_sw_toggle_anim(size_t n_args, const mp_obj_t *args) +{ + lv_obj_t *sw = mp_to_lv(args[0]); + bool res = lv_sw_toggle_anim(sw); + return convert_to_bool(res); +} + +STATIC MP_DEFINE_CONST_FUN_OBJ_VAR_BETWEEN(mp_lv_sw_toggle_anim_obj, 1, 1, mp_lv_sw_toggle_anim); + + + +/* + * lvgl extension definition for: + * void lv_sw_set_style(lv_obj_t *sw, lv_sw_style_t type, lv_style_t *style) + */ + +STATIC mp_obj_t mp_lv_sw_set_style(size_t n_args, const mp_obj_t *args) +{ + lv_obj_t *sw = mp_to_lv(args[0]); + lv_sw_style_t type = (uint8_t)mp_obj_get_int(args[1]); + lv_style_t *style = mp_write_ptr_lv_style_t(args[2]); + lv_sw_set_style(sw, type, style); + return mp_const_none; +} + +STATIC MP_DEFINE_CONST_FUN_OBJ_VAR_BETWEEN(mp_lv_sw_set_style_obj, 3, 3, mp_lv_sw_set_style); + + + +/* + * lvgl extension definition for: + * void lv_sw_set_anim_time(lv_obj_t *sw, uint16_t anim_time) + */ + +STATIC mp_obj_t mp_lv_sw_set_anim_time(size_t n_args, const mp_obj_t *args) +{ + lv_obj_t *sw = mp_to_lv(args[0]); + uint16_t anim_time = (uint16_t)mp_obj_get_int(args[1]); + lv_sw_set_anim_time(sw, anim_time); + return mp_const_none; +} + +STATIC MP_DEFINE_CONST_FUN_OBJ_VAR_BETWEEN(mp_lv_sw_set_anim_time_obj, 2, 2, mp_lv_sw_set_anim_time); + + + +/* + * lvgl extension definition for: + * lv_style_t *lv_sw_get_style(const lv_obj_t *sw, lv_sw_style_t type) + */ + +STATIC mp_obj_t mp_lv_sw_get_style(size_t n_args, const mp_obj_t *args) +{ + const lv_obj_t *sw = mp_to_lv(args[0]); + lv_sw_style_t type = (uint8_t)mp_obj_get_int(args[1]); + lv_style_t* res = lv_sw_get_style(sw, type); + return mp_read_ptr_lv_style_t((void*)res); +} + +STATIC MP_DEFINE_CONST_FUN_OBJ_VAR_BETWEEN(mp_lv_sw_get_style_obj, 2, 2, mp_lv_sw_get_style); + + + +/* + * lvgl extension definition for: + * uint16_t lv_sw_get_anim_time(const lv_obj_t *sw) + */ + +STATIC mp_obj_t mp_lv_sw_get_anim_time(size_t n_args, const mp_obj_t *args) +{ + const lv_obj_t *sw = mp_to_lv(args[0]); + uint16_t res = lv_sw_get_anim_time(sw); + return mp_obj_new_int_from_uint(res); +} + +STATIC MP_DEFINE_CONST_FUN_OBJ_VAR_BETWEEN(mp_lv_sw_get_anim_time_obj, 1, 1, mp_lv_sw_get_anim_time); + + + +/* + * lvgl sw object definitions + */ + + +STATIC const mp_rom_map_elem_t sw_locals_dict_table[] = { + { MP_ROM_QSTR(MP_QSTR_set_action), MP_ROM_PTR(&mp_lv_sw_set_action_obj) }, + { MP_ROM_QSTR(MP_QSTR_get_state), MP_ROM_PTR(&mp_lv_sw_get_state_obj) }, + { MP_ROM_QSTR(MP_QSTR_get_action), MP_ROM_PTR(&mp_lv_sw_get_action_obj) }, + { MP_ROM_QSTR(MP_QSTR_on), MP_ROM_PTR(&mp_lv_sw_on_obj) }, + { MP_ROM_QSTR(MP_QSTR_off), MP_ROM_PTR(&mp_lv_sw_off_obj) }, + { MP_ROM_QSTR(MP_QSTR_toggle), MP_ROM_PTR(&mp_lv_sw_toggle_obj) }, + { MP_ROM_QSTR(MP_QSTR_on_anim), MP_ROM_PTR(&mp_lv_sw_on_anim_obj) }, + { MP_ROM_QSTR(MP_QSTR_off_anim), MP_ROM_PTR(&mp_lv_sw_off_anim_obj) }, + { MP_ROM_QSTR(MP_QSTR_toggle_anim), MP_ROM_PTR(&mp_lv_sw_toggle_anim_obj) }, + { MP_ROM_QSTR(MP_QSTR_set_style), MP_ROM_PTR(&mp_lv_sw_set_style_obj) }, + { MP_ROM_QSTR(MP_QSTR_set_anim_time), MP_ROM_PTR(&mp_lv_sw_set_anim_time_obj) }, + { MP_ROM_QSTR(MP_QSTR_get_style), MP_ROM_PTR(&mp_lv_sw_get_style_obj) }, + { MP_ROM_QSTR(MP_QSTR_get_anim_time), MP_ROM_PTR(&mp_lv_sw_get_anim_time_obj) }, + { MP_ROM_QSTR(MP_QSTR_delete), MP_ROM_PTR(&mp_lv_obj_del_obj) }, + { MP_ROM_QSTR(MP_QSTR_clean), MP_ROM_PTR(&mp_lv_obj_clean_obj) }, + { MP_ROM_QSTR(MP_QSTR_invalidate), MP_ROM_PTR(&mp_lv_obj_invalidate_obj) }, + { MP_ROM_QSTR(MP_QSTR_set_parent), MP_ROM_PTR(&mp_lv_obj_set_parent_obj) }, + { MP_ROM_QSTR(MP_QSTR_set_pos), MP_ROM_PTR(&mp_lv_obj_set_pos_obj) }, + { MP_ROM_QSTR(MP_QSTR_set_x), MP_ROM_PTR(&mp_lv_obj_set_x_obj) }, + { MP_ROM_QSTR(MP_QSTR_set_y), MP_ROM_PTR(&mp_lv_obj_set_y_obj) }, + { MP_ROM_QSTR(MP_QSTR_set_size), MP_ROM_PTR(&mp_lv_obj_set_size_obj) }, + { MP_ROM_QSTR(MP_QSTR_set_width), MP_ROM_PTR(&mp_lv_obj_set_width_obj) }, + { MP_ROM_QSTR(MP_QSTR_set_height), MP_ROM_PTR(&mp_lv_obj_set_height_obj) }, + { MP_ROM_QSTR(MP_QSTR_align), MP_ROM_PTR(&mp_lv_obj_align_obj) }, + { MP_ROM_QSTR(MP_QSTR_align_origo), MP_ROM_PTR(&mp_lv_obj_align_origo_obj) }, + { MP_ROM_QSTR(MP_QSTR_realign), MP_ROM_PTR(&mp_lv_obj_realign_obj) }, + { MP_ROM_QSTR(MP_QSTR_set_auto_realign), MP_ROM_PTR(&mp_lv_obj_set_auto_realign_obj) }, + { MP_ROM_QSTR(MP_QSTR_set_style), MP_ROM_PTR(&mp_lv_obj_set_style_obj) }, + { MP_ROM_QSTR(MP_QSTR_refresh_style), MP_ROM_PTR(&mp_lv_obj_refresh_style_obj) }, + { MP_ROM_QSTR(MP_QSTR_report_style_mod), MP_ROM_PTR(&mp_lv_obj_report_style_mod_obj) }, + { MP_ROM_QSTR(MP_QSTR_set_hidden), MP_ROM_PTR(&mp_lv_obj_set_hidden_obj) }, + { MP_ROM_QSTR(MP_QSTR_set_click), MP_ROM_PTR(&mp_lv_obj_set_click_obj) }, + { MP_ROM_QSTR(MP_QSTR_set_top), MP_ROM_PTR(&mp_lv_obj_set_top_obj) }, + { MP_ROM_QSTR(MP_QSTR_set_drag), MP_ROM_PTR(&mp_lv_obj_set_drag_obj) }, + { MP_ROM_QSTR(MP_QSTR_set_drag_throw), MP_ROM_PTR(&mp_lv_obj_set_drag_throw_obj) }, + { MP_ROM_QSTR(MP_QSTR_set_drag_parent), MP_ROM_PTR(&mp_lv_obj_set_drag_parent_obj) }, + { MP_ROM_QSTR(MP_QSTR_set_opa_scale_enable), MP_ROM_PTR(&mp_lv_obj_set_opa_scale_enable_obj) }, + { MP_ROM_QSTR(MP_QSTR_set_opa_scale), MP_ROM_PTR(&mp_lv_obj_set_opa_scale_obj) }, + { MP_ROM_QSTR(MP_QSTR_set_protect), MP_ROM_PTR(&mp_lv_obj_set_protect_obj) }, + { MP_ROM_QSTR(MP_QSTR_clear_protect), MP_ROM_PTR(&mp_lv_obj_clear_protect_obj) }, + { MP_ROM_QSTR(MP_QSTR_set_signal_func), MP_ROM_PTR(&mp_lv_obj_set_signal_func_obj) }, + { MP_ROM_QSTR(MP_QSTR_set_design_func), MP_ROM_PTR(&mp_lv_obj_set_design_func_obj) }, + { MP_ROM_QSTR(MP_QSTR_allocate_ext_attr), MP_ROM_PTR(&mp_lv_obj_allocate_ext_attr_obj) }, + { MP_ROM_QSTR(MP_QSTR_refresh_ext_size), MP_ROM_PTR(&mp_lv_obj_refresh_ext_size_obj) }, + { MP_ROM_QSTR(MP_QSTR_set_free_num), MP_ROM_PTR(&mp_lv_obj_set_free_num_obj) }, + { MP_ROM_QSTR(MP_QSTR_set_free_ptr), MP_ROM_PTR(&mp_lv_obj_set_free_ptr_obj) }, + { MP_ROM_QSTR(MP_QSTR_animate), MP_ROM_PTR(&mp_lv_obj_animate_obj) }, + { MP_ROM_QSTR(MP_QSTR_get_screen), MP_ROM_PTR(&mp_lv_obj_get_screen_obj) }, + { MP_ROM_QSTR(MP_QSTR_get_parent), MP_ROM_PTR(&mp_lv_obj_get_parent_obj) }, + { MP_ROM_QSTR(MP_QSTR_get_child), MP_ROM_PTR(&mp_lv_obj_get_child_obj) }, + { MP_ROM_QSTR(MP_QSTR_get_child_back), MP_ROM_PTR(&mp_lv_obj_get_child_back_obj) }, + { MP_ROM_QSTR(MP_QSTR_count_children), MP_ROM_PTR(&mp_lv_obj_count_children_obj) }, + { MP_ROM_QSTR(MP_QSTR_get_coords), MP_ROM_PTR(&mp_lv_obj_get_coords_obj) }, + { MP_ROM_QSTR(MP_QSTR_get_x), MP_ROM_PTR(&mp_lv_obj_get_x_obj) }, + { MP_ROM_QSTR(MP_QSTR_get_y), MP_ROM_PTR(&mp_lv_obj_get_y_obj) }, + { MP_ROM_QSTR(MP_QSTR_get_width), MP_ROM_PTR(&mp_lv_obj_get_width_obj) }, + { MP_ROM_QSTR(MP_QSTR_get_height), MP_ROM_PTR(&mp_lv_obj_get_height_obj) }, + { MP_ROM_QSTR(MP_QSTR_get_ext_size), MP_ROM_PTR(&mp_lv_obj_get_ext_size_obj) }, + { MP_ROM_QSTR(MP_QSTR_get_auto_realign), MP_ROM_PTR(&mp_lv_obj_get_auto_realign_obj) }, + { MP_ROM_QSTR(MP_QSTR_get_style), MP_ROM_PTR(&mp_lv_obj_get_style_obj) }, + { MP_ROM_QSTR(MP_QSTR_get_hidden), MP_ROM_PTR(&mp_lv_obj_get_hidden_obj) }, + { MP_ROM_QSTR(MP_QSTR_get_click), MP_ROM_PTR(&mp_lv_obj_get_click_obj) }, + { MP_ROM_QSTR(MP_QSTR_get_top), MP_ROM_PTR(&mp_lv_obj_get_top_obj) }, + { MP_ROM_QSTR(MP_QSTR_get_drag), MP_ROM_PTR(&mp_lv_obj_get_drag_obj) }, + { MP_ROM_QSTR(MP_QSTR_get_drag_throw), MP_ROM_PTR(&mp_lv_obj_get_drag_throw_obj) }, + { MP_ROM_QSTR(MP_QSTR_get_drag_parent), MP_ROM_PTR(&mp_lv_obj_get_drag_parent_obj) }, + { MP_ROM_QSTR(MP_QSTR_get_opa_scale_enable), MP_ROM_PTR(&mp_lv_obj_get_opa_scale_enable_obj) }, + { MP_ROM_QSTR(MP_QSTR_get_opa_scale), MP_ROM_PTR(&mp_lv_obj_get_opa_scale_obj) }, + { MP_ROM_QSTR(MP_QSTR_get_protect), MP_ROM_PTR(&mp_lv_obj_get_protect_obj) }, + { MP_ROM_QSTR(MP_QSTR_is_protected), MP_ROM_PTR(&mp_lv_obj_is_protected_obj) }, + { MP_ROM_QSTR(MP_QSTR_get_signal_func), MP_ROM_PTR(&mp_lv_obj_get_signal_func_obj) }, + { MP_ROM_QSTR(MP_QSTR_get_design_func), MP_ROM_PTR(&mp_lv_obj_get_design_func_obj) }, + { MP_ROM_QSTR(MP_QSTR_get_ext_attr), MP_ROM_PTR(&mp_lv_obj_get_ext_attr_obj) }, + { MP_ROM_QSTR(MP_QSTR_get_free_num), MP_ROM_PTR(&mp_lv_obj_get_free_num_obj) }, + { MP_ROM_QSTR(MP_QSTR_get_free_ptr), MP_ROM_PTR(&mp_lv_obj_get_free_ptr_obj) }, + { MP_ROM_QSTR(MP_QSTR_get_group), MP_ROM_PTR(&mp_lv_obj_get_group_obj) }, + { MP_ROM_QSTR(MP_QSTR_is_focused), MP_ROM_PTR(&mp_lv_obj_is_focused_obj) }, + { MP_ROM_QSTR(MP_QSTR_STYLE), MP_ROM_PTR(&mp_LV_SW_STYLE_type) } +}; + +STATIC MP_DEFINE_CONST_DICT(sw_locals_dict, sw_locals_dict_table); + +STATIC void sw_print(const mp_print_t *print, + mp_obj_t self_in, + mp_print_kind_t kind) +{ + mp_printf(print, "lvgl sw"); +} + + +STATIC mp_obj_t sw_make_new( + const mp_obj_type_t *type, + size_t n_args, + size_t n_kw, + const mp_obj_t *args) +{ + return make_new(&lv_sw_create, type, n_args, n_kw, args); +} + + +STATIC const mp_obj_type_t mp_sw_type = { + { &mp_type_type }, + .name = MP_QSTR_sw, + .print = sw_print, + .make_new = sw_make_new, + .locals_dict = (mp_obj_dict_t*)&sw_locals_dict, +}; + + +/* + * lvgl extension definition for: + * void lv_arc_set_angles(lv_obj_t *arc, uint16_t start, uint16_t end) + */ + +STATIC mp_obj_t mp_lv_arc_set_angles(size_t n_args, const mp_obj_t *args) +{ + lv_obj_t *arc = mp_to_lv(args[0]); + uint16_t start = (uint16_t)mp_obj_get_int(args[1]); + uint16_t end = (uint16_t)mp_obj_get_int(args[2]); + lv_arc_set_angles(arc, start, end); + return mp_const_none; +} + +STATIC MP_DEFINE_CONST_FUN_OBJ_VAR_BETWEEN(mp_lv_arc_set_angles_obj, 3, 3, mp_lv_arc_set_angles); + + + +/* + * lvgl extension definition for: + * void lv_arc_set_style(lv_obj_t *arc, lv_arc_style_t type, lv_style_t *style) + */ + +STATIC mp_obj_t mp_lv_arc_set_style(size_t n_args, const mp_obj_t *args) +{ + lv_obj_t *arc = mp_to_lv(args[0]); + lv_arc_style_t type = (uint8_t)mp_obj_get_int(args[1]); + lv_style_t *style = mp_write_ptr_lv_style_t(args[2]); + lv_arc_set_style(arc, type, style); + return mp_const_none; +} + +STATIC MP_DEFINE_CONST_FUN_OBJ_VAR_BETWEEN(mp_lv_arc_set_style_obj, 3, 3, mp_lv_arc_set_style); + + + +/* + * lvgl extension definition for: + * uint16_t lv_arc_get_angle_start(lv_obj_t *arc) + */ + +STATIC mp_obj_t mp_lv_arc_get_angle_start(size_t n_args, const mp_obj_t *args) +{ + lv_obj_t *arc = mp_to_lv(args[0]); + uint16_t res = lv_arc_get_angle_start(arc); + return mp_obj_new_int_from_uint(res); +} + +STATIC MP_DEFINE_CONST_FUN_OBJ_VAR_BETWEEN(mp_lv_arc_get_angle_start_obj, 1, 1, mp_lv_arc_get_angle_start); + + + +/* + * lvgl extension definition for: + * uint16_t lv_arc_get_angle_end(lv_obj_t *arc) + */ + +STATIC mp_obj_t mp_lv_arc_get_angle_end(size_t n_args, const mp_obj_t *args) +{ + lv_obj_t *arc = mp_to_lv(args[0]); + uint16_t res = lv_arc_get_angle_end(arc); + return mp_obj_new_int_from_uint(res); +} + +STATIC MP_DEFINE_CONST_FUN_OBJ_VAR_BETWEEN(mp_lv_arc_get_angle_end_obj, 1, 1, mp_lv_arc_get_angle_end); + + + +/* + * lvgl extension definition for: + * lv_style_t *lv_arc_get_style(const lv_obj_t *arc, lv_arc_style_t type) + */ + +STATIC mp_obj_t mp_lv_arc_get_style(size_t n_args, const mp_obj_t *args) +{ + const lv_obj_t *arc = mp_to_lv(args[0]); + lv_arc_style_t type = (uint8_t)mp_obj_get_int(args[1]); + lv_style_t* res = lv_arc_get_style(arc, type); + return mp_read_ptr_lv_style_t((void*)res); +} + +STATIC MP_DEFINE_CONST_FUN_OBJ_VAR_BETWEEN(mp_lv_arc_get_style_obj, 2, 2, mp_lv_arc_get_style); + + + +/* + * lvgl arc object definitions + */ + + +STATIC const mp_rom_map_elem_t arc_locals_dict_table[] = { + { MP_ROM_QSTR(MP_QSTR_set_angles), MP_ROM_PTR(&mp_lv_arc_set_angles_obj) }, + { MP_ROM_QSTR(MP_QSTR_set_style), MP_ROM_PTR(&mp_lv_arc_set_style_obj) }, + { MP_ROM_QSTR(MP_QSTR_get_angle_start), MP_ROM_PTR(&mp_lv_arc_get_angle_start_obj) }, + { MP_ROM_QSTR(MP_QSTR_get_angle_end), MP_ROM_PTR(&mp_lv_arc_get_angle_end_obj) }, + { MP_ROM_QSTR(MP_QSTR_get_style), MP_ROM_PTR(&mp_lv_arc_get_style_obj) }, + { MP_ROM_QSTR(MP_QSTR_delete), MP_ROM_PTR(&mp_lv_obj_del_obj) }, + { MP_ROM_QSTR(MP_QSTR_clean), MP_ROM_PTR(&mp_lv_obj_clean_obj) }, + { MP_ROM_QSTR(MP_QSTR_invalidate), MP_ROM_PTR(&mp_lv_obj_invalidate_obj) }, + { MP_ROM_QSTR(MP_QSTR_set_parent), MP_ROM_PTR(&mp_lv_obj_set_parent_obj) }, + { MP_ROM_QSTR(MP_QSTR_set_pos), MP_ROM_PTR(&mp_lv_obj_set_pos_obj) }, + { MP_ROM_QSTR(MP_QSTR_set_x), MP_ROM_PTR(&mp_lv_obj_set_x_obj) }, + { MP_ROM_QSTR(MP_QSTR_set_y), MP_ROM_PTR(&mp_lv_obj_set_y_obj) }, + { MP_ROM_QSTR(MP_QSTR_set_size), MP_ROM_PTR(&mp_lv_obj_set_size_obj) }, + { MP_ROM_QSTR(MP_QSTR_set_width), MP_ROM_PTR(&mp_lv_obj_set_width_obj) }, + { MP_ROM_QSTR(MP_QSTR_set_height), MP_ROM_PTR(&mp_lv_obj_set_height_obj) }, + { MP_ROM_QSTR(MP_QSTR_align), MP_ROM_PTR(&mp_lv_obj_align_obj) }, + { MP_ROM_QSTR(MP_QSTR_align_origo), MP_ROM_PTR(&mp_lv_obj_align_origo_obj) }, + { MP_ROM_QSTR(MP_QSTR_realign), MP_ROM_PTR(&mp_lv_obj_realign_obj) }, + { MP_ROM_QSTR(MP_QSTR_set_auto_realign), MP_ROM_PTR(&mp_lv_obj_set_auto_realign_obj) }, + { MP_ROM_QSTR(MP_QSTR_set_style), MP_ROM_PTR(&mp_lv_obj_set_style_obj) }, + { MP_ROM_QSTR(MP_QSTR_refresh_style), MP_ROM_PTR(&mp_lv_obj_refresh_style_obj) }, + { MP_ROM_QSTR(MP_QSTR_report_style_mod), MP_ROM_PTR(&mp_lv_obj_report_style_mod_obj) }, + { MP_ROM_QSTR(MP_QSTR_set_hidden), MP_ROM_PTR(&mp_lv_obj_set_hidden_obj) }, + { MP_ROM_QSTR(MP_QSTR_set_click), MP_ROM_PTR(&mp_lv_obj_set_click_obj) }, + { MP_ROM_QSTR(MP_QSTR_set_top), MP_ROM_PTR(&mp_lv_obj_set_top_obj) }, + { MP_ROM_QSTR(MP_QSTR_set_drag), MP_ROM_PTR(&mp_lv_obj_set_drag_obj) }, + { MP_ROM_QSTR(MP_QSTR_set_drag_throw), MP_ROM_PTR(&mp_lv_obj_set_drag_throw_obj) }, + { MP_ROM_QSTR(MP_QSTR_set_drag_parent), MP_ROM_PTR(&mp_lv_obj_set_drag_parent_obj) }, + { MP_ROM_QSTR(MP_QSTR_set_opa_scale_enable), MP_ROM_PTR(&mp_lv_obj_set_opa_scale_enable_obj) }, + { MP_ROM_QSTR(MP_QSTR_set_opa_scale), MP_ROM_PTR(&mp_lv_obj_set_opa_scale_obj) }, + { MP_ROM_QSTR(MP_QSTR_set_protect), MP_ROM_PTR(&mp_lv_obj_set_protect_obj) }, + { MP_ROM_QSTR(MP_QSTR_clear_protect), MP_ROM_PTR(&mp_lv_obj_clear_protect_obj) }, + { MP_ROM_QSTR(MP_QSTR_set_signal_func), MP_ROM_PTR(&mp_lv_obj_set_signal_func_obj) }, + { MP_ROM_QSTR(MP_QSTR_set_design_func), MP_ROM_PTR(&mp_lv_obj_set_design_func_obj) }, + { MP_ROM_QSTR(MP_QSTR_allocate_ext_attr), MP_ROM_PTR(&mp_lv_obj_allocate_ext_attr_obj) }, + { MP_ROM_QSTR(MP_QSTR_refresh_ext_size), MP_ROM_PTR(&mp_lv_obj_refresh_ext_size_obj) }, + { MP_ROM_QSTR(MP_QSTR_set_free_num), MP_ROM_PTR(&mp_lv_obj_set_free_num_obj) }, + { MP_ROM_QSTR(MP_QSTR_set_free_ptr), MP_ROM_PTR(&mp_lv_obj_set_free_ptr_obj) }, + { MP_ROM_QSTR(MP_QSTR_animate), MP_ROM_PTR(&mp_lv_obj_animate_obj) }, + { MP_ROM_QSTR(MP_QSTR_get_screen), MP_ROM_PTR(&mp_lv_obj_get_screen_obj) }, + { MP_ROM_QSTR(MP_QSTR_get_parent), MP_ROM_PTR(&mp_lv_obj_get_parent_obj) }, + { MP_ROM_QSTR(MP_QSTR_get_child), MP_ROM_PTR(&mp_lv_obj_get_child_obj) }, + { MP_ROM_QSTR(MP_QSTR_get_child_back), MP_ROM_PTR(&mp_lv_obj_get_child_back_obj) }, + { MP_ROM_QSTR(MP_QSTR_count_children), MP_ROM_PTR(&mp_lv_obj_count_children_obj) }, + { MP_ROM_QSTR(MP_QSTR_get_coords), MP_ROM_PTR(&mp_lv_obj_get_coords_obj) }, + { MP_ROM_QSTR(MP_QSTR_get_x), MP_ROM_PTR(&mp_lv_obj_get_x_obj) }, + { MP_ROM_QSTR(MP_QSTR_get_y), MP_ROM_PTR(&mp_lv_obj_get_y_obj) }, + { MP_ROM_QSTR(MP_QSTR_get_width), MP_ROM_PTR(&mp_lv_obj_get_width_obj) }, + { MP_ROM_QSTR(MP_QSTR_get_height), MP_ROM_PTR(&mp_lv_obj_get_height_obj) }, + { MP_ROM_QSTR(MP_QSTR_get_ext_size), MP_ROM_PTR(&mp_lv_obj_get_ext_size_obj) }, + { MP_ROM_QSTR(MP_QSTR_get_auto_realign), MP_ROM_PTR(&mp_lv_obj_get_auto_realign_obj) }, + { MP_ROM_QSTR(MP_QSTR_get_style), MP_ROM_PTR(&mp_lv_obj_get_style_obj) }, + { MP_ROM_QSTR(MP_QSTR_get_hidden), MP_ROM_PTR(&mp_lv_obj_get_hidden_obj) }, + { MP_ROM_QSTR(MP_QSTR_get_click), MP_ROM_PTR(&mp_lv_obj_get_click_obj) }, + { MP_ROM_QSTR(MP_QSTR_get_top), MP_ROM_PTR(&mp_lv_obj_get_top_obj) }, + { MP_ROM_QSTR(MP_QSTR_get_drag), MP_ROM_PTR(&mp_lv_obj_get_drag_obj) }, + { MP_ROM_QSTR(MP_QSTR_get_drag_throw), MP_ROM_PTR(&mp_lv_obj_get_drag_throw_obj) }, + { MP_ROM_QSTR(MP_QSTR_get_drag_parent), MP_ROM_PTR(&mp_lv_obj_get_drag_parent_obj) }, + { MP_ROM_QSTR(MP_QSTR_get_opa_scale_enable), MP_ROM_PTR(&mp_lv_obj_get_opa_scale_enable_obj) }, + { MP_ROM_QSTR(MP_QSTR_get_opa_scale), MP_ROM_PTR(&mp_lv_obj_get_opa_scale_obj) }, + { MP_ROM_QSTR(MP_QSTR_get_protect), MP_ROM_PTR(&mp_lv_obj_get_protect_obj) }, + { MP_ROM_QSTR(MP_QSTR_is_protected), MP_ROM_PTR(&mp_lv_obj_is_protected_obj) }, + { MP_ROM_QSTR(MP_QSTR_get_signal_func), MP_ROM_PTR(&mp_lv_obj_get_signal_func_obj) }, + { MP_ROM_QSTR(MP_QSTR_get_design_func), MP_ROM_PTR(&mp_lv_obj_get_design_func_obj) }, + { MP_ROM_QSTR(MP_QSTR_get_ext_attr), MP_ROM_PTR(&mp_lv_obj_get_ext_attr_obj) }, + { MP_ROM_QSTR(MP_QSTR_get_free_num), MP_ROM_PTR(&mp_lv_obj_get_free_num_obj) }, + { MP_ROM_QSTR(MP_QSTR_get_free_ptr), MP_ROM_PTR(&mp_lv_obj_get_free_ptr_obj) }, + { MP_ROM_QSTR(MP_QSTR_get_group), MP_ROM_PTR(&mp_lv_obj_get_group_obj) }, + { MP_ROM_QSTR(MP_QSTR_is_focused), MP_ROM_PTR(&mp_lv_obj_is_focused_obj) }, + { MP_ROM_QSTR(MP_QSTR_STYLE), MP_ROM_PTR(&mp_LV_ARC_STYLE_type) } +}; + +STATIC MP_DEFINE_CONST_DICT(arc_locals_dict, arc_locals_dict_table); + +STATIC void arc_print(const mp_print_t *print, + mp_obj_t self_in, + mp_print_kind_t kind) +{ + mp_printf(print, "lvgl arc"); +} + + +STATIC mp_obj_t arc_make_new( + const mp_obj_type_t *type, + size_t n_args, + size_t n_kw, + const mp_obj_t *args) +{ + return make_new(&lv_arc_create, type, n_args, n_kw, args); +} + + +STATIC const mp_obj_type_t mp_arc_type = { + { &mp_type_type }, + .name = MP_QSTR_arc, + .print = arc_print, + .make_new = arc_make_new, + .locals_dict = (mp_obj_dict_t*)&arc_locals_dict, +}; + + +/* + * lvgl extension definition for: + * void lv_preload_set_arc_length(lv_obj_t *preload, uint16_t deg) + */ + +STATIC mp_obj_t mp_lv_preload_set_arc_length(size_t n_args, const mp_obj_t *args) +{ + lv_obj_t *preload = mp_to_lv(args[0]); + uint16_t deg = (uint16_t)mp_obj_get_int(args[1]); + lv_preload_set_arc_length(preload, deg); + return mp_const_none; +} + +STATIC MP_DEFINE_CONST_FUN_OBJ_VAR_BETWEEN(mp_lv_preload_set_arc_length_obj, 2, 2, mp_lv_preload_set_arc_length); + + + +/* + * lvgl extension definition for: + * void lv_preload_set_spin_time(lv_obj_t *preload, uint16_t time) + */ + +STATIC mp_obj_t mp_lv_preload_set_spin_time(size_t n_args, const mp_obj_t *args) +{ + lv_obj_t *preload = mp_to_lv(args[0]); + uint16_t time = (uint16_t)mp_obj_get_int(args[1]); + lv_preload_set_spin_time(preload, time); + return mp_const_none; +} + +STATIC MP_DEFINE_CONST_FUN_OBJ_VAR_BETWEEN(mp_lv_preload_set_spin_time_obj, 2, 2, mp_lv_preload_set_spin_time); + + + +/* + * lvgl extension definition for: + * void lv_preload_set_style(lv_obj_t *preload, lv_preload_style_t type, lv_style_t *style) + */ + +STATIC mp_obj_t mp_lv_preload_set_style(size_t n_args, const mp_obj_t *args) +{ + lv_obj_t *preload = mp_to_lv(args[0]); + lv_preload_style_t type = (uint8_t)mp_obj_get_int(args[1]); + lv_style_t *style = mp_write_ptr_lv_style_t(args[2]); + lv_preload_set_style(preload, type, style); + return mp_const_none; +} + +STATIC MP_DEFINE_CONST_FUN_OBJ_VAR_BETWEEN(mp_lv_preload_set_style_obj, 3, 3, mp_lv_preload_set_style); + + + +/* + * lvgl extension definition for: + * void lv_preload_set_animation_type(lv_obj_t *preload, lv_preloader_type_t type) + */ + +STATIC mp_obj_t mp_lv_preload_set_animation_type(size_t n_args, const mp_obj_t *args) +{ + lv_obj_t *preload = mp_to_lv(args[0]); + lv_preloader_type_t type = (uint8_t)mp_obj_get_int(args[1]); + lv_preload_set_animation_type(preload, type); + return mp_const_none; +} + +STATIC MP_DEFINE_CONST_FUN_OBJ_VAR_BETWEEN(mp_lv_preload_set_animation_type_obj, 2, 2, mp_lv_preload_set_animation_type); + + + +/* + * lvgl extension definition for: + * uint16_t lv_preload_get_arc_length(const lv_obj_t *preload) + */ + +STATIC mp_obj_t mp_lv_preload_get_arc_length(size_t n_args, const mp_obj_t *args) +{ + const lv_obj_t *preload = mp_to_lv(args[0]); + uint16_t res = lv_preload_get_arc_length(preload); + return mp_obj_new_int_from_uint(res); +} + +STATIC MP_DEFINE_CONST_FUN_OBJ_VAR_BETWEEN(mp_lv_preload_get_arc_length_obj, 1, 1, mp_lv_preload_get_arc_length); + + + +/* + * lvgl extension definition for: + * uint16_t lv_preload_get_spin_time(const lv_obj_t *preload) + */ + +STATIC mp_obj_t mp_lv_preload_get_spin_time(size_t n_args, const mp_obj_t *args) +{ + const lv_obj_t *preload = mp_to_lv(args[0]); + uint16_t res = lv_preload_get_spin_time(preload); + return mp_obj_new_int_from_uint(res); +} + +STATIC MP_DEFINE_CONST_FUN_OBJ_VAR_BETWEEN(mp_lv_preload_get_spin_time_obj, 1, 1, mp_lv_preload_get_spin_time); + + + +/* + * lvgl extension definition for: + * lv_style_t *lv_preload_get_style(const lv_obj_t *preload, lv_preload_style_t type) + */ + +STATIC mp_obj_t mp_lv_preload_get_style(size_t n_args, const mp_obj_t *args) +{ + const lv_obj_t *preload = mp_to_lv(args[0]); + lv_preload_style_t type = (uint8_t)mp_obj_get_int(args[1]); + lv_style_t* res = lv_preload_get_style(preload, type); + return mp_read_ptr_lv_style_t((void*)res); +} + +STATIC MP_DEFINE_CONST_FUN_OBJ_VAR_BETWEEN(mp_lv_preload_get_style_obj, 2, 2, mp_lv_preload_get_style); + + + +/* + * lvgl extension definition for: + * lv_preloader_type_t lv_preload_get_animation_type(lv_obj_t *preload) + */ + +STATIC mp_obj_t mp_lv_preload_get_animation_type(size_t n_args, const mp_obj_t *args) +{ + lv_obj_t *preload = mp_to_lv(args[0]); + lv_preloader_type_t res = lv_preload_get_animation_type(preload); + return mp_obj_new_int_from_uint(res); +} + +STATIC MP_DEFINE_CONST_FUN_OBJ_VAR_BETWEEN(mp_lv_preload_get_animation_type_obj, 1, 1, mp_lv_preload_get_animation_type); + + + +/* + * lvgl extension definition for: + * void lv_preload_spinner_animation(void *ptr, int32_t val) + */ + +STATIC mp_obj_t mp_lv_preload_spinner_animation(size_t n_args, const mp_obj_t *args) +{ + void *ptr = mp_to_ptr(args[0]); + int32_t val = (int32_t)mp_obj_get_int(args[1]); + lv_preload_spinner_animation(ptr, val); + return mp_const_none; +} + +STATIC MP_DEFINE_CONST_FUN_OBJ_VAR_BETWEEN(mp_lv_preload_spinner_animation_obj, 2, 2, mp_lv_preload_spinner_animation); + + + +/* + * lvgl preload object definitions + */ + + +STATIC const mp_rom_map_elem_t preload_locals_dict_table[] = { + { MP_ROM_QSTR(MP_QSTR_set_arc_length), MP_ROM_PTR(&mp_lv_preload_set_arc_length_obj) }, + { MP_ROM_QSTR(MP_QSTR_set_spin_time), MP_ROM_PTR(&mp_lv_preload_set_spin_time_obj) }, + { MP_ROM_QSTR(MP_QSTR_set_style), MP_ROM_PTR(&mp_lv_preload_set_style_obj) }, + { MP_ROM_QSTR(MP_QSTR_set_animation_type), MP_ROM_PTR(&mp_lv_preload_set_animation_type_obj) }, + { MP_ROM_QSTR(MP_QSTR_get_arc_length), MP_ROM_PTR(&mp_lv_preload_get_arc_length_obj) }, + { MP_ROM_QSTR(MP_QSTR_get_spin_time), MP_ROM_PTR(&mp_lv_preload_get_spin_time_obj) }, + { MP_ROM_QSTR(MP_QSTR_get_style), MP_ROM_PTR(&mp_lv_preload_get_style_obj) }, + { MP_ROM_QSTR(MP_QSTR_get_animation_type), MP_ROM_PTR(&mp_lv_preload_get_animation_type_obj) }, + { MP_ROM_QSTR(MP_QSTR_spinner_animation), MP_ROM_PTR(&mp_lv_preload_spinner_animation_obj) }, + { MP_ROM_QSTR(MP_QSTR_delete), MP_ROM_PTR(&mp_lv_obj_del_obj) }, + { MP_ROM_QSTR(MP_QSTR_clean), MP_ROM_PTR(&mp_lv_obj_clean_obj) }, + { MP_ROM_QSTR(MP_QSTR_invalidate), MP_ROM_PTR(&mp_lv_obj_invalidate_obj) }, + { MP_ROM_QSTR(MP_QSTR_set_parent), MP_ROM_PTR(&mp_lv_obj_set_parent_obj) }, + { MP_ROM_QSTR(MP_QSTR_set_pos), MP_ROM_PTR(&mp_lv_obj_set_pos_obj) }, + { MP_ROM_QSTR(MP_QSTR_set_x), MP_ROM_PTR(&mp_lv_obj_set_x_obj) }, + { MP_ROM_QSTR(MP_QSTR_set_y), MP_ROM_PTR(&mp_lv_obj_set_y_obj) }, + { MP_ROM_QSTR(MP_QSTR_set_size), MP_ROM_PTR(&mp_lv_obj_set_size_obj) }, + { MP_ROM_QSTR(MP_QSTR_set_width), MP_ROM_PTR(&mp_lv_obj_set_width_obj) }, + { MP_ROM_QSTR(MP_QSTR_set_height), MP_ROM_PTR(&mp_lv_obj_set_height_obj) }, + { MP_ROM_QSTR(MP_QSTR_align), MP_ROM_PTR(&mp_lv_obj_align_obj) }, + { MP_ROM_QSTR(MP_QSTR_align_origo), MP_ROM_PTR(&mp_lv_obj_align_origo_obj) }, + { MP_ROM_QSTR(MP_QSTR_realign), MP_ROM_PTR(&mp_lv_obj_realign_obj) }, + { MP_ROM_QSTR(MP_QSTR_set_auto_realign), MP_ROM_PTR(&mp_lv_obj_set_auto_realign_obj) }, + { MP_ROM_QSTR(MP_QSTR_set_style), MP_ROM_PTR(&mp_lv_obj_set_style_obj) }, + { MP_ROM_QSTR(MP_QSTR_refresh_style), MP_ROM_PTR(&mp_lv_obj_refresh_style_obj) }, + { MP_ROM_QSTR(MP_QSTR_report_style_mod), MP_ROM_PTR(&mp_lv_obj_report_style_mod_obj) }, + { MP_ROM_QSTR(MP_QSTR_set_hidden), MP_ROM_PTR(&mp_lv_obj_set_hidden_obj) }, + { MP_ROM_QSTR(MP_QSTR_set_click), MP_ROM_PTR(&mp_lv_obj_set_click_obj) }, + { MP_ROM_QSTR(MP_QSTR_set_top), MP_ROM_PTR(&mp_lv_obj_set_top_obj) }, + { MP_ROM_QSTR(MP_QSTR_set_drag), MP_ROM_PTR(&mp_lv_obj_set_drag_obj) }, + { MP_ROM_QSTR(MP_QSTR_set_drag_throw), MP_ROM_PTR(&mp_lv_obj_set_drag_throw_obj) }, + { MP_ROM_QSTR(MP_QSTR_set_drag_parent), MP_ROM_PTR(&mp_lv_obj_set_drag_parent_obj) }, + { MP_ROM_QSTR(MP_QSTR_set_opa_scale_enable), MP_ROM_PTR(&mp_lv_obj_set_opa_scale_enable_obj) }, + { MP_ROM_QSTR(MP_QSTR_set_opa_scale), MP_ROM_PTR(&mp_lv_obj_set_opa_scale_obj) }, + { MP_ROM_QSTR(MP_QSTR_set_protect), MP_ROM_PTR(&mp_lv_obj_set_protect_obj) }, + { MP_ROM_QSTR(MP_QSTR_clear_protect), MP_ROM_PTR(&mp_lv_obj_clear_protect_obj) }, + { MP_ROM_QSTR(MP_QSTR_set_signal_func), MP_ROM_PTR(&mp_lv_obj_set_signal_func_obj) }, + { MP_ROM_QSTR(MP_QSTR_set_design_func), MP_ROM_PTR(&mp_lv_obj_set_design_func_obj) }, + { MP_ROM_QSTR(MP_QSTR_allocate_ext_attr), MP_ROM_PTR(&mp_lv_obj_allocate_ext_attr_obj) }, + { MP_ROM_QSTR(MP_QSTR_refresh_ext_size), MP_ROM_PTR(&mp_lv_obj_refresh_ext_size_obj) }, + { MP_ROM_QSTR(MP_QSTR_set_free_num), MP_ROM_PTR(&mp_lv_obj_set_free_num_obj) }, + { MP_ROM_QSTR(MP_QSTR_set_free_ptr), MP_ROM_PTR(&mp_lv_obj_set_free_ptr_obj) }, + { MP_ROM_QSTR(MP_QSTR_animate), MP_ROM_PTR(&mp_lv_obj_animate_obj) }, + { MP_ROM_QSTR(MP_QSTR_get_screen), MP_ROM_PTR(&mp_lv_obj_get_screen_obj) }, + { MP_ROM_QSTR(MP_QSTR_get_parent), MP_ROM_PTR(&mp_lv_obj_get_parent_obj) }, + { MP_ROM_QSTR(MP_QSTR_get_child), MP_ROM_PTR(&mp_lv_obj_get_child_obj) }, + { MP_ROM_QSTR(MP_QSTR_get_child_back), MP_ROM_PTR(&mp_lv_obj_get_child_back_obj) }, + { MP_ROM_QSTR(MP_QSTR_count_children), MP_ROM_PTR(&mp_lv_obj_count_children_obj) }, + { MP_ROM_QSTR(MP_QSTR_get_coords), MP_ROM_PTR(&mp_lv_obj_get_coords_obj) }, + { MP_ROM_QSTR(MP_QSTR_get_x), MP_ROM_PTR(&mp_lv_obj_get_x_obj) }, + { MP_ROM_QSTR(MP_QSTR_get_y), MP_ROM_PTR(&mp_lv_obj_get_y_obj) }, + { MP_ROM_QSTR(MP_QSTR_get_width), MP_ROM_PTR(&mp_lv_obj_get_width_obj) }, + { MP_ROM_QSTR(MP_QSTR_get_height), MP_ROM_PTR(&mp_lv_obj_get_height_obj) }, + { MP_ROM_QSTR(MP_QSTR_get_ext_size), MP_ROM_PTR(&mp_lv_obj_get_ext_size_obj) }, + { MP_ROM_QSTR(MP_QSTR_get_auto_realign), MP_ROM_PTR(&mp_lv_obj_get_auto_realign_obj) }, + { MP_ROM_QSTR(MP_QSTR_get_style), MP_ROM_PTR(&mp_lv_obj_get_style_obj) }, + { MP_ROM_QSTR(MP_QSTR_get_hidden), MP_ROM_PTR(&mp_lv_obj_get_hidden_obj) }, + { MP_ROM_QSTR(MP_QSTR_get_click), MP_ROM_PTR(&mp_lv_obj_get_click_obj) }, + { MP_ROM_QSTR(MP_QSTR_get_top), MP_ROM_PTR(&mp_lv_obj_get_top_obj) }, + { MP_ROM_QSTR(MP_QSTR_get_drag), MP_ROM_PTR(&mp_lv_obj_get_drag_obj) }, + { MP_ROM_QSTR(MP_QSTR_get_drag_throw), MP_ROM_PTR(&mp_lv_obj_get_drag_throw_obj) }, + { MP_ROM_QSTR(MP_QSTR_get_drag_parent), MP_ROM_PTR(&mp_lv_obj_get_drag_parent_obj) }, + { MP_ROM_QSTR(MP_QSTR_get_opa_scale_enable), MP_ROM_PTR(&mp_lv_obj_get_opa_scale_enable_obj) }, + { MP_ROM_QSTR(MP_QSTR_get_opa_scale), MP_ROM_PTR(&mp_lv_obj_get_opa_scale_obj) }, + { MP_ROM_QSTR(MP_QSTR_get_protect), MP_ROM_PTR(&mp_lv_obj_get_protect_obj) }, + { MP_ROM_QSTR(MP_QSTR_is_protected), MP_ROM_PTR(&mp_lv_obj_is_protected_obj) }, + { MP_ROM_QSTR(MP_QSTR_get_signal_func), MP_ROM_PTR(&mp_lv_obj_get_signal_func_obj) }, + { MP_ROM_QSTR(MP_QSTR_get_design_func), MP_ROM_PTR(&mp_lv_obj_get_design_func_obj) }, + { MP_ROM_QSTR(MP_QSTR_get_ext_attr), MP_ROM_PTR(&mp_lv_obj_get_ext_attr_obj) }, + { MP_ROM_QSTR(MP_QSTR_get_free_num), MP_ROM_PTR(&mp_lv_obj_get_free_num_obj) }, + { MP_ROM_QSTR(MP_QSTR_get_free_ptr), MP_ROM_PTR(&mp_lv_obj_get_free_ptr_obj) }, + { MP_ROM_QSTR(MP_QSTR_get_group), MP_ROM_PTR(&mp_lv_obj_get_group_obj) }, + { MP_ROM_QSTR(MP_QSTR_is_focused), MP_ROM_PTR(&mp_lv_obj_is_focused_obj) }, + { MP_ROM_QSTR(MP_QSTR_TYPE), MP_ROM_PTR(&mp_LV_PRELOAD_TYPE_type) }, + { MP_ROM_QSTR(MP_QSTR_STYLE), MP_ROM_PTR(&mp_LV_PRELOAD_STYLE_type) } +}; + +STATIC MP_DEFINE_CONST_DICT(preload_locals_dict, preload_locals_dict_table); + +STATIC void preload_print(const mp_print_t *print, + mp_obj_t self_in, + mp_print_kind_t kind) +{ + mp_printf(print, "lvgl preload"); +} + + +STATIC mp_obj_t preload_make_new( + const mp_obj_type_t *type, + size_t n_args, + size_t n_kw, + const mp_obj_t *args) +{ + return make_new(&lv_preload_create, type, n_args, n_kw, args); +} + + +STATIC const mp_obj_type_t mp_preload_type = { + { &mp_type_type }, + .name = MP_QSTR_preload, + .print = preload_print, + .make_new = preload_make_new, + .locals_dict = (mp_obj_dict_t*)&preload_locals_dict, +}; + + +/* + * lvgl extension definition for: + * void lv_calendar_set_action(lv_obj_t *calendar, lv_calendar_action_t type, lv_action_t action) + */ + +STATIC mp_obj_t mp_lv_calendar_set_action(size_t n_args, const mp_obj_t *args) +{ + lv_obj_t *calendar = mp_to_lv(args[0]); + lv_calendar_action_t type = (uint8_t)mp_obj_get_int(args[1]); + set_action(args[0], args[2]); + lv_action_t action = &lv_action_t_callback; + lv_calendar_set_action(calendar, type, action); + return mp_const_none; +} + +STATIC MP_DEFINE_CONST_FUN_OBJ_VAR_BETWEEN(mp_lv_calendar_set_action_obj, 3, 3, mp_lv_calendar_set_action); + + + +/* + * Struct lv_calendar_date_t + */ + +STATIC inline const mp_obj_type_t *get_mp_lv_calendar_date_t_type(); + +STATIC inline lv_calendar_date_t* mp_write_ptr_lv_calendar_date_t(mp_obj_t self_in) +{ + mp_lv_struct_t *self = MP_OBJ_TO_PTR(cast(self_in, get_mp_lv_calendar_date_t_type())); + return (lv_calendar_date_t*)self->data; +} + +#define mp_write_lv_calendar_date_t(struct_obj) *mp_write_ptr_lv_calendar_date_t(struct_obj) + +STATIC inline mp_obj_t mp_read_ptr_lv_calendar_date_t(lv_calendar_date_t *field) +{ + return lv_to_mp_struct(get_mp_lv_calendar_date_t_type(), field); +} + +#define mp_read_lv_calendar_date_t(field) mp_read_ptr_lv_calendar_date_t(copy_buffer(&field, sizeof(lv_calendar_date_t))) +#define mp_read_byref_lv_calendar_date_t(field) mp_read_ptr_lv_calendar_date_t(&field) + +STATIC void mp_lv_calendar_date_t_attr(mp_obj_t self_in, qstr attr, mp_obj_t *dest) +{ + mp_lv_struct_t *self = MP_OBJ_TO_PTR(self_in); + lv_calendar_date_t *data = (lv_calendar_date_t*)self->data; + + if (dest[0] == MP_OBJ_NULL) { + // load attribute + switch(attr) + { + case MP_QSTR_year: dest[0] = mp_obj_new_int_from_uint(data->year); break; // converting from uint16_t; + case MP_QSTR_month: dest[0] = mp_obj_new_int(data->month); break; // converting from int8_t; + case MP_QSTR_day: dest[0] = mp_obj_new_int(data->day); break; // converting from int8_t; + default: field_not_found(MP_QSTR_lv_calendar_date_t, attr); + } + } else { + if (dest[1]) + { + // store attribute + switch(attr) + { + case MP_QSTR_year: data->year = (uint16_t)mp_obj_get_int(dest[1]); break; // converting to uint16_t; + case MP_QSTR_month: data->month = (int8_t)mp_obj_get_int(dest[1]); break; // converting to int8_t; + case MP_QSTR_day: data->day = (int8_t)mp_obj_get_int(dest[1]); break; // converting to int8_t; + default: field_not_found(MP_QSTR_lv_calendar_date_t, attr); + } + + dest[0] = MP_OBJ_NULL; // indicate success + } + } +} + +STATIC void mp_lv_calendar_date_t_print(const mp_print_t *print, + mp_obj_t self_in, + mp_print_kind_t kind) +{ + mp_printf(print, "lvgl struct lv_calendar_date_t"); +} + +STATIC const mp_rom_map_elem_t mp_lv_calendar_date_t_locals_dict_table[] = { + { MP_ROM_QSTR(MP_QSTR_SIZE), MP_ROM_PTR(MP_ROM_INT(sizeof(lv_calendar_date_t))) }, + { MP_ROM_QSTR(MP_QSTR_cast), MP_ROM_PTR(&mp_lv_cast_class_method) }, +}; + +STATIC MP_DEFINE_CONST_DICT(mp_lv_calendar_date_t_locals_dict, mp_lv_calendar_date_t_locals_dict_table); + +STATIC const mp_obj_type_t mp_lv_calendar_date_t_type = { + { &mp_type_type }, + .name = MP_QSTR_lv_calendar_date_t, + .print = mp_lv_calendar_date_t_print, + .make_new = make_new_lv_struct, + .attr = mp_lv_calendar_date_t_attr, + .locals_dict = (mp_obj_dict_t*)&mp_lv_calendar_date_t_locals_dict, + .buffer_p = { .get_buffer = mp_blob_get_buffer } +}; + +STATIC inline const mp_obj_type_t *get_mp_lv_calendar_date_t_type() +{ + return &mp_lv_calendar_date_t_type; +} + + +/* + * lvgl extension definition for: + * void lv_calendar_set_today_date(lv_obj_t *calendar, lv_calendar_date_t *today) + */ + +STATIC mp_obj_t mp_lv_calendar_set_today_date(size_t n_args, const mp_obj_t *args) +{ + lv_obj_t *calendar = mp_to_lv(args[0]); + lv_calendar_date_t *today = mp_write_ptr_lv_calendar_date_t(args[1]); + lv_calendar_set_today_date(calendar, today); + return mp_const_none; +} + +STATIC MP_DEFINE_CONST_FUN_OBJ_VAR_BETWEEN(mp_lv_calendar_set_today_date_obj, 2, 2, mp_lv_calendar_set_today_date); + + + +/* + * lvgl extension definition for: + * void lv_calendar_set_showed_date(lv_obj_t *calendar, lv_calendar_date_t *showed) + */ + +STATIC mp_obj_t mp_lv_calendar_set_showed_date(size_t n_args, const mp_obj_t *args) +{ + lv_obj_t *calendar = mp_to_lv(args[0]); + lv_calendar_date_t *showed = mp_write_ptr_lv_calendar_date_t(args[1]); + lv_calendar_set_showed_date(calendar, showed); + return mp_const_none; +} + +STATIC MP_DEFINE_CONST_FUN_OBJ_VAR_BETWEEN(mp_lv_calendar_set_showed_date_obj, 2, 2, mp_lv_calendar_set_showed_date); + + + +/* + * lvgl extension definition for: + * void lv_calendar_set_highlighted_dates(lv_obj_t *calendar, lv_calendar_date_t *highlighted, uint16_t date_num) + */ + +STATIC mp_obj_t mp_lv_calendar_set_highlighted_dates(size_t n_args, const mp_obj_t *args) +{ + lv_obj_t *calendar = mp_to_lv(args[0]); + lv_calendar_date_t *highlighted = mp_write_ptr_lv_calendar_date_t(args[1]); + uint16_t date_num = (uint16_t)mp_obj_get_int(args[2]); + lv_calendar_set_highlighted_dates(calendar, highlighted, date_num); + return mp_const_none; +} + +STATIC MP_DEFINE_CONST_FUN_OBJ_VAR_BETWEEN(mp_lv_calendar_set_highlighted_dates_obj, 3, 3, mp_lv_calendar_set_highlighted_dates); + + + +/* + * lvgl extension definition for: + * void lv_calendar_set_day_names(lv_obj_t *calendar, const char **day_names) + */ + +STATIC mp_obj_t mp_lv_calendar_set_day_names(size_t n_args, const mp_obj_t *args) +{ + lv_obj_t *calendar = mp_to_lv(args[0]); + const char **day_names = mp_to_ptr(args[1]); + lv_calendar_set_day_names(calendar, day_names); + return mp_const_none; +} + +STATIC MP_DEFINE_CONST_FUN_OBJ_VAR_BETWEEN(mp_lv_calendar_set_day_names_obj, 2, 2, mp_lv_calendar_set_day_names); + + + +/* + * lvgl extension definition for: + * void lv_calendar_set_month_names(lv_obj_t *calendar, const char **day_names) + */ + +STATIC mp_obj_t mp_lv_calendar_set_month_names(size_t n_args, const mp_obj_t *args) +{ + lv_obj_t *calendar = mp_to_lv(args[0]); + const char **day_names = mp_to_ptr(args[1]); + lv_calendar_set_month_names(calendar, day_names); + return mp_const_none; +} + +STATIC MP_DEFINE_CONST_FUN_OBJ_VAR_BETWEEN(mp_lv_calendar_set_month_names_obj, 2, 2, mp_lv_calendar_set_month_names); + + + +/* + * lvgl extension definition for: + * void lv_calendar_set_style(lv_obj_t *calendar, lv_calendar_style_t type, lv_style_t *style) + */ + +STATIC mp_obj_t mp_lv_calendar_set_style(size_t n_args, const mp_obj_t *args) +{ + lv_obj_t *calendar = mp_to_lv(args[0]); + lv_calendar_style_t type = (uint8_t)mp_obj_get_int(args[1]); + lv_style_t *style = mp_write_ptr_lv_style_t(args[2]); + lv_calendar_set_style(calendar, type, style); + return mp_const_none; +} + +STATIC MP_DEFINE_CONST_FUN_OBJ_VAR_BETWEEN(mp_lv_calendar_set_style_obj, 3, 3, mp_lv_calendar_set_style); + + + +/* + * lvgl extension definition for: + * lv_action_t lv_calendar_get_action(const lv_obj_t *calendar, lv_calendar_action_t type) + */ + +STATIC mp_obj_t mp_lv_calendar_get_action(size_t n_args, const mp_obj_t *args) +{ + const lv_obj_t *calendar = mp_to_lv(args[0]); + lv_calendar_action_t type = (uint8_t)mp_obj_get_int(args[1]); + lv_action_t res = lv_calendar_get_action(calendar, type); + return ptr_to_mp(res); +} + +STATIC MP_DEFINE_CONST_FUN_OBJ_VAR_BETWEEN(mp_lv_calendar_get_action_obj, 2, 2, mp_lv_calendar_get_action); + + + +/* + * lvgl extension definition for: + * lv_calendar_date_t *lv_calendar_get_today_date(const lv_obj_t *calendar) + */ + +STATIC mp_obj_t mp_lv_calendar_get_today_date(size_t n_args, const mp_obj_t *args) +{ + const lv_obj_t *calendar = mp_to_lv(args[0]); + lv_calendar_date_t* res = lv_calendar_get_today_date(calendar); + return mp_read_ptr_lv_calendar_date_t((void*)res); +} + +STATIC MP_DEFINE_CONST_FUN_OBJ_VAR_BETWEEN(mp_lv_calendar_get_today_date_obj, 1, 1, mp_lv_calendar_get_today_date); + + + +/* + * lvgl extension definition for: + * lv_calendar_date_t *lv_calendar_get_showed_date(const lv_obj_t *calendar) + */ + +STATIC mp_obj_t mp_lv_calendar_get_showed_date(size_t n_args, const mp_obj_t *args) +{ + const lv_obj_t *calendar = mp_to_lv(args[0]); + lv_calendar_date_t* res = lv_calendar_get_showed_date(calendar); + return mp_read_ptr_lv_calendar_date_t((void*)res); +} + +STATIC MP_DEFINE_CONST_FUN_OBJ_VAR_BETWEEN(mp_lv_calendar_get_showed_date_obj, 1, 1, mp_lv_calendar_get_showed_date); + + + +/* + * lvgl extension definition for: + * lv_calendar_date_t *lv_calendar_get_pressed_date(const lv_obj_t *calendar) + */ + +STATIC mp_obj_t mp_lv_calendar_get_pressed_date(size_t n_args, const mp_obj_t *args) +{ + const lv_obj_t *calendar = mp_to_lv(args[0]); + lv_calendar_date_t* res = lv_calendar_get_pressed_date(calendar); + return mp_read_ptr_lv_calendar_date_t((void*)res); +} + +STATIC MP_DEFINE_CONST_FUN_OBJ_VAR_BETWEEN(mp_lv_calendar_get_pressed_date_obj, 1, 1, mp_lv_calendar_get_pressed_date); + + + +/* + * lvgl extension definition for: + * lv_calendar_date_t *lv_calendar_get_highlighted_dates(const lv_obj_t *calendar) + */ + +STATIC mp_obj_t mp_lv_calendar_get_highlighted_dates(size_t n_args, const mp_obj_t *args) +{ + const lv_obj_t *calendar = mp_to_lv(args[0]); + lv_calendar_date_t* res = lv_calendar_get_highlighted_dates(calendar); + return mp_read_ptr_lv_calendar_date_t((void*)res); +} + +STATIC MP_DEFINE_CONST_FUN_OBJ_VAR_BETWEEN(mp_lv_calendar_get_highlighted_dates_obj, 1, 1, mp_lv_calendar_get_highlighted_dates); + + + +/* + * lvgl extension definition for: + * uint16_t lv_calendar_get_highlighted_dates_num(const lv_obj_t *calendar) + */ + +STATIC mp_obj_t mp_lv_calendar_get_highlighted_dates_num(size_t n_args, const mp_obj_t *args) +{ + const lv_obj_t *calendar = mp_to_lv(args[0]); + uint16_t res = lv_calendar_get_highlighted_dates_num(calendar); + return mp_obj_new_int_from_uint(res); +} + +STATIC MP_DEFINE_CONST_FUN_OBJ_VAR_BETWEEN(mp_lv_calendar_get_highlighted_dates_num_obj, 1, 1, mp_lv_calendar_get_highlighted_dates_num); + + + +/* + * lvgl extension definition for: + * const char **lv_calendar_get_day_names(const lv_obj_t *calendar) + */ + +STATIC mp_obj_t mp_lv_calendar_get_day_names(size_t n_args, const mp_obj_t *args) +{ + const lv_obj_t *calendar = mp_to_lv(args[0]); + const char** res = lv_calendar_get_day_names(calendar); + return ptr_to_mp((void*)res); +} + +STATIC MP_DEFINE_CONST_FUN_OBJ_VAR_BETWEEN(mp_lv_calendar_get_day_names_obj, 1, 1, mp_lv_calendar_get_day_names); + + + +/* + * lvgl extension definition for: + * const char **lv_calendar_get_month_names(const lv_obj_t *calendar) + */ + +STATIC mp_obj_t mp_lv_calendar_get_month_names(size_t n_args, const mp_obj_t *args) +{ + const lv_obj_t *calendar = mp_to_lv(args[0]); + const char** res = lv_calendar_get_month_names(calendar); + return ptr_to_mp((void*)res); +} + +STATIC MP_DEFINE_CONST_FUN_OBJ_VAR_BETWEEN(mp_lv_calendar_get_month_names_obj, 1, 1, mp_lv_calendar_get_month_names); + + + +/* + * lvgl extension definition for: + * lv_style_t *lv_calendar_get_style(const lv_obj_t *calendar, lv_calendar_style_t type) + */ + +STATIC mp_obj_t mp_lv_calendar_get_style(size_t n_args, const mp_obj_t *args) +{ + const lv_obj_t *calendar = mp_to_lv(args[0]); + lv_calendar_style_t type = (uint8_t)mp_obj_get_int(args[1]); + lv_style_t* res = lv_calendar_get_style(calendar, type); + return mp_read_ptr_lv_style_t((void*)res); +} + +STATIC MP_DEFINE_CONST_FUN_OBJ_VAR_BETWEEN(mp_lv_calendar_get_style_obj, 2, 2, mp_lv_calendar_get_style); + + + +/* + * lvgl calendar object definitions + */ + + +STATIC const mp_rom_map_elem_t calendar_locals_dict_table[] = { + { MP_ROM_QSTR(MP_QSTR_set_action), MP_ROM_PTR(&mp_lv_calendar_set_action_obj) }, + { MP_ROM_QSTR(MP_QSTR_set_today_date), MP_ROM_PTR(&mp_lv_calendar_set_today_date_obj) }, + { MP_ROM_QSTR(MP_QSTR_set_showed_date), MP_ROM_PTR(&mp_lv_calendar_set_showed_date_obj) }, + { MP_ROM_QSTR(MP_QSTR_set_highlighted_dates), MP_ROM_PTR(&mp_lv_calendar_set_highlighted_dates_obj) }, + { MP_ROM_QSTR(MP_QSTR_set_day_names), MP_ROM_PTR(&mp_lv_calendar_set_day_names_obj) }, + { MP_ROM_QSTR(MP_QSTR_set_month_names), MP_ROM_PTR(&mp_lv_calendar_set_month_names_obj) }, + { MP_ROM_QSTR(MP_QSTR_set_style), MP_ROM_PTR(&mp_lv_calendar_set_style_obj) }, + { MP_ROM_QSTR(MP_QSTR_get_action), MP_ROM_PTR(&mp_lv_calendar_get_action_obj) }, + { MP_ROM_QSTR(MP_QSTR_get_today_date), MP_ROM_PTR(&mp_lv_calendar_get_today_date_obj) }, + { MP_ROM_QSTR(MP_QSTR_get_showed_date), MP_ROM_PTR(&mp_lv_calendar_get_showed_date_obj) }, + { MP_ROM_QSTR(MP_QSTR_get_pressed_date), MP_ROM_PTR(&mp_lv_calendar_get_pressed_date_obj) }, + { MP_ROM_QSTR(MP_QSTR_get_highlighted_dates), MP_ROM_PTR(&mp_lv_calendar_get_highlighted_dates_obj) }, + { MP_ROM_QSTR(MP_QSTR_get_highlighted_dates_num), MP_ROM_PTR(&mp_lv_calendar_get_highlighted_dates_num_obj) }, + { MP_ROM_QSTR(MP_QSTR_get_day_names), MP_ROM_PTR(&mp_lv_calendar_get_day_names_obj) }, + { MP_ROM_QSTR(MP_QSTR_get_month_names), MP_ROM_PTR(&mp_lv_calendar_get_month_names_obj) }, + { MP_ROM_QSTR(MP_QSTR_get_style), MP_ROM_PTR(&mp_lv_calendar_get_style_obj) }, + { MP_ROM_QSTR(MP_QSTR_delete), MP_ROM_PTR(&mp_lv_obj_del_obj) }, + { MP_ROM_QSTR(MP_QSTR_clean), MP_ROM_PTR(&mp_lv_obj_clean_obj) }, + { MP_ROM_QSTR(MP_QSTR_invalidate), MP_ROM_PTR(&mp_lv_obj_invalidate_obj) }, + { MP_ROM_QSTR(MP_QSTR_set_parent), MP_ROM_PTR(&mp_lv_obj_set_parent_obj) }, + { MP_ROM_QSTR(MP_QSTR_set_pos), MP_ROM_PTR(&mp_lv_obj_set_pos_obj) }, + { MP_ROM_QSTR(MP_QSTR_set_x), MP_ROM_PTR(&mp_lv_obj_set_x_obj) }, + { MP_ROM_QSTR(MP_QSTR_set_y), MP_ROM_PTR(&mp_lv_obj_set_y_obj) }, + { MP_ROM_QSTR(MP_QSTR_set_size), MP_ROM_PTR(&mp_lv_obj_set_size_obj) }, + { MP_ROM_QSTR(MP_QSTR_set_width), MP_ROM_PTR(&mp_lv_obj_set_width_obj) }, + { MP_ROM_QSTR(MP_QSTR_set_height), MP_ROM_PTR(&mp_lv_obj_set_height_obj) }, + { MP_ROM_QSTR(MP_QSTR_align), MP_ROM_PTR(&mp_lv_obj_align_obj) }, + { MP_ROM_QSTR(MP_QSTR_align_origo), MP_ROM_PTR(&mp_lv_obj_align_origo_obj) }, + { MP_ROM_QSTR(MP_QSTR_realign), MP_ROM_PTR(&mp_lv_obj_realign_obj) }, + { MP_ROM_QSTR(MP_QSTR_set_auto_realign), MP_ROM_PTR(&mp_lv_obj_set_auto_realign_obj) }, + { MP_ROM_QSTR(MP_QSTR_set_style), MP_ROM_PTR(&mp_lv_obj_set_style_obj) }, + { MP_ROM_QSTR(MP_QSTR_refresh_style), MP_ROM_PTR(&mp_lv_obj_refresh_style_obj) }, + { MP_ROM_QSTR(MP_QSTR_report_style_mod), MP_ROM_PTR(&mp_lv_obj_report_style_mod_obj) }, + { MP_ROM_QSTR(MP_QSTR_set_hidden), MP_ROM_PTR(&mp_lv_obj_set_hidden_obj) }, + { MP_ROM_QSTR(MP_QSTR_set_click), MP_ROM_PTR(&mp_lv_obj_set_click_obj) }, + { MP_ROM_QSTR(MP_QSTR_set_top), MP_ROM_PTR(&mp_lv_obj_set_top_obj) }, + { MP_ROM_QSTR(MP_QSTR_set_drag), MP_ROM_PTR(&mp_lv_obj_set_drag_obj) }, + { MP_ROM_QSTR(MP_QSTR_set_drag_throw), MP_ROM_PTR(&mp_lv_obj_set_drag_throw_obj) }, + { MP_ROM_QSTR(MP_QSTR_set_drag_parent), MP_ROM_PTR(&mp_lv_obj_set_drag_parent_obj) }, + { MP_ROM_QSTR(MP_QSTR_set_opa_scale_enable), MP_ROM_PTR(&mp_lv_obj_set_opa_scale_enable_obj) }, + { MP_ROM_QSTR(MP_QSTR_set_opa_scale), MP_ROM_PTR(&mp_lv_obj_set_opa_scale_obj) }, + { MP_ROM_QSTR(MP_QSTR_set_protect), MP_ROM_PTR(&mp_lv_obj_set_protect_obj) }, + { MP_ROM_QSTR(MP_QSTR_clear_protect), MP_ROM_PTR(&mp_lv_obj_clear_protect_obj) }, + { MP_ROM_QSTR(MP_QSTR_set_signal_func), MP_ROM_PTR(&mp_lv_obj_set_signal_func_obj) }, + { MP_ROM_QSTR(MP_QSTR_set_design_func), MP_ROM_PTR(&mp_lv_obj_set_design_func_obj) }, + { MP_ROM_QSTR(MP_QSTR_allocate_ext_attr), MP_ROM_PTR(&mp_lv_obj_allocate_ext_attr_obj) }, + { MP_ROM_QSTR(MP_QSTR_refresh_ext_size), MP_ROM_PTR(&mp_lv_obj_refresh_ext_size_obj) }, + { MP_ROM_QSTR(MP_QSTR_set_free_num), MP_ROM_PTR(&mp_lv_obj_set_free_num_obj) }, + { MP_ROM_QSTR(MP_QSTR_set_free_ptr), MP_ROM_PTR(&mp_lv_obj_set_free_ptr_obj) }, + { MP_ROM_QSTR(MP_QSTR_animate), MP_ROM_PTR(&mp_lv_obj_animate_obj) }, + { MP_ROM_QSTR(MP_QSTR_get_screen), MP_ROM_PTR(&mp_lv_obj_get_screen_obj) }, + { MP_ROM_QSTR(MP_QSTR_get_parent), MP_ROM_PTR(&mp_lv_obj_get_parent_obj) }, + { MP_ROM_QSTR(MP_QSTR_get_child), MP_ROM_PTR(&mp_lv_obj_get_child_obj) }, + { MP_ROM_QSTR(MP_QSTR_get_child_back), MP_ROM_PTR(&mp_lv_obj_get_child_back_obj) }, + { MP_ROM_QSTR(MP_QSTR_count_children), MP_ROM_PTR(&mp_lv_obj_count_children_obj) }, + { MP_ROM_QSTR(MP_QSTR_get_coords), MP_ROM_PTR(&mp_lv_obj_get_coords_obj) }, + { MP_ROM_QSTR(MP_QSTR_get_x), MP_ROM_PTR(&mp_lv_obj_get_x_obj) }, + { MP_ROM_QSTR(MP_QSTR_get_y), MP_ROM_PTR(&mp_lv_obj_get_y_obj) }, + { MP_ROM_QSTR(MP_QSTR_get_width), MP_ROM_PTR(&mp_lv_obj_get_width_obj) }, + { MP_ROM_QSTR(MP_QSTR_get_height), MP_ROM_PTR(&mp_lv_obj_get_height_obj) }, + { MP_ROM_QSTR(MP_QSTR_get_ext_size), MP_ROM_PTR(&mp_lv_obj_get_ext_size_obj) }, + { MP_ROM_QSTR(MP_QSTR_get_auto_realign), MP_ROM_PTR(&mp_lv_obj_get_auto_realign_obj) }, + { MP_ROM_QSTR(MP_QSTR_get_style), MP_ROM_PTR(&mp_lv_obj_get_style_obj) }, + { MP_ROM_QSTR(MP_QSTR_get_hidden), MP_ROM_PTR(&mp_lv_obj_get_hidden_obj) }, + { MP_ROM_QSTR(MP_QSTR_get_click), MP_ROM_PTR(&mp_lv_obj_get_click_obj) }, + { MP_ROM_QSTR(MP_QSTR_get_top), MP_ROM_PTR(&mp_lv_obj_get_top_obj) }, + { MP_ROM_QSTR(MP_QSTR_get_drag), MP_ROM_PTR(&mp_lv_obj_get_drag_obj) }, + { MP_ROM_QSTR(MP_QSTR_get_drag_throw), MP_ROM_PTR(&mp_lv_obj_get_drag_throw_obj) }, + { MP_ROM_QSTR(MP_QSTR_get_drag_parent), MP_ROM_PTR(&mp_lv_obj_get_drag_parent_obj) }, + { MP_ROM_QSTR(MP_QSTR_get_opa_scale_enable), MP_ROM_PTR(&mp_lv_obj_get_opa_scale_enable_obj) }, + { MP_ROM_QSTR(MP_QSTR_get_opa_scale), MP_ROM_PTR(&mp_lv_obj_get_opa_scale_obj) }, + { MP_ROM_QSTR(MP_QSTR_get_protect), MP_ROM_PTR(&mp_lv_obj_get_protect_obj) }, + { MP_ROM_QSTR(MP_QSTR_is_protected), MP_ROM_PTR(&mp_lv_obj_is_protected_obj) }, + { MP_ROM_QSTR(MP_QSTR_get_signal_func), MP_ROM_PTR(&mp_lv_obj_get_signal_func_obj) }, + { MP_ROM_QSTR(MP_QSTR_get_design_func), MP_ROM_PTR(&mp_lv_obj_get_design_func_obj) }, + { MP_ROM_QSTR(MP_QSTR_get_ext_attr), MP_ROM_PTR(&mp_lv_obj_get_ext_attr_obj) }, + { MP_ROM_QSTR(MP_QSTR_get_free_num), MP_ROM_PTR(&mp_lv_obj_get_free_num_obj) }, + { MP_ROM_QSTR(MP_QSTR_get_free_ptr), MP_ROM_PTR(&mp_lv_obj_get_free_ptr_obj) }, + { MP_ROM_QSTR(MP_QSTR_get_group), MP_ROM_PTR(&mp_lv_obj_get_group_obj) }, + { MP_ROM_QSTR(MP_QSTR_is_focused), MP_ROM_PTR(&mp_lv_obj_is_focused_obj) }, + { MP_ROM_QSTR(MP_QSTR_ACTION), MP_ROM_PTR(&mp_LV_CALENDAR_ACTION_type) }, + { MP_ROM_QSTR(MP_QSTR_STYLE), MP_ROM_PTR(&mp_LV_CALENDAR_STYLE_type) } +}; + +STATIC MP_DEFINE_CONST_DICT(calendar_locals_dict, calendar_locals_dict_table); + +STATIC void calendar_print(const mp_print_t *print, + mp_obj_t self_in, + mp_print_kind_t kind) +{ + mp_printf(print, "lvgl calendar"); +} + + +STATIC mp_obj_t calendar_make_new( + const mp_obj_type_t *type, + size_t n_args, + size_t n_kw, + const mp_obj_t *args) +{ + return make_new(&lv_calendar_create, type, n_args, n_kw, args); +} + + +STATIC const mp_obj_type_t mp_calendar_type = { + { &mp_type_type }, + .name = MP_QSTR_calendar, + .print = calendar_print, + .make_new = calendar_make_new, + .locals_dict = (mp_obj_dict_t*)&calendar_locals_dict, +}; + + +/* + * lvgl extension definition for: + * inline static void lv_spinbox_set_style(lv_obj_t *spinbox, lv_spinbox_style_t type, lv_style_t *style) + */ + +STATIC mp_obj_t mp_lv_spinbox_set_style(size_t n_args, const mp_obj_t *args) +{ + lv_obj_t *spinbox = mp_to_lv(args[0]); + lv_spinbox_style_t type = (uint8_t)mp_obj_get_int(args[1]); + lv_style_t *style = mp_write_ptr_lv_style_t(args[2]); + lv_spinbox_set_style(spinbox, type, style); + return mp_const_none; +} + +STATIC MP_DEFINE_CONST_FUN_OBJ_VAR_BETWEEN(mp_lv_spinbox_set_style_obj, 3, 3, mp_lv_spinbox_set_style); + + + +/* + * lvgl extension definition for: + * inline static lv_style_t *lv_spinbox_get_style(lv_obj_t *spinbox, lv_spinbox_style_t type) + */ + +STATIC mp_obj_t mp_lv_spinbox_get_style(size_t n_args, const mp_obj_t *args) +{ + lv_obj_t *spinbox = mp_to_lv(args[0]); + lv_spinbox_style_t type = (uint8_t)mp_obj_get_int(args[1]); + lv_style_t* res = lv_spinbox_get_style(spinbox, type); + return mp_read_ptr_lv_style_t((void*)res); +} + +STATIC MP_DEFINE_CONST_FUN_OBJ_VAR_BETWEEN(mp_lv_spinbox_get_style_obj, 2, 2, mp_lv_spinbox_get_style); + + + +/* + * lvgl extension definition for: + * void lv_spinbox_set_value(lv_obj_t *spinbox, int32_t i) + */ + +STATIC mp_obj_t mp_lv_spinbox_set_value(size_t n_args, const mp_obj_t *args) +{ + lv_obj_t *spinbox = mp_to_lv(args[0]); + int32_t i = (int32_t)mp_obj_get_int(args[1]); + lv_spinbox_set_value(spinbox, i); + return mp_const_none; +} + +STATIC MP_DEFINE_CONST_FUN_OBJ_VAR_BETWEEN(mp_lv_spinbox_set_value_obj, 2, 2, mp_lv_spinbox_set_value); + + + +/* + * lvgl extension definition for: + * void lv_spinbox_set_digit_format(lv_obj_t *spinbox, uint8_t digit_count, uint8_t separator_position) + */ + +STATIC mp_obj_t mp_lv_spinbox_set_digit_format(size_t n_args, const mp_obj_t *args) +{ + lv_obj_t *spinbox = mp_to_lv(args[0]); + uint8_t digit_count = (uint8_t)mp_obj_get_int(args[1]); + uint8_t separator_position = (uint8_t)mp_obj_get_int(args[2]); + lv_spinbox_set_digit_format(spinbox, digit_count, separator_position); + return mp_const_none; +} + +STATIC MP_DEFINE_CONST_FUN_OBJ_VAR_BETWEEN(mp_lv_spinbox_set_digit_format_obj, 3, 3, mp_lv_spinbox_set_digit_format); + + + +/* + * lvgl extension definition for: + * void lv_spinbox_set_step(lv_obj_t *spinbox, uint32_t step) + */ + +STATIC mp_obj_t mp_lv_spinbox_set_step(size_t n_args, const mp_obj_t *args) +{ + lv_obj_t *spinbox = mp_to_lv(args[0]); + uint32_t step = (uint32_t)mp_obj_get_int(args[1]); + lv_spinbox_set_step(spinbox, step); + return mp_const_none; +} + +STATIC MP_DEFINE_CONST_FUN_OBJ_VAR_BETWEEN(mp_lv_spinbox_set_step_obj, 2, 2, mp_lv_spinbox_set_step); + + + +/* + * lvgl extension definition for: + * void lv_spinbox_set_range(lv_obj_t *spinbox, int32_t range_min, int32_t range_max) + */ + +STATIC mp_obj_t mp_lv_spinbox_set_range(size_t n_args, const mp_obj_t *args) +{ + lv_obj_t *spinbox = mp_to_lv(args[0]); + int32_t range_min = (int32_t)mp_obj_get_int(args[1]); + int32_t range_max = (int32_t)mp_obj_get_int(args[2]); + lv_spinbox_set_range(spinbox, range_min, range_max); + return mp_const_none; +} + +STATIC MP_DEFINE_CONST_FUN_OBJ_VAR_BETWEEN(mp_lv_spinbox_set_range_obj, 3, 3, mp_lv_spinbox_set_range); + + + +/* + * lvgl extension definition for: + * void lv_spinbox_set_value_changed_cb(lv_obj_t *spinbox, lv_spinbox_value_changed_cb_t cb) + */ + +STATIC mp_obj_t mp_lv_spinbox_set_value_changed_cb(size_t n_args, const mp_obj_t *args) +{ + lv_obj_t *spinbox = mp_to_lv(args[0]); + set_action(args[0], args[1]); + lv_spinbox_value_changed_cb_t cb = &lv_spinbox_value_changed_cb_t_callback; + lv_spinbox_set_value_changed_cb(spinbox, cb); + return mp_const_none; +} + +STATIC MP_DEFINE_CONST_FUN_OBJ_VAR_BETWEEN(mp_lv_spinbox_set_value_changed_cb_obj, 2, 2, mp_lv_spinbox_set_value_changed_cb); + + + +/* + * lvgl extension definition for: + * void lv_spinbox_set_padding_left(lv_obj_t *spinbox, uint8_t padding) + */ + +STATIC mp_obj_t mp_lv_spinbox_set_padding_left(size_t n_args, const mp_obj_t *args) +{ + lv_obj_t *spinbox = mp_to_lv(args[0]); + uint8_t padding = (uint8_t)mp_obj_get_int(args[1]); + lv_spinbox_set_padding_left(spinbox, padding); + return mp_const_none; +} + +STATIC MP_DEFINE_CONST_FUN_OBJ_VAR_BETWEEN(mp_lv_spinbox_set_padding_left_obj, 2, 2, mp_lv_spinbox_set_padding_left); + + + +/* + * lvgl extension definition for: + * int32_t lv_spinbox_get_value(lv_obj_t *spinbox) + */ + +STATIC mp_obj_t mp_lv_spinbox_get_value(size_t n_args, const mp_obj_t *args) +{ + lv_obj_t *spinbox = mp_to_lv(args[0]); + int32_t res = lv_spinbox_get_value(spinbox); + return mp_obj_new_int(res); +} + +STATIC MP_DEFINE_CONST_FUN_OBJ_VAR_BETWEEN(mp_lv_spinbox_get_value_obj, 1, 1, mp_lv_spinbox_get_value); + + + +/* + * lvgl extension definition for: + * void lv_spinbox_step_next(lv_obj_t *spinbox) + */ + +STATIC mp_obj_t mp_lv_spinbox_step_next(size_t n_args, const mp_obj_t *args) +{ + lv_obj_t *spinbox = mp_to_lv(args[0]); + lv_spinbox_step_next(spinbox); + return mp_const_none; +} + +STATIC MP_DEFINE_CONST_FUN_OBJ_VAR_BETWEEN(mp_lv_spinbox_step_next_obj, 1, 1, mp_lv_spinbox_step_next); + + + +/* + * lvgl extension definition for: + * void lv_spinbox_step_previous(lv_obj_t *spinbox) + */ + +STATIC mp_obj_t mp_lv_spinbox_step_previous(size_t n_args, const mp_obj_t *args) +{ + lv_obj_t *spinbox = mp_to_lv(args[0]); + lv_spinbox_step_previous(spinbox); + return mp_const_none; +} + +STATIC MP_DEFINE_CONST_FUN_OBJ_VAR_BETWEEN(mp_lv_spinbox_step_previous_obj, 1, 1, mp_lv_spinbox_step_previous); + + + +/* + * lvgl extension definition for: + * void lv_spinbox_increment(lv_obj_t *spinbox) + */ + +STATIC mp_obj_t mp_lv_spinbox_increment(size_t n_args, const mp_obj_t *args) +{ + lv_obj_t *spinbox = mp_to_lv(args[0]); + lv_spinbox_increment(spinbox); + return mp_const_none; +} + +STATIC MP_DEFINE_CONST_FUN_OBJ_VAR_BETWEEN(mp_lv_spinbox_increment_obj, 1, 1, mp_lv_spinbox_increment); + + + +/* + * lvgl extension definition for: + * void lv_spinbox_decrement(lv_obj_t *spinbox) + */ + +STATIC mp_obj_t mp_lv_spinbox_decrement(size_t n_args, const mp_obj_t *args) +{ + lv_obj_t *spinbox = mp_to_lv(args[0]); + lv_spinbox_decrement(spinbox); + return mp_const_none; +} + +STATIC MP_DEFINE_CONST_FUN_OBJ_VAR_BETWEEN(mp_lv_spinbox_decrement_obj, 1, 1, mp_lv_spinbox_decrement); + + + +/* + * lvgl spinbox object definitions + */ + + +STATIC const mp_rom_map_elem_t spinbox_locals_dict_table[] = { + { MP_ROM_QSTR(MP_QSTR_set_style), MP_ROM_PTR(&mp_lv_spinbox_set_style_obj) }, + { MP_ROM_QSTR(MP_QSTR_get_style), MP_ROM_PTR(&mp_lv_spinbox_get_style_obj) }, + { MP_ROM_QSTR(MP_QSTR_set_value), MP_ROM_PTR(&mp_lv_spinbox_set_value_obj) }, + { MP_ROM_QSTR(MP_QSTR_set_digit_format), MP_ROM_PTR(&mp_lv_spinbox_set_digit_format_obj) }, + { MP_ROM_QSTR(MP_QSTR_set_step), MP_ROM_PTR(&mp_lv_spinbox_set_step_obj) }, + { MP_ROM_QSTR(MP_QSTR_set_range), MP_ROM_PTR(&mp_lv_spinbox_set_range_obj) }, + { MP_ROM_QSTR(MP_QSTR_set_value_changed_cb), MP_ROM_PTR(&mp_lv_spinbox_set_value_changed_cb_obj) }, + { MP_ROM_QSTR(MP_QSTR_set_padding_left), MP_ROM_PTR(&mp_lv_spinbox_set_padding_left_obj) }, + { MP_ROM_QSTR(MP_QSTR_get_value), MP_ROM_PTR(&mp_lv_spinbox_get_value_obj) }, + { MP_ROM_QSTR(MP_QSTR_step_next), MP_ROM_PTR(&mp_lv_spinbox_step_next_obj) }, + { MP_ROM_QSTR(MP_QSTR_step_previous), MP_ROM_PTR(&mp_lv_spinbox_step_previous_obj) }, + { MP_ROM_QSTR(MP_QSTR_increment), MP_ROM_PTR(&mp_lv_spinbox_increment_obj) }, + { MP_ROM_QSTR(MP_QSTR_decrement), MP_ROM_PTR(&mp_lv_spinbox_decrement_obj) }, + { MP_ROM_QSTR(MP_QSTR_delete), MP_ROM_PTR(&mp_lv_obj_del_obj) }, + { MP_ROM_QSTR(MP_QSTR_clean), MP_ROM_PTR(&mp_lv_obj_clean_obj) }, + { MP_ROM_QSTR(MP_QSTR_invalidate), MP_ROM_PTR(&mp_lv_obj_invalidate_obj) }, + { MP_ROM_QSTR(MP_QSTR_set_parent), MP_ROM_PTR(&mp_lv_obj_set_parent_obj) }, + { MP_ROM_QSTR(MP_QSTR_set_pos), MP_ROM_PTR(&mp_lv_obj_set_pos_obj) }, + { MP_ROM_QSTR(MP_QSTR_set_x), MP_ROM_PTR(&mp_lv_obj_set_x_obj) }, + { MP_ROM_QSTR(MP_QSTR_set_y), MP_ROM_PTR(&mp_lv_obj_set_y_obj) }, + { MP_ROM_QSTR(MP_QSTR_set_size), MP_ROM_PTR(&mp_lv_obj_set_size_obj) }, + { MP_ROM_QSTR(MP_QSTR_set_width), MP_ROM_PTR(&mp_lv_obj_set_width_obj) }, + { MP_ROM_QSTR(MP_QSTR_set_height), MP_ROM_PTR(&mp_lv_obj_set_height_obj) }, + { MP_ROM_QSTR(MP_QSTR_align), MP_ROM_PTR(&mp_lv_obj_align_obj) }, + { MP_ROM_QSTR(MP_QSTR_align_origo), MP_ROM_PTR(&mp_lv_obj_align_origo_obj) }, + { MP_ROM_QSTR(MP_QSTR_realign), MP_ROM_PTR(&mp_lv_obj_realign_obj) }, + { MP_ROM_QSTR(MP_QSTR_set_auto_realign), MP_ROM_PTR(&mp_lv_obj_set_auto_realign_obj) }, + { MP_ROM_QSTR(MP_QSTR_set_style), MP_ROM_PTR(&mp_lv_obj_set_style_obj) }, + { MP_ROM_QSTR(MP_QSTR_refresh_style), MP_ROM_PTR(&mp_lv_obj_refresh_style_obj) }, + { MP_ROM_QSTR(MP_QSTR_report_style_mod), MP_ROM_PTR(&mp_lv_obj_report_style_mod_obj) }, + { MP_ROM_QSTR(MP_QSTR_set_hidden), MP_ROM_PTR(&mp_lv_obj_set_hidden_obj) }, + { MP_ROM_QSTR(MP_QSTR_set_click), MP_ROM_PTR(&mp_lv_obj_set_click_obj) }, + { MP_ROM_QSTR(MP_QSTR_set_top), MP_ROM_PTR(&mp_lv_obj_set_top_obj) }, + { MP_ROM_QSTR(MP_QSTR_set_drag), MP_ROM_PTR(&mp_lv_obj_set_drag_obj) }, + { MP_ROM_QSTR(MP_QSTR_set_drag_throw), MP_ROM_PTR(&mp_lv_obj_set_drag_throw_obj) }, + { MP_ROM_QSTR(MP_QSTR_set_drag_parent), MP_ROM_PTR(&mp_lv_obj_set_drag_parent_obj) }, + { MP_ROM_QSTR(MP_QSTR_set_opa_scale_enable), MP_ROM_PTR(&mp_lv_obj_set_opa_scale_enable_obj) }, + { MP_ROM_QSTR(MP_QSTR_set_opa_scale), MP_ROM_PTR(&mp_lv_obj_set_opa_scale_obj) }, + { MP_ROM_QSTR(MP_QSTR_set_protect), MP_ROM_PTR(&mp_lv_obj_set_protect_obj) }, + { MP_ROM_QSTR(MP_QSTR_clear_protect), MP_ROM_PTR(&mp_lv_obj_clear_protect_obj) }, + { MP_ROM_QSTR(MP_QSTR_set_signal_func), MP_ROM_PTR(&mp_lv_obj_set_signal_func_obj) }, + { MP_ROM_QSTR(MP_QSTR_set_design_func), MP_ROM_PTR(&mp_lv_obj_set_design_func_obj) }, + { MP_ROM_QSTR(MP_QSTR_allocate_ext_attr), MP_ROM_PTR(&mp_lv_obj_allocate_ext_attr_obj) }, + { MP_ROM_QSTR(MP_QSTR_refresh_ext_size), MP_ROM_PTR(&mp_lv_obj_refresh_ext_size_obj) }, + { MP_ROM_QSTR(MP_QSTR_set_free_num), MP_ROM_PTR(&mp_lv_obj_set_free_num_obj) }, + { MP_ROM_QSTR(MP_QSTR_set_free_ptr), MP_ROM_PTR(&mp_lv_obj_set_free_ptr_obj) }, + { MP_ROM_QSTR(MP_QSTR_animate), MP_ROM_PTR(&mp_lv_obj_animate_obj) }, + { MP_ROM_QSTR(MP_QSTR_get_screen), MP_ROM_PTR(&mp_lv_obj_get_screen_obj) }, + { MP_ROM_QSTR(MP_QSTR_get_parent), MP_ROM_PTR(&mp_lv_obj_get_parent_obj) }, + { MP_ROM_QSTR(MP_QSTR_get_child), MP_ROM_PTR(&mp_lv_obj_get_child_obj) }, + { MP_ROM_QSTR(MP_QSTR_get_child_back), MP_ROM_PTR(&mp_lv_obj_get_child_back_obj) }, + { MP_ROM_QSTR(MP_QSTR_count_children), MP_ROM_PTR(&mp_lv_obj_count_children_obj) }, + { MP_ROM_QSTR(MP_QSTR_get_coords), MP_ROM_PTR(&mp_lv_obj_get_coords_obj) }, + { MP_ROM_QSTR(MP_QSTR_get_x), MP_ROM_PTR(&mp_lv_obj_get_x_obj) }, + { MP_ROM_QSTR(MP_QSTR_get_y), MP_ROM_PTR(&mp_lv_obj_get_y_obj) }, + { MP_ROM_QSTR(MP_QSTR_get_width), MP_ROM_PTR(&mp_lv_obj_get_width_obj) }, + { MP_ROM_QSTR(MP_QSTR_get_height), MP_ROM_PTR(&mp_lv_obj_get_height_obj) }, + { MP_ROM_QSTR(MP_QSTR_get_ext_size), MP_ROM_PTR(&mp_lv_obj_get_ext_size_obj) }, + { MP_ROM_QSTR(MP_QSTR_get_auto_realign), MP_ROM_PTR(&mp_lv_obj_get_auto_realign_obj) }, + { MP_ROM_QSTR(MP_QSTR_get_style), MP_ROM_PTR(&mp_lv_obj_get_style_obj) }, + { MP_ROM_QSTR(MP_QSTR_get_hidden), MP_ROM_PTR(&mp_lv_obj_get_hidden_obj) }, + { MP_ROM_QSTR(MP_QSTR_get_click), MP_ROM_PTR(&mp_lv_obj_get_click_obj) }, + { MP_ROM_QSTR(MP_QSTR_get_top), MP_ROM_PTR(&mp_lv_obj_get_top_obj) }, + { MP_ROM_QSTR(MP_QSTR_get_drag), MP_ROM_PTR(&mp_lv_obj_get_drag_obj) }, + { MP_ROM_QSTR(MP_QSTR_get_drag_throw), MP_ROM_PTR(&mp_lv_obj_get_drag_throw_obj) }, + { MP_ROM_QSTR(MP_QSTR_get_drag_parent), MP_ROM_PTR(&mp_lv_obj_get_drag_parent_obj) }, + { MP_ROM_QSTR(MP_QSTR_get_opa_scale_enable), MP_ROM_PTR(&mp_lv_obj_get_opa_scale_enable_obj) }, + { MP_ROM_QSTR(MP_QSTR_get_opa_scale), MP_ROM_PTR(&mp_lv_obj_get_opa_scale_obj) }, + { MP_ROM_QSTR(MP_QSTR_get_protect), MP_ROM_PTR(&mp_lv_obj_get_protect_obj) }, + { MP_ROM_QSTR(MP_QSTR_is_protected), MP_ROM_PTR(&mp_lv_obj_is_protected_obj) }, + { MP_ROM_QSTR(MP_QSTR_get_signal_func), MP_ROM_PTR(&mp_lv_obj_get_signal_func_obj) }, + { MP_ROM_QSTR(MP_QSTR_get_design_func), MP_ROM_PTR(&mp_lv_obj_get_design_func_obj) }, + { MP_ROM_QSTR(MP_QSTR_get_ext_attr), MP_ROM_PTR(&mp_lv_obj_get_ext_attr_obj) }, + { MP_ROM_QSTR(MP_QSTR_get_free_num), MP_ROM_PTR(&mp_lv_obj_get_free_num_obj) }, + { MP_ROM_QSTR(MP_QSTR_get_free_ptr), MP_ROM_PTR(&mp_lv_obj_get_free_ptr_obj) }, + { MP_ROM_QSTR(MP_QSTR_get_group), MP_ROM_PTR(&mp_lv_obj_get_group_obj) }, + { MP_ROM_QSTR(MP_QSTR_is_focused), MP_ROM_PTR(&mp_lv_obj_is_focused_obj) }, + { MP_ROM_QSTR(MP_QSTR_STYLE), MP_ROM_PTR(&mp_LV_SPINBOX_STYLE_type) } +}; + +STATIC MP_DEFINE_CONST_DICT(spinbox_locals_dict, spinbox_locals_dict_table); + +STATIC void spinbox_print(const mp_print_t *print, + mp_obj_t self_in, + mp_print_kind_t kind) +{ + mp_printf(print, "lvgl spinbox"); +} + + +STATIC mp_obj_t spinbox_make_new( + const mp_obj_type_t *type, + size_t n_args, + size_t n_kw, + const mp_obj_t *args) +{ + return make_new(&lv_spinbox_create, type, n_args, n_kw, args); +} + + +STATIC const mp_obj_type_t mp_spinbox_type = { + { &mp_type_type }, + .name = MP_QSTR_spinbox, + .print = spinbox_print, + .make_new = spinbox_make_new, + .locals_dict = (mp_obj_dict_t*)&spinbox_locals_dict, +}; + + +STATIC inline const mp_obj_type_t *get_BaseObj_type() +{ + return &mp_obj_type; +} + + +/* + * + * Global Module Functions + * + */ + + +/* + * lvgl extension definition for: + * inline static uint8_t lv_color_to1(lv_color_t color) + */ + +STATIC mp_obj_t mp_lv_color_to1(size_t n_args, const mp_obj_t *args) +{ + lv_color_t color = mp_write_lv_color16_t(args[0]); + uint8_t res = lv_color_to1(color); + return mp_obj_new_int_from_uint(res); +} + +STATIC MP_DEFINE_CONST_FUN_OBJ_VAR_BETWEEN(mp_lv_color_to1_obj, 1, 1, mp_lv_color_to1); + + + +/* + * lvgl extension definition for: + * inline static uint8_t lv_color_to8(lv_color_t color) + */ + +STATIC mp_obj_t mp_lv_color_to8(size_t n_args, const mp_obj_t *args) +{ + lv_color_t color = mp_write_lv_color16_t(args[0]); + uint8_t res = lv_color_to8(color); + return mp_obj_new_int_from_uint(res); +} + +STATIC MP_DEFINE_CONST_FUN_OBJ_VAR_BETWEEN(mp_lv_color_to8_obj, 1, 1, mp_lv_color_to8); + + + +/* + * lvgl extension definition for: + * inline static uint16_t lv_color_to16(lv_color_t color) + */ + +STATIC mp_obj_t mp_lv_color_to16(size_t n_args, const mp_obj_t *args) +{ + lv_color_t color = mp_write_lv_color16_t(args[0]); + uint16_t res = lv_color_to16(color); + return mp_obj_new_int_from_uint(res); +} + +STATIC MP_DEFINE_CONST_FUN_OBJ_VAR_BETWEEN(mp_lv_color_to16_obj, 1, 1, mp_lv_color_to16); + + + +/* + * lvgl extension definition for: + * inline static uint32_t lv_color_to32(lv_color_t color) + */ + +STATIC mp_obj_t mp_lv_color_to32(size_t n_args, const mp_obj_t *args) +{ + lv_color_t color = mp_write_lv_color16_t(args[0]); + uint32_t res = lv_color_to32(color); + return mp_obj_new_int_from_uint(res); +} + +STATIC MP_DEFINE_CONST_FUN_OBJ_VAR_BETWEEN(mp_lv_color_to32_obj, 1, 1, mp_lv_color_to32); + + + +/* + * lvgl extension definition for: + * inline static lv_color_t lv_color_mix(lv_color_t c1, lv_color_t c2, uint8_t mix) + */ + +STATIC mp_obj_t mp_lv_color_mix(size_t n_args, const mp_obj_t *args) +{ + lv_color_t c1 = mp_write_lv_color16_t(args[0]); + lv_color_t c2 = mp_write_lv_color16_t(args[1]); + uint8_t mix = (uint8_t)mp_obj_get_int(args[2]); + lv_color_t res = lv_color_mix(c1, c2, mix); + return mp_read_lv_color16_t(res); +} + +STATIC MP_DEFINE_CONST_FUN_OBJ_VAR_BETWEEN(mp_lv_color_mix_obj, 3, 3, mp_lv_color_mix); + + + +/* + * lvgl extension definition for: + * inline static uint8_t lv_color_brightness(lv_color_t color) + */ + +STATIC mp_obj_t mp_lv_color_brightness(size_t n_args, const mp_obj_t *args) +{ + lv_color_t color = mp_write_lv_color16_t(args[0]); + uint8_t res = lv_color_brightness(color); + return mp_obj_new_int_from_uint(res); +} + +STATIC MP_DEFINE_CONST_FUN_OBJ_VAR_BETWEEN(mp_lv_color_brightness_obj, 1, 1, mp_lv_color_brightness); + + + +/* + * lvgl extension definition for: + * inline static lv_color_t lv_color_hex(uint32_t c) + */ + +STATIC mp_obj_t mp_lv_color_hex(size_t n_args, const mp_obj_t *args) +{ + uint32_t c = (uint32_t)mp_obj_get_int(args[0]); + lv_color_t res = lv_color_hex(c); + return mp_read_lv_color16_t(res); +} + +STATIC MP_DEFINE_CONST_FUN_OBJ_VAR_BETWEEN(mp_lv_color_hex_obj, 1, 1, mp_lv_color_hex); + + + +/* + * lvgl extension definition for: + * inline static lv_color_t lv_color_hex3(uint32_t c) + */ + +STATIC mp_obj_t mp_lv_color_hex3(size_t n_args, const mp_obj_t *args) +{ + uint32_t c = (uint32_t)mp_obj_get_int(args[0]); + lv_color_t res = lv_color_hex3(c); + return mp_read_lv_color16_t(res); +} + +STATIC MP_DEFINE_CONST_FUN_OBJ_VAR_BETWEEN(mp_lv_color_hex3_obj, 1, 1, mp_lv_color_hex3); + + + +/* + * lvgl extension definition for: + * inline static void lv_area_copy(lv_area_t *dest, const lv_area_t *src) + */ + +STATIC mp_obj_t mp_lv_area_copy(size_t n_args, const mp_obj_t *args) +{ + lv_area_t *dest = mp_write_ptr_lv_area_t(args[0]); + const lv_area_t *src = mp_write_ptr_lv_area_t(args[1]); + lv_area_copy(dest, src); + return mp_const_none; +} + +STATIC MP_DEFINE_CONST_FUN_OBJ_VAR_BETWEEN(mp_lv_area_copy_obj, 2, 2, mp_lv_area_copy); + + + +/* + * lvgl extension definition for: + * inline static lv_coord_t lv_area_get_width(const lv_area_t *area_p) + */ + +STATIC mp_obj_t mp_lv_area_get_width(size_t n_args, const mp_obj_t *args) +{ + const lv_area_t *area_p = mp_write_ptr_lv_area_t(args[0]); + lv_coord_t res = lv_area_get_width(area_p); + return mp_obj_new_int(res); +} + +STATIC MP_DEFINE_CONST_FUN_OBJ_VAR_BETWEEN(mp_lv_area_get_width_obj, 1, 1, mp_lv_area_get_width); + + + +/* + * lvgl extension definition for: + * inline static lv_coord_t lv_area_get_height(const lv_area_t *area_p) + */ + +STATIC mp_obj_t mp_lv_area_get_height(size_t n_args, const mp_obj_t *args) +{ + const lv_area_t *area_p = mp_write_ptr_lv_area_t(args[0]); + lv_coord_t res = lv_area_get_height(area_p); + return mp_obj_new_int(res); +} + +STATIC MP_DEFINE_CONST_FUN_OBJ_VAR_BETWEEN(mp_lv_area_get_height_obj, 1, 1, mp_lv_area_get_height); + + + +/* + * lvgl extension definition for: + * inline static uint8_t lv_font_get_height(const lv_font_t *font_p) + */ + +STATIC mp_obj_t mp_lv_font_get_height(size_t n_args, const mp_obj_t *args) +{ + const lv_font_t *font_p = mp_write_ptr_lv_font_t(args[0]); + uint8_t res = lv_font_get_height(font_p); + return mp_obj_new_int_from_uint(res); +} + +STATIC MP_DEFINE_CONST_FUN_OBJ_VAR_BETWEEN(mp_lv_font_get_height_obj, 1, 1, mp_lv_font_get_height); + + + +/* + * lvgl extension definition for: + * void lv_mem_init(void) + */ + +STATIC mp_obj_t mp_lv_mem_init(size_t n_args, const mp_obj_t *args) +{ + + lv_mem_init(); + return mp_const_none; +} + +STATIC MP_DEFINE_CONST_FUN_OBJ_VAR_BETWEEN(mp_lv_mem_init_obj, 0, 0, mp_lv_mem_init); + + + +/* + * lvgl extension definition for: + * void *lv_mem_alloc(uint32_t size) + */ + +STATIC mp_obj_t mp_lv_mem_alloc(size_t n_args, const mp_obj_t *args) +{ + uint32_t size = (uint32_t)mp_obj_get_int(args[0]); + void* res = lv_mem_alloc(size); + return ptr_to_mp((void*)res); +} + +STATIC MP_DEFINE_CONST_FUN_OBJ_VAR_BETWEEN(mp_lv_mem_alloc_obj, 1, 1, mp_lv_mem_alloc); + + + +/* + * lvgl extension definition for: + * void lv_mem_free(const void *data) + */ + +STATIC mp_obj_t mp_lv_mem_free(size_t n_args, const mp_obj_t *args) +{ + const void *data = mp_to_ptr(args[0]); + lv_mem_free(data); + return mp_const_none; +} + +STATIC MP_DEFINE_CONST_FUN_OBJ_VAR_BETWEEN(mp_lv_mem_free_obj, 1, 1, mp_lv_mem_free); + + + +/* + * lvgl extension definition for: + * void *lv_mem_realloc(void *data_p, uint32_t new_size) + */ + +STATIC mp_obj_t mp_lv_mem_realloc(size_t n_args, const mp_obj_t *args) +{ + void *data_p = mp_to_ptr(args[0]); + uint32_t new_size = (uint32_t)mp_obj_get_int(args[1]); + void* res = lv_mem_realloc(data_p, new_size); + return ptr_to_mp((void*)res); +} + +STATIC MP_DEFINE_CONST_FUN_OBJ_VAR_BETWEEN(mp_lv_mem_realloc_obj, 2, 2, mp_lv_mem_realloc); + + + +/* + * lvgl extension definition for: + * void lv_mem_defrag(void) + */ + +STATIC mp_obj_t mp_lv_mem_defrag(size_t n_args, const mp_obj_t *args) +{ + + lv_mem_defrag(); + return mp_const_none; +} + +STATIC MP_DEFINE_CONST_FUN_OBJ_VAR_BETWEEN(mp_lv_mem_defrag_obj, 0, 0, mp_lv_mem_defrag); + + + +/* + * Struct lv_mem_monitor_t + */ + +STATIC inline const mp_obj_type_t *get_mp_lv_mem_monitor_t_type(); + +STATIC inline lv_mem_monitor_t* mp_write_ptr_lv_mem_monitor_t(mp_obj_t self_in) +{ + mp_lv_struct_t *self = MP_OBJ_TO_PTR(cast(self_in, get_mp_lv_mem_monitor_t_type())); + return (lv_mem_monitor_t*)self->data; +} + +#define mp_write_lv_mem_monitor_t(struct_obj) *mp_write_ptr_lv_mem_monitor_t(struct_obj) + +STATIC inline mp_obj_t mp_read_ptr_lv_mem_monitor_t(lv_mem_monitor_t *field) +{ + return lv_to_mp_struct(get_mp_lv_mem_monitor_t_type(), field); +} + +#define mp_read_lv_mem_monitor_t(field) mp_read_ptr_lv_mem_monitor_t(copy_buffer(&field, sizeof(lv_mem_monitor_t))) +#define mp_read_byref_lv_mem_monitor_t(field) mp_read_ptr_lv_mem_monitor_t(&field) + +STATIC void mp_lv_mem_monitor_t_attr(mp_obj_t self_in, qstr attr, mp_obj_t *dest) +{ + mp_lv_struct_t *self = MP_OBJ_TO_PTR(self_in); + lv_mem_monitor_t *data = (lv_mem_monitor_t*)self->data; + + if (dest[0] == MP_OBJ_NULL) { + // load attribute + switch(attr) + { + case MP_QSTR_total_size: dest[0] = mp_obj_new_int_from_uint(data->total_size); break; // converting from uint32_t; + case MP_QSTR_free_cnt: dest[0] = mp_obj_new_int_from_uint(data->free_cnt); break; // converting from uint32_t; + case MP_QSTR_free_size: dest[0] = mp_obj_new_int_from_uint(data->free_size); break; // converting from uint32_t; + case MP_QSTR_free_biggest_size: dest[0] = mp_obj_new_int_from_uint(data->free_biggest_size); break; // converting from uint32_t; + case MP_QSTR_used_cnt: dest[0] = mp_obj_new_int_from_uint(data->used_cnt); break; // converting from uint32_t; + case MP_QSTR_used_pct: dest[0] = mp_obj_new_int_from_uint(data->used_pct); break; // converting from uint8_t; + case MP_QSTR_frag_pct: dest[0] = mp_obj_new_int_from_uint(data->frag_pct); break; // converting from uint8_t; + default: field_not_found(MP_QSTR_lv_mem_monitor_t, attr); + } + } else { + if (dest[1]) + { + // store attribute + switch(attr) + { + case MP_QSTR_total_size: data->total_size = (uint32_t)mp_obj_get_int(dest[1]); break; // converting to uint32_t; + case MP_QSTR_free_cnt: data->free_cnt = (uint32_t)mp_obj_get_int(dest[1]); break; // converting to uint32_t; + case MP_QSTR_free_size: data->free_size = (uint32_t)mp_obj_get_int(dest[1]); break; // converting to uint32_t; + case MP_QSTR_free_biggest_size: data->free_biggest_size = (uint32_t)mp_obj_get_int(dest[1]); break; // converting to uint32_t; + case MP_QSTR_used_cnt: data->used_cnt = (uint32_t)mp_obj_get_int(dest[1]); break; // converting to uint32_t; + case MP_QSTR_used_pct: data->used_pct = (uint8_t)mp_obj_get_int(dest[1]); break; // converting to uint8_t; + case MP_QSTR_frag_pct: data->frag_pct = (uint8_t)mp_obj_get_int(dest[1]); break; // converting to uint8_t; + default: field_not_found(MP_QSTR_lv_mem_monitor_t, attr); + } + + dest[0] = MP_OBJ_NULL; // indicate success + } + } +} + +STATIC void mp_lv_mem_monitor_t_print(const mp_print_t *print, + mp_obj_t self_in, + mp_print_kind_t kind) +{ + mp_printf(print, "lvgl struct lv_mem_monitor_t"); +} + +STATIC const mp_rom_map_elem_t mp_lv_mem_monitor_t_locals_dict_table[] = { + { MP_ROM_QSTR(MP_QSTR_SIZE), MP_ROM_PTR(MP_ROM_INT(sizeof(lv_mem_monitor_t))) }, + { MP_ROM_QSTR(MP_QSTR_cast), MP_ROM_PTR(&mp_lv_cast_class_method) }, +}; + +STATIC MP_DEFINE_CONST_DICT(mp_lv_mem_monitor_t_locals_dict, mp_lv_mem_monitor_t_locals_dict_table); + +STATIC const mp_obj_type_t mp_lv_mem_monitor_t_type = { + { &mp_type_type }, + .name = MP_QSTR_lv_mem_monitor_t, + .print = mp_lv_mem_monitor_t_print, + .make_new = make_new_lv_struct, + .attr = mp_lv_mem_monitor_t_attr, + .locals_dict = (mp_obj_dict_t*)&mp_lv_mem_monitor_t_locals_dict, + .buffer_p = { .get_buffer = mp_blob_get_buffer } +}; + +STATIC inline const mp_obj_type_t *get_mp_lv_mem_monitor_t_type() +{ + return &mp_lv_mem_monitor_t_type; +} + + +/* + * lvgl extension definition for: + * void lv_mem_monitor(lv_mem_monitor_t *mon_p) + */ + +STATIC mp_obj_t mp_lv_mem_monitor(size_t n_args, const mp_obj_t *args) +{ + lv_mem_monitor_t *mon_p = mp_write_ptr_lv_mem_monitor_t(args[0]); + lv_mem_monitor(mon_p); + return mp_const_none; +} + +STATIC MP_DEFINE_CONST_FUN_OBJ_VAR_BETWEEN(mp_lv_mem_monitor_obj, 1, 1, mp_lv_mem_monitor); + + + +/* + * lvgl extension definition for: + * uint32_t lv_mem_get_size(const void *data) + */ + +STATIC mp_obj_t mp_lv_mem_get_size(size_t n_args, const mp_obj_t *args) +{ + const void *data = mp_to_ptr(args[0]); + uint32_t res = lv_mem_get_size(data); + return mp_obj_new_int_from_uint(res); +} + +STATIC MP_DEFINE_CONST_FUN_OBJ_VAR_BETWEEN(mp_lv_mem_get_size_obj, 1, 1, mp_lv_mem_get_size); + + + +/* + * Struct lv_ll_t + */ + +STATIC inline const mp_obj_type_t *get_mp_lv_ll_t_type(); + +STATIC inline lv_ll_t* mp_write_ptr_lv_ll_t(mp_obj_t self_in) +{ + mp_lv_struct_t *self = MP_OBJ_TO_PTR(cast(self_in, get_mp_lv_ll_t_type())); + return (lv_ll_t*)self->data; +} + +#define mp_write_lv_ll_t(struct_obj) *mp_write_ptr_lv_ll_t(struct_obj) + +STATIC inline mp_obj_t mp_read_ptr_lv_ll_t(lv_ll_t *field) +{ + return lv_to_mp_struct(get_mp_lv_ll_t_type(), field); +} + +#define mp_read_lv_ll_t(field) mp_read_ptr_lv_ll_t(copy_buffer(&field, sizeof(lv_ll_t))) +#define mp_read_byref_lv_ll_t(field) mp_read_ptr_lv_ll_t(&field) + +STATIC void mp_lv_ll_t_attr(mp_obj_t self_in, qstr attr, mp_obj_t *dest) +{ + mp_lv_struct_t *self = MP_OBJ_TO_PTR(self_in); + lv_ll_t *data = (lv_ll_t*)self->data; + + if (dest[0] == MP_OBJ_NULL) { + // load attribute + switch(attr) + { + case MP_QSTR_n_size: dest[0] = mp_obj_new_int_from_uint(data->n_size); break; // converting from uint32_t; + case MP_QSTR_head: dest[0] = ptr_to_mp((void*)data->head); break; // converting from lv_ll_node_t*; + case MP_QSTR_tail: dest[0] = ptr_to_mp((void*)data->tail); break; // converting from lv_ll_node_t*; + default: field_not_found(MP_QSTR_lv_ll_t, attr); + } + } else { + if (dest[1]) + { + // store attribute + switch(attr) + { + case MP_QSTR_n_size: data->n_size = (uint32_t)mp_obj_get_int(dest[1]); break; // converting to uint32_t; + case MP_QSTR_head: data->head = (void*)mp_to_ptr(dest[1]); break; // converting to lv_ll_node_t*; + case MP_QSTR_tail: data->tail = (void*)mp_to_ptr(dest[1]); break; // converting to lv_ll_node_t*; + default: field_not_found(MP_QSTR_lv_ll_t, attr); + } + + dest[0] = MP_OBJ_NULL; // indicate success + } + } +} + +STATIC void mp_lv_ll_t_print(const mp_print_t *print, + mp_obj_t self_in, + mp_print_kind_t kind) +{ + mp_printf(print, "lvgl struct lv_ll_t"); +} + +STATIC const mp_rom_map_elem_t mp_lv_ll_t_locals_dict_table[] = { + { MP_ROM_QSTR(MP_QSTR_SIZE), MP_ROM_PTR(MP_ROM_INT(sizeof(lv_ll_t))) }, + { MP_ROM_QSTR(MP_QSTR_cast), MP_ROM_PTR(&mp_lv_cast_class_method) }, +}; + +STATIC MP_DEFINE_CONST_DICT(mp_lv_ll_t_locals_dict, mp_lv_ll_t_locals_dict_table); + +STATIC const mp_obj_type_t mp_lv_ll_t_type = { + { &mp_type_type }, + .name = MP_QSTR_lv_ll_t, + .print = mp_lv_ll_t_print, + .make_new = make_new_lv_struct, + .attr = mp_lv_ll_t_attr, + .locals_dict = (mp_obj_dict_t*)&mp_lv_ll_t_locals_dict, + .buffer_p = { .get_buffer = mp_blob_get_buffer } +}; + +STATIC inline const mp_obj_type_t *get_mp_lv_ll_t_type() +{ + return &mp_lv_ll_t_type; +} + + +/* + * lvgl extension definition for: + * void lv_ll_init(lv_ll_t *ll_p, uint32_t node_size) + */ + +STATIC mp_obj_t mp_lv_ll_init(size_t n_args, const mp_obj_t *args) +{ + lv_ll_t *ll_p = mp_write_ptr_lv_ll_t(args[0]); + uint32_t node_size = (uint32_t)mp_obj_get_int(args[1]); + lv_ll_init(ll_p, node_size); + return mp_const_none; +} + +STATIC MP_DEFINE_CONST_FUN_OBJ_VAR_BETWEEN(mp_lv_ll_init_obj, 2, 2, mp_lv_ll_init); + + + +/* + * lvgl extension definition for: + * void *lv_ll_ins_head(lv_ll_t *ll_p) + */ + +STATIC mp_obj_t mp_lv_ll_ins_head(size_t n_args, const mp_obj_t *args) +{ + lv_ll_t *ll_p = mp_write_ptr_lv_ll_t(args[0]); + void* res = lv_ll_ins_head(ll_p); + return ptr_to_mp((void*)res); +} + +STATIC MP_DEFINE_CONST_FUN_OBJ_VAR_BETWEEN(mp_lv_ll_ins_head_obj, 1, 1, mp_lv_ll_ins_head); + + + +/* + * lvgl extension definition for: + * void *lv_ll_ins_prev(lv_ll_t *ll_p, void *n_act) + */ + +STATIC mp_obj_t mp_lv_ll_ins_prev(size_t n_args, const mp_obj_t *args) +{ + lv_ll_t *ll_p = mp_write_ptr_lv_ll_t(args[0]); + void *n_act = mp_to_ptr(args[1]); + void* res = lv_ll_ins_prev(ll_p, n_act); + return ptr_to_mp((void*)res); +} + +STATIC MP_DEFINE_CONST_FUN_OBJ_VAR_BETWEEN(mp_lv_ll_ins_prev_obj, 2, 2, mp_lv_ll_ins_prev); + + + +/* + * lvgl extension definition for: + * void *lv_ll_ins_tail(lv_ll_t *ll_p) + */ + +STATIC mp_obj_t mp_lv_ll_ins_tail(size_t n_args, const mp_obj_t *args) +{ + lv_ll_t *ll_p = mp_write_ptr_lv_ll_t(args[0]); + void* res = lv_ll_ins_tail(ll_p); + return ptr_to_mp((void*)res); +} + +STATIC MP_DEFINE_CONST_FUN_OBJ_VAR_BETWEEN(mp_lv_ll_ins_tail_obj, 1, 1, mp_lv_ll_ins_tail); + + + +/* + * lvgl extension definition for: + * void lv_ll_rem(lv_ll_t *ll_p, void *node_p) + */ + +STATIC mp_obj_t mp_lv_ll_rem(size_t n_args, const mp_obj_t *args) +{ + lv_ll_t *ll_p = mp_write_ptr_lv_ll_t(args[0]); + void *node_p = mp_to_ptr(args[1]); + lv_ll_rem(ll_p, node_p); + return mp_const_none; +} + +STATIC MP_DEFINE_CONST_FUN_OBJ_VAR_BETWEEN(mp_lv_ll_rem_obj, 2, 2, mp_lv_ll_rem); + + + +/* + * lvgl extension definition for: + * void lv_ll_clear(lv_ll_t *ll_p) + */ + +STATIC mp_obj_t mp_lv_ll_clear(size_t n_args, const mp_obj_t *args) +{ + lv_ll_t *ll_p = mp_write_ptr_lv_ll_t(args[0]); + lv_ll_clear(ll_p); + return mp_const_none; +} + +STATIC MP_DEFINE_CONST_FUN_OBJ_VAR_BETWEEN(mp_lv_ll_clear_obj, 1, 1, mp_lv_ll_clear); + + + +/* + * lvgl extension definition for: + * void lv_ll_chg_list(lv_ll_t *ll_ori_p, lv_ll_t *ll_new_p, void *node) + */ + +STATIC mp_obj_t mp_lv_ll_chg_list(size_t n_args, const mp_obj_t *args) +{ + lv_ll_t *ll_ori_p = mp_write_ptr_lv_ll_t(args[0]); + lv_ll_t *ll_new_p = mp_write_ptr_lv_ll_t(args[1]); + void *node = mp_to_ptr(args[2]); + lv_ll_chg_list(ll_ori_p, ll_new_p, node); + return mp_const_none; +} + +STATIC MP_DEFINE_CONST_FUN_OBJ_VAR_BETWEEN(mp_lv_ll_chg_list_obj, 3, 3, mp_lv_ll_chg_list); + + + +/* + * lvgl extension definition for: + * void *lv_ll_get_head(const lv_ll_t *ll_p) + */ + +STATIC mp_obj_t mp_lv_ll_get_head(size_t n_args, const mp_obj_t *args) +{ + const lv_ll_t *ll_p = mp_write_ptr_lv_ll_t(args[0]); + void* res = lv_ll_get_head(ll_p); + return ptr_to_mp((void*)res); +} + +STATIC MP_DEFINE_CONST_FUN_OBJ_VAR_BETWEEN(mp_lv_ll_get_head_obj, 1, 1, mp_lv_ll_get_head); + + + +/* + * lvgl extension definition for: + * void *lv_ll_get_tail(const lv_ll_t *ll_p) + */ + +STATIC mp_obj_t mp_lv_ll_get_tail(size_t n_args, const mp_obj_t *args) +{ + const lv_ll_t *ll_p = mp_write_ptr_lv_ll_t(args[0]); + void* res = lv_ll_get_tail(ll_p); + return ptr_to_mp((void*)res); +} + +STATIC MP_DEFINE_CONST_FUN_OBJ_VAR_BETWEEN(mp_lv_ll_get_tail_obj, 1, 1, mp_lv_ll_get_tail); + + + +/* + * lvgl extension definition for: + * void *lv_ll_get_next(const lv_ll_t *ll_p, const void *n_act) + */ + +STATIC mp_obj_t mp_lv_ll_get_next(size_t n_args, const mp_obj_t *args) +{ + const lv_ll_t *ll_p = mp_write_ptr_lv_ll_t(args[0]); + const void *n_act = mp_to_ptr(args[1]); + void* res = lv_ll_get_next(ll_p, n_act); + return ptr_to_mp((void*)res); +} + +STATIC MP_DEFINE_CONST_FUN_OBJ_VAR_BETWEEN(mp_lv_ll_get_next_obj, 2, 2, mp_lv_ll_get_next); + + + +/* + * lvgl extension definition for: + * void *lv_ll_get_prev(const lv_ll_t *ll_p, const void *n_act) + */ + +STATIC mp_obj_t mp_lv_ll_get_prev(size_t n_args, const mp_obj_t *args) +{ + const lv_ll_t *ll_p = mp_write_ptr_lv_ll_t(args[0]); + const void *n_act = mp_to_ptr(args[1]); + void* res = lv_ll_get_prev(ll_p, n_act); + return ptr_to_mp((void*)res); +} + +STATIC MP_DEFINE_CONST_FUN_OBJ_VAR_BETWEEN(mp_lv_ll_get_prev_obj, 2, 2, mp_lv_ll_get_prev); + + + +/* + * lvgl extension definition for: + * void lv_ll_move_before(lv_ll_t *ll_p, void *n_act, void *n_after) + */ + +STATIC mp_obj_t mp_lv_ll_move_before(size_t n_args, const mp_obj_t *args) +{ + lv_ll_t *ll_p = mp_write_ptr_lv_ll_t(args[0]); + void *n_act = mp_to_ptr(args[1]); + void *n_after = mp_to_ptr(args[2]); + lv_ll_move_before(ll_p, n_act, n_after); + return mp_const_none; +} + +STATIC MP_DEFINE_CONST_FUN_OBJ_VAR_BETWEEN(mp_lv_ll_move_before_obj, 3, 3, mp_lv_ll_move_before); + + + +/* + * lvgl extension definition for: + * void lv_task_init(void) + */ + +STATIC mp_obj_t mp_lv_task_init(size_t n_args, const mp_obj_t *args) +{ + + lv_task_init(); + return mp_const_none; +} + +STATIC MP_DEFINE_CONST_FUN_OBJ_VAR_BETWEEN(mp_lv_task_init_obj, 0, 0, mp_lv_task_init); + + + +/* + * lvgl extension definition for: + * void lv_task_handler(void) + */ + +STATIC mp_obj_t mp_lv_task_handler(size_t n_args, const mp_obj_t *args) +{ + + lv_task_handler(); + return mp_const_none; +} + +STATIC MP_DEFINE_CONST_FUN_OBJ_VAR_BETWEEN(mp_lv_task_handler_obj, 0, 0, mp_lv_task_handler); + + + +/* + * Struct lv_task_t + */ + +STATIC inline const mp_obj_type_t *get_mp_lv_task_t_type(); + +STATIC inline lv_task_t* mp_write_ptr_lv_task_t(mp_obj_t self_in) +{ + mp_lv_struct_t *self = MP_OBJ_TO_PTR(cast(self_in, get_mp_lv_task_t_type())); + return (lv_task_t*)self->data; +} + +#define mp_write_lv_task_t(struct_obj) *mp_write_ptr_lv_task_t(struct_obj) + +STATIC inline mp_obj_t mp_read_ptr_lv_task_t(lv_task_t *field) +{ + return lv_to_mp_struct(get_mp_lv_task_t_type(), field); +} + +#define mp_read_lv_task_t(field) mp_read_ptr_lv_task_t(copy_buffer(&field, sizeof(lv_task_t))) +#define mp_read_byref_lv_task_t(field) mp_read_ptr_lv_task_t(&field) + +STATIC void mp_lv_task_t_attr(mp_obj_t self_in, qstr attr, mp_obj_t *dest) +{ + mp_lv_struct_t *self = MP_OBJ_TO_PTR(self_in); + lv_task_t *data = (lv_task_t*)self->data; + + if (dest[0] == MP_OBJ_NULL) { + // load attribute + switch(attr) + { + case MP_QSTR_period: dest[0] = mp_obj_new_int_from_uint(data->period); break; // converting from uint32_t; + case MP_QSTR_last_run: dest[0] = mp_obj_new_int_from_uint(data->last_run); break; // converting from uint32_t; + case MP_QSTR_task: dest[0] = ptr_to_mp((void*)data->task); break; // converting from void task(void *)*; + case MP_QSTR_param: dest[0] = ptr_to_mp((void*)data->param); break; // converting from void*; + case MP_QSTR_prio: dest[0] = mp_obj_new_int_from_uint(data->prio); break; // converting from uint8_t; + case MP_QSTR_once: dest[0] = mp_obj_new_int_from_uint(data->once); break; // converting from uint8_t; + default: field_not_found(MP_QSTR_lv_task_t, attr); + } + } else { + if (dest[1]) + { + // store attribute + switch(attr) + { + case MP_QSTR_period: data->period = (uint32_t)mp_obj_get_int(dest[1]); break; // converting to uint32_t; + case MP_QSTR_last_run: data->last_run = (uint32_t)mp_obj_get_int(dest[1]); break; // converting to uint32_t; + case MP_QSTR_task: data->task = (void*)mp_to_ptr(dest[1]); break; // converting to void task(void *)*; + case MP_QSTR_param: data->param = (void*)mp_to_ptr(dest[1]); break; // converting to void*; + case MP_QSTR_prio: data->prio = (uint8_t)mp_obj_get_int(dest[1]); break; // converting to uint8_t; + case MP_QSTR_once: data->once = (uint8_t)mp_obj_get_int(dest[1]); break; // converting to uint8_t; + default: field_not_found(MP_QSTR_lv_task_t, attr); + } + + dest[0] = MP_OBJ_NULL; // indicate success + } + } +} + +STATIC void mp_lv_task_t_print(const mp_print_t *print, + mp_obj_t self_in, + mp_print_kind_t kind) +{ + mp_printf(print, "lvgl struct lv_task_t"); +} + +STATIC const mp_rom_map_elem_t mp_lv_task_t_locals_dict_table[] = { + { MP_ROM_QSTR(MP_QSTR_SIZE), MP_ROM_PTR(MP_ROM_INT(sizeof(lv_task_t))) }, + { MP_ROM_QSTR(MP_QSTR_cast), MP_ROM_PTR(&mp_lv_cast_class_method) }, +}; + +STATIC MP_DEFINE_CONST_DICT(mp_lv_task_t_locals_dict, mp_lv_task_t_locals_dict_table); + +STATIC const mp_obj_type_t mp_lv_task_t_type = { + { &mp_type_type }, + .name = MP_QSTR_lv_task_t, + .print = mp_lv_task_t_print, + .make_new = make_new_lv_struct, + .attr = mp_lv_task_t_attr, + .locals_dict = (mp_obj_dict_t*)&mp_lv_task_t_locals_dict, + .buffer_p = { .get_buffer = mp_blob_get_buffer } +}; + +STATIC inline const mp_obj_type_t *get_mp_lv_task_t_type() +{ + return &mp_lv_task_t_type; +} + + +/* + * lvgl extension definition for: + * lv_task_t *lv_task_create(void (*task)(void *), uint32_t period, lv_task_prio_t prio, void *param) + */ + +STATIC mp_obj_t mp_lv_task_create(size_t n_args, const mp_obj_t *args) +{ + void (*task)(void *) = mp_to_ptr(args[0]); + uint32_t period = (uint32_t)mp_obj_get_int(args[1]); + lv_task_prio_t prio = (uint8_t)mp_obj_get_int(args[2]); + void *param = mp_to_ptr(args[3]); + lv_task_t* res = lv_task_create(task, period, prio, param); + return mp_read_ptr_lv_task_t((void*)res); +} + +STATIC MP_DEFINE_CONST_FUN_OBJ_VAR_BETWEEN(mp_lv_task_create_obj, 4, 4, mp_lv_task_create); + + + +/* + * lvgl extension definition for: + * void lv_task_del(lv_task_t *lv_task_p) + */ + +STATIC mp_obj_t mp_lv_task_del(size_t n_args, const mp_obj_t *args) +{ + lv_task_t *lv_task_p = mp_write_ptr_lv_task_t(args[0]); + lv_task_del(lv_task_p); + return mp_const_none; +} + +STATIC MP_DEFINE_CONST_FUN_OBJ_VAR_BETWEEN(mp_lv_task_del_obj, 1, 1, mp_lv_task_del); + + + +/* + * lvgl extension definition for: + * void lv_task_set_prio(lv_task_t *lv_task_p, lv_task_prio_t prio) + */ + +STATIC mp_obj_t mp_lv_task_set_prio(size_t n_args, const mp_obj_t *args) +{ + lv_task_t *lv_task_p = mp_write_ptr_lv_task_t(args[0]); + lv_task_prio_t prio = (uint8_t)mp_obj_get_int(args[1]); + lv_task_set_prio(lv_task_p, prio); + return mp_const_none; +} + +STATIC MP_DEFINE_CONST_FUN_OBJ_VAR_BETWEEN(mp_lv_task_set_prio_obj, 2, 2, mp_lv_task_set_prio); + + + +/* + * lvgl extension definition for: + * void lv_task_set_period(lv_task_t *lv_task_p, uint32_t period) + */ + +STATIC mp_obj_t mp_lv_task_set_period(size_t n_args, const mp_obj_t *args) +{ + lv_task_t *lv_task_p = mp_write_ptr_lv_task_t(args[0]); + uint32_t period = (uint32_t)mp_obj_get_int(args[1]); + lv_task_set_period(lv_task_p, period); + return mp_const_none; +} + +STATIC MP_DEFINE_CONST_FUN_OBJ_VAR_BETWEEN(mp_lv_task_set_period_obj, 2, 2, mp_lv_task_set_period); + + + +/* + * lvgl extension definition for: + * void lv_task_ready(lv_task_t *lv_task_p) + */ + +STATIC mp_obj_t mp_lv_task_ready(size_t n_args, const mp_obj_t *args) +{ + lv_task_t *lv_task_p = mp_write_ptr_lv_task_t(args[0]); + lv_task_ready(lv_task_p); + return mp_const_none; +} + +STATIC MP_DEFINE_CONST_FUN_OBJ_VAR_BETWEEN(mp_lv_task_ready_obj, 1, 1, mp_lv_task_ready); + + + +/* + * lvgl extension definition for: + * void lv_task_once(lv_task_t *lv_task_p) + */ + +STATIC mp_obj_t mp_lv_task_once(size_t n_args, const mp_obj_t *args) +{ + lv_task_t *lv_task_p = mp_write_ptr_lv_task_t(args[0]); + lv_task_once(lv_task_p); + return mp_const_none; +} + +STATIC MP_DEFINE_CONST_FUN_OBJ_VAR_BETWEEN(mp_lv_task_once_obj, 1, 1, mp_lv_task_once); + + + +/* + * lvgl extension definition for: + * void lv_task_reset(lv_task_t *lv_task_p) + */ + +STATIC mp_obj_t mp_lv_task_reset(size_t n_args, const mp_obj_t *args) +{ + lv_task_t *lv_task_p = mp_write_ptr_lv_task_t(args[0]); + lv_task_reset(lv_task_p); + return mp_const_none; +} + +STATIC MP_DEFINE_CONST_FUN_OBJ_VAR_BETWEEN(mp_lv_task_reset_obj, 1, 1, mp_lv_task_reset); + + + +/* + * lvgl extension definition for: + * void lv_task_enable(bool en) + */ + +STATIC mp_obj_t mp_lv_task_enable(size_t n_args, const mp_obj_t *args) +{ + bool en = mp_obj_is_true(args[0]); + lv_task_enable(en); + return mp_const_none; +} + +STATIC MP_DEFINE_CONST_FUN_OBJ_VAR_BETWEEN(mp_lv_task_enable_obj, 1, 1, mp_lv_task_enable); + + + +/* + * lvgl extension definition for: + * uint8_t lv_task_get_idle(void) + */ + +STATIC mp_obj_t mp_lv_task_get_idle(size_t n_args, const mp_obj_t *args) +{ + + uint8_t res = lv_task_get_idle(); + return mp_obj_new_int_from_uint(res); +} + +STATIC MP_DEFINE_CONST_FUN_OBJ_VAR_BETWEEN(mp_lv_task_get_idle_obj, 0, 0, mp_lv_task_get_idle); + + + +/* + * lvgl extension definition for: + * lv_color_t lv_color_hsv_to_rgb(uint16_t h, uint8_t s, uint8_t v) + */ + +STATIC mp_obj_t mp_lv_color_hsv_to_rgb(size_t n_args, const mp_obj_t *args) +{ + uint16_t h = (uint16_t)mp_obj_get_int(args[0]); + uint8_t s = (uint8_t)mp_obj_get_int(args[1]); + uint8_t v = (uint8_t)mp_obj_get_int(args[2]); + lv_color_t res = lv_color_hsv_to_rgb(h, s, v); + return mp_read_lv_color16_t(res); +} + +STATIC MP_DEFINE_CONST_FUN_OBJ_VAR_BETWEEN(mp_lv_color_hsv_to_rgb_obj, 3, 3, mp_lv_color_hsv_to_rgb); + + + +/* + * Struct lv_color_hsv_t + */ + +STATIC inline const mp_obj_type_t *get_mp_lv_color_hsv_t_type(); + +STATIC inline lv_color_hsv_t* mp_write_ptr_lv_color_hsv_t(mp_obj_t self_in) +{ + mp_lv_struct_t *self = MP_OBJ_TO_PTR(cast(self_in, get_mp_lv_color_hsv_t_type())); + return (lv_color_hsv_t*)self->data; +} + +#define mp_write_lv_color_hsv_t(struct_obj) *mp_write_ptr_lv_color_hsv_t(struct_obj) + +STATIC inline mp_obj_t mp_read_ptr_lv_color_hsv_t(lv_color_hsv_t *field) +{ + return lv_to_mp_struct(get_mp_lv_color_hsv_t_type(), field); +} + +#define mp_read_lv_color_hsv_t(field) mp_read_ptr_lv_color_hsv_t(copy_buffer(&field, sizeof(lv_color_hsv_t))) +#define mp_read_byref_lv_color_hsv_t(field) mp_read_ptr_lv_color_hsv_t(&field) + +STATIC void mp_lv_color_hsv_t_attr(mp_obj_t self_in, qstr attr, mp_obj_t *dest) +{ + mp_lv_struct_t *self = MP_OBJ_TO_PTR(self_in); + lv_color_hsv_t *data = (lv_color_hsv_t*)self->data; + + if (dest[0] == MP_OBJ_NULL) { + // load attribute + switch(attr) + { + case MP_QSTR_h: dest[0] = mp_obj_new_int_from_uint(data->h); break; // converting from uint16_t; + case MP_QSTR_s: dest[0] = mp_obj_new_int_from_uint(data->s); break; // converting from uint8_t; + case MP_QSTR_v: dest[0] = mp_obj_new_int_from_uint(data->v); break; // converting from uint8_t; + default: field_not_found(MP_QSTR_lv_color_hsv_t, attr); + } + } else { + if (dest[1]) + { + // store attribute + switch(attr) + { + case MP_QSTR_h: data->h = (uint16_t)mp_obj_get_int(dest[1]); break; // converting to uint16_t; + case MP_QSTR_s: data->s = (uint8_t)mp_obj_get_int(dest[1]); break; // converting to uint8_t; + case MP_QSTR_v: data->v = (uint8_t)mp_obj_get_int(dest[1]); break; // converting to uint8_t; + default: field_not_found(MP_QSTR_lv_color_hsv_t, attr); + } + + dest[0] = MP_OBJ_NULL; // indicate success + } + } +} + +STATIC void mp_lv_color_hsv_t_print(const mp_print_t *print, + mp_obj_t self_in, + mp_print_kind_t kind) +{ + mp_printf(print, "lvgl struct lv_color_hsv_t"); +} + +STATIC const mp_rom_map_elem_t mp_lv_color_hsv_t_locals_dict_table[] = { + { MP_ROM_QSTR(MP_QSTR_SIZE), MP_ROM_PTR(MP_ROM_INT(sizeof(lv_color_hsv_t))) }, + { MP_ROM_QSTR(MP_QSTR_cast), MP_ROM_PTR(&mp_lv_cast_class_method) }, +}; + +STATIC MP_DEFINE_CONST_DICT(mp_lv_color_hsv_t_locals_dict, mp_lv_color_hsv_t_locals_dict_table); + +STATIC const mp_obj_type_t mp_lv_color_hsv_t_type = { + { &mp_type_type }, + .name = MP_QSTR_lv_color_hsv_t, + .print = mp_lv_color_hsv_t_print, + .make_new = make_new_lv_struct, + .attr = mp_lv_color_hsv_t_attr, + .locals_dict = (mp_obj_dict_t*)&mp_lv_color_hsv_t_locals_dict, + .buffer_p = { .get_buffer = mp_blob_get_buffer } +}; + +STATIC inline const mp_obj_type_t *get_mp_lv_color_hsv_t_type() +{ + return &mp_lv_color_hsv_t_type; +} + + +/* + * lvgl extension definition for: + * lv_color_hsv_t lv_color_rgb_to_hsv(uint8_t r, uint8_t g, uint8_t b) + */ + +STATIC mp_obj_t mp_lv_color_rgb_to_hsv(size_t n_args, const mp_obj_t *args) +{ + uint8_t r = (uint8_t)mp_obj_get_int(args[0]); + uint8_t g = (uint8_t)mp_obj_get_int(args[1]); + uint8_t b = (uint8_t)mp_obj_get_int(args[2]); + lv_color_hsv_t res = lv_color_rgb_to_hsv(r, g, b); + return mp_read_lv_color_hsv_t(res); +} + +STATIC MP_DEFINE_CONST_FUN_OBJ_VAR_BETWEEN(mp_lv_color_rgb_to_hsv_obj, 3, 3, mp_lv_color_rgb_to_hsv); + + + +/* + * lvgl extension definition for: + * void lv_area_set(lv_area_t *area_p, lv_coord_t x1, lv_coord_t y1, lv_coord_t x2, lv_coord_t y2) + */ + +STATIC mp_obj_t mp_lv_area_set(size_t n_args, const mp_obj_t *args) +{ + lv_area_t *area_p = mp_write_ptr_lv_area_t(args[0]); + lv_coord_t x1 = (int16_t)mp_obj_get_int(args[1]); + lv_coord_t y1 = (int16_t)mp_obj_get_int(args[2]); + lv_coord_t x2 = (int16_t)mp_obj_get_int(args[3]); + lv_coord_t y2 = (int16_t)mp_obj_get_int(args[4]); + lv_area_set(area_p, x1, y1, x2, y2); + return mp_const_none; +} + +STATIC MP_DEFINE_CONST_FUN_OBJ_VAR_BETWEEN(mp_lv_area_set_obj, 5, 5, mp_lv_area_set); + + + +/* + * lvgl extension definition for: + * void lv_area_set_width(lv_area_t *area_p, lv_coord_t w) + */ + +STATIC mp_obj_t mp_lv_area_set_width(size_t n_args, const mp_obj_t *args) +{ + lv_area_t *area_p = mp_write_ptr_lv_area_t(args[0]); + lv_coord_t w = (int16_t)mp_obj_get_int(args[1]); + lv_area_set_width(area_p, w); + return mp_const_none; +} + +STATIC MP_DEFINE_CONST_FUN_OBJ_VAR_BETWEEN(mp_lv_area_set_width_obj, 2, 2, mp_lv_area_set_width); + + + +/* + * lvgl extension definition for: + * void lv_area_set_height(lv_area_t *area_p, lv_coord_t h) + */ + +STATIC mp_obj_t mp_lv_area_set_height(size_t n_args, const mp_obj_t *args) +{ + lv_area_t *area_p = mp_write_ptr_lv_area_t(args[0]); + lv_coord_t h = (int16_t)mp_obj_get_int(args[1]); + lv_area_set_height(area_p, h); + return mp_const_none; +} + +STATIC MP_DEFINE_CONST_FUN_OBJ_VAR_BETWEEN(mp_lv_area_set_height_obj, 2, 2, mp_lv_area_set_height); + + + +/* + * lvgl extension definition for: + * void lv_area_set_pos(lv_area_t *area_p, lv_coord_t x, lv_coord_t y) + */ + +STATIC mp_obj_t mp_lv_area_set_pos(size_t n_args, const mp_obj_t *args) +{ + lv_area_t *area_p = mp_write_ptr_lv_area_t(args[0]); + lv_coord_t x = (int16_t)mp_obj_get_int(args[1]); + lv_coord_t y = (int16_t)mp_obj_get_int(args[2]); + lv_area_set_pos(area_p, x, y); + return mp_const_none; +} + +STATIC MP_DEFINE_CONST_FUN_OBJ_VAR_BETWEEN(mp_lv_area_set_pos_obj, 3, 3, mp_lv_area_set_pos); + + + +/* + * lvgl extension definition for: + * uint32_t lv_area_get_size(const lv_area_t *area_p) + */ + +STATIC mp_obj_t mp_lv_area_get_size(size_t n_args, const mp_obj_t *args) +{ + const lv_area_t *area_p = mp_write_ptr_lv_area_t(args[0]); + uint32_t res = lv_area_get_size(area_p); + return mp_obj_new_int_from_uint(res); +} + +STATIC MP_DEFINE_CONST_FUN_OBJ_VAR_BETWEEN(mp_lv_area_get_size_obj, 1, 1, mp_lv_area_get_size); + + + +/* + * lvgl extension definition for: + * bool lv_area_intersect(lv_area_t *res_p, const lv_area_t *a1_p, const lv_area_t *a2_p) + */ + +STATIC mp_obj_t mp_lv_area_intersect(size_t n_args, const mp_obj_t *args) +{ + lv_area_t *res_p = mp_write_ptr_lv_area_t(args[0]); + const lv_area_t *a1_p = mp_write_ptr_lv_area_t(args[1]); + const lv_area_t *a2_p = mp_write_ptr_lv_area_t(args[2]); + bool res = lv_area_intersect(res_p, a1_p, a2_p); + return convert_to_bool(res); +} + +STATIC MP_DEFINE_CONST_FUN_OBJ_VAR_BETWEEN(mp_lv_area_intersect_obj, 3, 3, mp_lv_area_intersect); + + + +/* + * lvgl extension definition for: + * void lv_area_join(lv_area_t *a_res_p, const lv_area_t *a1_p, const lv_area_t *a2_p) + */ + +STATIC mp_obj_t mp_lv_area_join(size_t n_args, const mp_obj_t *args) +{ + lv_area_t *a_res_p = mp_write_ptr_lv_area_t(args[0]); + const lv_area_t *a1_p = mp_write_ptr_lv_area_t(args[1]); + const lv_area_t *a2_p = mp_write_ptr_lv_area_t(args[2]); + lv_area_join(a_res_p, a1_p, a2_p); + return mp_const_none; +} + +STATIC MP_DEFINE_CONST_FUN_OBJ_VAR_BETWEEN(mp_lv_area_join_obj, 3, 3, mp_lv_area_join); + + + +/* + * lvgl extension definition for: + * bool lv_area_is_point_on(const lv_area_t *a_p, const lv_point_t *p_p) + */ + +STATIC mp_obj_t mp_lv_area_is_point_on(size_t n_args, const mp_obj_t *args) +{ + const lv_area_t *a_p = mp_write_ptr_lv_area_t(args[0]); + const lv_point_t *p_p = mp_write_ptr_lv_point_t(args[1]); + bool res = lv_area_is_point_on(a_p, p_p); + return convert_to_bool(res); +} + +STATIC MP_DEFINE_CONST_FUN_OBJ_VAR_BETWEEN(mp_lv_area_is_point_on_obj, 2, 2, mp_lv_area_is_point_on); + + + +/* + * lvgl extension definition for: + * bool lv_area_is_on(const lv_area_t *a1_p, const lv_area_t *a2_p) + */ + +STATIC mp_obj_t mp_lv_area_is_on(size_t n_args, const mp_obj_t *args) +{ + const lv_area_t *a1_p = mp_write_ptr_lv_area_t(args[0]); + const lv_area_t *a2_p = mp_write_ptr_lv_area_t(args[1]); + bool res = lv_area_is_on(a1_p, a2_p); + return convert_to_bool(res); +} + +STATIC MP_DEFINE_CONST_FUN_OBJ_VAR_BETWEEN(mp_lv_area_is_on_obj, 2, 2, mp_lv_area_is_on); + + + +/* + * lvgl extension definition for: + * bool lv_area_is_in(const lv_area_t *ain_p, const lv_area_t *aholder_p) + */ + +STATIC mp_obj_t mp_lv_area_is_in(size_t n_args, const mp_obj_t *args) +{ + const lv_area_t *ain_p = mp_write_ptr_lv_area_t(args[0]); + const lv_area_t *aholder_p = mp_write_ptr_lv_area_t(args[1]); + bool res = lv_area_is_in(ain_p, aholder_p); + return convert_to_bool(res); +} + +STATIC MP_DEFINE_CONST_FUN_OBJ_VAR_BETWEEN(mp_lv_area_is_in_obj, 2, 2, mp_lv_area_is_in); + + + +/* + * Struct lv_disp_drv_t + */ + +STATIC inline const mp_obj_type_t *get_mp_lv_disp_drv_t_type(); + +STATIC inline lv_disp_drv_t* mp_write_ptr_lv_disp_drv_t(mp_obj_t self_in) +{ + mp_lv_struct_t *self = MP_OBJ_TO_PTR(cast(self_in, get_mp_lv_disp_drv_t_type())); + return (lv_disp_drv_t*)self->data; +} + +#define mp_write_lv_disp_drv_t(struct_obj) *mp_write_ptr_lv_disp_drv_t(struct_obj) + +STATIC inline mp_obj_t mp_read_ptr_lv_disp_drv_t(lv_disp_drv_t *field) +{ + return lv_to_mp_struct(get_mp_lv_disp_drv_t_type(), field); +} + +#define mp_read_lv_disp_drv_t(field) mp_read_ptr_lv_disp_drv_t(copy_buffer(&field, sizeof(lv_disp_drv_t))) +#define mp_read_byref_lv_disp_drv_t(field) mp_read_ptr_lv_disp_drv_t(&field) + +STATIC void mp_lv_disp_drv_t_attr(mp_obj_t self_in, qstr attr, mp_obj_t *dest) +{ + mp_lv_struct_t *self = MP_OBJ_TO_PTR(self_in); + lv_disp_drv_t *data = (lv_disp_drv_t*)self->data; + + if (dest[0] == MP_OBJ_NULL) { + // load attribute + switch(attr) + { + case MP_QSTR_disp_flush: dest[0] = ptr_to_mp((void*)data->disp_flush); break; // converting from void disp_flush(int32_t x1, int32_t y1, int32_t x2, int32_t y2, const lv_color_t *color_p)*; + case MP_QSTR_disp_fill: dest[0] = ptr_to_mp((void*)data->disp_fill); break; // converting from void disp_fill(int32_t x1, int32_t y1, int32_t x2, int32_t y2, lv_color_t color)*; + case MP_QSTR_disp_map: dest[0] = ptr_to_mp((void*)data->disp_map); break; // converting from void disp_map(int32_t x1, int32_t y1, int32_t x2, int32_t y2, const lv_color_t *color_p)*; + case MP_QSTR_vdb_wr: dest[0] = ptr_to_mp((void*)data->vdb_wr); break; // converting from void vdb_wr(uint8_t *buf, lv_coord_t buf_w, lv_coord_t x, lv_coord_t y, lv_color_t color, lv_opa_t opa)*; + default: field_not_found(MP_QSTR_lv_disp_drv_t, attr); + } + } else { + if (dest[1]) + { + // store attribute + switch(attr) + { + case MP_QSTR_disp_flush: data->disp_flush = (void*)mp_to_ptr(dest[1]); break; // converting to void disp_flush(int32_t x1, int32_t y1, int32_t x2, int32_t y2, const lv_color_t *color_p)*; + case MP_QSTR_disp_fill: data->disp_fill = (void*)mp_to_ptr(dest[1]); break; // converting to void disp_fill(int32_t x1, int32_t y1, int32_t x2, int32_t y2, lv_color_t color)*; + case MP_QSTR_disp_map: data->disp_map = (void*)mp_to_ptr(dest[1]); break; // converting to void disp_map(int32_t x1, int32_t y1, int32_t x2, int32_t y2, const lv_color_t *color_p)*; + case MP_QSTR_vdb_wr: data->vdb_wr = (void*)mp_to_ptr(dest[1]); break; // converting to void vdb_wr(uint8_t *buf, lv_coord_t buf_w, lv_coord_t x, lv_coord_t y, lv_color_t color, lv_opa_t opa)*; + default: field_not_found(MP_QSTR_lv_disp_drv_t, attr); + } + + dest[0] = MP_OBJ_NULL; // indicate success + } + } +} + +STATIC void mp_lv_disp_drv_t_print(const mp_print_t *print, + mp_obj_t self_in, + mp_print_kind_t kind) +{ + mp_printf(print, "lvgl struct lv_disp_drv_t"); +} + +STATIC const mp_rom_map_elem_t mp_lv_disp_drv_t_locals_dict_table[] = { + { MP_ROM_QSTR(MP_QSTR_SIZE), MP_ROM_PTR(MP_ROM_INT(sizeof(lv_disp_drv_t))) }, + { MP_ROM_QSTR(MP_QSTR_cast), MP_ROM_PTR(&mp_lv_cast_class_method) }, +}; + +STATIC MP_DEFINE_CONST_DICT(mp_lv_disp_drv_t_locals_dict, mp_lv_disp_drv_t_locals_dict_table); + +STATIC const mp_obj_type_t mp_lv_disp_drv_t_type = { + { &mp_type_type }, + .name = MP_QSTR_lv_disp_drv_t, + .print = mp_lv_disp_drv_t_print, + .make_new = make_new_lv_struct, + .attr = mp_lv_disp_drv_t_attr, + .locals_dict = (mp_obj_dict_t*)&mp_lv_disp_drv_t_locals_dict, + .buffer_p = { .get_buffer = mp_blob_get_buffer } +}; + +STATIC inline const mp_obj_type_t *get_mp_lv_disp_drv_t_type() +{ + return &mp_lv_disp_drv_t_type; +} + + +/* + * lvgl extension definition for: + * void lv_disp_drv_init(lv_disp_drv_t *driver) + */ + +STATIC mp_obj_t mp_lv_disp_drv_init(size_t n_args, const mp_obj_t *args) +{ + lv_disp_drv_t *driver = mp_write_ptr_lv_disp_drv_t(args[0]); + lv_disp_drv_init(driver); + return mp_const_none; +} + +STATIC MP_DEFINE_CONST_FUN_OBJ_VAR_BETWEEN(mp_lv_disp_drv_init_obj, 1, 1, mp_lv_disp_drv_init); + + + +/* + * Struct lv_disp_t + */ + +STATIC inline const mp_obj_type_t *get_mp_lv_disp_t_type(); + +STATIC inline lv_disp_t* mp_write_ptr_lv_disp_t(mp_obj_t self_in) +{ + mp_lv_struct_t *self = MP_OBJ_TO_PTR(cast(self_in, get_mp_lv_disp_t_type())); + return (lv_disp_t*)self->data; +} + +#define mp_write_lv_disp_t(struct_obj) *mp_write_ptr_lv_disp_t(struct_obj) + +STATIC inline mp_obj_t mp_read_ptr_lv_disp_t(lv_disp_t *field) +{ + return lv_to_mp_struct(get_mp_lv_disp_t_type(), field); +} + +#define mp_read_lv_disp_t(field) mp_read_ptr_lv_disp_t(copy_buffer(&field, sizeof(lv_disp_t))) +#define mp_read_byref_lv_disp_t(field) mp_read_ptr_lv_disp_t(&field) + +STATIC void mp_lv_disp_t_attr(mp_obj_t self_in, qstr attr, mp_obj_t *dest) +{ + mp_lv_struct_t *self = MP_OBJ_TO_PTR(self_in); + lv_disp_t *data = (lv_disp_t*)self->data; + + if (dest[0] == MP_OBJ_NULL) { + // load attribute + switch(attr) + { + case MP_QSTR_driver: dest[0] = mp_read_byref_lv_disp_drv_t(data->driver); break; // converting from lv_disp_drv_t; + case MP_QSTR_next: dest[0] = ptr_to_mp((void*)data->next); break; // converting from struct _disp_t*; + default: field_not_found(MP_QSTR_lv_disp_t, attr); + } + } else { + if (dest[1]) + { + // store attribute + switch(attr) + { + case MP_QSTR_driver: data->driver = mp_write_lv_disp_drv_t(dest[1]); break; // converting to lv_disp_drv_t; + case MP_QSTR_next: data->next = (void*)mp_to_ptr(dest[1]); break; // converting to struct _disp_t*; + default: field_not_found(MP_QSTR_lv_disp_t, attr); + } + + dest[0] = MP_OBJ_NULL; // indicate success + } + } +} + +STATIC void mp_lv_disp_t_print(const mp_print_t *print, + mp_obj_t self_in, + mp_print_kind_t kind) +{ + mp_printf(print, "lvgl struct lv_disp_t"); +} + +STATIC const mp_rom_map_elem_t mp_lv_disp_t_locals_dict_table[] = { + { MP_ROM_QSTR(MP_QSTR_SIZE), MP_ROM_PTR(MP_ROM_INT(sizeof(lv_disp_t))) }, + { MP_ROM_QSTR(MP_QSTR_cast), MP_ROM_PTR(&mp_lv_cast_class_method) }, +}; + +STATIC MP_DEFINE_CONST_DICT(mp_lv_disp_t_locals_dict, mp_lv_disp_t_locals_dict_table); + +STATIC const mp_obj_type_t mp_lv_disp_t_type = { + { &mp_type_type }, + .name = MP_QSTR_lv_disp_t, + .print = mp_lv_disp_t_print, + .make_new = make_new_lv_struct, + .attr = mp_lv_disp_t_attr, + .locals_dict = (mp_obj_dict_t*)&mp_lv_disp_t_locals_dict, + .buffer_p = { .get_buffer = mp_blob_get_buffer } +}; + +STATIC inline const mp_obj_type_t *get_mp_lv_disp_t_type() +{ + return &mp_lv_disp_t_type; +} + + +/* + * lvgl extension definition for: + * lv_disp_t *lv_disp_drv_register(lv_disp_drv_t *driver) + */ + +STATIC mp_obj_t mp_lv_disp_drv_register(size_t n_args, const mp_obj_t *args) +{ + lv_disp_drv_t *driver = mp_write_ptr_lv_disp_drv_t(args[0]); + lv_disp_t* res = lv_disp_drv_register(driver); + return mp_read_ptr_lv_disp_t((void*)res); +} + +STATIC MP_DEFINE_CONST_FUN_OBJ_VAR_BETWEEN(mp_lv_disp_drv_register_obj, 1, 1, mp_lv_disp_drv_register); + + + +/* + * lvgl extension definition for: + * void lv_disp_set_active(lv_disp_t *disp) + */ + +STATIC mp_obj_t mp_lv_disp_set_active(size_t n_args, const mp_obj_t *args) +{ + lv_disp_t *disp = mp_write_ptr_lv_disp_t(args[0]); + lv_disp_set_active(disp); + return mp_const_none; +} + +STATIC MP_DEFINE_CONST_FUN_OBJ_VAR_BETWEEN(mp_lv_disp_set_active_obj, 1, 1, mp_lv_disp_set_active); + + + +/* + * lvgl extension definition for: + * lv_disp_t *lv_disp_get_active(void) + */ + +STATIC mp_obj_t mp_lv_disp_get_active(size_t n_args, const mp_obj_t *args) +{ + + lv_disp_t* res = lv_disp_get_active(); + return mp_read_ptr_lv_disp_t((void*)res); +} + +STATIC MP_DEFINE_CONST_FUN_OBJ_VAR_BETWEEN(mp_lv_disp_get_active_obj, 0, 0, mp_lv_disp_get_active); + + + +/* + * lvgl extension definition for: + * lv_disp_t *lv_disp_next(lv_disp_t *disp) + */ + +STATIC mp_obj_t mp_lv_disp_next(size_t n_args, const mp_obj_t *args) +{ + lv_disp_t *disp = mp_write_ptr_lv_disp_t(args[0]); + lv_disp_t* res = lv_disp_next(disp); + return mp_read_ptr_lv_disp_t((void*)res); +} + +STATIC MP_DEFINE_CONST_FUN_OBJ_VAR_BETWEEN(mp_lv_disp_next_obj, 1, 1, mp_lv_disp_next); + + + +/* + * lvgl extension definition for: + * void lv_disp_flush(int32_t x1, int32_t y1, int32_t x2, int32_t y2, lv_color_t *color_p) + */ + +STATIC mp_obj_t mp_lv_disp_flush(size_t n_args, const mp_obj_t *args) +{ + int32_t x1 = (int32_t)mp_obj_get_int(args[0]); + int32_t y1 = (int32_t)mp_obj_get_int(args[1]); + int32_t x2 = (int32_t)mp_obj_get_int(args[2]); + int32_t y2 = (int32_t)mp_obj_get_int(args[3]); + lv_color_t *color_p = mp_write_ptr_lv_color16_t(args[4]); + lv_disp_flush(x1, y1, x2, y2, color_p); + return mp_const_none; +} + +STATIC MP_DEFINE_CONST_FUN_OBJ_VAR_BETWEEN(mp_lv_disp_flush_obj, 5, 5, mp_lv_disp_flush); + + + +/* + * lvgl extension definition for: + * void lv_disp_fill(int32_t x1, int32_t y1, int32_t x2, int32_t y2, lv_color_t color) + */ + +STATIC mp_obj_t mp_lv_disp_fill(size_t n_args, const mp_obj_t *args) +{ + int32_t x1 = (int32_t)mp_obj_get_int(args[0]); + int32_t y1 = (int32_t)mp_obj_get_int(args[1]); + int32_t x2 = (int32_t)mp_obj_get_int(args[2]); + int32_t y2 = (int32_t)mp_obj_get_int(args[3]); + lv_color_t color = mp_write_lv_color16_t(args[4]); + lv_disp_fill(x1, y1, x2, y2, color); + return mp_const_none; +} + +STATIC MP_DEFINE_CONST_FUN_OBJ_VAR_BETWEEN(mp_lv_disp_fill_obj, 5, 5, mp_lv_disp_fill); + + + +/* + * lvgl extension definition for: + * void lv_disp_map(int32_t x1, int32_t y1, int32_t x2, int32_t y2, const lv_color_t *color_map) + */ + +STATIC mp_obj_t mp_lv_disp_map(size_t n_args, const mp_obj_t *args) +{ + int32_t x1 = (int32_t)mp_obj_get_int(args[0]); + int32_t y1 = (int32_t)mp_obj_get_int(args[1]); + int32_t x2 = (int32_t)mp_obj_get_int(args[2]); + int32_t y2 = (int32_t)mp_obj_get_int(args[3]); + const lv_color_t *color_map = mp_write_ptr_lv_color16_t(args[4]); + lv_disp_map(x1, y1, x2, y2, color_map); + return mp_const_none; +} + +STATIC MP_DEFINE_CONST_FUN_OBJ_VAR_BETWEEN(mp_lv_disp_map_obj, 5, 5, mp_lv_disp_map); + + + +/* + * lvgl extension definition for: + * void lv_font_init(void) + */ + +STATIC mp_obj_t mp_lv_font_init(size_t n_args, const mp_obj_t *args) +{ + + lv_font_init(); + return mp_const_none; +} + +STATIC MP_DEFINE_CONST_FUN_OBJ_VAR_BETWEEN(mp_lv_font_init_obj, 0, 0, mp_lv_font_init); + + + +/* + * lvgl extension definition for: + * void lv_font_add(lv_font_t *child, lv_font_t *parent) + */ + +STATIC mp_obj_t mp_lv_font_add(size_t n_args, const mp_obj_t *args) +{ + lv_font_t *child = mp_write_ptr_lv_font_t(args[0]); + lv_font_t *parent = mp_write_ptr_lv_font_t(args[1]); + lv_font_add(child, parent); + return mp_const_none; +} + +STATIC MP_DEFINE_CONST_FUN_OBJ_VAR_BETWEEN(mp_lv_font_add_obj, 2, 2, mp_lv_font_add); + + + +/* + * lvgl extension definition for: + * void lv_font_remove(lv_font_t *child, lv_font_t *parent) + */ + +STATIC mp_obj_t mp_lv_font_remove(size_t n_args, const mp_obj_t *args) +{ + lv_font_t *child = mp_write_ptr_lv_font_t(args[0]); + lv_font_t *parent = mp_write_ptr_lv_font_t(args[1]); + lv_font_remove(child, parent); + return mp_const_none; +} + +STATIC MP_DEFINE_CONST_FUN_OBJ_VAR_BETWEEN(mp_lv_font_remove_obj, 2, 2, mp_lv_font_remove); + + + +/* + * lvgl extension definition for: + * bool lv_font_is_monospace(const lv_font_t *font_p, uint32_t letter) + */ + +STATIC mp_obj_t mp_lv_font_is_monospace(size_t n_args, const mp_obj_t *args) +{ + const lv_font_t *font_p = mp_write_ptr_lv_font_t(args[0]); + uint32_t letter = (uint32_t)mp_obj_get_int(args[1]); + bool res = lv_font_is_monospace(font_p, letter); + return convert_to_bool(res); +} + +STATIC MP_DEFINE_CONST_FUN_OBJ_VAR_BETWEEN(mp_lv_font_is_monospace_obj, 2, 2, mp_lv_font_is_monospace); + + + +/* + * lvgl extension definition for: + * const uint8_t *lv_font_get_bitmap(const lv_font_t *font_p, uint32_t letter) + */ + +STATIC mp_obj_t mp_lv_font_get_bitmap(size_t n_args, const mp_obj_t *args) +{ + const lv_font_t *font_p = mp_write_ptr_lv_font_t(args[0]); + uint32_t letter = (uint32_t)mp_obj_get_int(args[1]); + const uint8_t* res = lv_font_get_bitmap(font_p, letter); + return ptr_to_mp((void*)res); +} + +STATIC MP_DEFINE_CONST_FUN_OBJ_VAR_BETWEEN(mp_lv_font_get_bitmap_obj, 2, 2, mp_lv_font_get_bitmap); + + + +/* + * lvgl extension definition for: + * uint8_t lv_font_get_width(const lv_font_t *font_p, uint32_t letter) + */ + +STATIC mp_obj_t mp_lv_font_get_width(size_t n_args, const mp_obj_t *args) +{ + const lv_font_t *font_p = mp_write_ptr_lv_font_t(args[0]); + uint32_t letter = (uint32_t)mp_obj_get_int(args[1]); + uint8_t res = lv_font_get_width(font_p, letter); + return mp_obj_new_int_from_uint(res); +} + +STATIC MP_DEFINE_CONST_FUN_OBJ_VAR_BETWEEN(mp_lv_font_get_width_obj, 2, 2, mp_lv_font_get_width); + + + +/* + * lvgl extension definition for: + * uint8_t lv_font_get_real_width(const lv_font_t *font_p, uint32_t letter) + */ + +STATIC mp_obj_t mp_lv_font_get_real_width(size_t n_args, const mp_obj_t *args) +{ + const lv_font_t *font_p = mp_write_ptr_lv_font_t(args[0]); + uint32_t letter = (uint32_t)mp_obj_get_int(args[1]); + uint8_t res = lv_font_get_real_width(font_p, letter); + return mp_obj_new_int_from_uint(res); +} + +STATIC MP_DEFINE_CONST_FUN_OBJ_VAR_BETWEEN(mp_lv_font_get_real_width_obj, 2, 2, mp_lv_font_get_real_width); + + + +/* + * lvgl extension definition for: + * uint8_t lv_font_get_bpp(const lv_font_t *font, uint32_t letter) + */ + +STATIC mp_obj_t mp_lv_font_get_bpp(size_t n_args, const mp_obj_t *args) +{ + const lv_font_t *font = mp_write_ptr_lv_font_t(args[0]); + uint32_t letter = (uint32_t)mp_obj_get_int(args[1]); + uint8_t res = lv_font_get_bpp(font, letter); + return mp_obj_new_int_from_uint(res); +} + +STATIC MP_DEFINE_CONST_FUN_OBJ_VAR_BETWEEN(mp_lv_font_get_bpp_obj, 2, 2, mp_lv_font_get_bpp); + + + +/* + * lvgl extension definition for: + * const uint8_t *lv_font_get_bitmap_continuous(const lv_font_t *font, uint32_t unicode_letter) + */ + +STATIC mp_obj_t mp_lv_font_get_bitmap_continuous(size_t n_args, const mp_obj_t *args) +{ + const lv_font_t *font = mp_write_ptr_lv_font_t(args[0]); + uint32_t unicode_letter = (uint32_t)mp_obj_get_int(args[1]); + const uint8_t* res = lv_font_get_bitmap_continuous(font, unicode_letter); + return ptr_to_mp((void*)res); +} + +STATIC MP_DEFINE_CONST_FUN_OBJ_VAR_BETWEEN(mp_lv_font_get_bitmap_continuous_obj, 2, 2, mp_lv_font_get_bitmap_continuous); + + + +/* + * lvgl extension definition for: + * const uint8_t *lv_font_get_bitmap_sparse(const lv_font_t *font, uint32_t unicode_letter) + */ + +STATIC mp_obj_t mp_lv_font_get_bitmap_sparse(size_t n_args, const mp_obj_t *args) +{ + const lv_font_t *font = mp_write_ptr_lv_font_t(args[0]); + uint32_t unicode_letter = (uint32_t)mp_obj_get_int(args[1]); + const uint8_t* res = lv_font_get_bitmap_sparse(font, unicode_letter); + return ptr_to_mp((void*)res); +} + +STATIC MP_DEFINE_CONST_FUN_OBJ_VAR_BETWEEN(mp_lv_font_get_bitmap_sparse_obj, 2, 2, mp_lv_font_get_bitmap_sparse); + + + +/* + * lvgl extension definition for: + * int16_t lv_font_get_width_continuous(const lv_font_t *font, uint32_t unicode_letter) + */ + +STATIC mp_obj_t mp_lv_font_get_width_continuous(size_t n_args, const mp_obj_t *args) +{ + const lv_font_t *font = mp_write_ptr_lv_font_t(args[0]); + uint32_t unicode_letter = (uint32_t)mp_obj_get_int(args[1]); + int16_t res = lv_font_get_width_continuous(font, unicode_letter); + return mp_obj_new_int(res); +} + +STATIC MP_DEFINE_CONST_FUN_OBJ_VAR_BETWEEN(mp_lv_font_get_width_continuous_obj, 2, 2, mp_lv_font_get_width_continuous); + + + +/* + * lvgl extension definition for: + * int16_t lv_font_get_width_sparse(const lv_font_t *font, uint32_t unicode_letter) + */ + +STATIC mp_obj_t mp_lv_font_get_width_sparse(size_t n_args, const mp_obj_t *args) +{ + const lv_font_t *font = mp_write_ptr_lv_font_t(args[0]); + uint32_t unicode_letter = (uint32_t)mp_obj_get_int(args[1]); + int16_t res = lv_font_get_width_sparse(font, unicode_letter); + return mp_obj_new_int(res); +} + +STATIC MP_DEFINE_CONST_FUN_OBJ_VAR_BETWEEN(mp_lv_font_get_width_sparse_obj, 2, 2, mp_lv_font_get_width_sparse); + + + +/* + * lvgl extension definition for: + * void lv_font_builtin_init(void) + */ + +STATIC mp_obj_t mp_lv_font_builtin_init(size_t n_args, const mp_obj_t *args) +{ + + lv_font_builtin_init(); + return mp_const_none; +} + +STATIC MP_DEFINE_CONST_FUN_OBJ_VAR_BETWEEN(mp_lv_font_builtin_init_obj, 0, 0, mp_lv_font_builtin_init); + + + +/* + * lvgl extension definition for: + * void lv_anim_init(void) + */ + +STATIC mp_obj_t mp_lv_anim_init(size_t n_args, const mp_obj_t *args) +{ + + lv_anim_init(); + return mp_const_none; +} + +STATIC MP_DEFINE_CONST_FUN_OBJ_VAR_BETWEEN(mp_lv_anim_init_obj, 0, 0, mp_lv_anim_init); + + + +/* + * Struct lv_anim_t + */ + +STATIC inline const mp_obj_type_t *get_mp_lv_anim_t_type(); + +STATIC inline lv_anim_t* mp_write_ptr_lv_anim_t(mp_obj_t self_in) +{ + mp_lv_struct_t *self = MP_OBJ_TO_PTR(cast(self_in, get_mp_lv_anim_t_type())); + return (lv_anim_t*)self->data; +} + +#define mp_write_lv_anim_t(struct_obj) *mp_write_ptr_lv_anim_t(struct_obj) + +STATIC inline mp_obj_t mp_read_ptr_lv_anim_t(lv_anim_t *field) +{ + return lv_to_mp_struct(get_mp_lv_anim_t_type(), field); +} + +#define mp_read_lv_anim_t(field) mp_read_ptr_lv_anim_t(copy_buffer(&field, sizeof(lv_anim_t))) +#define mp_read_byref_lv_anim_t(field) mp_read_ptr_lv_anim_t(&field) + +STATIC void mp_lv_anim_t_attr(mp_obj_t self_in, qstr attr, mp_obj_t *dest) +{ + mp_lv_struct_t *self = MP_OBJ_TO_PTR(self_in); + lv_anim_t *data = (lv_anim_t*)self->data; + + if (dest[0] == MP_OBJ_NULL) { + // load attribute + switch(attr) + { + case MP_QSTR_var: dest[0] = ptr_to_mp((void*)data->var); break; // converting from void*; + case MP_QSTR_fp: dest[0] = ptr_to_mp(data->fp); break; // converting from lv_anim_fp_t; + case MP_QSTR_end_cb: dest[0] = ptr_to_mp(data->end_cb); break; // converting from lv_anim_cb_t; + case MP_QSTR_path: dest[0] = ptr_to_mp(data->path); break; // converting from lv_anim_path_t; + case MP_QSTR_start: dest[0] = mp_obj_new_int(data->start); break; // converting from int32_t; + case MP_QSTR_end: dest[0] = mp_obj_new_int(data->end); break; // converting from int32_t; + case MP_QSTR_time: dest[0] = mp_obj_new_int_from_uint(data->time); break; // converting from uint16_t; + case MP_QSTR_act_time: dest[0] = mp_obj_new_int(data->act_time); break; // converting from int16_t; + case MP_QSTR_playback_pause: dest[0] = mp_obj_new_int_from_uint(data->playback_pause); break; // converting from uint16_t; + case MP_QSTR_repeat_pause: dest[0] = mp_obj_new_int_from_uint(data->repeat_pause); break; // converting from uint16_t; + case MP_QSTR_playback: dest[0] = mp_obj_new_int_from_uint(data->playback); break; // converting from uint8_t; + case MP_QSTR_repeat: dest[0] = mp_obj_new_int_from_uint(data->repeat); break; // converting from uint8_t; + case MP_QSTR_playback_now: dest[0] = mp_obj_new_int_from_uint(data->playback_now); break; // converting from uint8_t; + case MP_QSTR_has_run: dest[0] = mp_obj_new_int_from_uint(data->has_run); break; // converting from uint32_t; + default: field_not_found(MP_QSTR_lv_anim_t, attr); + } + } else { + if (dest[1]) + { + // store attribute + switch(attr) + { + case MP_QSTR_var: data->var = (void*)mp_to_ptr(dest[1]); break; // converting to void*; + case MP_QSTR_fp: data->fp = mp_to_ptr(dest[1]); break; // converting to lv_anim_fp_t; + case MP_QSTR_end_cb: data->end_cb = mp_to_ptr(dest[1]); break; // converting to lv_anim_cb_t; + case MP_QSTR_path: data->path = mp_to_ptr(dest[1]); break; // converting to lv_anim_path_t; + case MP_QSTR_start: data->start = (int32_t)mp_obj_get_int(dest[1]); break; // converting to int32_t; + case MP_QSTR_end: data->end = (int32_t)mp_obj_get_int(dest[1]); break; // converting to int32_t; + case MP_QSTR_time: data->time = (uint16_t)mp_obj_get_int(dest[1]); break; // converting to uint16_t; + case MP_QSTR_act_time: data->act_time = (int16_t)mp_obj_get_int(dest[1]); break; // converting to int16_t; + case MP_QSTR_playback_pause: data->playback_pause = (uint16_t)mp_obj_get_int(dest[1]); break; // converting to uint16_t; + case MP_QSTR_repeat_pause: data->repeat_pause = (uint16_t)mp_obj_get_int(dest[1]); break; // converting to uint16_t; + case MP_QSTR_playback: data->playback = (uint8_t)mp_obj_get_int(dest[1]); break; // converting to uint8_t; + case MP_QSTR_repeat: data->repeat = (uint8_t)mp_obj_get_int(dest[1]); break; // converting to uint8_t; + case MP_QSTR_playback_now: data->playback_now = (uint8_t)mp_obj_get_int(dest[1]); break; // converting to uint8_t; + case MP_QSTR_has_run: data->has_run = (uint32_t)mp_obj_get_int(dest[1]); break; // converting to uint32_t; + default: field_not_found(MP_QSTR_lv_anim_t, attr); + } + + dest[0] = MP_OBJ_NULL; // indicate success + } + } +} + +STATIC void mp_lv_anim_t_print(const mp_print_t *print, + mp_obj_t self_in, + mp_print_kind_t kind) +{ + mp_printf(print, "lvgl struct lv_anim_t"); +} + +STATIC const mp_rom_map_elem_t mp_lv_anim_t_locals_dict_table[] = { + { MP_ROM_QSTR(MP_QSTR_SIZE), MP_ROM_PTR(MP_ROM_INT(sizeof(lv_anim_t))) }, + { MP_ROM_QSTR(MP_QSTR_cast), MP_ROM_PTR(&mp_lv_cast_class_method) }, +}; + +STATIC MP_DEFINE_CONST_DICT(mp_lv_anim_t_locals_dict, mp_lv_anim_t_locals_dict_table); + +STATIC const mp_obj_type_t mp_lv_anim_t_type = { + { &mp_type_type }, + .name = MP_QSTR_lv_anim_t, + .print = mp_lv_anim_t_print, + .make_new = make_new_lv_struct, + .attr = mp_lv_anim_t_attr, + .locals_dict = (mp_obj_dict_t*)&mp_lv_anim_t_locals_dict, + .buffer_p = { .get_buffer = mp_blob_get_buffer } +}; + +STATIC inline const mp_obj_type_t *get_mp_lv_anim_t_type() +{ + return &mp_lv_anim_t_type; +} + + +/* + * lvgl extension definition for: + * void lv_anim_create(lv_anim_t *anim_p) + */ + +STATIC mp_obj_t mp_lv_anim_create(size_t n_args, const mp_obj_t *args) +{ + lv_anim_t *anim_p = mp_write_ptr_lv_anim_t(args[0]); + lv_anim_create(anim_p); + return mp_const_none; +} + +STATIC MP_DEFINE_CONST_FUN_OBJ_VAR_BETWEEN(mp_lv_anim_create_obj, 1, 1, mp_lv_anim_create); + + + +/* + * lvgl extension definition for: + * bool lv_anim_del(void *var, lv_anim_fp_t fp) + */ + +STATIC mp_obj_t mp_lv_anim_del(size_t n_args, const mp_obj_t *args) +{ + void *var = mp_to_ptr(args[0]); + set_action(args[0], args[1]); + lv_anim_fp_t fp = &lv_anim_fp_t_callback; + bool res = lv_anim_del(var, fp); + return convert_to_bool(res); +} + +STATIC MP_DEFINE_CONST_FUN_OBJ_VAR_BETWEEN(mp_lv_anim_del_obj, 2, 2, mp_lv_anim_del); + + + +/* + * lvgl extension definition for: + * uint16_t lv_anim_count_running(void) + */ + +STATIC mp_obj_t mp_lv_anim_count_running(size_t n_args, const mp_obj_t *args) +{ + + uint16_t res = lv_anim_count_running(); + return mp_obj_new_int_from_uint(res); +} + +STATIC MP_DEFINE_CONST_FUN_OBJ_VAR_BETWEEN(mp_lv_anim_count_running_obj, 0, 0, mp_lv_anim_count_running); + + + +/* + * lvgl extension definition for: + * uint16_t lv_anim_speed_to_time(uint16_t speed, int32_t start, int32_t end) + */ + +STATIC mp_obj_t mp_lv_anim_speed_to_time(size_t n_args, const mp_obj_t *args) +{ + uint16_t speed = (uint16_t)mp_obj_get_int(args[0]); + int32_t start = (int32_t)mp_obj_get_int(args[1]); + int32_t end = (int32_t)mp_obj_get_int(args[2]); + uint16_t res = lv_anim_speed_to_time(speed, start, end); + return mp_obj_new_int_from_uint(res); +} + +STATIC MP_DEFINE_CONST_FUN_OBJ_VAR_BETWEEN(mp_lv_anim_speed_to_time_obj, 3, 3, mp_lv_anim_speed_to_time); + + + +/* + * lvgl extension definition for: + * int32_t lv_anim_path_linear(const lv_anim_t *a) + */ + +STATIC mp_obj_t mp_lv_anim_path_linear(size_t n_args, const mp_obj_t *args) +{ + const lv_anim_t *a = mp_write_ptr_lv_anim_t(args[0]); + int32_t res = lv_anim_path_linear(a); + return mp_obj_new_int(res); +} + +STATIC MP_DEFINE_CONST_FUN_OBJ_VAR_BETWEEN(mp_lv_anim_path_linear_obj, 1, 1, mp_lv_anim_path_linear); + + + +/* + * lvgl extension definition for: + * int32_t lv_anim_path_ease_in(const lv_anim_t *a) + */ + +STATIC mp_obj_t mp_lv_anim_path_ease_in(size_t n_args, const mp_obj_t *args) +{ + const lv_anim_t *a = mp_write_ptr_lv_anim_t(args[0]); + int32_t res = lv_anim_path_ease_in(a); + return mp_obj_new_int(res); +} + +STATIC MP_DEFINE_CONST_FUN_OBJ_VAR_BETWEEN(mp_lv_anim_path_ease_in_obj, 1, 1, mp_lv_anim_path_ease_in); + + + +/* + * lvgl extension definition for: + * int32_t lv_anim_path_ease_out(const lv_anim_t *a) + */ + +STATIC mp_obj_t mp_lv_anim_path_ease_out(size_t n_args, const mp_obj_t *args) +{ + const lv_anim_t *a = mp_write_ptr_lv_anim_t(args[0]); + int32_t res = lv_anim_path_ease_out(a); + return mp_obj_new_int(res); +} + +STATIC MP_DEFINE_CONST_FUN_OBJ_VAR_BETWEEN(mp_lv_anim_path_ease_out_obj, 1, 1, mp_lv_anim_path_ease_out); + + + +/* + * lvgl extension definition for: + * int32_t lv_anim_path_ease_in_out(const lv_anim_t *a) + */ + +STATIC mp_obj_t mp_lv_anim_path_ease_in_out(size_t n_args, const mp_obj_t *args) +{ + const lv_anim_t *a = mp_write_ptr_lv_anim_t(args[0]); + int32_t res = lv_anim_path_ease_in_out(a); + return mp_obj_new_int(res); +} + +STATIC MP_DEFINE_CONST_FUN_OBJ_VAR_BETWEEN(mp_lv_anim_path_ease_in_out_obj, 1, 1, mp_lv_anim_path_ease_in_out); + + + +/* + * lvgl extension definition for: + * int32_t lv_anim_path_overshoot(const lv_anim_t *a) + */ + +STATIC mp_obj_t mp_lv_anim_path_overshoot(size_t n_args, const mp_obj_t *args) +{ + const lv_anim_t *a = mp_write_ptr_lv_anim_t(args[0]); + int32_t res = lv_anim_path_overshoot(a); + return mp_obj_new_int(res); +} + +STATIC MP_DEFINE_CONST_FUN_OBJ_VAR_BETWEEN(mp_lv_anim_path_overshoot_obj, 1, 1, mp_lv_anim_path_overshoot); + + + +/* + * lvgl extension definition for: + * int32_t lv_anim_path_bounce(const lv_anim_t *a) + */ + +STATIC mp_obj_t mp_lv_anim_path_bounce(size_t n_args, const mp_obj_t *args) +{ + const lv_anim_t *a = mp_write_ptr_lv_anim_t(args[0]); + int32_t res = lv_anim_path_bounce(a); + return mp_obj_new_int(res); +} + +STATIC MP_DEFINE_CONST_FUN_OBJ_VAR_BETWEEN(mp_lv_anim_path_bounce_obj, 1, 1, mp_lv_anim_path_bounce); + + + +/* + * lvgl extension definition for: + * int32_t lv_anim_path_step(const lv_anim_t *a) + */ + +STATIC mp_obj_t mp_lv_anim_path_step(size_t n_args, const mp_obj_t *args) +{ + const lv_anim_t *a = mp_write_ptr_lv_anim_t(args[0]); + int32_t res = lv_anim_path_step(a); + return mp_obj_new_int(res); +} + +STATIC MP_DEFINE_CONST_FUN_OBJ_VAR_BETWEEN(mp_lv_anim_path_step_obj, 1, 1, mp_lv_anim_path_step); + + + +/* + * lvgl extension definition for: + * void lv_style_init(void) + */ + +STATIC mp_obj_t mp_lv_style_init(size_t n_args, const mp_obj_t *args) +{ + + lv_style_init(); + return mp_const_none; +} + +STATIC MP_DEFINE_CONST_FUN_OBJ_VAR_BETWEEN(mp_lv_style_init_obj, 0, 0, mp_lv_style_init); + + + +/* + * lvgl extension definition for: + * void lv_style_copy(lv_style_t *dest, const lv_style_t *src) + */ + +STATIC mp_obj_t mp_lv_style_copy(size_t n_args, const mp_obj_t *args) +{ + lv_style_t *dest = mp_write_ptr_lv_style_t(args[0]); + const lv_style_t *src = mp_write_ptr_lv_style_t(args[1]); + lv_style_copy(dest, src); + return mp_const_none; +} + +STATIC MP_DEFINE_CONST_FUN_OBJ_VAR_BETWEEN(mp_lv_style_copy_obj, 2, 2, mp_lv_style_copy); + + + +/* + * lvgl extension definition for: + * void lv_style_mix(const lv_style_t *start, const lv_style_t *end, lv_style_t *res, uint16_t ratio) + */ + +STATIC mp_obj_t mp_lv_style_mix(size_t n_args, const mp_obj_t *args) +{ + const lv_style_t *start = mp_write_ptr_lv_style_t(args[0]); + const lv_style_t *end = mp_write_ptr_lv_style_t(args[1]); + lv_style_t *res = mp_write_ptr_lv_style_t(args[2]); + uint16_t ratio = (uint16_t)mp_obj_get_int(args[3]); + lv_style_mix(start, end, res, ratio); + return mp_const_none; +} + +STATIC MP_DEFINE_CONST_FUN_OBJ_VAR_BETWEEN(mp_lv_style_mix_obj, 4, 4, mp_lv_style_mix); + + + +/* + * Struct lv_style_anim_t + */ + +STATIC inline const mp_obj_type_t *get_mp_lv_style_anim_t_type(); + +STATIC inline lv_style_anim_t* mp_write_ptr_lv_style_anim_t(mp_obj_t self_in) +{ + mp_lv_struct_t *self = MP_OBJ_TO_PTR(cast(self_in, get_mp_lv_style_anim_t_type())); + return (lv_style_anim_t*)self->data; +} + +#define mp_write_lv_style_anim_t(struct_obj) *mp_write_ptr_lv_style_anim_t(struct_obj) + +STATIC inline mp_obj_t mp_read_ptr_lv_style_anim_t(lv_style_anim_t *field) +{ + return lv_to_mp_struct(get_mp_lv_style_anim_t_type(), field); +} + +#define mp_read_lv_style_anim_t(field) mp_read_ptr_lv_style_anim_t(copy_buffer(&field, sizeof(lv_style_anim_t))) +#define mp_read_byref_lv_style_anim_t(field) mp_read_ptr_lv_style_anim_t(&field) + +STATIC void mp_lv_style_anim_t_attr(mp_obj_t self_in, qstr attr, mp_obj_t *dest) +{ + mp_lv_struct_t *self = MP_OBJ_TO_PTR(self_in); + lv_style_anim_t *data = (lv_style_anim_t*)self->data; + + if (dest[0] == MP_OBJ_NULL) { + // load attribute + switch(attr) + { + case MP_QSTR_style_start: dest[0] = mp_read_ptr_lv_style_t((void*)data->style_start); break; // converting from lv_style_t*; + case MP_QSTR_style_end: dest[0] = mp_read_ptr_lv_style_t((void*)data->style_end); break; // converting from lv_style_t*; + case MP_QSTR_style_anim: dest[0] = mp_read_ptr_lv_style_t((void*)data->style_anim); break; // converting from lv_style_t*; + case MP_QSTR_end_cb: dest[0] = ptr_to_mp(data->end_cb); break; // converting from lv_anim_cb_t; + case MP_QSTR_time: dest[0] = mp_obj_new_int(data->time); break; // converting from int16_t; + case MP_QSTR_act_time: dest[0] = mp_obj_new_int(data->act_time); break; // converting from int16_t; + case MP_QSTR_playback_pause: dest[0] = mp_obj_new_int_from_uint(data->playback_pause); break; // converting from uint16_t; + case MP_QSTR_repeat_pause: dest[0] = mp_obj_new_int_from_uint(data->repeat_pause); break; // converting from uint16_t; + case MP_QSTR_playback: dest[0] = mp_obj_new_int_from_uint(data->playback); break; // converting from uint8_t; + case MP_QSTR_repeat: dest[0] = mp_obj_new_int_from_uint(data->repeat); break; // converting from uint8_t; + default: field_not_found(MP_QSTR_lv_style_anim_t, attr); + } + } else { + if (dest[1]) + { + // store attribute + switch(attr) + { + case MP_QSTR_style_start: data->style_start = (void*)mp_write_ptr_lv_style_t(dest[1]); break; // converting to lv_style_t*; + case MP_QSTR_style_end: data->style_end = (void*)mp_write_ptr_lv_style_t(dest[1]); break; // converting to lv_style_t*; + case MP_QSTR_style_anim: data->style_anim = (void*)mp_write_ptr_lv_style_t(dest[1]); break; // converting to lv_style_t*; + case MP_QSTR_end_cb: data->end_cb = mp_to_ptr(dest[1]); break; // converting to lv_anim_cb_t; + case MP_QSTR_time: data->time = (int16_t)mp_obj_get_int(dest[1]); break; // converting to int16_t; + case MP_QSTR_act_time: data->act_time = (int16_t)mp_obj_get_int(dest[1]); break; // converting to int16_t; + case MP_QSTR_playback_pause: data->playback_pause = (uint16_t)mp_obj_get_int(dest[1]); break; // converting to uint16_t; + case MP_QSTR_repeat_pause: data->repeat_pause = (uint16_t)mp_obj_get_int(dest[1]); break; // converting to uint16_t; + case MP_QSTR_playback: data->playback = (uint8_t)mp_obj_get_int(dest[1]); break; // converting to uint8_t; + case MP_QSTR_repeat: data->repeat = (uint8_t)mp_obj_get_int(dest[1]); break; // converting to uint8_t; + default: field_not_found(MP_QSTR_lv_style_anim_t, attr); + } + + dest[0] = MP_OBJ_NULL; // indicate success + } + } +} + +STATIC void mp_lv_style_anim_t_print(const mp_print_t *print, + mp_obj_t self_in, + mp_print_kind_t kind) +{ + mp_printf(print, "lvgl struct lv_style_anim_t"); +} + +STATIC const mp_rom_map_elem_t mp_lv_style_anim_t_locals_dict_table[] = { + { MP_ROM_QSTR(MP_QSTR_SIZE), MP_ROM_PTR(MP_ROM_INT(sizeof(lv_style_anim_t))) }, + { MP_ROM_QSTR(MP_QSTR_cast), MP_ROM_PTR(&mp_lv_cast_class_method) }, +}; + +STATIC MP_DEFINE_CONST_DICT(mp_lv_style_anim_t_locals_dict, mp_lv_style_anim_t_locals_dict_table); + +STATIC const mp_obj_type_t mp_lv_style_anim_t_type = { + { &mp_type_type }, + .name = MP_QSTR_lv_style_anim_t, + .print = mp_lv_style_anim_t_print, + .make_new = make_new_lv_struct, + .attr = mp_lv_style_anim_t_attr, + .locals_dict = (mp_obj_dict_t*)&mp_lv_style_anim_t_locals_dict, + .buffer_p = { .get_buffer = mp_blob_get_buffer } +}; + +STATIC inline const mp_obj_type_t *get_mp_lv_style_anim_t_type() +{ + return &mp_lv_style_anim_t_type; +} + + +/* + * lvgl extension definition for: + * void *lv_style_anim_create(lv_style_anim_t *anim) + */ + +STATIC mp_obj_t mp_lv_style_anim_create(size_t n_args, const mp_obj_t *args) +{ + lv_style_anim_t *anim = mp_write_ptr_lv_style_anim_t(args[0]); + void* res = lv_style_anim_create(anim); + return ptr_to_mp((void*)res); +} + +STATIC MP_DEFINE_CONST_FUN_OBJ_VAR_BETWEEN(mp_lv_style_anim_create_obj, 1, 1, mp_lv_style_anim_create); + + + +/* + * lvgl extension definition for: + * void lv_init(void) + */ + +STATIC mp_obj_t mp_lv_init(size_t n_args, const mp_obj_t *args) +{ + + lv_init(); + return mp_const_none; +} + +STATIC MP_DEFINE_CONST_FUN_OBJ_VAR_BETWEEN(mp_lv_init_obj, 0, 0, mp_lv_init); + + + +/* + * lvgl extension definition for: + * void lv_scr_load(lv_obj_t *scr) + */ + +STATIC mp_obj_t mp_lv_scr_load(size_t n_args, const mp_obj_t *args) +{ + lv_obj_t *scr = mp_to_lv(args[0]); + lv_scr_load(scr); + return mp_const_none; +} + +STATIC MP_DEFINE_CONST_FUN_OBJ_VAR_BETWEEN(mp_lv_scr_load_obj, 1, 1, mp_lv_scr_load); + + + +/* + * lvgl extension definition for: + * lv_obj_t *lv_scr_act(void) + */ + +STATIC mp_obj_t mp_lv_scr_act(size_t n_args, const mp_obj_t *args) +{ + + lv_obj_t* res = lv_scr_act(); + return lv_to_mp((void*)res); +} + +STATIC MP_DEFINE_CONST_FUN_OBJ_VAR_BETWEEN(mp_lv_scr_act_obj, 0, 0, mp_lv_scr_act); + + + +/* + * lvgl extension definition for: + * lv_obj_t *lv_layer_top(void) + */ + +STATIC mp_obj_t mp_lv_layer_top(size_t n_args, const mp_obj_t *args) +{ + + lv_obj_t* res = lv_layer_top(); + return lv_to_mp((void*)res); +} + +STATIC MP_DEFINE_CONST_FUN_OBJ_VAR_BETWEEN(mp_lv_layer_top_obj, 0, 0, mp_lv_layer_top); + + + +/* + * lvgl extension definition for: + * lv_obj_t *lv_layer_sys(void) + */ + +STATIC mp_obj_t mp_lv_layer_sys(size_t n_args, const mp_obj_t *args) +{ + + lv_obj_t* res = lv_layer_sys(); + return lv_to_mp((void*)res); +} + +STATIC MP_DEFINE_CONST_FUN_OBJ_VAR_BETWEEN(mp_lv_layer_sys_obj, 0, 0, mp_lv_layer_sys); + + + +/* + * Struct lv_indev_drv_t + */ + +STATIC inline const mp_obj_type_t *get_mp_lv_indev_drv_t_type(); + +STATIC inline lv_indev_drv_t* mp_write_ptr_lv_indev_drv_t(mp_obj_t self_in) +{ + mp_lv_struct_t *self = MP_OBJ_TO_PTR(cast(self_in, get_mp_lv_indev_drv_t_type())); + return (lv_indev_drv_t*)self->data; +} + +#define mp_write_lv_indev_drv_t(struct_obj) *mp_write_ptr_lv_indev_drv_t(struct_obj) + +STATIC inline mp_obj_t mp_read_ptr_lv_indev_drv_t(lv_indev_drv_t *field) +{ + return lv_to_mp_struct(get_mp_lv_indev_drv_t_type(), field); +} + +#define mp_read_lv_indev_drv_t(field) mp_read_ptr_lv_indev_drv_t(copy_buffer(&field, sizeof(lv_indev_drv_t))) +#define mp_read_byref_lv_indev_drv_t(field) mp_read_ptr_lv_indev_drv_t(&field) + +STATIC void mp_lv_indev_drv_t_attr(mp_obj_t self_in, qstr attr, mp_obj_t *dest) +{ + mp_lv_struct_t *self = MP_OBJ_TO_PTR(self_in); + lv_indev_drv_t *data = (lv_indev_drv_t*)self->data; + + if (dest[0] == MP_OBJ_NULL) { + // load attribute + switch(attr) + { + case MP_QSTR_type: dest[0] = mp_obj_new_int_from_uint(data->type); break; // converting from lv_hal_indev_type_t; + case MP_QSTR_read: dest[0] = ptr_to_mp((void*)data->read); break; // converting from bool read(lv_indev_data_t *data)*; + case MP_QSTR_user_data: dest[0] = ptr_to_mp((void*)data->user_data); break; // converting from void*; + default: field_not_found(MP_QSTR_lv_indev_drv_t, attr); + } + } else { + if (dest[1]) + { + // store attribute + switch(attr) + { + case MP_QSTR_type: data->type = (uint8_t)mp_obj_get_int(dest[1]); break; // converting to lv_hal_indev_type_t; + case MP_QSTR_read: data->read = (void*)mp_to_ptr(dest[1]); break; // converting to bool read(lv_indev_data_t *data)*; + case MP_QSTR_user_data: data->user_data = (void*)mp_to_ptr(dest[1]); break; // converting to void*; + default: field_not_found(MP_QSTR_lv_indev_drv_t, attr); + } + + dest[0] = MP_OBJ_NULL; // indicate success + } + } +} + +STATIC void mp_lv_indev_drv_t_print(const mp_print_t *print, + mp_obj_t self_in, + mp_print_kind_t kind) +{ + mp_printf(print, "lvgl struct lv_indev_drv_t"); +} + +STATIC const mp_rom_map_elem_t mp_lv_indev_drv_t_locals_dict_table[] = { + { MP_ROM_QSTR(MP_QSTR_SIZE), MP_ROM_PTR(MP_ROM_INT(sizeof(lv_indev_drv_t))) }, + { MP_ROM_QSTR(MP_QSTR_cast), MP_ROM_PTR(&mp_lv_cast_class_method) }, +}; + +STATIC MP_DEFINE_CONST_DICT(mp_lv_indev_drv_t_locals_dict, mp_lv_indev_drv_t_locals_dict_table); + +STATIC const mp_obj_type_t mp_lv_indev_drv_t_type = { + { &mp_type_type }, + .name = MP_QSTR_lv_indev_drv_t, + .print = mp_lv_indev_drv_t_print, + .make_new = make_new_lv_struct, + .attr = mp_lv_indev_drv_t_attr, + .locals_dict = (mp_obj_dict_t*)&mp_lv_indev_drv_t_locals_dict, + .buffer_p = { .get_buffer = mp_blob_get_buffer } +}; + +STATIC inline const mp_obj_type_t *get_mp_lv_indev_drv_t_type() +{ + return &mp_lv_indev_drv_t_type; +} + + +/* + * lvgl extension definition for: + * void lv_indev_drv_init(lv_indev_drv_t *driver) + */ + +STATIC mp_obj_t mp_lv_indev_drv_init(size_t n_args, const mp_obj_t *args) +{ + lv_indev_drv_t *driver = mp_write_ptr_lv_indev_drv_t(args[0]); + lv_indev_drv_init(driver); + return mp_const_none; +} + +STATIC MP_DEFINE_CONST_FUN_OBJ_VAR_BETWEEN(mp_lv_indev_drv_init_obj, 1, 1, mp_lv_indev_drv_init); + + + +/* + * Struct lv_indev_proc_t + */ + +STATIC inline const mp_obj_type_t *get_mp_lv_indev_proc_t_type(); + +STATIC inline lv_indev_proc_t* mp_write_ptr_lv_indev_proc_t(mp_obj_t self_in) +{ + mp_lv_struct_t *self = MP_OBJ_TO_PTR(cast(self_in, get_mp_lv_indev_proc_t_type())); + return (lv_indev_proc_t*)self->data; +} + +#define mp_write_lv_indev_proc_t(struct_obj) *mp_write_ptr_lv_indev_proc_t(struct_obj) + +STATIC inline mp_obj_t mp_read_ptr_lv_indev_proc_t(lv_indev_proc_t *field) +{ + return lv_to_mp_struct(get_mp_lv_indev_proc_t_type(), field); +} + +#define mp_read_lv_indev_proc_t(field) mp_read_ptr_lv_indev_proc_t(copy_buffer(&field, sizeof(lv_indev_proc_t))) +#define mp_read_byref_lv_indev_proc_t(field) mp_read_ptr_lv_indev_proc_t(&field) + +STATIC void mp_lv_indev_proc_t_attr(mp_obj_t self_in, qstr attr, mp_obj_t *dest) +{ + mp_lv_struct_t *self = MP_OBJ_TO_PTR(self_in); + lv_indev_proc_t *data = (lv_indev_proc_t*)self->data; + + if (dest[0] == MP_OBJ_NULL) { + // load attribute + switch(attr) + { + case MP_QSTR_state: dest[0] = mp_obj_new_int_from_uint(data->state); break; // converting from lv_indev_state_t; + case MP_QSTR_act_point: dest[0] = mp_read_byref_lv_point_t(data->act_point); break; // converting from lv_point_t; + case MP_QSTR_last_point: dest[0] = mp_read_byref_lv_point_t(data->last_point); break; // converting from lv_point_t; + case MP_QSTR_vect: dest[0] = mp_read_byref_lv_point_t(data->vect); break; // converting from lv_point_t; + case MP_QSTR_drag_sum: dest[0] = mp_read_byref_lv_point_t(data->drag_sum); break; // converting from lv_point_t; + case MP_QSTR_act_obj: dest[0] = lv_to_mp((void*)data->act_obj); break; // converting from struct _lv_obj_t*; + case MP_QSTR_last_obj: dest[0] = lv_to_mp((void*)data->last_obj); break; // converting from struct _lv_obj_t*; + case MP_QSTR_drag_range_out: dest[0] = mp_obj_new_int_from_uint(data->drag_range_out); break; // converting from uint8_t; + case MP_QSTR_drag_in_prog: dest[0] = mp_obj_new_int_from_uint(data->drag_in_prog); break; // converting from uint8_t; + case MP_QSTR_wait_unil_release: dest[0] = mp_obj_new_int_from_uint(data->wait_unil_release); break; // converting from uint8_t; + case MP_QSTR_last_state: dest[0] = mp_obj_new_int_from_uint(data->last_state); break; // converting from lv_indev_state_t; + case MP_QSTR_last_key: dest[0] = mp_obj_new_int_from_uint(data->last_key); break; // converting from uint32_t; + case MP_QSTR_pr_timestamp: dest[0] = mp_obj_new_int_from_uint(data->pr_timestamp); break; // converting from uint32_t; + case MP_QSTR_longpr_rep_timestamp: dest[0] = mp_obj_new_int_from_uint(data->longpr_rep_timestamp); break; // converting from uint32_t; + case MP_QSTR_long_pr_sent: dest[0] = mp_obj_new_int_from_uint(data->long_pr_sent); break; // converting from uint8_t; + case MP_QSTR_reset_query: dest[0] = mp_obj_new_int_from_uint(data->reset_query); break; // converting from uint8_t; + case MP_QSTR_disabled: dest[0] = mp_obj_new_int_from_uint(data->disabled); break; // converting from uint8_t; + default: field_not_found(MP_QSTR_lv_indev_proc_t, attr); + } + } else { + if (dest[1]) + { + // store attribute + switch(attr) + { + case MP_QSTR_state: data->state = (uint8_t)mp_obj_get_int(dest[1]); break; // converting to lv_indev_state_t; + case MP_QSTR_act_point: data->act_point = mp_write_lv_point_t(dest[1]); break; // converting to lv_point_t; + case MP_QSTR_last_point: data->last_point = mp_write_lv_point_t(dest[1]); break; // converting to lv_point_t; + case MP_QSTR_vect: data->vect = mp_write_lv_point_t(dest[1]); break; // converting to lv_point_t; + case MP_QSTR_drag_sum: data->drag_sum = mp_write_lv_point_t(dest[1]); break; // converting to lv_point_t; + case MP_QSTR_act_obj: data->act_obj = (void*)mp_to_lv(dest[1]); break; // converting to struct _lv_obj_t*; + case MP_QSTR_last_obj: data->last_obj = (void*)mp_to_lv(dest[1]); break; // converting to struct _lv_obj_t*; + case MP_QSTR_drag_range_out: data->drag_range_out = (uint8_t)mp_obj_get_int(dest[1]); break; // converting to uint8_t; + case MP_QSTR_drag_in_prog: data->drag_in_prog = (uint8_t)mp_obj_get_int(dest[1]); break; // converting to uint8_t; + case MP_QSTR_wait_unil_release: data->wait_unil_release = (uint8_t)mp_obj_get_int(dest[1]); break; // converting to uint8_t; + case MP_QSTR_last_state: data->last_state = (uint8_t)mp_obj_get_int(dest[1]); break; // converting to lv_indev_state_t; + case MP_QSTR_last_key: data->last_key = (uint32_t)mp_obj_get_int(dest[1]); break; // converting to uint32_t; + case MP_QSTR_pr_timestamp: data->pr_timestamp = (uint32_t)mp_obj_get_int(dest[1]); break; // converting to uint32_t; + case MP_QSTR_longpr_rep_timestamp: data->longpr_rep_timestamp = (uint32_t)mp_obj_get_int(dest[1]); break; // converting to uint32_t; + case MP_QSTR_long_pr_sent: data->long_pr_sent = (uint8_t)mp_obj_get_int(dest[1]); break; // converting to uint8_t; + case MP_QSTR_reset_query: data->reset_query = (uint8_t)mp_obj_get_int(dest[1]); break; // converting to uint8_t; + case MP_QSTR_disabled: data->disabled = (uint8_t)mp_obj_get_int(dest[1]); break; // converting to uint8_t; + default: field_not_found(MP_QSTR_lv_indev_proc_t, attr); + } + + dest[0] = MP_OBJ_NULL; // indicate success + } + } +} + +STATIC void mp_lv_indev_proc_t_print(const mp_print_t *print, + mp_obj_t self_in, + mp_print_kind_t kind) +{ + mp_printf(print, "lvgl struct lv_indev_proc_t"); +} + +STATIC const mp_rom_map_elem_t mp_lv_indev_proc_t_locals_dict_table[] = { + { MP_ROM_QSTR(MP_QSTR_SIZE), MP_ROM_PTR(MP_ROM_INT(sizeof(lv_indev_proc_t))) }, + { MP_ROM_QSTR(MP_QSTR_cast), MP_ROM_PTR(&mp_lv_cast_class_method) }, +}; + +STATIC MP_DEFINE_CONST_DICT(mp_lv_indev_proc_t_locals_dict, mp_lv_indev_proc_t_locals_dict_table); + +STATIC const mp_obj_type_t mp_lv_indev_proc_t_type = { + { &mp_type_type }, + .name = MP_QSTR_lv_indev_proc_t, + .print = mp_lv_indev_proc_t_print, + .make_new = make_new_lv_struct, + .attr = mp_lv_indev_proc_t_attr, + .locals_dict = (mp_obj_dict_t*)&mp_lv_indev_proc_t_locals_dict, + .buffer_p = { .get_buffer = mp_blob_get_buffer } +}; + +STATIC inline const mp_obj_type_t *get_mp_lv_indev_proc_t_type() +{ + return &mp_lv_indev_proc_t_type; +} + + +/* + * Struct lv_indev_t + */ + +STATIC inline const mp_obj_type_t *get_mp_lv_indev_t_type(); + +STATIC inline lv_indev_t* mp_write_ptr_lv_indev_t(mp_obj_t self_in) +{ + mp_lv_struct_t *self = MP_OBJ_TO_PTR(cast(self_in, get_mp_lv_indev_t_type())); + return (lv_indev_t*)self->data; +} + +#define mp_write_lv_indev_t(struct_obj) *mp_write_ptr_lv_indev_t(struct_obj) + +STATIC inline mp_obj_t mp_read_ptr_lv_indev_t(lv_indev_t *field) +{ + return lv_to_mp_struct(get_mp_lv_indev_t_type(), field); +} + +#define mp_read_lv_indev_t(field) mp_read_ptr_lv_indev_t(copy_buffer(&field, sizeof(lv_indev_t))) +#define mp_read_byref_lv_indev_t(field) mp_read_ptr_lv_indev_t(&field) + +STATIC void mp_lv_indev_t_attr(mp_obj_t self_in, qstr attr, mp_obj_t *dest) +{ + mp_lv_struct_t *self = MP_OBJ_TO_PTR(self_in); + lv_indev_t *data = (lv_indev_t*)self->data; + + if (dest[0] == MP_OBJ_NULL) { + // load attribute + switch(attr) + { + case MP_QSTR_driver: dest[0] = mp_read_byref_lv_indev_drv_t(data->driver); break; // converting from lv_indev_drv_t; + case MP_QSTR_proc: dest[0] = mp_read_byref_lv_indev_proc_t(data->proc); break; // converting from lv_indev_proc_t; + case MP_QSTR_feedback: dest[0] = ptr_to_mp(data->feedback); break; // converting from lv_indev_feedback_t; + case MP_QSTR_last_activity_time: dest[0] = mp_obj_new_int_from_uint(data->last_activity_time); break; // converting from uint32_t; + case MP_QSTR_cursor: dest[0] = lv_to_mp((void*)data->cursor); break; // converting from struct _lv_obj_t*; + case MP_QSTR_group: dest[0] = ptr_to_mp((void*)data->group); break; // converting from struct _lv_group_t*; + case MP_QSTR_btn_points: dest[0] = mp_read_ptr_lv_point_t((void*)data->btn_points); break; // converting from lv_point_t*; + case MP_QSTR_next: dest[0] = ptr_to_mp((void*)data->next); break; // converting from struct _lv_indev_t*; + default: field_not_found(MP_QSTR_lv_indev_t, attr); + } + } else { + if (dest[1]) + { + // store attribute + switch(attr) + { + case MP_QSTR_driver: data->driver = mp_write_lv_indev_drv_t(dest[1]); break; // converting to lv_indev_drv_t; + case MP_QSTR_proc: data->proc = mp_write_lv_indev_proc_t(dest[1]); break; // converting to lv_indev_proc_t; + case MP_QSTR_feedback: data->feedback = mp_to_ptr(dest[1]); break; // converting to lv_indev_feedback_t; + case MP_QSTR_last_activity_time: data->last_activity_time = (uint32_t)mp_obj_get_int(dest[1]); break; // converting to uint32_t; + case MP_QSTR_cursor: data->cursor = (void*)mp_to_lv(dest[1]); break; // converting to struct _lv_obj_t*; + case MP_QSTR_group: data->group = (void*)mp_to_ptr(dest[1]); break; // converting to struct _lv_group_t*; + case MP_QSTR_btn_points: data->btn_points = (void*)mp_write_ptr_lv_point_t(dest[1]); break; // converting to lv_point_t*; + case MP_QSTR_next: data->next = (void*)mp_to_ptr(dest[1]); break; // converting to struct _lv_indev_t*; + default: field_not_found(MP_QSTR_lv_indev_t, attr); + } + + dest[0] = MP_OBJ_NULL; // indicate success + } + } +} + +STATIC void mp_lv_indev_t_print(const mp_print_t *print, + mp_obj_t self_in, + mp_print_kind_t kind) +{ + mp_printf(print, "lvgl struct lv_indev_t"); +} + +STATIC const mp_rom_map_elem_t mp_lv_indev_t_locals_dict_table[] = { + { MP_ROM_QSTR(MP_QSTR_SIZE), MP_ROM_PTR(MP_ROM_INT(sizeof(lv_indev_t))) }, + { MP_ROM_QSTR(MP_QSTR_cast), MP_ROM_PTR(&mp_lv_cast_class_method) }, +}; + +STATIC MP_DEFINE_CONST_DICT(mp_lv_indev_t_locals_dict, mp_lv_indev_t_locals_dict_table); + +STATIC const mp_obj_type_t mp_lv_indev_t_type = { + { &mp_type_type }, + .name = MP_QSTR_lv_indev_t, + .print = mp_lv_indev_t_print, + .make_new = make_new_lv_struct, + .attr = mp_lv_indev_t_attr, + .locals_dict = (mp_obj_dict_t*)&mp_lv_indev_t_locals_dict, + .buffer_p = { .get_buffer = mp_blob_get_buffer } +}; + +STATIC inline const mp_obj_type_t *get_mp_lv_indev_t_type() +{ + return &mp_lv_indev_t_type; +} + + +/* + * lvgl extension definition for: + * lv_indev_t *lv_indev_drv_register(lv_indev_drv_t *driver) + */ + +STATIC mp_obj_t mp_lv_indev_drv_register(size_t n_args, const mp_obj_t *args) +{ + lv_indev_drv_t *driver = mp_write_ptr_lv_indev_drv_t(args[0]); + lv_indev_t* res = lv_indev_drv_register(driver); + return mp_read_ptr_lv_indev_t((void*)res); +} + +STATIC MP_DEFINE_CONST_FUN_OBJ_VAR_BETWEEN(mp_lv_indev_drv_register_obj, 1, 1, mp_lv_indev_drv_register); + + + +/* + * lvgl extension definition for: + * lv_indev_t *lv_indev_next(lv_indev_t *indev) + */ + +STATIC mp_obj_t mp_lv_indev_next(size_t n_args, const mp_obj_t *args) +{ + lv_indev_t *indev = mp_write_ptr_lv_indev_t(args[0]); + lv_indev_t* res = lv_indev_next(indev); + return mp_read_ptr_lv_indev_t((void*)res); +} + +STATIC MP_DEFINE_CONST_FUN_OBJ_VAR_BETWEEN(mp_lv_indev_next_obj, 1, 1, mp_lv_indev_next); + + + +/* + * Struct lv_indev_data_t + */ + +STATIC inline const mp_obj_type_t *get_mp_lv_indev_data_t_type(); + +STATIC inline lv_indev_data_t* mp_write_ptr_lv_indev_data_t(mp_obj_t self_in) +{ + mp_lv_struct_t *self = MP_OBJ_TO_PTR(cast(self_in, get_mp_lv_indev_data_t_type())); + return (lv_indev_data_t*)self->data; +} + +#define mp_write_lv_indev_data_t(struct_obj) *mp_write_ptr_lv_indev_data_t(struct_obj) + +STATIC inline mp_obj_t mp_read_ptr_lv_indev_data_t(lv_indev_data_t *field) +{ + return lv_to_mp_struct(get_mp_lv_indev_data_t_type(), field); +} + +#define mp_read_lv_indev_data_t(field) mp_read_ptr_lv_indev_data_t(copy_buffer(&field, sizeof(lv_indev_data_t))) +#define mp_read_byref_lv_indev_data_t(field) mp_read_ptr_lv_indev_data_t(&field) + +STATIC void mp_lv_indev_data_t_attr(mp_obj_t self_in, qstr attr, mp_obj_t *dest) +{ + mp_lv_struct_t *self = MP_OBJ_TO_PTR(self_in); + lv_indev_data_t *data = (lv_indev_data_t*)self->data; + + if (dest[0] == MP_OBJ_NULL) { + // load attribute + switch(attr) + { + case MP_QSTR_point: dest[0] = mp_read_byref_lv_point_t(data->point); break; // converting from lv_point_t; + case MP_QSTR_key: dest[0] = mp_obj_new_int_from_uint(data->key); break; // converting from uint32_t; + case MP_QSTR_btn: dest[0] = mp_obj_new_int_from_uint(data->btn); break; // converting from uint32_t; + case MP_QSTR_enc_diff: dest[0] = mp_obj_new_int(data->enc_diff); break; // converting from int16_t; + case MP_QSTR_user_data: dest[0] = ptr_to_mp((void*)data->user_data); break; // converting from void*; + case MP_QSTR_state: dest[0] = mp_obj_new_int_from_uint(data->state); break; // converting from lv_indev_state_t; + default: field_not_found(MP_QSTR_lv_indev_data_t, attr); + } + } else { + if (dest[1]) + { + // store attribute + switch(attr) + { + case MP_QSTR_point: data->point = mp_write_lv_point_t(dest[1]); break; // converting to lv_point_t; + case MP_QSTR_key: data->key = (uint32_t)mp_obj_get_int(dest[1]); break; // converting to uint32_t; + case MP_QSTR_btn: data->btn = (uint32_t)mp_obj_get_int(dest[1]); break; // converting to uint32_t; + case MP_QSTR_enc_diff: data->enc_diff = (int16_t)mp_obj_get_int(dest[1]); break; // converting to int16_t; + case MP_QSTR_user_data: data->user_data = (void*)mp_to_ptr(dest[1]); break; // converting to void*; + case MP_QSTR_state: data->state = (uint8_t)mp_obj_get_int(dest[1]); break; // converting to lv_indev_state_t; + default: field_not_found(MP_QSTR_lv_indev_data_t, attr); + } + + dest[0] = MP_OBJ_NULL; // indicate success + } + } +} + +STATIC void mp_lv_indev_data_t_print(const mp_print_t *print, + mp_obj_t self_in, + mp_print_kind_t kind) +{ + mp_printf(print, "lvgl struct lv_indev_data_t"); +} + +STATIC const mp_rom_map_elem_t mp_lv_indev_data_t_locals_dict_table[] = { + { MP_ROM_QSTR(MP_QSTR_SIZE), MP_ROM_PTR(MP_ROM_INT(sizeof(lv_indev_data_t))) }, + { MP_ROM_QSTR(MP_QSTR_cast), MP_ROM_PTR(&mp_lv_cast_class_method) }, +}; + +STATIC MP_DEFINE_CONST_DICT(mp_lv_indev_data_t_locals_dict, mp_lv_indev_data_t_locals_dict_table); + +STATIC const mp_obj_type_t mp_lv_indev_data_t_type = { + { &mp_type_type }, + .name = MP_QSTR_lv_indev_data_t, + .print = mp_lv_indev_data_t_print, + .make_new = make_new_lv_struct, + .attr = mp_lv_indev_data_t_attr, + .locals_dict = (mp_obj_dict_t*)&mp_lv_indev_data_t_locals_dict, + .buffer_p = { .get_buffer = mp_blob_get_buffer } +}; + +STATIC inline const mp_obj_type_t *get_mp_lv_indev_data_t_type() +{ + return &mp_lv_indev_data_t_type; +} + + +/* + * lvgl extension definition for: + * bool lv_indev_read(lv_indev_t *indev, lv_indev_data_t *data) + */ + +STATIC mp_obj_t mp_lv_indev_read(size_t n_args, const mp_obj_t *args) +{ + lv_indev_t *indev = mp_write_ptr_lv_indev_t(args[0]); + lv_indev_data_t *data = mp_write_ptr_lv_indev_data_t(args[1]); + bool res = lv_indev_read(indev, data); + return convert_to_bool(res); +} + +STATIC MP_DEFINE_CONST_FUN_OBJ_VAR_BETWEEN(mp_lv_indev_read_obj, 2, 2, mp_lv_indev_read); + + + +/* + * lvgl extension definition for: + * void lv_tick_inc(uint32_t tick_period) + */ + +STATIC mp_obj_t mp_lv_tick_inc(size_t n_args, const mp_obj_t *args) +{ + uint32_t tick_period = (uint32_t)mp_obj_get_int(args[0]); + lv_tick_inc(tick_period); + return mp_const_none; +} + +STATIC MP_DEFINE_CONST_FUN_OBJ_VAR_BETWEEN(mp_lv_tick_inc_obj, 1, 1, mp_lv_tick_inc); + + + +/* + * lvgl extension definition for: + * uint32_t lv_tick_get(void) + */ + +STATIC mp_obj_t mp_lv_tick_get(size_t n_args, const mp_obj_t *args) +{ + + uint32_t res = lv_tick_get(); + return mp_obj_new_int_from_uint(res); +} + +STATIC MP_DEFINE_CONST_FUN_OBJ_VAR_BETWEEN(mp_lv_tick_get_obj, 0, 0, mp_lv_tick_get); + + + +/* + * lvgl extension definition for: + * uint32_t lv_tick_elaps(uint32_t prev_tick) + */ + +STATIC mp_obj_t mp_lv_tick_elaps(size_t n_args, const mp_obj_t *args) +{ + uint32_t prev_tick = (uint32_t)mp_obj_get_int(args[0]); + uint32_t res = lv_tick_elaps(prev_tick); + return mp_obj_new_int_from_uint(res); +} + +STATIC MP_DEFINE_CONST_FUN_OBJ_VAR_BETWEEN(mp_lv_tick_elaps_obj, 1, 1, mp_lv_tick_elaps); + + + +/* + * Struct lv_group_t + */ + +STATIC inline const mp_obj_type_t *get_mp_lv_group_t_type(); + +STATIC inline lv_group_t* mp_write_ptr_lv_group_t(mp_obj_t self_in) +{ + mp_lv_struct_t *self = MP_OBJ_TO_PTR(cast(self_in, get_mp_lv_group_t_type())); + return (lv_group_t*)self->data; +} + +#define mp_write_lv_group_t(struct_obj) *mp_write_ptr_lv_group_t(struct_obj) + +STATIC inline mp_obj_t mp_read_ptr_lv_group_t(lv_group_t *field) +{ + return lv_to_mp_struct(get_mp_lv_group_t_type(), field); +} + +#define mp_read_lv_group_t(field) mp_read_ptr_lv_group_t(copy_buffer(&field, sizeof(lv_group_t))) +#define mp_read_byref_lv_group_t(field) mp_read_ptr_lv_group_t(&field) + +STATIC void mp_lv_group_t_attr(mp_obj_t self_in, qstr attr, mp_obj_t *dest) +{ + mp_lv_struct_t *self = MP_OBJ_TO_PTR(self_in); + lv_group_t *data = (lv_group_t*)self->data; + + if (dest[0] == MP_OBJ_NULL) { + // load attribute + switch(attr) + { + case MP_QSTR_obj_ll: dest[0] = mp_read_byref_lv_ll_t(data->obj_ll); break; // converting from lv_ll_t; + case MP_QSTR_obj_focus: dest[0] = ptr_to_mp((void*)data->obj_focus); break; // converting from lv_obj_t**; + case MP_QSTR_style_mod: dest[0] = ptr_to_mp(data->style_mod); break; // converting from lv_group_style_mod_func_t; + case MP_QSTR_style_mod_edit: dest[0] = ptr_to_mp(data->style_mod_edit); break; // converting from lv_group_style_mod_func_t; + case MP_QSTR_focus_cb: dest[0] = ptr_to_mp(data->focus_cb); break; // converting from lv_group_focus_cb_t; + case MP_QSTR_style_tmp: dest[0] = mp_read_byref_lv_style_t(data->style_tmp); break; // converting from lv_style_t; + case MP_QSTR_frozen: dest[0] = mp_obj_new_int_from_uint(data->frozen); break; // converting from uint8_t; + case MP_QSTR_editing: dest[0] = mp_obj_new_int_from_uint(data->editing); break; // converting from uint8_t; + case MP_QSTR_click_focus: dest[0] = mp_obj_new_int_from_uint(data->click_focus); break; // converting from uint8_t; + case MP_QSTR_refocus_policy: dest[0] = mp_obj_new_int_from_uint(data->refocus_policy); break; // converting from uint8_t; + case MP_QSTR_wrap: dest[0] = mp_obj_new_int_from_uint(data->wrap); break; // converting from uint8_t; + default: field_not_found(MP_QSTR_lv_group_t, attr); + } + } else { + if (dest[1]) + { + // store attribute + switch(attr) + { + case MP_QSTR_obj_ll: data->obj_ll = mp_write_lv_ll_t(dest[1]); break; // converting to lv_ll_t; + case MP_QSTR_obj_focus: data->obj_focus = (void*)mp_to_ptr(dest[1]); break; // converting to lv_obj_t**; + case MP_QSTR_style_mod: data->style_mod = mp_to_ptr(dest[1]); break; // converting to lv_group_style_mod_func_t; + case MP_QSTR_style_mod_edit: data->style_mod_edit = mp_to_ptr(dest[1]); break; // converting to lv_group_style_mod_func_t; + case MP_QSTR_focus_cb: data->focus_cb = mp_to_ptr(dest[1]); break; // converting to lv_group_focus_cb_t; + case MP_QSTR_style_tmp: data->style_tmp = mp_write_lv_style_t(dest[1]); break; // converting to lv_style_t; + case MP_QSTR_frozen: data->frozen = (uint8_t)mp_obj_get_int(dest[1]); break; // converting to uint8_t; + case MP_QSTR_editing: data->editing = (uint8_t)mp_obj_get_int(dest[1]); break; // converting to uint8_t; + case MP_QSTR_click_focus: data->click_focus = (uint8_t)mp_obj_get_int(dest[1]); break; // converting to uint8_t; + case MP_QSTR_refocus_policy: data->refocus_policy = (uint8_t)mp_obj_get_int(dest[1]); break; // converting to uint8_t; + case MP_QSTR_wrap: data->wrap = (uint8_t)mp_obj_get_int(dest[1]); break; // converting to uint8_t; + default: field_not_found(MP_QSTR_lv_group_t, attr); + } + + dest[0] = MP_OBJ_NULL; // indicate success + } + } +} + +STATIC void mp_lv_group_t_print(const mp_print_t *print, + mp_obj_t self_in, + mp_print_kind_t kind) +{ + mp_printf(print, "lvgl struct lv_group_t"); +} + +STATIC const mp_rom_map_elem_t mp_lv_group_t_locals_dict_table[] = { + { MP_ROM_QSTR(MP_QSTR_SIZE), MP_ROM_PTR(MP_ROM_INT(sizeof(lv_group_t))) }, + { MP_ROM_QSTR(MP_QSTR_cast), MP_ROM_PTR(&mp_lv_cast_class_method) }, +}; + +STATIC MP_DEFINE_CONST_DICT(mp_lv_group_t_locals_dict, mp_lv_group_t_locals_dict_table); + +STATIC const mp_obj_type_t mp_lv_group_t_type = { + { &mp_type_type }, + .name = MP_QSTR_lv_group_t, + .print = mp_lv_group_t_print, + .make_new = make_new_lv_struct, + .attr = mp_lv_group_t_attr, + .locals_dict = (mp_obj_dict_t*)&mp_lv_group_t_locals_dict, + .buffer_p = { .get_buffer = mp_blob_get_buffer } +}; + +STATIC inline const mp_obj_type_t *get_mp_lv_group_t_type() +{ + return &mp_lv_group_t_type; +} + + +/* + * lvgl extension definition for: + * lv_group_t *lv_group_create(void) + */ + +STATIC mp_obj_t mp_lv_group_create(size_t n_args, const mp_obj_t *args) +{ + + lv_group_t* res = lv_group_create(); + return mp_read_ptr_lv_group_t((void*)res); +} + +STATIC MP_DEFINE_CONST_FUN_OBJ_VAR_BETWEEN(mp_lv_group_create_obj, 0, 0, mp_lv_group_create); + + + +/* + * lvgl extension definition for: + * void lv_group_del(lv_group_t *group) + */ + +STATIC mp_obj_t mp_lv_group_del(size_t n_args, const mp_obj_t *args) +{ + lv_group_t *group = mp_write_ptr_lv_group_t(args[0]); + lv_group_del(group); + return mp_const_none; +} + +STATIC MP_DEFINE_CONST_FUN_OBJ_VAR_BETWEEN(mp_lv_group_del_obj, 1, 1, mp_lv_group_del); + + + +/* + * lvgl extension definition for: + * void lv_group_add_obj(lv_group_t *group, lv_obj_t *obj) + */ + +STATIC mp_obj_t mp_lv_group_add_obj(size_t n_args, const mp_obj_t *args) +{ + lv_group_t *group = mp_write_ptr_lv_group_t(args[0]); + lv_obj_t *obj = mp_to_lv(args[1]); + lv_group_add_obj(group, obj); + return mp_const_none; +} + +STATIC MP_DEFINE_CONST_FUN_OBJ_VAR_BETWEEN(mp_lv_group_add_obj_obj, 2, 2, mp_lv_group_add_obj); + + + +/* + * lvgl extension definition for: + * void lv_group_remove_obj(lv_obj_t *obj) + */ + +STATIC mp_obj_t mp_lv_group_remove_obj(size_t n_args, const mp_obj_t *args) +{ + lv_obj_t *obj = mp_to_lv(args[0]); + lv_group_remove_obj(obj); + return mp_const_none; +} + +STATIC MP_DEFINE_CONST_FUN_OBJ_VAR_BETWEEN(mp_lv_group_remove_obj_obj, 1, 1, mp_lv_group_remove_obj); + + + +/* + * lvgl extension definition for: + * void lv_group_focus_obj(lv_obj_t *obj) + */ + +STATIC mp_obj_t mp_lv_group_focus_obj(size_t n_args, const mp_obj_t *args) +{ + lv_obj_t *obj = mp_to_lv(args[0]); + lv_group_focus_obj(obj); + return mp_const_none; +} + +STATIC MP_DEFINE_CONST_FUN_OBJ_VAR_BETWEEN(mp_lv_group_focus_obj_obj, 1, 1, mp_lv_group_focus_obj); + + + +/* + * lvgl extension definition for: + * void lv_group_focus_next(lv_group_t *group) + */ + +STATIC mp_obj_t mp_lv_group_focus_next(size_t n_args, const mp_obj_t *args) +{ + lv_group_t *group = mp_write_ptr_lv_group_t(args[0]); + lv_group_focus_next(group); + return mp_const_none; +} + +STATIC MP_DEFINE_CONST_FUN_OBJ_VAR_BETWEEN(mp_lv_group_focus_next_obj, 1, 1, mp_lv_group_focus_next); + + + +/* + * lvgl extension definition for: + * void lv_group_focus_prev(lv_group_t *group) + */ + +STATIC mp_obj_t mp_lv_group_focus_prev(size_t n_args, const mp_obj_t *args) +{ + lv_group_t *group = mp_write_ptr_lv_group_t(args[0]); + lv_group_focus_prev(group); + return mp_const_none; +} + +STATIC MP_DEFINE_CONST_FUN_OBJ_VAR_BETWEEN(mp_lv_group_focus_prev_obj, 1, 1, mp_lv_group_focus_prev); + + + +/* + * lvgl extension definition for: + * void lv_group_focus_freeze(lv_group_t *group, bool en) + */ + +STATIC mp_obj_t mp_lv_group_focus_freeze(size_t n_args, const mp_obj_t *args) +{ + lv_group_t *group = mp_write_ptr_lv_group_t(args[0]); + bool en = mp_obj_is_true(args[1]); + lv_group_focus_freeze(group, en); + return mp_const_none; +} + +STATIC MP_DEFINE_CONST_FUN_OBJ_VAR_BETWEEN(mp_lv_group_focus_freeze_obj, 2, 2, mp_lv_group_focus_freeze); + + + +/* + * lvgl extension definition for: + * lv_res_t lv_group_send_data(lv_group_t *group, uint32_t c) + */ + +STATIC mp_obj_t mp_lv_group_send_data(size_t n_args, const mp_obj_t *args) +{ + lv_group_t *group = mp_write_ptr_lv_group_t(args[0]); + uint32_t c = (uint32_t)mp_obj_get_int(args[1]); + lv_res_t res = lv_group_send_data(group, c); + return mp_obj_new_int_from_uint(res); +} + +STATIC MP_DEFINE_CONST_FUN_OBJ_VAR_BETWEEN(mp_lv_group_send_data_obj, 2, 2, mp_lv_group_send_data); + + + +/* + * lvgl extension definition for: + * void lv_group_set_style_mod_cb(lv_group_t *group, lv_group_style_mod_func_t style_mod_func) + */ + +STATIC mp_obj_t mp_lv_group_set_style_mod_cb(size_t n_args, const mp_obj_t *args) +{ + lv_group_t *group = mp_write_ptr_lv_group_t(args[0]); + set_action(args[0], args[1]); + lv_group_style_mod_func_t style_mod_func = &lv_group_style_mod_func_t_callback; + lv_group_set_style_mod_cb(group, style_mod_func); + return mp_const_none; +} + +STATIC MP_DEFINE_CONST_FUN_OBJ_VAR_BETWEEN(mp_lv_group_set_style_mod_cb_obj, 2, 2, mp_lv_group_set_style_mod_cb); + + + +/* + * lvgl extension definition for: + * void lv_group_set_style_mod_edit_cb(lv_group_t *group, lv_group_style_mod_func_t style_mod_func) + */ + +STATIC mp_obj_t mp_lv_group_set_style_mod_edit_cb(size_t n_args, const mp_obj_t *args) +{ + lv_group_t *group = mp_write_ptr_lv_group_t(args[0]); + set_action(args[0], args[1]); + lv_group_style_mod_func_t style_mod_func = &lv_group_style_mod_func_t_callback; + lv_group_set_style_mod_edit_cb(group, style_mod_func); + return mp_const_none; +} + +STATIC MP_DEFINE_CONST_FUN_OBJ_VAR_BETWEEN(mp_lv_group_set_style_mod_edit_cb_obj, 2, 2, mp_lv_group_set_style_mod_edit_cb); + + + +/* + * lvgl extension definition for: + * void lv_group_set_focus_cb(lv_group_t *group, lv_group_focus_cb_t focus_cb) + */ + +STATIC mp_obj_t mp_lv_group_set_focus_cb(size_t n_args, const mp_obj_t *args) +{ + lv_group_t *group = mp_write_ptr_lv_group_t(args[0]); + set_action(args[0], args[1]); + lv_group_focus_cb_t focus_cb = &lv_group_focus_cb_t_callback; + lv_group_set_focus_cb(group, focus_cb); + return mp_const_none; +} + +STATIC MP_DEFINE_CONST_FUN_OBJ_VAR_BETWEEN(mp_lv_group_set_focus_cb_obj, 2, 2, mp_lv_group_set_focus_cb); + + + +/* + * Function NOT generated: + * Missing conversion to lv_group_refocus_policy_t + * void lv_group_set_refocus_policy(lv_group_t *group, lv_group_refocus_policy_t policy) + */ + + +/* + * lvgl extension definition for: + * void lv_group_set_editing(lv_group_t *group, bool edit) + */ + +STATIC mp_obj_t mp_lv_group_set_editing(size_t n_args, const mp_obj_t *args) +{ + lv_group_t *group = mp_write_ptr_lv_group_t(args[0]); + bool edit = mp_obj_is_true(args[1]); + lv_group_set_editing(group, edit); + return mp_const_none; +} + +STATIC MP_DEFINE_CONST_FUN_OBJ_VAR_BETWEEN(mp_lv_group_set_editing_obj, 2, 2, mp_lv_group_set_editing); + + + +/* + * lvgl extension definition for: + * void lv_group_set_click_focus(lv_group_t *group, bool en) + */ + +STATIC mp_obj_t mp_lv_group_set_click_focus(size_t n_args, const mp_obj_t *args) +{ + lv_group_t *group = mp_write_ptr_lv_group_t(args[0]); + bool en = mp_obj_is_true(args[1]); + lv_group_set_click_focus(group, en); + return mp_const_none; +} + +STATIC MP_DEFINE_CONST_FUN_OBJ_VAR_BETWEEN(mp_lv_group_set_click_focus_obj, 2, 2, mp_lv_group_set_click_focus); + + + +/* + * lvgl extension definition for: + * void lv_group_set_wrap(lv_group_t *group, bool en) + */ + +STATIC mp_obj_t mp_lv_group_set_wrap(size_t n_args, const mp_obj_t *args) +{ + lv_group_t *group = mp_write_ptr_lv_group_t(args[0]); + bool en = mp_obj_is_true(args[1]); + lv_group_set_wrap(group, en); + return mp_const_none; +} + +STATIC MP_DEFINE_CONST_FUN_OBJ_VAR_BETWEEN(mp_lv_group_set_wrap_obj, 2, 2, mp_lv_group_set_wrap); + + + +/* + * lvgl extension definition for: + * lv_style_t *lv_group_mod_style(lv_group_t *group, const lv_style_t *style) + */ + +STATIC mp_obj_t mp_lv_group_mod_style(size_t n_args, const mp_obj_t *args) +{ + lv_group_t *group = mp_write_ptr_lv_group_t(args[0]); + const lv_style_t *style = mp_write_ptr_lv_style_t(args[1]); + lv_style_t* res = lv_group_mod_style(group, style); + return mp_read_ptr_lv_style_t((void*)res); +} + +STATIC MP_DEFINE_CONST_FUN_OBJ_VAR_BETWEEN(mp_lv_group_mod_style_obj, 2, 2, mp_lv_group_mod_style); + + + +/* + * lvgl extension definition for: + * lv_obj_t *lv_group_get_focused(const lv_group_t *group) + */ + +STATIC mp_obj_t mp_lv_group_get_focused(size_t n_args, const mp_obj_t *args) +{ + const lv_group_t *group = mp_write_ptr_lv_group_t(args[0]); + lv_obj_t* res = lv_group_get_focused(group); + return lv_to_mp((void*)res); +} + +STATIC MP_DEFINE_CONST_FUN_OBJ_VAR_BETWEEN(mp_lv_group_get_focused_obj, 1, 1, mp_lv_group_get_focused); + + + +/* + * lvgl extension definition for: + * lv_group_style_mod_func_t lv_group_get_style_mod_cb(const lv_group_t *group) + */ + +STATIC mp_obj_t mp_lv_group_get_style_mod_cb(size_t n_args, const mp_obj_t *args) +{ + const lv_group_t *group = mp_write_ptr_lv_group_t(args[0]); + lv_group_style_mod_func_t res = lv_group_get_style_mod_cb(group); + return ptr_to_mp(res); +} + +STATIC MP_DEFINE_CONST_FUN_OBJ_VAR_BETWEEN(mp_lv_group_get_style_mod_cb_obj, 1, 1, mp_lv_group_get_style_mod_cb); + + + +/* + * lvgl extension definition for: + * lv_group_style_mod_func_t lv_group_get_style_mod_edit_cb(const lv_group_t *group) + */ + +STATIC mp_obj_t mp_lv_group_get_style_mod_edit_cb(size_t n_args, const mp_obj_t *args) +{ + const lv_group_t *group = mp_write_ptr_lv_group_t(args[0]); + lv_group_style_mod_func_t res = lv_group_get_style_mod_edit_cb(group); + return ptr_to_mp(res); +} + +STATIC MP_DEFINE_CONST_FUN_OBJ_VAR_BETWEEN(mp_lv_group_get_style_mod_edit_cb_obj, 1, 1, mp_lv_group_get_style_mod_edit_cb); + + + +/* + * lvgl extension definition for: + * lv_group_focus_cb_t lv_group_get_focus_cb(const lv_group_t *group) + */ + +STATIC mp_obj_t mp_lv_group_get_focus_cb(size_t n_args, const mp_obj_t *args) +{ + const lv_group_t *group = mp_write_ptr_lv_group_t(args[0]); + lv_group_focus_cb_t res = lv_group_get_focus_cb(group); + return ptr_to_mp(res); +} + +STATIC MP_DEFINE_CONST_FUN_OBJ_VAR_BETWEEN(mp_lv_group_get_focus_cb_obj, 1, 1, mp_lv_group_get_focus_cb); + + + +/* + * lvgl extension definition for: + * bool lv_group_get_editing(const lv_group_t *group) + */ + +STATIC mp_obj_t mp_lv_group_get_editing(size_t n_args, const mp_obj_t *args) +{ + const lv_group_t *group = mp_write_ptr_lv_group_t(args[0]); + bool res = lv_group_get_editing(group); + return convert_to_bool(res); +} + +STATIC MP_DEFINE_CONST_FUN_OBJ_VAR_BETWEEN(mp_lv_group_get_editing_obj, 1, 1, mp_lv_group_get_editing); + + + +/* + * lvgl extension definition for: + * bool lv_group_get_click_focus(const lv_group_t *group) + */ + +STATIC mp_obj_t mp_lv_group_get_click_focus(size_t n_args, const mp_obj_t *args) +{ + const lv_group_t *group = mp_write_ptr_lv_group_t(args[0]); + bool res = lv_group_get_click_focus(group); + return convert_to_bool(res); +} + +STATIC MP_DEFINE_CONST_FUN_OBJ_VAR_BETWEEN(mp_lv_group_get_click_focus_obj, 1, 1, mp_lv_group_get_click_focus); + + + +/* + * lvgl extension definition for: + * bool lv_group_get_wrap(lv_group_t *group) + */ + +STATIC mp_obj_t mp_lv_group_get_wrap(size_t n_args, const mp_obj_t *args) +{ + lv_group_t *group = mp_write_ptr_lv_group_t(args[0]); + bool res = lv_group_get_wrap(group); + return convert_to_bool(res); +} + +STATIC MP_DEFINE_CONST_FUN_OBJ_VAR_BETWEEN(mp_lv_group_get_wrap_obj, 1, 1, mp_lv_group_get_wrap); + + + +/* + * Struct lv_vdb_t + */ + +STATIC inline const mp_obj_type_t *get_mp_lv_vdb_t_type(); + +STATIC inline lv_vdb_t* mp_write_ptr_lv_vdb_t(mp_obj_t self_in) +{ + mp_lv_struct_t *self = MP_OBJ_TO_PTR(cast(self_in, get_mp_lv_vdb_t_type())); + return (lv_vdb_t*)self->data; +} + +#define mp_write_lv_vdb_t(struct_obj) *mp_write_ptr_lv_vdb_t(struct_obj) + +STATIC inline mp_obj_t mp_read_ptr_lv_vdb_t(lv_vdb_t *field) +{ + return lv_to_mp_struct(get_mp_lv_vdb_t_type(), field); +} + +#define mp_read_lv_vdb_t(field) mp_read_ptr_lv_vdb_t(copy_buffer(&field, sizeof(lv_vdb_t))) +#define mp_read_byref_lv_vdb_t(field) mp_read_ptr_lv_vdb_t(&field) + +STATIC void mp_lv_vdb_t_attr(mp_obj_t self_in, qstr attr, mp_obj_t *dest) +{ + mp_lv_struct_t *self = MP_OBJ_TO_PTR(self_in); + lv_vdb_t *data = (lv_vdb_t*)self->data; + + if (dest[0] == MP_OBJ_NULL) { + // load attribute + switch(attr) + { + case MP_QSTR_area: dest[0] = mp_read_byref_lv_area_t(data->area); break; // converting from lv_area_t; + case MP_QSTR_buf: dest[0] = mp_read_ptr_lv_color16_t((void*)data->buf); break; // converting from lv_color_t*; + default: field_not_found(MP_QSTR_lv_vdb_t, attr); + } + } else { + if (dest[1]) + { + // store attribute + switch(attr) + { + case MP_QSTR_area: data->area = mp_write_lv_area_t(dest[1]); break; // converting to lv_area_t; + case MP_QSTR_buf: data->buf = (void*)mp_write_ptr_lv_color16_t(dest[1]); break; // converting to lv_color_t*; + default: field_not_found(MP_QSTR_lv_vdb_t, attr); + } + + dest[0] = MP_OBJ_NULL; // indicate success + } + } +} + +STATIC void mp_lv_vdb_t_print(const mp_print_t *print, + mp_obj_t self_in, + mp_print_kind_t kind) +{ + mp_printf(print, "lvgl struct lv_vdb_t"); +} + +STATIC const mp_rom_map_elem_t mp_lv_vdb_t_locals_dict_table[] = { + { MP_ROM_QSTR(MP_QSTR_SIZE), MP_ROM_PTR(MP_ROM_INT(sizeof(lv_vdb_t))) }, + { MP_ROM_QSTR(MP_QSTR_cast), MP_ROM_PTR(&mp_lv_cast_class_method) }, +}; + +STATIC MP_DEFINE_CONST_DICT(mp_lv_vdb_t_locals_dict, mp_lv_vdb_t_locals_dict_table); + +STATIC const mp_obj_type_t mp_lv_vdb_t_type = { + { &mp_type_type }, + .name = MP_QSTR_lv_vdb_t, + .print = mp_lv_vdb_t_print, + .make_new = make_new_lv_struct, + .attr = mp_lv_vdb_t_attr, + .locals_dict = (mp_obj_dict_t*)&mp_lv_vdb_t_locals_dict, + .buffer_p = { .get_buffer = mp_blob_get_buffer } +}; + +STATIC inline const mp_obj_type_t *get_mp_lv_vdb_t_type() +{ + return &mp_lv_vdb_t_type; +} + + +/* + * lvgl extension definition for: + * lv_vdb_t *lv_vdb_get(void) + */ + +STATIC mp_obj_t mp_lv_vdb_get(size_t n_args, const mp_obj_t *args) +{ + + lv_vdb_t* res = lv_vdb_get(); + return mp_read_ptr_lv_vdb_t((void*)res); +} + +STATIC MP_DEFINE_CONST_FUN_OBJ_VAR_BETWEEN(mp_lv_vdb_get_obj, 0, 0, mp_lv_vdb_get); + + + +/* + * lvgl extension definition for: + * void lv_vdb_flush(void) + */ + +STATIC mp_obj_t mp_lv_vdb_flush(size_t n_args, const mp_obj_t *args) +{ + + lv_vdb_flush(); + return mp_const_none; +} + +STATIC MP_DEFINE_CONST_FUN_OBJ_VAR_BETWEEN(mp_lv_vdb_flush_obj, 0, 0, mp_lv_vdb_flush); + + + +/* + * lvgl extension definition for: + * void lv_vdb_set_adr(void *buf1, void *buf2) + */ + +STATIC mp_obj_t mp_lv_vdb_set_adr(size_t n_args, const mp_obj_t *args) +{ + void *buf1 = mp_to_ptr(args[0]); + void *buf2 = mp_to_ptr(args[1]); + lv_vdb_set_adr(buf1, buf2); + return mp_const_none; +} + +STATIC MP_DEFINE_CONST_FUN_OBJ_VAR_BETWEEN(mp_lv_vdb_set_adr_obj, 2, 2, mp_lv_vdb_set_adr); + + + +/* + * lvgl extension definition for: + * void lv_flush_ready(void) + */ + +STATIC mp_obj_t mp_lv_flush_ready(size_t n_args, const mp_obj_t *args) +{ + + lv_flush_ready(); + return mp_const_none; +} + +STATIC MP_DEFINE_CONST_FUN_OBJ_VAR_BETWEEN(mp_lv_flush_ready_obj, 0, 0, mp_lv_flush_ready); + + + +/* + * lvgl extension definition for: + * lv_vdb_t *lv_vdb_get_active(void) + */ + +STATIC mp_obj_t mp_lv_vdb_get_active(size_t n_args, const mp_obj_t *args) +{ + + lv_vdb_t* res = lv_vdb_get_active(); + return mp_read_ptr_lv_vdb_t((void*)res); +} + +STATIC MP_DEFINE_CONST_FUN_OBJ_VAR_BETWEEN(mp_lv_vdb_get_active_obj, 0, 0, mp_lv_vdb_get_active); + + + +/* + * lvgl extension definition for: + * lv_vdb_t *lv_vdb_get_inactive(void) + */ + +STATIC mp_obj_t mp_lv_vdb_get_inactive(size_t n_args, const mp_obj_t *args) +{ + + lv_vdb_t* res = lv_vdb_get_inactive(); + return mp_read_ptr_lv_vdb_t((void*)res); +} + +STATIC MP_DEFINE_CONST_FUN_OBJ_VAR_BETWEEN(mp_lv_vdb_get_inactive_obj, 0, 0, mp_lv_vdb_get_inactive); + + + +/* + * lvgl extension definition for: + * bool lv_vdb_is_flushing(void) + */ + +STATIC mp_obj_t mp_lv_vdb_is_flushing(size_t n_args, const mp_obj_t *args) +{ + + bool res = lv_vdb_is_flushing(); + return convert_to_bool(res); +} + +STATIC MP_DEFINE_CONST_FUN_OBJ_VAR_BETWEEN(mp_lv_vdb_is_flushing_obj, 0, 0, mp_lv_vdb_is_flushing); + + + +/* + * lvgl extension definition for: + * void lv_refr_init(void) + */ + +STATIC mp_obj_t mp_lv_refr_init(size_t n_args, const mp_obj_t *args) +{ + + lv_refr_init(); + return mp_const_none; +} + +STATIC MP_DEFINE_CONST_FUN_OBJ_VAR_BETWEEN(mp_lv_refr_init_obj, 0, 0, mp_lv_refr_init); + + + +/* + * lvgl extension definition for: + * void lv_refr_now(void) + */ + +STATIC mp_obj_t mp_lv_refr_now(size_t n_args, const mp_obj_t *args) +{ + + lv_refr_now(); + return mp_const_none; +} + +STATIC MP_DEFINE_CONST_FUN_OBJ_VAR_BETWEEN(mp_lv_refr_now_obj, 0, 0, mp_lv_refr_now); + + + +/* + * lvgl extension definition for: + * void lv_inv_area(const lv_area_t *area_p) + */ + +STATIC mp_obj_t mp_lv_inv_area(size_t n_args, const mp_obj_t *args) +{ + const lv_area_t *area_p = mp_write_ptr_lv_area_t(args[0]); + lv_inv_area(area_p); + return mp_const_none; +} + +STATIC MP_DEFINE_CONST_FUN_OBJ_VAR_BETWEEN(mp_lv_inv_area_obj, 1, 1, mp_lv_inv_area); + + + +/* + * lvgl extension definition for: + * void lv_refr_set_monitor_cb(void (*cb)(uint32_t, uint32_t)) + */ + +STATIC mp_obj_t mp_lv_refr_set_monitor_cb(size_t n_args, const mp_obj_t *args) +{ + void (*cb)(uint32_t, uint32_t) = mp_to_ptr(args[0]); + lv_refr_set_monitor_cb(cb); + return mp_const_none; +} + +STATIC MP_DEFINE_CONST_FUN_OBJ_VAR_BETWEEN(mp_lv_refr_set_monitor_cb_obj, 1, 1, mp_lv_refr_set_monitor_cb); + + + +/* + * lvgl extension definition for: + * void lv_refr_set_round_cb(void (*cb)(lv_area_t *)) + */ + +STATIC mp_obj_t mp_lv_refr_set_round_cb(size_t n_args, const mp_obj_t *args) +{ + void (*cb)(lv_area_t *) = mp_to_ptr(args[0]); + lv_refr_set_round_cb(cb); + return mp_const_none; +} + +STATIC MP_DEFINE_CONST_FUN_OBJ_VAR_BETWEEN(mp_lv_refr_set_round_cb_obj, 1, 1, mp_lv_refr_set_round_cb); + + + +/* + * lvgl extension definition for: + * uint16_t lv_refr_get_buf_size(void) + */ + +STATIC mp_obj_t mp_lv_refr_get_buf_size(size_t n_args, const mp_obj_t *args) +{ + + uint16_t res = lv_refr_get_buf_size(); + return mp_obj_new_int_from_uint(res); +} + +STATIC MP_DEFINE_CONST_FUN_OBJ_VAR_BETWEEN(mp_lv_refr_get_buf_size_obj, 0, 0, mp_lv_refr_get_buf_size); + + + +/* + * lvgl extension definition for: + * void lv_refr_pop_from_buf(uint16_t num) + */ + +STATIC mp_obj_t mp_lv_refr_pop_from_buf(size_t n_args, const mp_obj_t *args) +{ + uint16_t num = (uint16_t)mp_obj_get_int(args[0]); + lv_refr_pop_from_buf(num); + return mp_const_none; +} + +STATIC MP_DEFINE_CONST_FUN_OBJ_VAR_BETWEEN(mp_lv_refr_pop_from_buf_obj, 1, 1, mp_lv_refr_pop_from_buf); + + +typedef __typeof__( ((lv_theme_t*)(0))->btn ) lv_theme_btn_t; + +/* + * Struct lv_theme_btn_t + */ + +STATIC inline const mp_obj_type_t *get_mp_lv_theme_btn_t_type(); + +STATIC inline lv_theme_btn_t* mp_write_ptr_lv_theme_btn_t(mp_obj_t self_in) +{ + mp_lv_struct_t *self = MP_OBJ_TO_PTR(cast(self_in, get_mp_lv_theme_btn_t_type())); + return (lv_theme_btn_t*)self->data; +} + +#define mp_write_lv_theme_btn_t(struct_obj) *mp_write_ptr_lv_theme_btn_t(struct_obj) + +STATIC inline mp_obj_t mp_read_ptr_lv_theme_btn_t(lv_theme_btn_t *field) +{ + return lv_to_mp_struct(get_mp_lv_theme_btn_t_type(), field); +} + +#define mp_read_lv_theme_btn_t(field) mp_read_ptr_lv_theme_btn_t(copy_buffer(&field, sizeof(lv_theme_btn_t))) +#define mp_read_byref_lv_theme_btn_t(field) mp_read_ptr_lv_theme_btn_t(&field) + +STATIC void mp_lv_theme_btn_t_attr(mp_obj_t self_in, qstr attr, mp_obj_t *dest) +{ + mp_lv_struct_t *self = MP_OBJ_TO_PTR(self_in); + lv_theme_btn_t *data = (lv_theme_btn_t*)self->data; + + if (dest[0] == MP_OBJ_NULL) { + // load attribute + switch(attr) + { + case MP_QSTR_rel: dest[0] = mp_read_ptr_lv_style_t((void*)data->rel); break; // converting from lv_style_t*; + case MP_QSTR_pr: dest[0] = mp_read_ptr_lv_style_t((void*)data->pr); break; // converting from lv_style_t*; + case MP_QSTR_tgl_rel: dest[0] = mp_read_ptr_lv_style_t((void*)data->tgl_rel); break; // converting from lv_style_t*; + case MP_QSTR_tgl_pr: dest[0] = mp_read_ptr_lv_style_t((void*)data->tgl_pr); break; // converting from lv_style_t*; + case MP_QSTR_ina: dest[0] = mp_read_ptr_lv_style_t((void*)data->ina); break; // converting from lv_style_t*; + default: field_not_found(MP_QSTR_lv_theme_btn_t, attr); + } + } else { + if (dest[1]) + { + // store attribute + switch(attr) + { + case MP_QSTR_rel: data->rel = (void*)mp_write_ptr_lv_style_t(dest[1]); break; // converting to lv_style_t*; + case MP_QSTR_pr: data->pr = (void*)mp_write_ptr_lv_style_t(dest[1]); break; // converting to lv_style_t*; + case MP_QSTR_tgl_rel: data->tgl_rel = (void*)mp_write_ptr_lv_style_t(dest[1]); break; // converting to lv_style_t*; + case MP_QSTR_tgl_pr: data->tgl_pr = (void*)mp_write_ptr_lv_style_t(dest[1]); break; // converting to lv_style_t*; + case MP_QSTR_ina: data->ina = (void*)mp_write_ptr_lv_style_t(dest[1]); break; // converting to lv_style_t*; + default: field_not_found(MP_QSTR_lv_theme_btn_t, attr); + } + + dest[0] = MP_OBJ_NULL; // indicate success + } + } +} + +STATIC void mp_lv_theme_btn_t_print(const mp_print_t *print, + mp_obj_t self_in, + mp_print_kind_t kind) +{ + mp_printf(print, "lvgl struct lv_theme_btn_t"); +} + +STATIC const mp_rom_map_elem_t mp_lv_theme_btn_t_locals_dict_table[] = { + { MP_ROM_QSTR(MP_QSTR_SIZE), MP_ROM_PTR(MP_ROM_INT(sizeof(lv_theme_btn_t))) }, + { MP_ROM_QSTR(MP_QSTR_cast), MP_ROM_PTR(&mp_lv_cast_class_method) }, +}; + +STATIC MP_DEFINE_CONST_DICT(mp_lv_theme_btn_t_locals_dict, mp_lv_theme_btn_t_locals_dict_table); + +STATIC const mp_obj_type_t mp_lv_theme_btn_t_type = { + { &mp_type_type }, + .name = MP_QSTR_lv_theme_btn_t, + .print = mp_lv_theme_btn_t_print, + .make_new = make_new_lv_struct, + .attr = mp_lv_theme_btn_t_attr, + .locals_dict = (mp_obj_dict_t*)&mp_lv_theme_btn_t_locals_dict, + .buffer_p = { .get_buffer = mp_blob_get_buffer } +}; + +STATIC inline const mp_obj_type_t *get_mp_lv_theme_btn_t_type() +{ + return &mp_lv_theme_btn_t_type; +} + +typedef __typeof__( ((lv_theme_t*)(0))->imgbtn ) lv_theme_imgbtn_t; + +/* + * Struct lv_theme_imgbtn_t + */ + +STATIC inline const mp_obj_type_t *get_mp_lv_theme_imgbtn_t_type(); + +STATIC inline lv_theme_imgbtn_t* mp_write_ptr_lv_theme_imgbtn_t(mp_obj_t self_in) +{ + mp_lv_struct_t *self = MP_OBJ_TO_PTR(cast(self_in, get_mp_lv_theme_imgbtn_t_type())); + return (lv_theme_imgbtn_t*)self->data; +} + +#define mp_write_lv_theme_imgbtn_t(struct_obj) *mp_write_ptr_lv_theme_imgbtn_t(struct_obj) + +STATIC inline mp_obj_t mp_read_ptr_lv_theme_imgbtn_t(lv_theme_imgbtn_t *field) +{ + return lv_to_mp_struct(get_mp_lv_theme_imgbtn_t_type(), field); +} + +#define mp_read_lv_theme_imgbtn_t(field) mp_read_ptr_lv_theme_imgbtn_t(copy_buffer(&field, sizeof(lv_theme_imgbtn_t))) +#define mp_read_byref_lv_theme_imgbtn_t(field) mp_read_ptr_lv_theme_imgbtn_t(&field) + +STATIC void mp_lv_theme_imgbtn_t_attr(mp_obj_t self_in, qstr attr, mp_obj_t *dest) +{ + mp_lv_struct_t *self = MP_OBJ_TO_PTR(self_in); + lv_theme_imgbtn_t *data = (lv_theme_imgbtn_t*)self->data; + + if (dest[0] == MP_OBJ_NULL) { + // load attribute + switch(attr) + { + case MP_QSTR_rel: dest[0] = mp_read_ptr_lv_style_t((void*)data->rel); break; // converting from lv_style_t*; + case MP_QSTR_pr: dest[0] = mp_read_ptr_lv_style_t((void*)data->pr); break; // converting from lv_style_t*; + case MP_QSTR_tgl_rel: dest[0] = mp_read_ptr_lv_style_t((void*)data->tgl_rel); break; // converting from lv_style_t*; + case MP_QSTR_tgl_pr: dest[0] = mp_read_ptr_lv_style_t((void*)data->tgl_pr); break; // converting from lv_style_t*; + case MP_QSTR_ina: dest[0] = mp_read_ptr_lv_style_t((void*)data->ina); break; // converting from lv_style_t*; + default: field_not_found(MP_QSTR_lv_theme_imgbtn_t, attr); + } + } else { + if (dest[1]) + { + // store attribute + switch(attr) + { + case MP_QSTR_rel: data->rel = (void*)mp_write_ptr_lv_style_t(dest[1]); break; // converting to lv_style_t*; + case MP_QSTR_pr: data->pr = (void*)mp_write_ptr_lv_style_t(dest[1]); break; // converting to lv_style_t*; + case MP_QSTR_tgl_rel: data->tgl_rel = (void*)mp_write_ptr_lv_style_t(dest[1]); break; // converting to lv_style_t*; + case MP_QSTR_tgl_pr: data->tgl_pr = (void*)mp_write_ptr_lv_style_t(dest[1]); break; // converting to lv_style_t*; + case MP_QSTR_ina: data->ina = (void*)mp_write_ptr_lv_style_t(dest[1]); break; // converting to lv_style_t*; + default: field_not_found(MP_QSTR_lv_theme_imgbtn_t, attr); + } + + dest[0] = MP_OBJ_NULL; // indicate success + } + } +} + +STATIC void mp_lv_theme_imgbtn_t_print(const mp_print_t *print, + mp_obj_t self_in, + mp_print_kind_t kind) +{ + mp_printf(print, "lvgl struct lv_theme_imgbtn_t"); +} + +STATIC const mp_rom_map_elem_t mp_lv_theme_imgbtn_t_locals_dict_table[] = { + { MP_ROM_QSTR(MP_QSTR_SIZE), MP_ROM_PTR(MP_ROM_INT(sizeof(lv_theme_imgbtn_t))) }, + { MP_ROM_QSTR(MP_QSTR_cast), MP_ROM_PTR(&mp_lv_cast_class_method) }, +}; + +STATIC MP_DEFINE_CONST_DICT(mp_lv_theme_imgbtn_t_locals_dict, mp_lv_theme_imgbtn_t_locals_dict_table); + +STATIC const mp_obj_type_t mp_lv_theme_imgbtn_t_type = { + { &mp_type_type }, + .name = MP_QSTR_lv_theme_imgbtn_t, + .print = mp_lv_theme_imgbtn_t_print, + .make_new = make_new_lv_struct, + .attr = mp_lv_theme_imgbtn_t_attr, + .locals_dict = (mp_obj_dict_t*)&mp_lv_theme_imgbtn_t_locals_dict, + .buffer_p = { .get_buffer = mp_blob_get_buffer } +}; + +STATIC inline const mp_obj_type_t *get_mp_lv_theme_imgbtn_t_type() +{ + return &mp_lv_theme_imgbtn_t_type; +} + +typedef __typeof__( ((lv_theme_t*)(0))->label ) lv_theme_label_t; + +/* + * Struct lv_theme_label_t + */ + +STATIC inline const mp_obj_type_t *get_mp_lv_theme_label_t_type(); + +STATIC inline lv_theme_label_t* mp_write_ptr_lv_theme_label_t(mp_obj_t self_in) +{ + mp_lv_struct_t *self = MP_OBJ_TO_PTR(cast(self_in, get_mp_lv_theme_label_t_type())); + return (lv_theme_label_t*)self->data; +} + +#define mp_write_lv_theme_label_t(struct_obj) *mp_write_ptr_lv_theme_label_t(struct_obj) + +STATIC inline mp_obj_t mp_read_ptr_lv_theme_label_t(lv_theme_label_t *field) +{ + return lv_to_mp_struct(get_mp_lv_theme_label_t_type(), field); +} + +#define mp_read_lv_theme_label_t(field) mp_read_ptr_lv_theme_label_t(copy_buffer(&field, sizeof(lv_theme_label_t))) +#define mp_read_byref_lv_theme_label_t(field) mp_read_ptr_lv_theme_label_t(&field) + +STATIC void mp_lv_theme_label_t_attr(mp_obj_t self_in, qstr attr, mp_obj_t *dest) +{ + mp_lv_struct_t *self = MP_OBJ_TO_PTR(self_in); + lv_theme_label_t *data = (lv_theme_label_t*)self->data; + + if (dest[0] == MP_OBJ_NULL) { + // load attribute + switch(attr) + { + case MP_QSTR_prim: dest[0] = mp_read_ptr_lv_style_t((void*)data->prim); break; // converting from lv_style_t*; + case MP_QSTR_sec: dest[0] = mp_read_ptr_lv_style_t((void*)data->sec); break; // converting from lv_style_t*; + case MP_QSTR_hint: dest[0] = mp_read_ptr_lv_style_t((void*)data->hint); break; // converting from lv_style_t*; + default: field_not_found(MP_QSTR_lv_theme_label_t, attr); + } + } else { + if (dest[1]) + { + // store attribute + switch(attr) + { + case MP_QSTR_prim: data->prim = (void*)mp_write_ptr_lv_style_t(dest[1]); break; // converting to lv_style_t*; + case MP_QSTR_sec: data->sec = (void*)mp_write_ptr_lv_style_t(dest[1]); break; // converting to lv_style_t*; + case MP_QSTR_hint: data->hint = (void*)mp_write_ptr_lv_style_t(dest[1]); break; // converting to lv_style_t*; + default: field_not_found(MP_QSTR_lv_theme_label_t, attr); + } + + dest[0] = MP_OBJ_NULL; // indicate success + } + } +} + +STATIC void mp_lv_theme_label_t_print(const mp_print_t *print, + mp_obj_t self_in, + mp_print_kind_t kind) +{ + mp_printf(print, "lvgl struct lv_theme_label_t"); +} + +STATIC const mp_rom_map_elem_t mp_lv_theme_label_t_locals_dict_table[] = { + { MP_ROM_QSTR(MP_QSTR_SIZE), MP_ROM_PTR(MP_ROM_INT(sizeof(lv_theme_label_t))) }, + { MP_ROM_QSTR(MP_QSTR_cast), MP_ROM_PTR(&mp_lv_cast_class_method) }, +}; + +STATIC MP_DEFINE_CONST_DICT(mp_lv_theme_label_t_locals_dict, mp_lv_theme_label_t_locals_dict_table); + +STATIC const mp_obj_type_t mp_lv_theme_label_t_type = { + { &mp_type_type }, + .name = MP_QSTR_lv_theme_label_t, + .print = mp_lv_theme_label_t_print, + .make_new = make_new_lv_struct, + .attr = mp_lv_theme_label_t_attr, + .locals_dict = (mp_obj_dict_t*)&mp_lv_theme_label_t_locals_dict, + .buffer_p = { .get_buffer = mp_blob_get_buffer } +}; + +STATIC inline const mp_obj_type_t *get_mp_lv_theme_label_t_type() +{ + return &mp_lv_theme_label_t_type; +} + +typedef __typeof__( ((lv_theme_t*)(0))->img ) lv_theme_img_t; + +/* + * Struct lv_theme_img_t + */ + +STATIC inline const mp_obj_type_t *get_mp_lv_theme_img_t_type(); + +STATIC inline lv_theme_img_t* mp_write_ptr_lv_theme_img_t(mp_obj_t self_in) +{ + mp_lv_struct_t *self = MP_OBJ_TO_PTR(cast(self_in, get_mp_lv_theme_img_t_type())); + return (lv_theme_img_t*)self->data; +} + +#define mp_write_lv_theme_img_t(struct_obj) *mp_write_ptr_lv_theme_img_t(struct_obj) + +STATIC inline mp_obj_t mp_read_ptr_lv_theme_img_t(lv_theme_img_t *field) +{ + return lv_to_mp_struct(get_mp_lv_theme_img_t_type(), field); +} + +#define mp_read_lv_theme_img_t(field) mp_read_ptr_lv_theme_img_t(copy_buffer(&field, sizeof(lv_theme_img_t))) +#define mp_read_byref_lv_theme_img_t(field) mp_read_ptr_lv_theme_img_t(&field) + +STATIC void mp_lv_theme_img_t_attr(mp_obj_t self_in, qstr attr, mp_obj_t *dest) +{ + mp_lv_struct_t *self = MP_OBJ_TO_PTR(self_in); + lv_theme_img_t *data = (lv_theme_img_t*)self->data; + + if (dest[0] == MP_OBJ_NULL) { + // load attribute + switch(attr) + { + case MP_QSTR_light: dest[0] = mp_read_ptr_lv_style_t((void*)data->light); break; // converting from lv_style_t*; + case MP_QSTR_dark: dest[0] = mp_read_ptr_lv_style_t((void*)data->dark); break; // converting from lv_style_t*; + default: field_not_found(MP_QSTR_lv_theme_img_t, attr); + } + } else { + if (dest[1]) + { + // store attribute + switch(attr) + { + case MP_QSTR_light: data->light = (void*)mp_write_ptr_lv_style_t(dest[1]); break; // converting to lv_style_t*; + case MP_QSTR_dark: data->dark = (void*)mp_write_ptr_lv_style_t(dest[1]); break; // converting to lv_style_t*; + default: field_not_found(MP_QSTR_lv_theme_img_t, attr); + } + + dest[0] = MP_OBJ_NULL; // indicate success + } + } +} + +STATIC void mp_lv_theme_img_t_print(const mp_print_t *print, + mp_obj_t self_in, + mp_print_kind_t kind) +{ + mp_printf(print, "lvgl struct lv_theme_img_t"); +} + +STATIC const mp_rom_map_elem_t mp_lv_theme_img_t_locals_dict_table[] = { + { MP_ROM_QSTR(MP_QSTR_SIZE), MP_ROM_PTR(MP_ROM_INT(sizeof(lv_theme_img_t))) }, + { MP_ROM_QSTR(MP_QSTR_cast), MP_ROM_PTR(&mp_lv_cast_class_method) }, +}; + +STATIC MP_DEFINE_CONST_DICT(mp_lv_theme_img_t_locals_dict, mp_lv_theme_img_t_locals_dict_table); + +STATIC const mp_obj_type_t mp_lv_theme_img_t_type = { + { &mp_type_type }, + .name = MP_QSTR_lv_theme_img_t, + .print = mp_lv_theme_img_t_print, + .make_new = make_new_lv_struct, + .attr = mp_lv_theme_img_t_attr, + .locals_dict = (mp_obj_dict_t*)&mp_lv_theme_img_t_locals_dict, + .buffer_p = { .get_buffer = mp_blob_get_buffer } +}; + +STATIC inline const mp_obj_type_t *get_mp_lv_theme_img_t_type() +{ + return &mp_lv_theme_img_t_type; +} + +typedef __typeof__( ((lv_theme_t*)(0))->line ) lv_theme_line_t; + +/* + * Struct lv_theme_line_t + */ + +STATIC inline const mp_obj_type_t *get_mp_lv_theme_line_t_type(); + +STATIC inline lv_theme_line_t* mp_write_ptr_lv_theme_line_t(mp_obj_t self_in) +{ + mp_lv_struct_t *self = MP_OBJ_TO_PTR(cast(self_in, get_mp_lv_theme_line_t_type())); + return (lv_theme_line_t*)self->data; +} + +#define mp_write_lv_theme_line_t(struct_obj) *mp_write_ptr_lv_theme_line_t(struct_obj) + +STATIC inline mp_obj_t mp_read_ptr_lv_theme_line_t(lv_theme_line_t *field) +{ + return lv_to_mp_struct(get_mp_lv_theme_line_t_type(), field); +} + +#define mp_read_lv_theme_line_t(field) mp_read_ptr_lv_theme_line_t(copy_buffer(&field, sizeof(lv_theme_line_t))) +#define mp_read_byref_lv_theme_line_t(field) mp_read_ptr_lv_theme_line_t(&field) + +STATIC void mp_lv_theme_line_t_attr(mp_obj_t self_in, qstr attr, mp_obj_t *dest) +{ + mp_lv_struct_t *self = MP_OBJ_TO_PTR(self_in); + lv_theme_line_t *data = (lv_theme_line_t*)self->data; + + if (dest[0] == MP_OBJ_NULL) { + // load attribute + switch(attr) + { + case MP_QSTR_decor: dest[0] = mp_read_ptr_lv_style_t((void*)data->decor); break; // converting from lv_style_t*; + default: field_not_found(MP_QSTR_lv_theme_line_t, attr); + } + } else { + if (dest[1]) + { + // store attribute + switch(attr) + { + case MP_QSTR_decor: data->decor = (void*)mp_write_ptr_lv_style_t(dest[1]); break; // converting to lv_style_t*; + default: field_not_found(MP_QSTR_lv_theme_line_t, attr); + } + + dest[0] = MP_OBJ_NULL; // indicate success + } + } +} + +STATIC void mp_lv_theme_line_t_print(const mp_print_t *print, + mp_obj_t self_in, + mp_print_kind_t kind) +{ + mp_printf(print, "lvgl struct lv_theme_line_t"); +} + +STATIC const mp_rom_map_elem_t mp_lv_theme_line_t_locals_dict_table[] = { + { MP_ROM_QSTR(MP_QSTR_SIZE), MP_ROM_PTR(MP_ROM_INT(sizeof(lv_theme_line_t))) }, + { MP_ROM_QSTR(MP_QSTR_cast), MP_ROM_PTR(&mp_lv_cast_class_method) }, +}; + +STATIC MP_DEFINE_CONST_DICT(mp_lv_theme_line_t_locals_dict, mp_lv_theme_line_t_locals_dict_table); + +STATIC const mp_obj_type_t mp_lv_theme_line_t_type = { + { &mp_type_type }, + .name = MP_QSTR_lv_theme_line_t, + .print = mp_lv_theme_line_t_print, + .make_new = make_new_lv_struct, + .attr = mp_lv_theme_line_t_attr, + .locals_dict = (mp_obj_dict_t*)&mp_lv_theme_line_t_locals_dict, + .buffer_p = { .get_buffer = mp_blob_get_buffer } +}; + +STATIC inline const mp_obj_type_t *get_mp_lv_theme_line_t_type() +{ + return &mp_lv_theme_line_t_type; +} + +typedef __typeof__( ((lv_theme_t*)(0))->bar ) lv_theme_bar_t; + +/* + * Struct lv_theme_bar_t + */ + +STATIC inline const mp_obj_type_t *get_mp_lv_theme_bar_t_type(); + +STATIC inline lv_theme_bar_t* mp_write_ptr_lv_theme_bar_t(mp_obj_t self_in) +{ + mp_lv_struct_t *self = MP_OBJ_TO_PTR(cast(self_in, get_mp_lv_theme_bar_t_type())); + return (lv_theme_bar_t*)self->data; +} + +#define mp_write_lv_theme_bar_t(struct_obj) *mp_write_ptr_lv_theme_bar_t(struct_obj) + +STATIC inline mp_obj_t mp_read_ptr_lv_theme_bar_t(lv_theme_bar_t *field) +{ + return lv_to_mp_struct(get_mp_lv_theme_bar_t_type(), field); +} + +#define mp_read_lv_theme_bar_t(field) mp_read_ptr_lv_theme_bar_t(copy_buffer(&field, sizeof(lv_theme_bar_t))) +#define mp_read_byref_lv_theme_bar_t(field) mp_read_ptr_lv_theme_bar_t(&field) + +STATIC void mp_lv_theme_bar_t_attr(mp_obj_t self_in, qstr attr, mp_obj_t *dest) +{ + mp_lv_struct_t *self = MP_OBJ_TO_PTR(self_in); + lv_theme_bar_t *data = (lv_theme_bar_t*)self->data; + + if (dest[0] == MP_OBJ_NULL) { + // load attribute + switch(attr) + { + case MP_QSTR_bg: dest[0] = mp_read_ptr_lv_style_t((void*)data->bg); break; // converting from lv_style_t*; + case MP_QSTR_indic: dest[0] = mp_read_ptr_lv_style_t((void*)data->indic); break; // converting from lv_style_t*; + default: field_not_found(MP_QSTR_lv_theme_bar_t, attr); + } + } else { + if (dest[1]) + { + // store attribute + switch(attr) + { + case MP_QSTR_bg: data->bg = (void*)mp_write_ptr_lv_style_t(dest[1]); break; // converting to lv_style_t*; + case MP_QSTR_indic: data->indic = (void*)mp_write_ptr_lv_style_t(dest[1]); break; // converting to lv_style_t*; + default: field_not_found(MP_QSTR_lv_theme_bar_t, attr); + } + + dest[0] = MP_OBJ_NULL; // indicate success + } + } +} + +STATIC void mp_lv_theme_bar_t_print(const mp_print_t *print, + mp_obj_t self_in, + mp_print_kind_t kind) +{ + mp_printf(print, "lvgl struct lv_theme_bar_t"); +} + +STATIC const mp_rom_map_elem_t mp_lv_theme_bar_t_locals_dict_table[] = { + { MP_ROM_QSTR(MP_QSTR_SIZE), MP_ROM_PTR(MP_ROM_INT(sizeof(lv_theme_bar_t))) }, + { MP_ROM_QSTR(MP_QSTR_cast), MP_ROM_PTR(&mp_lv_cast_class_method) }, +}; + +STATIC MP_DEFINE_CONST_DICT(mp_lv_theme_bar_t_locals_dict, mp_lv_theme_bar_t_locals_dict_table); + +STATIC const mp_obj_type_t mp_lv_theme_bar_t_type = { + { &mp_type_type }, + .name = MP_QSTR_lv_theme_bar_t, + .print = mp_lv_theme_bar_t_print, + .make_new = make_new_lv_struct, + .attr = mp_lv_theme_bar_t_attr, + .locals_dict = (mp_obj_dict_t*)&mp_lv_theme_bar_t_locals_dict, + .buffer_p = { .get_buffer = mp_blob_get_buffer } +}; + +STATIC inline const mp_obj_type_t *get_mp_lv_theme_bar_t_type() +{ + return &mp_lv_theme_bar_t_type; +} + +typedef __typeof__( ((lv_theme_t*)(0))->slider ) lv_theme_slider_t; + +/* + * Struct lv_theme_slider_t + */ + +STATIC inline const mp_obj_type_t *get_mp_lv_theme_slider_t_type(); + +STATIC inline lv_theme_slider_t* mp_write_ptr_lv_theme_slider_t(mp_obj_t self_in) +{ + mp_lv_struct_t *self = MP_OBJ_TO_PTR(cast(self_in, get_mp_lv_theme_slider_t_type())); + return (lv_theme_slider_t*)self->data; +} + +#define mp_write_lv_theme_slider_t(struct_obj) *mp_write_ptr_lv_theme_slider_t(struct_obj) + +STATIC inline mp_obj_t mp_read_ptr_lv_theme_slider_t(lv_theme_slider_t *field) +{ + return lv_to_mp_struct(get_mp_lv_theme_slider_t_type(), field); +} + +#define mp_read_lv_theme_slider_t(field) mp_read_ptr_lv_theme_slider_t(copy_buffer(&field, sizeof(lv_theme_slider_t))) +#define mp_read_byref_lv_theme_slider_t(field) mp_read_ptr_lv_theme_slider_t(&field) + +STATIC void mp_lv_theme_slider_t_attr(mp_obj_t self_in, qstr attr, mp_obj_t *dest) +{ + mp_lv_struct_t *self = MP_OBJ_TO_PTR(self_in); + lv_theme_slider_t *data = (lv_theme_slider_t*)self->data; + + if (dest[0] == MP_OBJ_NULL) { + // load attribute + switch(attr) + { + case MP_QSTR_bg: dest[0] = mp_read_ptr_lv_style_t((void*)data->bg); break; // converting from lv_style_t*; + case MP_QSTR_indic: dest[0] = mp_read_ptr_lv_style_t((void*)data->indic); break; // converting from lv_style_t*; + case MP_QSTR_knob: dest[0] = mp_read_ptr_lv_style_t((void*)data->knob); break; // converting from lv_style_t*; + default: field_not_found(MP_QSTR_lv_theme_slider_t, attr); + } + } else { + if (dest[1]) + { + // store attribute + switch(attr) + { + case MP_QSTR_bg: data->bg = (void*)mp_write_ptr_lv_style_t(dest[1]); break; // converting to lv_style_t*; + case MP_QSTR_indic: data->indic = (void*)mp_write_ptr_lv_style_t(dest[1]); break; // converting to lv_style_t*; + case MP_QSTR_knob: data->knob = (void*)mp_write_ptr_lv_style_t(dest[1]); break; // converting to lv_style_t*; + default: field_not_found(MP_QSTR_lv_theme_slider_t, attr); + } + + dest[0] = MP_OBJ_NULL; // indicate success + } + } +} + +STATIC void mp_lv_theme_slider_t_print(const mp_print_t *print, + mp_obj_t self_in, + mp_print_kind_t kind) +{ + mp_printf(print, "lvgl struct lv_theme_slider_t"); +} + +STATIC const mp_rom_map_elem_t mp_lv_theme_slider_t_locals_dict_table[] = { + { MP_ROM_QSTR(MP_QSTR_SIZE), MP_ROM_PTR(MP_ROM_INT(sizeof(lv_theme_slider_t))) }, + { MP_ROM_QSTR(MP_QSTR_cast), MP_ROM_PTR(&mp_lv_cast_class_method) }, +}; + +STATIC MP_DEFINE_CONST_DICT(mp_lv_theme_slider_t_locals_dict, mp_lv_theme_slider_t_locals_dict_table); + +STATIC const mp_obj_type_t mp_lv_theme_slider_t_type = { + { &mp_type_type }, + .name = MP_QSTR_lv_theme_slider_t, + .print = mp_lv_theme_slider_t_print, + .make_new = make_new_lv_struct, + .attr = mp_lv_theme_slider_t_attr, + .locals_dict = (mp_obj_dict_t*)&mp_lv_theme_slider_t_locals_dict, + .buffer_p = { .get_buffer = mp_blob_get_buffer } +}; + +STATIC inline const mp_obj_type_t *get_mp_lv_theme_slider_t_type() +{ + return &mp_lv_theme_slider_t_type; +} + +typedef __typeof__( ((lv_theme_t*)(0))->sw ) lv_theme_sw_t; + +/* + * Struct lv_theme_sw_t + */ + +STATIC inline const mp_obj_type_t *get_mp_lv_theme_sw_t_type(); + +STATIC inline lv_theme_sw_t* mp_write_ptr_lv_theme_sw_t(mp_obj_t self_in) +{ + mp_lv_struct_t *self = MP_OBJ_TO_PTR(cast(self_in, get_mp_lv_theme_sw_t_type())); + return (lv_theme_sw_t*)self->data; +} + +#define mp_write_lv_theme_sw_t(struct_obj) *mp_write_ptr_lv_theme_sw_t(struct_obj) + +STATIC inline mp_obj_t mp_read_ptr_lv_theme_sw_t(lv_theme_sw_t *field) +{ + return lv_to_mp_struct(get_mp_lv_theme_sw_t_type(), field); +} + +#define mp_read_lv_theme_sw_t(field) mp_read_ptr_lv_theme_sw_t(copy_buffer(&field, sizeof(lv_theme_sw_t))) +#define mp_read_byref_lv_theme_sw_t(field) mp_read_ptr_lv_theme_sw_t(&field) + +STATIC void mp_lv_theme_sw_t_attr(mp_obj_t self_in, qstr attr, mp_obj_t *dest) +{ + mp_lv_struct_t *self = MP_OBJ_TO_PTR(self_in); + lv_theme_sw_t *data = (lv_theme_sw_t*)self->data; + + if (dest[0] == MP_OBJ_NULL) { + // load attribute + switch(attr) + { + case MP_QSTR_bg: dest[0] = mp_read_ptr_lv_style_t((void*)data->bg); break; // converting from lv_style_t*; + case MP_QSTR_indic: dest[0] = mp_read_ptr_lv_style_t((void*)data->indic); break; // converting from lv_style_t*; + case MP_QSTR_knob_off: dest[0] = mp_read_ptr_lv_style_t((void*)data->knob_off); break; // converting from lv_style_t*; + case MP_QSTR_knob_on: dest[0] = mp_read_ptr_lv_style_t((void*)data->knob_on); break; // converting from lv_style_t*; + default: field_not_found(MP_QSTR_lv_theme_sw_t, attr); + } + } else { + if (dest[1]) + { + // store attribute + switch(attr) + { + case MP_QSTR_bg: data->bg = (void*)mp_write_ptr_lv_style_t(dest[1]); break; // converting to lv_style_t*; + case MP_QSTR_indic: data->indic = (void*)mp_write_ptr_lv_style_t(dest[1]); break; // converting to lv_style_t*; + case MP_QSTR_knob_off: data->knob_off = (void*)mp_write_ptr_lv_style_t(dest[1]); break; // converting to lv_style_t*; + case MP_QSTR_knob_on: data->knob_on = (void*)mp_write_ptr_lv_style_t(dest[1]); break; // converting to lv_style_t*; + default: field_not_found(MP_QSTR_lv_theme_sw_t, attr); + } + + dest[0] = MP_OBJ_NULL; // indicate success + } + } +} + +STATIC void mp_lv_theme_sw_t_print(const mp_print_t *print, + mp_obj_t self_in, + mp_print_kind_t kind) +{ + mp_printf(print, "lvgl struct lv_theme_sw_t"); +} + +STATIC const mp_rom_map_elem_t mp_lv_theme_sw_t_locals_dict_table[] = { + { MP_ROM_QSTR(MP_QSTR_SIZE), MP_ROM_PTR(MP_ROM_INT(sizeof(lv_theme_sw_t))) }, + { MP_ROM_QSTR(MP_QSTR_cast), MP_ROM_PTR(&mp_lv_cast_class_method) }, +}; + +STATIC MP_DEFINE_CONST_DICT(mp_lv_theme_sw_t_locals_dict, mp_lv_theme_sw_t_locals_dict_table); + +STATIC const mp_obj_type_t mp_lv_theme_sw_t_type = { + { &mp_type_type }, + .name = MP_QSTR_lv_theme_sw_t, + .print = mp_lv_theme_sw_t_print, + .make_new = make_new_lv_struct, + .attr = mp_lv_theme_sw_t_attr, + .locals_dict = (mp_obj_dict_t*)&mp_lv_theme_sw_t_locals_dict, + .buffer_p = { .get_buffer = mp_blob_get_buffer } +}; + +STATIC inline const mp_obj_type_t *get_mp_lv_theme_sw_t_type() +{ + return &mp_lv_theme_sw_t_type; +} + +typedef __typeof__( ((lv_theme_t*)(0))->calendar ) lv_theme_calendar_t; + +/* + * Struct lv_theme_calendar_t + */ + +STATIC inline const mp_obj_type_t *get_mp_lv_theme_calendar_t_type(); + +STATIC inline lv_theme_calendar_t* mp_write_ptr_lv_theme_calendar_t(mp_obj_t self_in) +{ + mp_lv_struct_t *self = MP_OBJ_TO_PTR(cast(self_in, get_mp_lv_theme_calendar_t_type())); + return (lv_theme_calendar_t*)self->data; +} + +#define mp_write_lv_theme_calendar_t(struct_obj) *mp_write_ptr_lv_theme_calendar_t(struct_obj) + +STATIC inline mp_obj_t mp_read_ptr_lv_theme_calendar_t(lv_theme_calendar_t *field) +{ + return lv_to_mp_struct(get_mp_lv_theme_calendar_t_type(), field); +} + +#define mp_read_lv_theme_calendar_t(field) mp_read_ptr_lv_theme_calendar_t(copy_buffer(&field, sizeof(lv_theme_calendar_t))) +#define mp_read_byref_lv_theme_calendar_t(field) mp_read_ptr_lv_theme_calendar_t(&field) + +STATIC void mp_lv_theme_calendar_t_attr(mp_obj_t self_in, qstr attr, mp_obj_t *dest) +{ + mp_lv_struct_t *self = MP_OBJ_TO_PTR(self_in); + lv_theme_calendar_t *data = (lv_theme_calendar_t*)self->data; + + if (dest[0] == MP_OBJ_NULL) { + // load attribute + switch(attr) + { + case MP_QSTR_bg: dest[0] = mp_read_ptr_lv_style_t((void*)data->bg); break; // converting from lv_style_t*; + case MP_QSTR_header: dest[0] = mp_read_ptr_lv_style_t((void*)data->header); break; // converting from lv_style_t*; + case MP_QSTR_header_pr: dest[0] = mp_read_ptr_lv_style_t((void*)data->header_pr); break; // converting from lv_style_t*; + case MP_QSTR_day_names: dest[0] = mp_read_ptr_lv_style_t((void*)data->day_names); break; // converting from lv_style_t*; + case MP_QSTR_highlighted_days: dest[0] = mp_read_ptr_lv_style_t((void*)data->highlighted_days); break; // converting from lv_style_t*; + case MP_QSTR_inactive_days: dest[0] = mp_read_ptr_lv_style_t((void*)data->inactive_days); break; // converting from lv_style_t*; + case MP_QSTR_week_box: dest[0] = mp_read_ptr_lv_style_t((void*)data->week_box); break; // converting from lv_style_t*; + case MP_QSTR_today_box: dest[0] = mp_read_ptr_lv_style_t((void*)data->today_box); break; // converting from lv_style_t*; + default: field_not_found(MP_QSTR_lv_theme_calendar_t, attr); + } + } else { + if (dest[1]) + { + // store attribute + switch(attr) + { + case MP_QSTR_bg: data->bg = (void*)mp_write_ptr_lv_style_t(dest[1]); break; // converting to lv_style_t*; + case MP_QSTR_header: data->header = (void*)mp_write_ptr_lv_style_t(dest[1]); break; // converting to lv_style_t*; + case MP_QSTR_header_pr: data->header_pr = (void*)mp_write_ptr_lv_style_t(dest[1]); break; // converting to lv_style_t*; + case MP_QSTR_day_names: data->day_names = (void*)mp_write_ptr_lv_style_t(dest[1]); break; // converting to lv_style_t*; + case MP_QSTR_highlighted_days: data->highlighted_days = (void*)mp_write_ptr_lv_style_t(dest[1]); break; // converting to lv_style_t*; + case MP_QSTR_inactive_days: data->inactive_days = (void*)mp_write_ptr_lv_style_t(dest[1]); break; // converting to lv_style_t*; + case MP_QSTR_week_box: data->week_box = (void*)mp_write_ptr_lv_style_t(dest[1]); break; // converting to lv_style_t*; + case MP_QSTR_today_box: data->today_box = (void*)mp_write_ptr_lv_style_t(dest[1]); break; // converting to lv_style_t*; + default: field_not_found(MP_QSTR_lv_theme_calendar_t, attr); + } + + dest[0] = MP_OBJ_NULL; // indicate success + } + } +} + +STATIC void mp_lv_theme_calendar_t_print(const mp_print_t *print, + mp_obj_t self_in, + mp_print_kind_t kind) +{ + mp_printf(print, "lvgl struct lv_theme_calendar_t"); +} + +STATIC const mp_rom_map_elem_t mp_lv_theme_calendar_t_locals_dict_table[] = { + { MP_ROM_QSTR(MP_QSTR_SIZE), MP_ROM_PTR(MP_ROM_INT(sizeof(lv_theme_calendar_t))) }, + { MP_ROM_QSTR(MP_QSTR_cast), MP_ROM_PTR(&mp_lv_cast_class_method) }, +}; + +STATIC MP_DEFINE_CONST_DICT(mp_lv_theme_calendar_t_locals_dict, mp_lv_theme_calendar_t_locals_dict_table); + +STATIC const mp_obj_type_t mp_lv_theme_calendar_t_type = { + { &mp_type_type }, + .name = MP_QSTR_lv_theme_calendar_t, + .print = mp_lv_theme_calendar_t_print, + .make_new = make_new_lv_struct, + .attr = mp_lv_theme_calendar_t_attr, + .locals_dict = (mp_obj_dict_t*)&mp_lv_theme_calendar_t_locals_dict, + .buffer_p = { .get_buffer = mp_blob_get_buffer } +}; + +STATIC inline const mp_obj_type_t *get_mp_lv_theme_calendar_t_type() +{ + return &mp_lv_theme_calendar_t_type; +} + +typedef __typeof__( ((lv_theme_t*)(0))->cb ) lv_theme_cb_t; +typedef __typeof__( ((lv_theme_cb_t*)(0))->box ) lv_theme_cb_box_t; + +/* + * Struct lv_theme_cb_box_t + */ + +STATIC inline const mp_obj_type_t *get_mp_lv_theme_cb_box_t_type(); + +STATIC inline lv_theme_cb_box_t* mp_write_ptr_lv_theme_cb_box_t(mp_obj_t self_in) +{ + mp_lv_struct_t *self = MP_OBJ_TO_PTR(cast(self_in, get_mp_lv_theme_cb_box_t_type())); + return (lv_theme_cb_box_t*)self->data; +} + +#define mp_write_lv_theme_cb_box_t(struct_obj) *mp_write_ptr_lv_theme_cb_box_t(struct_obj) + +STATIC inline mp_obj_t mp_read_ptr_lv_theme_cb_box_t(lv_theme_cb_box_t *field) +{ + return lv_to_mp_struct(get_mp_lv_theme_cb_box_t_type(), field); +} + +#define mp_read_lv_theme_cb_box_t(field) mp_read_ptr_lv_theme_cb_box_t(copy_buffer(&field, sizeof(lv_theme_cb_box_t))) +#define mp_read_byref_lv_theme_cb_box_t(field) mp_read_ptr_lv_theme_cb_box_t(&field) + +STATIC void mp_lv_theme_cb_box_t_attr(mp_obj_t self_in, qstr attr, mp_obj_t *dest) +{ + mp_lv_struct_t *self = MP_OBJ_TO_PTR(self_in); + lv_theme_cb_box_t *data = (lv_theme_cb_box_t*)self->data; + + if (dest[0] == MP_OBJ_NULL) { + // load attribute + switch(attr) + { + case MP_QSTR_rel: dest[0] = mp_read_ptr_lv_style_t((void*)data->rel); break; // converting from lv_style_t*; + case MP_QSTR_pr: dest[0] = mp_read_ptr_lv_style_t((void*)data->pr); break; // converting from lv_style_t*; + case MP_QSTR_tgl_rel: dest[0] = mp_read_ptr_lv_style_t((void*)data->tgl_rel); break; // converting from lv_style_t*; + case MP_QSTR_tgl_pr: dest[0] = mp_read_ptr_lv_style_t((void*)data->tgl_pr); break; // converting from lv_style_t*; + case MP_QSTR_ina: dest[0] = mp_read_ptr_lv_style_t((void*)data->ina); break; // converting from lv_style_t*; + default: field_not_found(MP_QSTR_lv_theme_cb_box_t, attr); + } + } else { + if (dest[1]) + { + // store attribute + switch(attr) + { + case MP_QSTR_rel: data->rel = (void*)mp_write_ptr_lv_style_t(dest[1]); break; // converting to lv_style_t*; + case MP_QSTR_pr: data->pr = (void*)mp_write_ptr_lv_style_t(dest[1]); break; // converting to lv_style_t*; + case MP_QSTR_tgl_rel: data->tgl_rel = (void*)mp_write_ptr_lv_style_t(dest[1]); break; // converting to lv_style_t*; + case MP_QSTR_tgl_pr: data->tgl_pr = (void*)mp_write_ptr_lv_style_t(dest[1]); break; // converting to lv_style_t*; + case MP_QSTR_ina: data->ina = (void*)mp_write_ptr_lv_style_t(dest[1]); break; // converting to lv_style_t*; + default: field_not_found(MP_QSTR_lv_theme_cb_box_t, attr); + } + + dest[0] = MP_OBJ_NULL; // indicate success + } + } +} + +STATIC void mp_lv_theme_cb_box_t_print(const mp_print_t *print, + mp_obj_t self_in, + mp_print_kind_t kind) +{ + mp_printf(print, "lvgl struct lv_theme_cb_box_t"); +} + +STATIC const mp_rom_map_elem_t mp_lv_theme_cb_box_t_locals_dict_table[] = { + { MP_ROM_QSTR(MP_QSTR_SIZE), MP_ROM_PTR(MP_ROM_INT(sizeof(lv_theme_cb_box_t))) }, + { MP_ROM_QSTR(MP_QSTR_cast), MP_ROM_PTR(&mp_lv_cast_class_method) }, +}; + +STATIC MP_DEFINE_CONST_DICT(mp_lv_theme_cb_box_t_locals_dict, mp_lv_theme_cb_box_t_locals_dict_table); + +STATIC const mp_obj_type_t mp_lv_theme_cb_box_t_type = { + { &mp_type_type }, + .name = MP_QSTR_lv_theme_cb_box_t, + .print = mp_lv_theme_cb_box_t_print, + .make_new = make_new_lv_struct, + .attr = mp_lv_theme_cb_box_t_attr, + .locals_dict = (mp_obj_dict_t*)&mp_lv_theme_cb_box_t_locals_dict, + .buffer_p = { .get_buffer = mp_blob_get_buffer } +}; + +STATIC inline const mp_obj_type_t *get_mp_lv_theme_cb_box_t_type() +{ + return &mp_lv_theme_cb_box_t_type; +} + + +/* + * Struct lv_theme_cb_t + */ + +STATIC inline const mp_obj_type_t *get_mp_lv_theme_cb_t_type(); + +STATIC inline lv_theme_cb_t* mp_write_ptr_lv_theme_cb_t(mp_obj_t self_in) +{ + mp_lv_struct_t *self = MP_OBJ_TO_PTR(cast(self_in, get_mp_lv_theme_cb_t_type())); + return (lv_theme_cb_t*)self->data; +} + +#define mp_write_lv_theme_cb_t(struct_obj) *mp_write_ptr_lv_theme_cb_t(struct_obj) + +STATIC inline mp_obj_t mp_read_ptr_lv_theme_cb_t(lv_theme_cb_t *field) +{ + return lv_to_mp_struct(get_mp_lv_theme_cb_t_type(), field); +} + +#define mp_read_lv_theme_cb_t(field) mp_read_ptr_lv_theme_cb_t(copy_buffer(&field, sizeof(lv_theme_cb_t))) +#define mp_read_byref_lv_theme_cb_t(field) mp_read_ptr_lv_theme_cb_t(&field) + +STATIC void mp_lv_theme_cb_t_attr(mp_obj_t self_in, qstr attr, mp_obj_t *dest) +{ + mp_lv_struct_t *self = MP_OBJ_TO_PTR(self_in); + lv_theme_cb_t *data = (lv_theme_cb_t*)self->data; + + if (dest[0] == MP_OBJ_NULL) { + // load attribute + switch(attr) + { + case MP_QSTR_bg: dest[0] = mp_read_ptr_lv_style_t((void*)data->bg); break; // converting from lv_style_t*; + case MP_QSTR_box: dest[0] = mp_read_byref_lv_theme_cb_box_t(data->box); break; // converting from lv_theme_cb_box_t; + default: field_not_found(MP_QSTR_lv_theme_cb_t, attr); + } + } else { + if (dest[1]) + { + // store attribute + switch(attr) + { + case MP_QSTR_bg: data->bg = (void*)mp_write_ptr_lv_style_t(dest[1]); break; // converting to lv_style_t*; + case MP_QSTR_box: data->box = mp_write_lv_theme_cb_box_t(dest[1]); break; // converting to lv_theme_cb_box_t; + default: field_not_found(MP_QSTR_lv_theme_cb_t, attr); + } + + dest[0] = MP_OBJ_NULL; // indicate success + } + } +} + +STATIC void mp_lv_theme_cb_t_print(const mp_print_t *print, + mp_obj_t self_in, + mp_print_kind_t kind) +{ + mp_printf(print, "lvgl struct lv_theme_cb_t"); +} + +STATIC const mp_rom_map_elem_t mp_lv_theme_cb_t_locals_dict_table[] = { + { MP_ROM_QSTR(MP_QSTR_SIZE), MP_ROM_PTR(MP_ROM_INT(sizeof(lv_theme_cb_t))) }, + { MP_ROM_QSTR(MP_QSTR_cast), MP_ROM_PTR(&mp_lv_cast_class_method) }, +}; + +STATIC MP_DEFINE_CONST_DICT(mp_lv_theme_cb_t_locals_dict, mp_lv_theme_cb_t_locals_dict_table); + +STATIC const mp_obj_type_t mp_lv_theme_cb_t_type = { + { &mp_type_type }, + .name = MP_QSTR_lv_theme_cb_t, + .print = mp_lv_theme_cb_t_print, + .make_new = make_new_lv_struct, + .attr = mp_lv_theme_cb_t_attr, + .locals_dict = (mp_obj_dict_t*)&mp_lv_theme_cb_t_locals_dict, + .buffer_p = { .get_buffer = mp_blob_get_buffer } +}; + +STATIC inline const mp_obj_type_t *get_mp_lv_theme_cb_t_type() +{ + return &mp_lv_theme_cb_t_type; +} + +typedef __typeof__( ((lv_theme_t*)(0))->btnm ) lv_theme_btnm_t; +typedef __typeof__( ((lv_theme_btnm_t*)(0))->btn ) lv_theme_btnm_btn_t; + +/* + * Struct lv_theme_btnm_btn_t + */ + +STATIC inline const mp_obj_type_t *get_mp_lv_theme_btnm_btn_t_type(); + +STATIC inline lv_theme_btnm_btn_t* mp_write_ptr_lv_theme_btnm_btn_t(mp_obj_t self_in) +{ + mp_lv_struct_t *self = MP_OBJ_TO_PTR(cast(self_in, get_mp_lv_theme_btnm_btn_t_type())); + return (lv_theme_btnm_btn_t*)self->data; +} + +#define mp_write_lv_theme_btnm_btn_t(struct_obj) *mp_write_ptr_lv_theme_btnm_btn_t(struct_obj) + +STATIC inline mp_obj_t mp_read_ptr_lv_theme_btnm_btn_t(lv_theme_btnm_btn_t *field) +{ + return lv_to_mp_struct(get_mp_lv_theme_btnm_btn_t_type(), field); +} + +#define mp_read_lv_theme_btnm_btn_t(field) mp_read_ptr_lv_theme_btnm_btn_t(copy_buffer(&field, sizeof(lv_theme_btnm_btn_t))) +#define mp_read_byref_lv_theme_btnm_btn_t(field) mp_read_ptr_lv_theme_btnm_btn_t(&field) + +STATIC void mp_lv_theme_btnm_btn_t_attr(mp_obj_t self_in, qstr attr, mp_obj_t *dest) +{ + mp_lv_struct_t *self = MP_OBJ_TO_PTR(self_in); + lv_theme_btnm_btn_t *data = (lv_theme_btnm_btn_t*)self->data; + + if (dest[0] == MP_OBJ_NULL) { + // load attribute + switch(attr) + { + case MP_QSTR_rel: dest[0] = mp_read_ptr_lv_style_t((void*)data->rel); break; // converting from lv_style_t*; + case MP_QSTR_pr: dest[0] = mp_read_ptr_lv_style_t((void*)data->pr); break; // converting from lv_style_t*; + case MP_QSTR_tgl_rel: dest[0] = mp_read_ptr_lv_style_t((void*)data->tgl_rel); break; // converting from lv_style_t*; + case MP_QSTR_tgl_pr: dest[0] = mp_read_ptr_lv_style_t((void*)data->tgl_pr); break; // converting from lv_style_t*; + case MP_QSTR_ina: dest[0] = mp_read_ptr_lv_style_t((void*)data->ina); break; // converting from lv_style_t*; + default: field_not_found(MP_QSTR_lv_theme_btnm_btn_t, attr); + } + } else { + if (dest[1]) + { + // store attribute + switch(attr) + { + case MP_QSTR_rel: data->rel = (void*)mp_write_ptr_lv_style_t(dest[1]); break; // converting to lv_style_t*; + case MP_QSTR_pr: data->pr = (void*)mp_write_ptr_lv_style_t(dest[1]); break; // converting to lv_style_t*; + case MP_QSTR_tgl_rel: data->tgl_rel = (void*)mp_write_ptr_lv_style_t(dest[1]); break; // converting to lv_style_t*; + case MP_QSTR_tgl_pr: data->tgl_pr = (void*)mp_write_ptr_lv_style_t(dest[1]); break; // converting to lv_style_t*; + case MP_QSTR_ina: data->ina = (void*)mp_write_ptr_lv_style_t(dest[1]); break; // converting to lv_style_t*; + default: field_not_found(MP_QSTR_lv_theme_btnm_btn_t, attr); + } + + dest[0] = MP_OBJ_NULL; // indicate success + } + } +} + +STATIC void mp_lv_theme_btnm_btn_t_print(const mp_print_t *print, + mp_obj_t self_in, + mp_print_kind_t kind) +{ + mp_printf(print, "lvgl struct lv_theme_btnm_btn_t"); +} + +STATIC const mp_rom_map_elem_t mp_lv_theme_btnm_btn_t_locals_dict_table[] = { + { MP_ROM_QSTR(MP_QSTR_SIZE), MP_ROM_PTR(MP_ROM_INT(sizeof(lv_theme_btnm_btn_t))) }, + { MP_ROM_QSTR(MP_QSTR_cast), MP_ROM_PTR(&mp_lv_cast_class_method) }, +}; + +STATIC MP_DEFINE_CONST_DICT(mp_lv_theme_btnm_btn_t_locals_dict, mp_lv_theme_btnm_btn_t_locals_dict_table); + +STATIC const mp_obj_type_t mp_lv_theme_btnm_btn_t_type = { + { &mp_type_type }, + .name = MP_QSTR_lv_theme_btnm_btn_t, + .print = mp_lv_theme_btnm_btn_t_print, + .make_new = make_new_lv_struct, + .attr = mp_lv_theme_btnm_btn_t_attr, + .locals_dict = (mp_obj_dict_t*)&mp_lv_theme_btnm_btn_t_locals_dict, + .buffer_p = { .get_buffer = mp_blob_get_buffer } +}; + +STATIC inline const mp_obj_type_t *get_mp_lv_theme_btnm_btn_t_type() +{ + return &mp_lv_theme_btnm_btn_t_type; +} + + +/* + * Struct lv_theme_btnm_t + */ + +STATIC inline const mp_obj_type_t *get_mp_lv_theme_btnm_t_type(); + +STATIC inline lv_theme_btnm_t* mp_write_ptr_lv_theme_btnm_t(mp_obj_t self_in) +{ + mp_lv_struct_t *self = MP_OBJ_TO_PTR(cast(self_in, get_mp_lv_theme_btnm_t_type())); + return (lv_theme_btnm_t*)self->data; +} + +#define mp_write_lv_theme_btnm_t(struct_obj) *mp_write_ptr_lv_theme_btnm_t(struct_obj) + +STATIC inline mp_obj_t mp_read_ptr_lv_theme_btnm_t(lv_theme_btnm_t *field) +{ + return lv_to_mp_struct(get_mp_lv_theme_btnm_t_type(), field); +} + +#define mp_read_lv_theme_btnm_t(field) mp_read_ptr_lv_theme_btnm_t(copy_buffer(&field, sizeof(lv_theme_btnm_t))) +#define mp_read_byref_lv_theme_btnm_t(field) mp_read_ptr_lv_theme_btnm_t(&field) + +STATIC void mp_lv_theme_btnm_t_attr(mp_obj_t self_in, qstr attr, mp_obj_t *dest) +{ + mp_lv_struct_t *self = MP_OBJ_TO_PTR(self_in); + lv_theme_btnm_t *data = (lv_theme_btnm_t*)self->data; + + if (dest[0] == MP_OBJ_NULL) { + // load attribute + switch(attr) + { + case MP_QSTR_bg: dest[0] = mp_read_ptr_lv_style_t((void*)data->bg); break; // converting from lv_style_t*; + case MP_QSTR_btn: dest[0] = mp_read_byref_lv_theme_btnm_btn_t(data->btn); break; // converting from lv_theme_btnm_btn_t; + default: field_not_found(MP_QSTR_lv_theme_btnm_t, attr); + } + } else { + if (dest[1]) + { + // store attribute + switch(attr) + { + case MP_QSTR_bg: data->bg = (void*)mp_write_ptr_lv_style_t(dest[1]); break; // converting to lv_style_t*; + case MP_QSTR_btn: data->btn = mp_write_lv_theme_btnm_btn_t(dest[1]); break; // converting to lv_theme_btnm_btn_t; + default: field_not_found(MP_QSTR_lv_theme_btnm_t, attr); + } + + dest[0] = MP_OBJ_NULL; // indicate success + } + } +} + +STATIC void mp_lv_theme_btnm_t_print(const mp_print_t *print, + mp_obj_t self_in, + mp_print_kind_t kind) +{ + mp_printf(print, "lvgl struct lv_theme_btnm_t"); +} + +STATIC const mp_rom_map_elem_t mp_lv_theme_btnm_t_locals_dict_table[] = { + { MP_ROM_QSTR(MP_QSTR_SIZE), MP_ROM_PTR(MP_ROM_INT(sizeof(lv_theme_btnm_t))) }, + { MP_ROM_QSTR(MP_QSTR_cast), MP_ROM_PTR(&mp_lv_cast_class_method) }, +}; + +STATIC MP_DEFINE_CONST_DICT(mp_lv_theme_btnm_t_locals_dict, mp_lv_theme_btnm_t_locals_dict_table); + +STATIC const mp_obj_type_t mp_lv_theme_btnm_t_type = { + { &mp_type_type }, + .name = MP_QSTR_lv_theme_btnm_t, + .print = mp_lv_theme_btnm_t_print, + .make_new = make_new_lv_struct, + .attr = mp_lv_theme_btnm_t_attr, + .locals_dict = (mp_obj_dict_t*)&mp_lv_theme_btnm_t_locals_dict, + .buffer_p = { .get_buffer = mp_blob_get_buffer } +}; + +STATIC inline const mp_obj_type_t *get_mp_lv_theme_btnm_t_type() +{ + return &mp_lv_theme_btnm_t_type; +} + +typedef __typeof__( ((lv_theme_t*)(0))->kb ) lv_theme_kb_t; +typedef __typeof__( ((lv_theme_kb_t*)(0))->btn ) lv_theme_kb_btn_t; + +/* + * Struct lv_theme_kb_btn_t + */ + +STATIC inline const mp_obj_type_t *get_mp_lv_theme_kb_btn_t_type(); + +STATIC inline lv_theme_kb_btn_t* mp_write_ptr_lv_theme_kb_btn_t(mp_obj_t self_in) +{ + mp_lv_struct_t *self = MP_OBJ_TO_PTR(cast(self_in, get_mp_lv_theme_kb_btn_t_type())); + return (lv_theme_kb_btn_t*)self->data; +} + +#define mp_write_lv_theme_kb_btn_t(struct_obj) *mp_write_ptr_lv_theme_kb_btn_t(struct_obj) + +STATIC inline mp_obj_t mp_read_ptr_lv_theme_kb_btn_t(lv_theme_kb_btn_t *field) +{ + return lv_to_mp_struct(get_mp_lv_theme_kb_btn_t_type(), field); +} + +#define mp_read_lv_theme_kb_btn_t(field) mp_read_ptr_lv_theme_kb_btn_t(copy_buffer(&field, sizeof(lv_theme_kb_btn_t))) +#define mp_read_byref_lv_theme_kb_btn_t(field) mp_read_ptr_lv_theme_kb_btn_t(&field) + +STATIC void mp_lv_theme_kb_btn_t_attr(mp_obj_t self_in, qstr attr, mp_obj_t *dest) +{ + mp_lv_struct_t *self = MP_OBJ_TO_PTR(self_in); + lv_theme_kb_btn_t *data = (lv_theme_kb_btn_t*)self->data; + + if (dest[0] == MP_OBJ_NULL) { + // load attribute + switch(attr) + { + case MP_QSTR_rel: dest[0] = mp_read_ptr_lv_style_t((void*)data->rel); break; // converting from lv_style_t*; + case MP_QSTR_pr: dest[0] = mp_read_ptr_lv_style_t((void*)data->pr); break; // converting from lv_style_t*; + case MP_QSTR_tgl_rel: dest[0] = mp_read_ptr_lv_style_t((void*)data->tgl_rel); break; // converting from lv_style_t*; + case MP_QSTR_tgl_pr: dest[0] = mp_read_ptr_lv_style_t((void*)data->tgl_pr); break; // converting from lv_style_t*; + case MP_QSTR_ina: dest[0] = mp_read_ptr_lv_style_t((void*)data->ina); break; // converting from lv_style_t*; + default: field_not_found(MP_QSTR_lv_theme_kb_btn_t, attr); + } + } else { + if (dest[1]) + { + // store attribute + switch(attr) + { + case MP_QSTR_rel: data->rel = (void*)mp_write_ptr_lv_style_t(dest[1]); break; // converting to lv_style_t*; + case MP_QSTR_pr: data->pr = (void*)mp_write_ptr_lv_style_t(dest[1]); break; // converting to lv_style_t*; + case MP_QSTR_tgl_rel: data->tgl_rel = (void*)mp_write_ptr_lv_style_t(dest[1]); break; // converting to lv_style_t*; + case MP_QSTR_tgl_pr: data->tgl_pr = (void*)mp_write_ptr_lv_style_t(dest[1]); break; // converting to lv_style_t*; + case MP_QSTR_ina: data->ina = (void*)mp_write_ptr_lv_style_t(dest[1]); break; // converting to lv_style_t*; + default: field_not_found(MP_QSTR_lv_theme_kb_btn_t, attr); + } + + dest[0] = MP_OBJ_NULL; // indicate success + } + } +} + +STATIC void mp_lv_theme_kb_btn_t_print(const mp_print_t *print, + mp_obj_t self_in, + mp_print_kind_t kind) +{ + mp_printf(print, "lvgl struct lv_theme_kb_btn_t"); +} + +STATIC const mp_rom_map_elem_t mp_lv_theme_kb_btn_t_locals_dict_table[] = { + { MP_ROM_QSTR(MP_QSTR_SIZE), MP_ROM_PTR(MP_ROM_INT(sizeof(lv_theme_kb_btn_t))) }, + { MP_ROM_QSTR(MP_QSTR_cast), MP_ROM_PTR(&mp_lv_cast_class_method) }, +}; + +STATIC MP_DEFINE_CONST_DICT(mp_lv_theme_kb_btn_t_locals_dict, mp_lv_theme_kb_btn_t_locals_dict_table); + +STATIC const mp_obj_type_t mp_lv_theme_kb_btn_t_type = { + { &mp_type_type }, + .name = MP_QSTR_lv_theme_kb_btn_t, + .print = mp_lv_theme_kb_btn_t_print, + .make_new = make_new_lv_struct, + .attr = mp_lv_theme_kb_btn_t_attr, + .locals_dict = (mp_obj_dict_t*)&mp_lv_theme_kb_btn_t_locals_dict, + .buffer_p = { .get_buffer = mp_blob_get_buffer } +}; + +STATIC inline const mp_obj_type_t *get_mp_lv_theme_kb_btn_t_type() +{ + return &mp_lv_theme_kb_btn_t_type; +} + + +/* + * Struct lv_theme_kb_t + */ + +STATIC inline const mp_obj_type_t *get_mp_lv_theme_kb_t_type(); + +STATIC inline lv_theme_kb_t* mp_write_ptr_lv_theme_kb_t(mp_obj_t self_in) +{ + mp_lv_struct_t *self = MP_OBJ_TO_PTR(cast(self_in, get_mp_lv_theme_kb_t_type())); + return (lv_theme_kb_t*)self->data; +} + +#define mp_write_lv_theme_kb_t(struct_obj) *mp_write_ptr_lv_theme_kb_t(struct_obj) + +STATIC inline mp_obj_t mp_read_ptr_lv_theme_kb_t(lv_theme_kb_t *field) +{ + return lv_to_mp_struct(get_mp_lv_theme_kb_t_type(), field); +} + +#define mp_read_lv_theme_kb_t(field) mp_read_ptr_lv_theme_kb_t(copy_buffer(&field, sizeof(lv_theme_kb_t))) +#define mp_read_byref_lv_theme_kb_t(field) mp_read_ptr_lv_theme_kb_t(&field) + +STATIC void mp_lv_theme_kb_t_attr(mp_obj_t self_in, qstr attr, mp_obj_t *dest) +{ + mp_lv_struct_t *self = MP_OBJ_TO_PTR(self_in); + lv_theme_kb_t *data = (lv_theme_kb_t*)self->data; + + if (dest[0] == MP_OBJ_NULL) { + // load attribute + switch(attr) + { + case MP_QSTR_bg: dest[0] = mp_read_ptr_lv_style_t((void*)data->bg); break; // converting from lv_style_t*; + case MP_QSTR_btn: dest[0] = mp_read_byref_lv_theme_kb_btn_t(data->btn); break; // converting from lv_theme_kb_btn_t; + default: field_not_found(MP_QSTR_lv_theme_kb_t, attr); + } + } else { + if (dest[1]) + { + // store attribute + switch(attr) + { + case MP_QSTR_bg: data->bg = (void*)mp_write_ptr_lv_style_t(dest[1]); break; // converting to lv_style_t*; + case MP_QSTR_btn: data->btn = mp_write_lv_theme_kb_btn_t(dest[1]); break; // converting to lv_theme_kb_btn_t; + default: field_not_found(MP_QSTR_lv_theme_kb_t, attr); + } + + dest[0] = MP_OBJ_NULL; // indicate success + } + } +} + +STATIC void mp_lv_theme_kb_t_print(const mp_print_t *print, + mp_obj_t self_in, + mp_print_kind_t kind) +{ + mp_printf(print, "lvgl struct lv_theme_kb_t"); +} + +STATIC const mp_rom_map_elem_t mp_lv_theme_kb_t_locals_dict_table[] = { + { MP_ROM_QSTR(MP_QSTR_SIZE), MP_ROM_PTR(MP_ROM_INT(sizeof(lv_theme_kb_t))) }, + { MP_ROM_QSTR(MP_QSTR_cast), MP_ROM_PTR(&mp_lv_cast_class_method) }, +}; + +STATIC MP_DEFINE_CONST_DICT(mp_lv_theme_kb_t_locals_dict, mp_lv_theme_kb_t_locals_dict_table); + +STATIC const mp_obj_type_t mp_lv_theme_kb_t_type = { + { &mp_type_type }, + .name = MP_QSTR_lv_theme_kb_t, + .print = mp_lv_theme_kb_t_print, + .make_new = make_new_lv_struct, + .attr = mp_lv_theme_kb_t_attr, + .locals_dict = (mp_obj_dict_t*)&mp_lv_theme_kb_t_locals_dict, + .buffer_p = { .get_buffer = mp_blob_get_buffer } +}; + +STATIC inline const mp_obj_type_t *get_mp_lv_theme_kb_t_type() +{ + return &mp_lv_theme_kb_t_type; +} + +typedef __typeof__( ((lv_theme_t*)(0))->mbox ) lv_theme_mbox_t; +typedef __typeof__( ((lv_theme_mbox_t*)(0))->btn ) lv_theme_mbox_btn_t; + +/* + * Struct lv_theme_mbox_btn_t + */ + +STATIC inline const mp_obj_type_t *get_mp_lv_theme_mbox_btn_t_type(); + +STATIC inline lv_theme_mbox_btn_t* mp_write_ptr_lv_theme_mbox_btn_t(mp_obj_t self_in) +{ + mp_lv_struct_t *self = MP_OBJ_TO_PTR(cast(self_in, get_mp_lv_theme_mbox_btn_t_type())); + return (lv_theme_mbox_btn_t*)self->data; +} + +#define mp_write_lv_theme_mbox_btn_t(struct_obj) *mp_write_ptr_lv_theme_mbox_btn_t(struct_obj) + +STATIC inline mp_obj_t mp_read_ptr_lv_theme_mbox_btn_t(lv_theme_mbox_btn_t *field) +{ + return lv_to_mp_struct(get_mp_lv_theme_mbox_btn_t_type(), field); +} + +#define mp_read_lv_theme_mbox_btn_t(field) mp_read_ptr_lv_theme_mbox_btn_t(copy_buffer(&field, sizeof(lv_theme_mbox_btn_t))) +#define mp_read_byref_lv_theme_mbox_btn_t(field) mp_read_ptr_lv_theme_mbox_btn_t(&field) + +STATIC void mp_lv_theme_mbox_btn_t_attr(mp_obj_t self_in, qstr attr, mp_obj_t *dest) +{ + mp_lv_struct_t *self = MP_OBJ_TO_PTR(self_in); + lv_theme_mbox_btn_t *data = (lv_theme_mbox_btn_t*)self->data; + + if (dest[0] == MP_OBJ_NULL) { + // load attribute + switch(attr) + { + case MP_QSTR_bg: dest[0] = mp_read_ptr_lv_style_t((void*)data->bg); break; // converting from lv_style_t*; + case MP_QSTR_rel: dest[0] = mp_read_ptr_lv_style_t((void*)data->rel); break; // converting from lv_style_t*; + case MP_QSTR_pr: dest[0] = mp_read_ptr_lv_style_t((void*)data->pr); break; // converting from lv_style_t*; + default: field_not_found(MP_QSTR_lv_theme_mbox_btn_t, attr); + } + } else { + if (dest[1]) + { + // store attribute + switch(attr) + { + case MP_QSTR_bg: data->bg = (void*)mp_write_ptr_lv_style_t(dest[1]); break; // converting to lv_style_t*; + case MP_QSTR_rel: data->rel = (void*)mp_write_ptr_lv_style_t(dest[1]); break; // converting to lv_style_t*; + case MP_QSTR_pr: data->pr = (void*)mp_write_ptr_lv_style_t(dest[1]); break; // converting to lv_style_t*; + default: field_not_found(MP_QSTR_lv_theme_mbox_btn_t, attr); + } + + dest[0] = MP_OBJ_NULL; // indicate success + } + } +} + +STATIC void mp_lv_theme_mbox_btn_t_print(const mp_print_t *print, + mp_obj_t self_in, + mp_print_kind_t kind) +{ + mp_printf(print, "lvgl struct lv_theme_mbox_btn_t"); +} + +STATIC const mp_rom_map_elem_t mp_lv_theme_mbox_btn_t_locals_dict_table[] = { + { MP_ROM_QSTR(MP_QSTR_SIZE), MP_ROM_PTR(MP_ROM_INT(sizeof(lv_theme_mbox_btn_t))) }, + { MP_ROM_QSTR(MP_QSTR_cast), MP_ROM_PTR(&mp_lv_cast_class_method) }, +}; + +STATIC MP_DEFINE_CONST_DICT(mp_lv_theme_mbox_btn_t_locals_dict, mp_lv_theme_mbox_btn_t_locals_dict_table); + +STATIC const mp_obj_type_t mp_lv_theme_mbox_btn_t_type = { + { &mp_type_type }, + .name = MP_QSTR_lv_theme_mbox_btn_t, + .print = mp_lv_theme_mbox_btn_t_print, + .make_new = make_new_lv_struct, + .attr = mp_lv_theme_mbox_btn_t_attr, + .locals_dict = (mp_obj_dict_t*)&mp_lv_theme_mbox_btn_t_locals_dict, + .buffer_p = { .get_buffer = mp_blob_get_buffer } +}; + +STATIC inline const mp_obj_type_t *get_mp_lv_theme_mbox_btn_t_type() +{ + return &mp_lv_theme_mbox_btn_t_type; +} + + +/* + * Struct lv_theme_mbox_t + */ + +STATIC inline const mp_obj_type_t *get_mp_lv_theme_mbox_t_type(); + +STATIC inline lv_theme_mbox_t* mp_write_ptr_lv_theme_mbox_t(mp_obj_t self_in) +{ + mp_lv_struct_t *self = MP_OBJ_TO_PTR(cast(self_in, get_mp_lv_theme_mbox_t_type())); + return (lv_theme_mbox_t*)self->data; +} + +#define mp_write_lv_theme_mbox_t(struct_obj) *mp_write_ptr_lv_theme_mbox_t(struct_obj) + +STATIC inline mp_obj_t mp_read_ptr_lv_theme_mbox_t(lv_theme_mbox_t *field) +{ + return lv_to_mp_struct(get_mp_lv_theme_mbox_t_type(), field); +} + +#define mp_read_lv_theme_mbox_t(field) mp_read_ptr_lv_theme_mbox_t(copy_buffer(&field, sizeof(lv_theme_mbox_t))) +#define mp_read_byref_lv_theme_mbox_t(field) mp_read_ptr_lv_theme_mbox_t(&field) + +STATIC void mp_lv_theme_mbox_t_attr(mp_obj_t self_in, qstr attr, mp_obj_t *dest) +{ + mp_lv_struct_t *self = MP_OBJ_TO_PTR(self_in); + lv_theme_mbox_t *data = (lv_theme_mbox_t*)self->data; + + if (dest[0] == MP_OBJ_NULL) { + // load attribute + switch(attr) + { + case MP_QSTR_bg: dest[0] = mp_read_ptr_lv_style_t((void*)data->bg); break; // converting from lv_style_t*; + case MP_QSTR_btn: dest[0] = mp_read_byref_lv_theme_mbox_btn_t(data->btn); break; // converting from lv_theme_mbox_btn_t; + default: field_not_found(MP_QSTR_lv_theme_mbox_t, attr); + } + } else { + if (dest[1]) + { + // store attribute + switch(attr) + { + case MP_QSTR_bg: data->bg = (void*)mp_write_ptr_lv_style_t(dest[1]); break; // converting to lv_style_t*; + case MP_QSTR_btn: data->btn = mp_write_lv_theme_mbox_btn_t(dest[1]); break; // converting to lv_theme_mbox_btn_t; + default: field_not_found(MP_QSTR_lv_theme_mbox_t, attr); + } + + dest[0] = MP_OBJ_NULL; // indicate success + } + } +} + +STATIC void mp_lv_theme_mbox_t_print(const mp_print_t *print, + mp_obj_t self_in, + mp_print_kind_t kind) +{ + mp_printf(print, "lvgl struct lv_theme_mbox_t"); +} + +STATIC const mp_rom_map_elem_t mp_lv_theme_mbox_t_locals_dict_table[] = { + { MP_ROM_QSTR(MP_QSTR_SIZE), MP_ROM_PTR(MP_ROM_INT(sizeof(lv_theme_mbox_t))) }, + { MP_ROM_QSTR(MP_QSTR_cast), MP_ROM_PTR(&mp_lv_cast_class_method) }, +}; + +STATIC MP_DEFINE_CONST_DICT(mp_lv_theme_mbox_t_locals_dict, mp_lv_theme_mbox_t_locals_dict_table); + +STATIC const mp_obj_type_t mp_lv_theme_mbox_t_type = { + { &mp_type_type }, + .name = MP_QSTR_lv_theme_mbox_t, + .print = mp_lv_theme_mbox_t_print, + .make_new = make_new_lv_struct, + .attr = mp_lv_theme_mbox_t_attr, + .locals_dict = (mp_obj_dict_t*)&mp_lv_theme_mbox_t_locals_dict, + .buffer_p = { .get_buffer = mp_blob_get_buffer } +}; + +STATIC inline const mp_obj_type_t *get_mp_lv_theme_mbox_t_type() +{ + return &mp_lv_theme_mbox_t_type; +} + +typedef __typeof__( ((lv_theme_t*)(0))->page ) lv_theme_page_t; + +/* + * Struct lv_theme_page_t + */ + +STATIC inline const mp_obj_type_t *get_mp_lv_theme_page_t_type(); + +STATIC inline lv_theme_page_t* mp_write_ptr_lv_theme_page_t(mp_obj_t self_in) +{ + mp_lv_struct_t *self = MP_OBJ_TO_PTR(cast(self_in, get_mp_lv_theme_page_t_type())); + return (lv_theme_page_t*)self->data; +} + +#define mp_write_lv_theme_page_t(struct_obj) *mp_write_ptr_lv_theme_page_t(struct_obj) + +STATIC inline mp_obj_t mp_read_ptr_lv_theme_page_t(lv_theme_page_t *field) +{ + return lv_to_mp_struct(get_mp_lv_theme_page_t_type(), field); +} + +#define mp_read_lv_theme_page_t(field) mp_read_ptr_lv_theme_page_t(copy_buffer(&field, sizeof(lv_theme_page_t))) +#define mp_read_byref_lv_theme_page_t(field) mp_read_ptr_lv_theme_page_t(&field) + +STATIC void mp_lv_theme_page_t_attr(mp_obj_t self_in, qstr attr, mp_obj_t *dest) +{ + mp_lv_struct_t *self = MP_OBJ_TO_PTR(self_in); + lv_theme_page_t *data = (lv_theme_page_t*)self->data; + + if (dest[0] == MP_OBJ_NULL) { + // load attribute + switch(attr) + { + case MP_QSTR_bg: dest[0] = mp_read_ptr_lv_style_t((void*)data->bg); break; // converting from lv_style_t*; + case MP_QSTR_scrl: dest[0] = mp_read_ptr_lv_style_t((void*)data->scrl); break; // converting from lv_style_t*; + case MP_QSTR_sb: dest[0] = mp_read_ptr_lv_style_t((void*)data->sb); break; // converting from lv_style_t*; + default: field_not_found(MP_QSTR_lv_theme_page_t, attr); + } + } else { + if (dest[1]) + { + // store attribute + switch(attr) + { + case MP_QSTR_bg: data->bg = (void*)mp_write_ptr_lv_style_t(dest[1]); break; // converting to lv_style_t*; + case MP_QSTR_scrl: data->scrl = (void*)mp_write_ptr_lv_style_t(dest[1]); break; // converting to lv_style_t*; + case MP_QSTR_sb: data->sb = (void*)mp_write_ptr_lv_style_t(dest[1]); break; // converting to lv_style_t*; + default: field_not_found(MP_QSTR_lv_theme_page_t, attr); + } + + dest[0] = MP_OBJ_NULL; // indicate success + } + } +} + +STATIC void mp_lv_theme_page_t_print(const mp_print_t *print, + mp_obj_t self_in, + mp_print_kind_t kind) +{ + mp_printf(print, "lvgl struct lv_theme_page_t"); +} + +STATIC const mp_rom_map_elem_t mp_lv_theme_page_t_locals_dict_table[] = { + { MP_ROM_QSTR(MP_QSTR_SIZE), MP_ROM_PTR(MP_ROM_INT(sizeof(lv_theme_page_t))) }, + { MP_ROM_QSTR(MP_QSTR_cast), MP_ROM_PTR(&mp_lv_cast_class_method) }, +}; + +STATIC MP_DEFINE_CONST_DICT(mp_lv_theme_page_t_locals_dict, mp_lv_theme_page_t_locals_dict_table); + +STATIC const mp_obj_type_t mp_lv_theme_page_t_type = { + { &mp_type_type }, + .name = MP_QSTR_lv_theme_page_t, + .print = mp_lv_theme_page_t_print, + .make_new = make_new_lv_struct, + .attr = mp_lv_theme_page_t_attr, + .locals_dict = (mp_obj_dict_t*)&mp_lv_theme_page_t_locals_dict, + .buffer_p = { .get_buffer = mp_blob_get_buffer } +}; + +STATIC inline const mp_obj_type_t *get_mp_lv_theme_page_t_type() +{ + return &mp_lv_theme_page_t_type; +} + +typedef __typeof__( ((lv_theme_t*)(0))->ta ) lv_theme_ta_t; + +/* + * Struct lv_theme_ta_t + */ + +STATIC inline const mp_obj_type_t *get_mp_lv_theme_ta_t_type(); + +STATIC inline lv_theme_ta_t* mp_write_ptr_lv_theme_ta_t(mp_obj_t self_in) +{ + mp_lv_struct_t *self = MP_OBJ_TO_PTR(cast(self_in, get_mp_lv_theme_ta_t_type())); + return (lv_theme_ta_t*)self->data; +} + +#define mp_write_lv_theme_ta_t(struct_obj) *mp_write_ptr_lv_theme_ta_t(struct_obj) + +STATIC inline mp_obj_t mp_read_ptr_lv_theme_ta_t(lv_theme_ta_t *field) +{ + return lv_to_mp_struct(get_mp_lv_theme_ta_t_type(), field); +} + +#define mp_read_lv_theme_ta_t(field) mp_read_ptr_lv_theme_ta_t(copy_buffer(&field, sizeof(lv_theme_ta_t))) +#define mp_read_byref_lv_theme_ta_t(field) mp_read_ptr_lv_theme_ta_t(&field) + +STATIC void mp_lv_theme_ta_t_attr(mp_obj_t self_in, qstr attr, mp_obj_t *dest) +{ + mp_lv_struct_t *self = MP_OBJ_TO_PTR(self_in); + lv_theme_ta_t *data = (lv_theme_ta_t*)self->data; + + if (dest[0] == MP_OBJ_NULL) { + // load attribute + switch(attr) + { + case MP_QSTR_area: dest[0] = mp_read_ptr_lv_style_t((void*)data->area); break; // converting from lv_style_t*; + case MP_QSTR_oneline: dest[0] = mp_read_ptr_lv_style_t((void*)data->oneline); break; // converting from lv_style_t*; + case MP_QSTR_cursor: dest[0] = mp_read_ptr_lv_style_t((void*)data->cursor); break; // converting from lv_style_t*; + case MP_QSTR_sb: dest[0] = mp_read_ptr_lv_style_t((void*)data->sb); break; // converting from lv_style_t*; + default: field_not_found(MP_QSTR_lv_theme_ta_t, attr); + } + } else { + if (dest[1]) + { + // store attribute + switch(attr) + { + case MP_QSTR_area: data->area = (void*)mp_write_ptr_lv_style_t(dest[1]); break; // converting to lv_style_t*; + case MP_QSTR_oneline: data->oneline = (void*)mp_write_ptr_lv_style_t(dest[1]); break; // converting to lv_style_t*; + case MP_QSTR_cursor: data->cursor = (void*)mp_write_ptr_lv_style_t(dest[1]); break; // converting to lv_style_t*; + case MP_QSTR_sb: data->sb = (void*)mp_write_ptr_lv_style_t(dest[1]); break; // converting to lv_style_t*; + default: field_not_found(MP_QSTR_lv_theme_ta_t, attr); + } + + dest[0] = MP_OBJ_NULL; // indicate success + } + } +} + +STATIC void mp_lv_theme_ta_t_print(const mp_print_t *print, + mp_obj_t self_in, + mp_print_kind_t kind) +{ + mp_printf(print, "lvgl struct lv_theme_ta_t"); +} + +STATIC const mp_rom_map_elem_t mp_lv_theme_ta_t_locals_dict_table[] = { + { MP_ROM_QSTR(MP_QSTR_SIZE), MP_ROM_PTR(MP_ROM_INT(sizeof(lv_theme_ta_t))) }, + { MP_ROM_QSTR(MP_QSTR_cast), MP_ROM_PTR(&mp_lv_cast_class_method) }, +}; + +STATIC MP_DEFINE_CONST_DICT(mp_lv_theme_ta_t_locals_dict, mp_lv_theme_ta_t_locals_dict_table); + +STATIC const mp_obj_type_t mp_lv_theme_ta_t_type = { + { &mp_type_type }, + .name = MP_QSTR_lv_theme_ta_t, + .print = mp_lv_theme_ta_t_print, + .make_new = make_new_lv_struct, + .attr = mp_lv_theme_ta_t_attr, + .locals_dict = (mp_obj_dict_t*)&mp_lv_theme_ta_t_locals_dict, + .buffer_p = { .get_buffer = mp_blob_get_buffer } +}; + +STATIC inline const mp_obj_type_t *get_mp_lv_theme_ta_t_type() +{ + return &mp_lv_theme_ta_t_type; +} + +typedef __typeof__( ((lv_theme_t*)(0))->spinbox ) lv_theme_spinbox_t; + +/* + * Struct lv_theme_spinbox_t + */ + +STATIC inline const mp_obj_type_t *get_mp_lv_theme_spinbox_t_type(); + +STATIC inline lv_theme_spinbox_t* mp_write_ptr_lv_theme_spinbox_t(mp_obj_t self_in) +{ + mp_lv_struct_t *self = MP_OBJ_TO_PTR(cast(self_in, get_mp_lv_theme_spinbox_t_type())); + return (lv_theme_spinbox_t*)self->data; +} + +#define mp_write_lv_theme_spinbox_t(struct_obj) *mp_write_ptr_lv_theme_spinbox_t(struct_obj) + +STATIC inline mp_obj_t mp_read_ptr_lv_theme_spinbox_t(lv_theme_spinbox_t *field) +{ + return lv_to_mp_struct(get_mp_lv_theme_spinbox_t_type(), field); +} + +#define mp_read_lv_theme_spinbox_t(field) mp_read_ptr_lv_theme_spinbox_t(copy_buffer(&field, sizeof(lv_theme_spinbox_t))) +#define mp_read_byref_lv_theme_spinbox_t(field) mp_read_ptr_lv_theme_spinbox_t(&field) + +STATIC void mp_lv_theme_spinbox_t_attr(mp_obj_t self_in, qstr attr, mp_obj_t *dest) +{ + mp_lv_struct_t *self = MP_OBJ_TO_PTR(self_in); + lv_theme_spinbox_t *data = (lv_theme_spinbox_t*)self->data; + + if (dest[0] == MP_OBJ_NULL) { + // load attribute + switch(attr) + { + case MP_QSTR_bg: dest[0] = mp_read_ptr_lv_style_t((void*)data->bg); break; // converting from lv_style_t*; + case MP_QSTR_cursor: dest[0] = mp_read_ptr_lv_style_t((void*)data->cursor); break; // converting from lv_style_t*; + case MP_QSTR_sb: dest[0] = mp_read_ptr_lv_style_t((void*)data->sb); break; // converting from lv_style_t*; + default: field_not_found(MP_QSTR_lv_theme_spinbox_t, attr); + } + } else { + if (dest[1]) + { + // store attribute + switch(attr) + { + case MP_QSTR_bg: data->bg = (void*)mp_write_ptr_lv_style_t(dest[1]); break; // converting to lv_style_t*; + case MP_QSTR_cursor: data->cursor = (void*)mp_write_ptr_lv_style_t(dest[1]); break; // converting to lv_style_t*; + case MP_QSTR_sb: data->sb = (void*)mp_write_ptr_lv_style_t(dest[1]); break; // converting to lv_style_t*; + default: field_not_found(MP_QSTR_lv_theme_spinbox_t, attr); + } + + dest[0] = MP_OBJ_NULL; // indicate success + } + } +} + +STATIC void mp_lv_theme_spinbox_t_print(const mp_print_t *print, + mp_obj_t self_in, + mp_print_kind_t kind) +{ + mp_printf(print, "lvgl struct lv_theme_spinbox_t"); +} + +STATIC const mp_rom_map_elem_t mp_lv_theme_spinbox_t_locals_dict_table[] = { + { MP_ROM_QSTR(MP_QSTR_SIZE), MP_ROM_PTR(MP_ROM_INT(sizeof(lv_theme_spinbox_t))) }, + { MP_ROM_QSTR(MP_QSTR_cast), MP_ROM_PTR(&mp_lv_cast_class_method) }, +}; + +STATIC MP_DEFINE_CONST_DICT(mp_lv_theme_spinbox_t_locals_dict, mp_lv_theme_spinbox_t_locals_dict_table); + +STATIC const mp_obj_type_t mp_lv_theme_spinbox_t_type = { + { &mp_type_type }, + .name = MP_QSTR_lv_theme_spinbox_t, + .print = mp_lv_theme_spinbox_t_print, + .make_new = make_new_lv_struct, + .attr = mp_lv_theme_spinbox_t_attr, + .locals_dict = (mp_obj_dict_t*)&mp_lv_theme_spinbox_t_locals_dict, + .buffer_p = { .get_buffer = mp_blob_get_buffer } +}; + +STATIC inline const mp_obj_type_t *get_mp_lv_theme_spinbox_t_type() +{ + return &mp_lv_theme_spinbox_t_type; +} + +typedef __typeof__( ((lv_theme_t*)(0))->list ) lv_theme_list_t; +typedef __typeof__( ((lv_theme_list_t*)(0))->btn ) lv_theme_list_btn_t; + +/* + * Struct lv_theme_list_btn_t + */ + +STATIC inline const mp_obj_type_t *get_mp_lv_theme_list_btn_t_type(); + +STATIC inline lv_theme_list_btn_t* mp_write_ptr_lv_theme_list_btn_t(mp_obj_t self_in) +{ + mp_lv_struct_t *self = MP_OBJ_TO_PTR(cast(self_in, get_mp_lv_theme_list_btn_t_type())); + return (lv_theme_list_btn_t*)self->data; +} + +#define mp_write_lv_theme_list_btn_t(struct_obj) *mp_write_ptr_lv_theme_list_btn_t(struct_obj) + +STATIC inline mp_obj_t mp_read_ptr_lv_theme_list_btn_t(lv_theme_list_btn_t *field) +{ + return lv_to_mp_struct(get_mp_lv_theme_list_btn_t_type(), field); +} + +#define mp_read_lv_theme_list_btn_t(field) mp_read_ptr_lv_theme_list_btn_t(copy_buffer(&field, sizeof(lv_theme_list_btn_t))) +#define mp_read_byref_lv_theme_list_btn_t(field) mp_read_ptr_lv_theme_list_btn_t(&field) + +STATIC void mp_lv_theme_list_btn_t_attr(mp_obj_t self_in, qstr attr, mp_obj_t *dest) +{ + mp_lv_struct_t *self = MP_OBJ_TO_PTR(self_in); + lv_theme_list_btn_t *data = (lv_theme_list_btn_t*)self->data; + + if (dest[0] == MP_OBJ_NULL) { + // load attribute + switch(attr) + { + case MP_QSTR_rel: dest[0] = mp_read_ptr_lv_style_t((void*)data->rel); break; // converting from lv_style_t*; + case MP_QSTR_pr: dest[0] = mp_read_ptr_lv_style_t((void*)data->pr); break; // converting from lv_style_t*; + case MP_QSTR_tgl_rel: dest[0] = mp_read_ptr_lv_style_t((void*)data->tgl_rel); break; // converting from lv_style_t*; + case MP_QSTR_tgl_pr: dest[0] = mp_read_ptr_lv_style_t((void*)data->tgl_pr); break; // converting from lv_style_t*; + case MP_QSTR_ina: dest[0] = mp_read_ptr_lv_style_t((void*)data->ina); break; // converting from lv_style_t*; + default: field_not_found(MP_QSTR_lv_theme_list_btn_t, attr); + } + } else { + if (dest[1]) + { + // store attribute + switch(attr) + { + case MP_QSTR_rel: data->rel = (void*)mp_write_ptr_lv_style_t(dest[1]); break; // converting to lv_style_t*; + case MP_QSTR_pr: data->pr = (void*)mp_write_ptr_lv_style_t(dest[1]); break; // converting to lv_style_t*; + case MP_QSTR_tgl_rel: data->tgl_rel = (void*)mp_write_ptr_lv_style_t(dest[1]); break; // converting to lv_style_t*; + case MP_QSTR_tgl_pr: data->tgl_pr = (void*)mp_write_ptr_lv_style_t(dest[1]); break; // converting to lv_style_t*; + case MP_QSTR_ina: data->ina = (void*)mp_write_ptr_lv_style_t(dest[1]); break; // converting to lv_style_t*; + default: field_not_found(MP_QSTR_lv_theme_list_btn_t, attr); + } + + dest[0] = MP_OBJ_NULL; // indicate success + } + } +} + +STATIC void mp_lv_theme_list_btn_t_print(const mp_print_t *print, + mp_obj_t self_in, + mp_print_kind_t kind) +{ + mp_printf(print, "lvgl struct lv_theme_list_btn_t"); +} + +STATIC const mp_rom_map_elem_t mp_lv_theme_list_btn_t_locals_dict_table[] = { + { MP_ROM_QSTR(MP_QSTR_SIZE), MP_ROM_PTR(MP_ROM_INT(sizeof(lv_theme_list_btn_t))) }, + { MP_ROM_QSTR(MP_QSTR_cast), MP_ROM_PTR(&mp_lv_cast_class_method) }, +}; + +STATIC MP_DEFINE_CONST_DICT(mp_lv_theme_list_btn_t_locals_dict, mp_lv_theme_list_btn_t_locals_dict_table); + +STATIC const mp_obj_type_t mp_lv_theme_list_btn_t_type = { + { &mp_type_type }, + .name = MP_QSTR_lv_theme_list_btn_t, + .print = mp_lv_theme_list_btn_t_print, + .make_new = make_new_lv_struct, + .attr = mp_lv_theme_list_btn_t_attr, + .locals_dict = (mp_obj_dict_t*)&mp_lv_theme_list_btn_t_locals_dict, + .buffer_p = { .get_buffer = mp_blob_get_buffer } +}; + +STATIC inline const mp_obj_type_t *get_mp_lv_theme_list_btn_t_type() +{ + return &mp_lv_theme_list_btn_t_type; +} + + +/* + * Struct lv_theme_list_t + */ + +STATIC inline const mp_obj_type_t *get_mp_lv_theme_list_t_type(); + +STATIC inline lv_theme_list_t* mp_write_ptr_lv_theme_list_t(mp_obj_t self_in) +{ + mp_lv_struct_t *self = MP_OBJ_TO_PTR(cast(self_in, get_mp_lv_theme_list_t_type())); + return (lv_theme_list_t*)self->data; +} + +#define mp_write_lv_theme_list_t(struct_obj) *mp_write_ptr_lv_theme_list_t(struct_obj) + +STATIC inline mp_obj_t mp_read_ptr_lv_theme_list_t(lv_theme_list_t *field) +{ + return lv_to_mp_struct(get_mp_lv_theme_list_t_type(), field); +} + +#define mp_read_lv_theme_list_t(field) mp_read_ptr_lv_theme_list_t(copy_buffer(&field, sizeof(lv_theme_list_t))) +#define mp_read_byref_lv_theme_list_t(field) mp_read_ptr_lv_theme_list_t(&field) + +STATIC void mp_lv_theme_list_t_attr(mp_obj_t self_in, qstr attr, mp_obj_t *dest) +{ + mp_lv_struct_t *self = MP_OBJ_TO_PTR(self_in); + lv_theme_list_t *data = (lv_theme_list_t*)self->data; + + if (dest[0] == MP_OBJ_NULL) { + // load attribute + switch(attr) + { + case MP_QSTR_bg: dest[0] = mp_read_ptr_lv_style_t((void*)data->bg); break; // converting from lv_style_t*; + case MP_QSTR_scrl: dest[0] = mp_read_ptr_lv_style_t((void*)data->scrl); break; // converting from lv_style_t*; + case MP_QSTR_sb: dest[0] = mp_read_ptr_lv_style_t((void*)data->sb); break; // converting from lv_style_t*; + case MP_QSTR_btn: dest[0] = mp_read_byref_lv_theme_list_btn_t(data->btn); break; // converting from lv_theme_list_btn_t; + default: field_not_found(MP_QSTR_lv_theme_list_t, attr); + } + } else { + if (dest[1]) + { + // store attribute + switch(attr) + { + case MP_QSTR_bg: data->bg = (void*)mp_write_ptr_lv_style_t(dest[1]); break; // converting to lv_style_t*; + case MP_QSTR_scrl: data->scrl = (void*)mp_write_ptr_lv_style_t(dest[1]); break; // converting to lv_style_t*; + case MP_QSTR_sb: data->sb = (void*)mp_write_ptr_lv_style_t(dest[1]); break; // converting to lv_style_t*; + case MP_QSTR_btn: data->btn = mp_write_lv_theme_list_btn_t(dest[1]); break; // converting to lv_theme_list_btn_t; + default: field_not_found(MP_QSTR_lv_theme_list_t, attr); + } + + dest[0] = MP_OBJ_NULL; // indicate success + } + } +} + +STATIC void mp_lv_theme_list_t_print(const mp_print_t *print, + mp_obj_t self_in, + mp_print_kind_t kind) +{ + mp_printf(print, "lvgl struct lv_theme_list_t"); +} + +STATIC const mp_rom_map_elem_t mp_lv_theme_list_t_locals_dict_table[] = { + { MP_ROM_QSTR(MP_QSTR_SIZE), MP_ROM_PTR(MP_ROM_INT(sizeof(lv_theme_list_t))) }, + { MP_ROM_QSTR(MP_QSTR_cast), MP_ROM_PTR(&mp_lv_cast_class_method) }, +}; + +STATIC MP_DEFINE_CONST_DICT(mp_lv_theme_list_t_locals_dict, mp_lv_theme_list_t_locals_dict_table); + +STATIC const mp_obj_type_t mp_lv_theme_list_t_type = { + { &mp_type_type }, + .name = MP_QSTR_lv_theme_list_t, + .print = mp_lv_theme_list_t_print, + .make_new = make_new_lv_struct, + .attr = mp_lv_theme_list_t_attr, + .locals_dict = (mp_obj_dict_t*)&mp_lv_theme_list_t_locals_dict, + .buffer_p = { .get_buffer = mp_blob_get_buffer } +}; + +STATIC inline const mp_obj_type_t *get_mp_lv_theme_list_t_type() +{ + return &mp_lv_theme_list_t_type; +} + +typedef __typeof__( ((lv_theme_t*)(0))->ddlist ) lv_theme_ddlist_t; + +/* + * Struct lv_theme_ddlist_t + */ + +STATIC inline const mp_obj_type_t *get_mp_lv_theme_ddlist_t_type(); + +STATIC inline lv_theme_ddlist_t* mp_write_ptr_lv_theme_ddlist_t(mp_obj_t self_in) +{ + mp_lv_struct_t *self = MP_OBJ_TO_PTR(cast(self_in, get_mp_lv_theme_ddlist_t_type())); + return (lv_theme_ddlist_t*)self->data; +} + +#define mp_write_lv_theme_ddlist_t(struct_obj) *mp_write_ptr_lv_theme_ddlist_t(struct_obj) + +STATIC inline mp_obj_t mp_read_ptr_lv_theme_ddlist_t(lv_theme_ddlist_t *field) +{ + return lv_to_mp_struct(get_mp_lv_theme_ddlist_t_type(), field); +} + +#define mp_read_lv_theme_ddlist_t(field) mp_read_ptr_lv_theme_ddlist_t(copy_buffer(&field, sizeof(lv_theme_ddlist_t))) +#define mp_read_byref_lv_theme_ddlist_t(field) mp_read_ptr_lv_theme_ddlist_t(&field) + +STATIC void mp_lv_theme_ddlist_t_attr(mp_obj_t self_in, qstr attr, mp_obj_t *dest) +{ + mp_lv_struct_t *self = MP_OBJ_TO_PTR(self_in); + lv_theme_ddlist_t *data = (lv_theme_ddlist_t*)self->data; + + if (dest[0] == MP_OBJ_NULL) { + // load attribute + switch(attr) + { + case MP_QSTR_bg: dest[0] = mp_read_ptr_lv_style_t((void*)data->bg); break; // converting from lv_style_t*; + case MP_QSTR_sel: dest[0] = mp_read_ptr_lv_style_t((void*)data->sel); break; // converting from lv_style_t*; + case MP_QSTR_sb: dest[0] = mp_read_ptr_lv_style_t((void*)data->sb); break; // converting from lv_style_t*; + default: field_not_found(MP_QSTR_lv_theme_ddlist_t, attr); + } + } else { + if (dest[1]) + { + // store attribute + switch(attr) + { + case MP_QSTR_bg: data->bg = (void*)mp_write_ptr_lv_style_t(dest[1]); break; // converting to lv_style_t*; + case MP_QSTR_sel: data->sel = (void*)mp_write_ptr_lv_style_t(dest[1]); break; // converting to lv_style_t*; + case MP_QSTR_sb: data->sb = (void*)mp_write_ptr_lv_style_t(dest[1]); break; // converting to lv_style_t*; + default: field_not_found(MP_QSTR_lv_theme_ddlist_t, attr); + } + + dest[0] = MP_OBJ_NULL; // indicate success + } + } +} + +STATIC void mp_lv_theme_ddlist_t_print(const mp_print_t *print, + mp_obj_t self_in, + mp_print_kind_t kind) +{ + mp_printf(print, "lvgl struct lv_theme_ddlist_t"); +} + +STATIC const mp_rom_map_elem_t mp_lv_theme_ddlist_t_locals_dict_table[] = { + { MP_ROM_QSTR(MP_QSTR_SIZE), MP_ROM_PTR(MP_ROM_INT(sizeof(lv_theme_ddlist_t))) }, + { MP_ROM_QSTR(MP_QSTR_cast), MP_ROM_PTR(&mp_lv_cast_class_method) }, +}; + +STATIC MP_DEFINE_CONST_DICT(mp_lv_theme_ddlist_t_locals_dict, mp_lv_theme_ddlist_t_locals_dict_table); + +STATIC const mp_obj_type_t mp_lv_theme_ddlist_t_type = { + { &mp_type_type }, + .name = MP_QSTR_lv_theme_ddlist_t, + .print = mp_lv_theme_ddlist_t_print, + .make_new = make_new_lv_struct, + .attr = mp_lv_theme_ddlist_t_attr, + .locals_dict = (mp_obj_dict_t*)&mp_lv_theme_ddlist_t_locals_dict, + .buffer_p = { .get_buffer = mp_blob_get_buffer } +}; + +STATIC inline const mp_obj_type_t *get_mp_lv_theme_ddlist_t_type() +{ + return &mp_lv_theme_ddlist_t_type; +} + +typedef __typeof__( ((lv_theme_t*)(0))->roller ) lv_theme_roller_t; + +/* + * Struct lv_theme_roller_t + */ + +STATIC inline const mp_obj_type_t *get_mp_lv_theme_roller_t_type(); + +STATIC inline lv_theme_roller_t* mp_write_ptr_lv_theme_roller_t(mp_obj_t self_in) +{ + mp_lv_struct_t *self = MP_OBJ_TO_PTR(cast(self_in, get_mp_lv_theme_roller_t_type())); + return (lv_theme_roller_t*)self->data; +} + +#define mp_write_lv_theme_roller_t(struct_obj) *mp_write_ptr_lv_theme_roller_t(struct_obj) + +STATIC inline mp_obj_t mp_read_ptr_lv_theme_roller_t(lv_theme_roller_t *field) +{ + return lv_to_mp_struct(get_mp_lv_theme_roller_t_type(), field); +} + +#define mp_read_lv_theme_roller_t(field) mp_read_ptr_lv_theme_roller_t(copy_buffer(&field, sizeof(lv_theme_roller_t))) +#define mp_read_byref_lv_theme_roller_t(field) mp_read_ptr_lv_theme_roller_t(&field) + +STATIC void mp_lv_theme_roller_t_attr(mp_obj_t self_in, qstr attr, mp_obj_t *dest) +{ + mp_lv_struct_t *self = MP_OBJ_TO_PTR(self_in); + lv_theme_roller_t *data = (lv_theme_roller_t*)self->data; + + if (dest[0] == MP_OBJ_NULL) { + // load attribute + switch(attr) + { + case MP_QSTR_bg: dest[0] = mp_read_ptr_lv_style_t((void*)data->bg); break; // converting from lv_style_t*; + case MP_QSTR_sel: dest[0] = mp_read_ptr_lv_style_t((void*)data->sel); break; // converting from lv_style_t*; + default: field_not_found(MP_QSTR_lv_theme_roller_t, attr); + } + } else { + if (dest[1]) + { + // store attribute + switch(attr) + { + case MP_QSTR_bg: data->bg = (void*)mp_write_ptr_lv_style_t(dest[1]); break; // converting to lv_style_t*; + case MP_QSTR_sel: data->sel = (void*)mp_write_ptr_lv_style_t(dest[1]); break; // converting to lv_style_t*; + default: field_not_found(MP_QSTR_lv_theme_roller_t, attr); + } + + dest[0] = MP_OBJ_NULL; // indicate success + } + } +} + +STATIC void mp_lv_theme_roller_t_print(const mp_print_t *print, + mp_obj_t self_in, + mp_print_kind_t kind) +{ + mp_printf(print, "lvgl struct lv_theme_roller_t"); +} + +STATIC const mp_rom_map_elem_t mp_lv_theme_roller_t_locals_dict_table[] = { + { MP_ROM_QSTR(MP_QSTR_SIZE), MP_ROM_PTR(MP_ROM_INT(sizeof(lv_theme_roller_t))) }, + { MP_ROM_QSTR(MP_QSTR_cast), MP_ROM_PTR(&mp_lv_cast_class_method) }, +}; + +STATIC MP_DEFINE_CONST_DICT(mp_lv_theme_roller_t_locals_dict, mp_lv_theme_roller_t_locals_dict_table); + +STATIC const mp_obj_type_t mp_lv_theme_roller_t_type = { + { &mp_type_type }, + .name = MP_QSTR_lv_theme_roller_t, + .print = mp_lv_theme_roller_t_print, + .make_new = make_new_lv_struct, + .attr = mp_lv_theme_roller_t_attr, + .locals_dict = (mp_obj_dict_t*)&mp_lv_theme_roller_t_locals_dict, + .buffer_p = { .get_buffer = mp_blob_get_buffer } +}; + +STATIC inline const mp_obj_type_t *get_mp_lv_theme_roller_t_type() +{ + return &mp_lv_theme_roller_t_type; +} + +typedef __typeof__( ((lv_theme_t*)(0))->tabview ) lv_theme_tabview_t; +typedef __typeof__( ((lv_theme_tabview_t*)(0))->btn ) lv_theme_tabview_btn_t; + +/* + * Struct lv_theme_tabview_btn_t + */ + +STATIC inline const mp_obj_type_t *get_mp_lv_theme_tabview_btn_t_type(); + +STATIC inline lv_theme_tabview_btn_t* mp_write_ptr_lv_theme_tabview_btn_t(mp_obj_t self_in) +{ + mp_lv_struct_t *self = MP_OBJ_TO_PTR(cast(self_in, get_mp_lv_theme_tabview_btn_t_type())); + return (lv_theme_tabview_btn_t*)self->data; +} + +#define mp_write_lv_theme_tabview_btn_t(struct_obj) *mp_write_ptr_lv_theme_tabview_btn_t(struct_obj) + +STATIC inline mp_obj_t mp_read_ptr_lv_theme_tabview_btn_t(lv_theme_tabview_btn_t *field) +{ + return lv_to_mp_struct(get_mp_lv_theme_tabview_btn_t_type(), field); +} + +#define mp_read_lv_theme_tabview_btn_t(field) mp_read_ptr_lv_theme_tabview_btn_t(copy_buffer(&field, sizeof(lv_theme_tabview_btn_t))) +#define mp_read_byref_lv_theme_tabview_btn_t(field) mp_read_ptr_lv_theme_tabview_btn_t(&field) + +STATIC void mp_lv_theme_tabview_btn_t_attr(mp_obj_t self_in, qstr attr, mp_obj_t *dest) +{ + mp_lv_struct_t *self = MP_OBJ_TO_PTR(self_in); + lv_theme_tabview_btn_t *data = (lv_theme_tabview_btn_t*)self->data; + + if (dest[0] == MP_OBJ_NULL) { + // load attribute + switch(attr) + { + case MP_QSTR_bg: dest[0] = mp_read_ptr_lv_style_t((void*)data->bg); break; // converting from lv_style_t*; + case MP_QSTR_rel: dest[0] = mp_read_ptr_lv_style_t((void*)data->rel); break; // converting from lv_style_t*; + case MP_QSTR_pr: dest[0] = mp_read_ptr_lv_style_t((void*)data->pr); break; // converting from lv_style_t*; + case MP_QSTR_tgl_rel: dest[0] = mp_read_ptr_lv_style_t((void*)data->tgl_rel); break; // converting from lv_style_t*; + case MP_QSTR_tgl_pr: dest[0] = mp_read_ptr_lv_style_t((void*)data->tgl_pr); break; // converting from lv_style_t*; + default: field_not_found(MP_QSTR_lv_theme_tabview_btn_t, attr); + } + } else { + if (dest[1]) + { + // store attribute + switch(attr) + { + case MP_QSTR_bg: data->bg = (void*)mp_write_ptr_lv_style_t(dest[1]); break; // converting to lv_style_t*; + case MP_QSTR_rel: data->rel = (void*)mp_write_ptr_lv_style_t(dest[1]); break; // converting to lv_style_t*; + case MP_QSTR_pr: data->pr = (void*)mp_write_ptr_lv_style_t(dest[1]); break; // converting to lv_style_t*; + case MP_QSTR_tgl_rel: data->tgl_rel = (void*)mp_write_ptr_lv_style_t(dest[1]); break; // converting to lv_style_t*; + case MP_QSTR_tgl_pr: data->tgl_pr = (void*)mp_write_ptr_lv_style_t(dest[1]); break; // converting to lv_style_t*; + default: field_not_found(MP_QSTR_lv_theme_tabview_btn_t, attr); + } + + dest[0] = MP_OBJ_NULL; // indicate success + } + } +} + +STATIC void mp_lv_theme_tabview_btn_t_print(const mp_print_t *print, + mp_obj_t self_in, + mp_print_kind_t kind) +{ + mp_printf(print, "lvgl struct lv_theme_tabview_btn_t"); +} + +STATIC const mp_rom_map_elem_t mp_lv_theme_tabview_btn_t_locals_dict_table[] = { + { MP_ROM_QSTR(MP_QSTR_SIZE), MP_ROM_PTR(MP_ROM_INT(sizeof(lv_theme_tabview_btn_t))) }, + { MP_ROM_QSTR(MP_QSTR_cast), MP_ROM_PTR(&mp_lv_cast_class_method) }, +}; + +STATIC MP_DEFINE_CONST_DICT(mp_lv_theme_tabview_btn_t_locals_dict, mp_lv_theme_tabview_btn_t_locals_dict_table); + +STATIC const mp_obj_type_t mp_lv_theme_tabview_btn_t_type = { + { &mp_type_type }, + .name = MP_QSTR_lv_theme_tabview_btn_t, + .print = mp_lv_theme_tabview_btn_t_print, + .make_new = make_new_lv_struct, + .attr = mp_lv_theme_tabview_btn_t_attr, + .locals_dict = (mp_obj_dict_t*)&mp_lv_theme_tabview_btn_t_locals_dict, + .buffer_p = { .get_buffer = mp_blob_get_buffer } +}; + +STATIC inline const mp_obj_type_t *get_mp_lv_theme_tabview_btn_t_type() +{ + return &mp_lv_theme_tabview_btn_t_type; +} + + +/* + * Struct lv_theme_tabview_t + */ + +STATIC inline const mp_obj_type_t *get_mp_lv_theme_tabview_t_type(); + +STATIC inline lv_theme_tabview_t* mp_write_ptr_lv_theme_tabview_t(mp_obj_t self_in) +{ + mp_lv_struct_t *self = MP_OBJ_TO_PTR(cast(self_in, get_mp_lv_theme_tabview_t_type())); + return (lv_theme_tabview_t*)self->data; +} + +#define mp_write_lv_theme_tabview_t(struct_obj) *mp_write_ptr_lv_theme_tabview_t(struct_obj) + +STATIC inline mp_obj_t mp_read_ptr_lv_theme_tabview_t(lv_theme_tabview_t *field) +{ + return lv_to_mp_struct(get_mp_lv_theme_tabview_t_type(), field); +} + +#define mp_read_lv_theme_tabview_t(field) mp_read_ptr_lv_theme_tabview_t(copy_buffer(&field, sizeof(lv_theme_tabview_t))) +#define mp_read_byref_lv_theme_tabview_t(field) mp_read_ptr_lv_theme_tabview_t(&field) + +STATIC void mp_lv_theme_tabview_t_attr(mp_obj_t self_in, qstr attr, mp_obj_t *dest) +{ + mp_lv_struct_t *self = MP_OBJ_TO_PTR(self_in); + lv_theme_tabview_t *data = (lv_theme_tabview_t*)self->data; + + if (dest[0] == MP_OBJ_NULL) { + // load attribute + switch(attr) + { + case MP_QSTR_bg: dest[0] = mp_read_ptr_lv_style_t((void*)data->bg); break; // converting from lv_style_t*; + case MP_QSTR_indic: dest[0] = mp_read_ptr_lv_style_t((void*)data->indic); break; // converting from lv_style_t*; + case MP_QSTR_btn: dest[0] = mp_read_byref_lv_theme_tabview_btn_t(data->btn); break; // converting from lv_theme_tabview_btn_t; + default: field_not_found(MP_QSTR_lv_theme_tabview_t, attr); + } + } else { + if (dest[1]) + { + // store attribute + switch(attr) + { + case MP_QSTR_bg: data->bg = (void*)mp_write_ptr_lv_style_t(dest[1]); break; // converting to lv_style_t*; + case MP_QSTR_indic: data->indic = (void*)mp_write_ptr_lv_style_t(dest[1]); break; // converting to lv_style_t*; + case MP_QSTR_btn: data->btn = mp_write_lv_theme_tabview_btn_t(dest[1]); break; // converting to lv_theme_tabview_btn_t; + default: field_not_found(MP_QSTR_lv_theme_tabview_t, attr); + } + + dest[0] = MP_OBJ_NULL; // indicate success + } + } +} + +STATIC void mp_lv_theme_tabview_t_print(const mp_print_t *print, + mp_obj_t self_in, + mp_print_kind_t kind) +{ + mp_printf(print, "lvgl struct lv_theme_tabview_t"); +} + +STATIC const mp_rom_map_elem_t mp_lv_theme_tabview_t_locals_dict_table[] = { + { MP_ROM_QSTR(MP_QSTR_SIZE), MP_ROM_PTR(MP_ROM_INT(sizeof(lv_theme_tabview_t))) }, + { MP_ROM_QSTR(MP_QSTR_cast), MP_ROM_PTR(&mp_lv_cast_class_method) }, +}; + +STATIC MP_DEFINE_CONST_DICT(mp_lv_theme_tabview_t_locals_dict, mp_lv_theme_tabview_t_locals_dict_table); + +STATIC const mp_obj_type_t mp_lv_theme_tabview_t_type = { + { &mp_type_type }, + .name = MP_QSTR_lv_theme_tabview_t, + .print = mp_lv_theme_tabview_t_print, + .make_new = make_new_lv_struct, + .attr = mp_lv_theme_tabview_t_attr, + .locals_dict = (mp_obj_dict_t*)&mp_lv_theme_tabview_t_locals_dict, + .buffer_p = { .get_buffer = mp_blob_get_buffer } +}; + +STATIC inline const mp_obj_type_t *get_mp_lv_theme_tabview_t_type() +{ + return &mp_lv_theme_tabview_t_type; +} + +typedef __typeof__( ((lv_theme_t*)(0))->tileview ) lv_theme_tileview_t; + +/* + * Struct lv_theme_tileview_t + */ + +STATIC inline const mp_obj_type_t *get_mp_lv_theme_tileview_t_type(); + +STATIC inline lv_theme_tileview_t* mp_write_ptr_lv_theme_tileview_t(mp_obj_t self_in) +{ + mp_lv_struct_t *self = MP_OBJ_TO_PTR(cast(self_in, get_mp_lv_theme_tileview_t_type())); + return (lv_theme_tileview_t*)self->data; +} + +#define mp_write_lv_theme_tileview_t(struct_obj) *mp_write_ptr_lv_theme_tileview_t(struct_obj) + +STATIC inline mp_obj_t mp_read_ptr_lv_theme_tileview_t(lv_theme_tileview_t *field) +{ + return lv_to_mp_struct(get_mp_lv_theme_tileview_t_type(), field); +} + +#define mp_read_lv_theme_tileview_t(field) mp_read_ptr_lv_theme_tileview_t(copy_buffer(&field, sizeof(lv_theme_tileview_t))) +#define mp_read_byref_lv_theme_tileview_t(field) mp_read_ptr_lv_theme_tileview_t(&field) + +STATIC void mp_lv_theme_tileview_t_attr(mp_obj_t self_in, qstr attr, mp_obj_t *dest) +{ + mp_lv_struct_t *self = MP_OBJ_TO_PTR(self_in); + lv_theme_tileview_t *data = (lv_theme_tileview_t*)self->data; + + if (dest[0] == MP_OBJ_NULL) { + // load attribute + switch(attr) + { + case MP_QSTR_bg: dest[0] = mp_read_ptr_lv_style_t((void*)data->bg); break; // converting from lv_style_t*; + case MP_QSTR_scrl: dest[0] = mp_read_ptr_lv_style_t((void*)data->scrl); break; // converting from lv_style_t*; + case MP_QSTR_sb: dest[0] = mp_read_ptr_lv_style_t((void*)data->sb); break; // converting from lv_style_t*; + default: field_not_found(MP_QSTR_lv_theme_tileview_t, attr); + } + } else { + if (dest[1]) + { + // store attribute + switch(attr) + { + case MP_QSTR_bg: data->bg = (void*)mp_write_ptr_lv_style_t(dest[1]); break; // converting to lv_style_t*; + case MP_QSTR_scrl: data->scrl = (void*)mp_write_ptr_lv_style_t(dest[1]); break; // converting to lv_style_t*; + case MP_QSTR_sb: data->sb = (void*)mp_write_ptr_lv_style_t(dest[1]); break; // converting to lv_style_t*; + default: field_not_found(MP_QSTR_lv_theme_tileview_t, attr); + } + + dest[0] = MP_OBJ_NULL; // indicate success + } + } +} + +STATIC void mp_lv_theme_tileview_t_print(const mp_print_t *print, + mp_obj_t self_in, + mp_print_kind_t kind) +{ + mp_printf(print, "lvgl struct lv_theme_tileview_t"); +} + +STATIC const mp_rom_map_elem_t mp_lv_theme_tileview_t_locals_dict_table[] = { + { MP_ROM_QSTR(MP_QSTR_SIZE), MP_ROM_PTR(MP_ROM_INT(sizeof(lv_theme_tileview_t))) }, + { MP_ROM_QSTR(MP_QSTR_cast), MP_ROM_PTR(&mp_lv_cast_class_method) }, +}; + +STATIC MP_DEFINE_CONST_DICT(mp_lv_theme_tileview_t_locals_dict, mp_lv_theme_tileview_t_locals_dict_table); + +STATIC const mp_obj_type_t mp_lv_theme_tileview_t_type = { + { &mp_type_type }, + .name = MP_QSTR_lv_theme_tileview_t, + .print = mp_lv_theme_tileview_t_print, + .make_new = make_new_lv_struct, + .attr = mp_lv_theme_tileview_t_attr, + .locals_dict = (mp_obj_dict_t*)&mp_lv_theme_tileview_t_locals_dict, + .buffer_p = { .get_buffer = mp_blob_get_buffer } +}; + +STATIC inline const mp_obj_type_t *get_mp_lv_theme_tileview_t_type() +{ + return &mp_lv_theme_tileview_t_type; +} + +typedef __typeof__( ((lv_theme_t*)(0))->table ) lv_theme_table_t; + +/* + * Struct lv_theme_table_t + */ + +STATIC inline const mp_obj_type_t *get_mp_lv_theme_table_t_type(); + +STATIC inline lv_theme_table_t* mp_write_ptr_lv_theme_table_t(mp_obj_t self_in) +{ + mp_lv_struct_t *self = MP_OBJ_TO_PTR(cast(self_in, get_mp_lv_theme_table_t_type())); + return (lv_theme_table_t*)self->data; +} + +#define mp_write_lv_theme_table_t(struct_obj) *mp_write_ptr_lv_theme_table_t(struct_obj) + +STATIC inline mp_obj_t mp_read_ptr_lv_theme_table_t(lv_theme_table_t *field) +{ + return lv_to_mp_struct(get_mp_lv_theme_table_t_type(), field); +} + +#define mp_read_lv_theme_table_t(field) mp_read_ptr_lv_theme_table_t(copy_buffer(&field, sizeof(lv_theme_table_t))) +#define mp_read_byref_lv_theme_table_t(field) mp_read_ptr_lv_theme_table_t(&field) + +STATIC void mp_lv_theme_table_t_attr(mp_obj_t self_in, qstr attr, mp_obj_t *dest) +{ + mp_lv_struct_t *self = MP_OBJ_TO_PTR(self_in); + lv_theme_table_t *data = (lv_theme_table_t*)self->data; + + if (dest[0] == MP_OBJ_NULL) { + // load attribute + switch(attr) + { + case MP_QSTR_bg: dest[0] = mp_read_ptr_lv_style_t((void*)data->bg); break; // converting from lv_style_t*; + case MP_QSTR_cell: dest[0] = mp_read_ptr_lv_style_t((void*)data->cell); break; // converting from lv_style_t*; + default: field_not_found(MP_QSTR_lv_theme_table_t, attr); + } + } else { + if (dest[1]) + { + // store attribute + switch(attr) + { + case MP_QSTR_bg: data->bg = (void*)mp_write_ptr_lv_style_t(dest[1]); break; // converting to lv_style_t*; + case MP_QSTR_cell: data->cell = (void*)mp_write_ptr_lv_style_t(dest[1]); break; // converting to lv_style_t*; + default: field_not_found(MP_QSTR_lv_theme_table_t, attr); + } + + dest[0] = MP_OBJ_NULL; // indicate success + } + } +} + +STATIC void mp_lv_theme_table_t_print(const mp_print_t *print, + mp_obj_t self_in, + mp_print_kind_t kind) +{ + mp_printf(print, "lvgl struct lv_theme_table_t"); +} + +STATIC const mp_rom_map_elem_t mp_lv_theme_table_t_locals_dict_table[] = { + { MP_ROM_QSTR(MP_QSTR_SIZE), MP_ROM_PTR(MP_ROM_INT(sizeof(lv_theme_table_t))) }, + { MP_ROM_QSTR(MP_QSTR_cast), MP_ROM_PTR(&mp_lv_cast_class_method) }, +}; + +STATIC MP_DEFINE_CONST_DICT(mp_lv_theme_table_t_locals_dict, mp_lv_theme_table_t_locals_dict_table); + +STATIC const mp_obj_type_t mp_lv_theme_table_t_type = { + { &mp_type_type }, + .name = MP_QSTR_lv_theme_table_t, + .print = mp_lv_theme_table_t_print, + .make_new = make_new_lv_struct, + .attr = mp_lv_theme_table_t_attr, + .locals_dict = (mp_obj_dict_t*)&mp_lv_theme_table_t_locals_dict, + .buffer_p = { .get_buffer = mp_blob_get_buffer } +}; + +STATIC inline const mp_obj_type_t *get_mp_lv_theme_table_t_type() +{ + return &mp_lv_theme_table_t_type; +} + +typedef __typeof__( ((lv_theme_t*)(0))->win ) lv_theme_win_t; +typedef __typeof__( ((lv_theme_win_t*)(0))->content ) lv_theme_win_content_t; + +/* + * Struct lv_theme_win_content_t + */ + +STATIC inline const mp_obj_type_t *get_mp_lv_theme_win_content_t_type(); + +STATIC inline lv_theme_win_content_t* mp_write_ptr_lv_theme_win_content_t(mp_obj_t self_in) +{ + mp_lv_struct_t *self = MP_OBJ_TO_PTR(cast(self_in, get_mp_lv_theme_win_content_t_type())); + return (lv_theme_win_content_t*)self->data; +} + +#define mp_write_lv_theme_win_content_t(struct_obj) *mp_write_ptr_lv_theme_win_content_t(struct_obj) + +STATIC inline mp_obj_t mp_read_ptr_lv_theme_win_content_t(lv_theme_win_content_t *field) +{ + return lv_to_mp_struct(get_mp_lv_theme_win_content_t_type(), field); +} + +#define mp_read_lv_theme_win_content_t(field) mp_read_ptr_lv_theme_win_content_t(copy_buffer(&field, sizeof(lv_theme_win_content_t))) +#define mp_read_byref_lv_theme_win_content_t(field) mp_read_ptr_lv_theme_win_content_t(&field) + +STATIC void mp_lv_theme_win_content_t_attr(mp_obj_t self_in, qstr attr, mp_obj_t *dest) +{ + mp_lv_struct_t *self = MP_OBJ_TO_PTR(self_in); + lv_theme_win_content_t *data = (lv_theme_win_content_t*)self->data; + + if (dest[0] == MP_OBJ_NULL) { + // load attribute + switch(attr) + { + case MP_QSTR_bg: dest[0] = mp_read_ptr_lv_style_t((void*)data->bg); break; // converting from lv_style_t*; + case MP_QSTR_scrl: dest[0] = mp_read_ptr_lv_style_t((void*)data->scrl); break; // converting from lv_style_t*; + default: field_not_found(MP_QSTR_lv_theme_win_content_t, attr); + } + } else { + if (dest[1]) + { + // store attribute + switch(attr) + { + case MP_QSTR_bg: data->bg = (void*)mp_write_ptr_lv_style_t(dest[1]); break; // converting to lv_style_t*; + case MP_QSTR_scrl: data->scrl = (void*)mp_write_ptr_lv_style_t(dest[1]); break; // converting to lv_style_t*; + default: field_not_found(MP_QSTR_lv_theme_win_content_t, attr); + } + + dest[0] = MP_OBJ_NULL; // indicate success + } + } +} + +STATIC void mp_lv_theme_win_content_t_print(const mp_print_t *print, + mp_obj_t self_in, + mp_print_kind_t kind) +{ + mp_printf(print, "lvgl struct lv_theme_win_content_t"); +} + +STATIC const mp_rom_map_elem_t mp_lv_theme_win_content_t_locals_dict_table[] = { + { MP_ROM_QSTR(MP_QSTR_SIZE), MP_ROM_PTR(MP_ROM_INT(sizeof(lv_theme_win_content_t))) }, + { MP_ROM_QSTR(MP_QSTR_cast), MP_ROM_PTR(&mp_lv_cast_class_method) }, +}; + +STATIC MP_DEFINE_CONST_DICT(mp_lv_theme_win_content_t_locals_dict, mp_lv_theme_win_content_t_locals_dict_table); + +STATIC const mp_obj_type_t mp_lv_theme_win_content_t_type = { + { &mp_type_type }, + .name = MP_QSTR_lv_theme_win_content_t, + .print = mp_lv_theme_win_content_t_print, + .make_new = make_new_lv_struct, + .attr = mp_lv_theme_win_content_t_attr, + .locals_dict = (mp_obj_dict_t*)&mp_lv_theme_win_content_t_locals_dict, + .buffer_p = { .get_buffer = mp_blob_get_buffer } +}; + +STATIC inline const mp_obj_type_t *get_mp_lv_theme_win_content_t_type() +{ + return &mp_lv_theme_win_content_t_type; +} + +typedef __typeof__( ((lv_theme_win_t*)(0))->btn ) lv_theme_win_btn_t; + +/* + * Struct lv_theme_win_btn_t + */ + +STATIC inline const mp_obj_type_t *get_mp_lv_theme_win_btn_t_type(); + +STATIC inline lv_theme_win_btn_t* mp_write_ptr_lv_theme_win_btn_t(mp_obj_t self_in) +{ + mp_lv_struct_t *self = MP_OBJ_TO_PTR(cast(self_in, get_mp_lv_theme_win_btn_t_type())); + return (lv_theme_win_btn_t*)self->data; +} + +#define mp_write_lv_theme_win_btn_t(struct_obj) *mp_write_ptr_lv_theme_win_btn_t(struct_obj) + +STATIC inline mp_obj_t mp_read_ptr_lv_theme_win_btn_t(lv_theme_win_btn_t *field) +{ + return lv_to_mp_struct(get_mp_lv_theme_win_btn_t_type(), field); +} + +#define mp_read_lv_theme_win_btn_t(field) mp_read_ptr_lv_theme_win_btn_t(copy_buffer(&field, sizeof(lv_theme_win_btn_t))) +#define mp_read_byref_lv_theme_win_btn_t(field) mp_read_ptr_lv_theme_win_btn_t(&field) + +STATIC void mp_lv_theme_win_btn_t_attr(mp_obj_t self_in, qstr attr, mp_obj_t *dest) +{ + mp_lv_struct_t *self = MP_OBJ_TO_PTR(self_in); + lv_theme_win_btn_t *data = (lv_theme_win_btn_t*)self->data; + + if (dest[0] == MP_OBJ_NULL) { + // load attribute + switch(attr) + { + case MP_QSTR_rel: dest[0] = mp_read_ptr_lv_style_t((void*)data->rel); break; // converting from lv_style_t*; + case MP_QSTR_pr: dest[0] = mp_read_ptr_lv_style_t((void*)data->pr); break; // converting from lv_style_t*; + default: field_not_found(MP_QSTR_lv_theme_win_btn_t, attr); + } + } else { + if (dest[1]) + { + // store attribute + switch(attr) + { + case MP_QSTR_rel: data->rel = (void*)mp_write_ptr_lv_style_t(dest[1]); break; // converting to lv_style_t*; + case MP_QSTR_pr: data->pr = (void*)mp_write_ptr_lv_style_t(dest[1]); break; // converting to lv_style_t*; + default: field_not_found(MP_QSTR_lv_theme_win_btn_t, attr); + } + + dest[0] = MP_OBJ_NULL; // indicate success + } + } +} + +STATIC void mp_lv_theme_win_btn_t_print(const mp_print_t *print, + mp_obj_t self_in, + mp_print_kind_t kind) +{ + mp_printf(print, "lvgl struct lv_theme_win_btn_t"); +} + +STATIC const mp_rom_map_elem_t mp_lv_theme_win_btn_t_locals_dict_table[] = { + { MP_ROM_QSTR(MP_QSTR_SIZE), MP_ROM_PTR(MP_ROM_INT(sizeof(lv_theme_win_btn_t))) }, + { MP_ROM_QSTR(MP_QSTR_cast), MP_ROM_PTR(&mp_lv_cast_class_method) }, +}; + +STATIC MP_DEFINE_CONST_DICT(mp_lv_theme_win_btn_t_locals_dict, mp_lv_theme_win_btn_t_locals_dict_table); + +STATIC const mp_obj_type_t mp_lv_theme_win_btn_t_type = { + { &mp_type_type }, + .name = MP_QSTR_lv_theme_win_btn_t, + .print = mp_lv_theme_win_btn_t_print, + .make_new = make_new_lv_struct, + .attr = mp_lv_theme_win_btn_t_attr, + .locals_dict = (mp_obj_dict_t*)&mp_lv_theme_win_btn_t_locals_dict, + .buffer_p = { .get_buffer = mp_blob_get_buffer } +}; + +STATIC inline const mp_obj_type_t *get_mp_lv_theme_win_btn_t_type() +{ + return &mp_lv_theme_win_btn_t_type; +} + + +/* + * Struct lv_theme_win_t + */ + +STATIC inline const mp_obj_type_t *get_mp_lv_theme_win_t_type(); + +STATIC inline lv_theme_win_t* mp_write_ptr_lv_theme_win_t(mp_obj_t self_in) +{ + mp_lv_struct_t *self = MP_OBJ_TO_PTR(cast(self_in, get_mp_lv_theme_win_t_type())); + return (lv_theme_win_t*)self->data; +} + +#define mp_write_lv_theme_win_t(struct_obj) *mp_write_ptr_lv_theme_win_t(struct_obj) + +STATIC inline mp_obj_t mp_read_ptr_lv_theme_win_t(lv_theme_win_t *field) +{ + return lv_to_mp_struct(get_mp_lv_theme_win_t_type(), field); +} + +#define mp_read_lv_theme_win_t(field) mp_read_ptr_lv_theme_win_t(copy_buffer(&field, sizeof(lv_theme_win_t))) +#define mp_read_byref_lv_theme_win_t(field) mp_read_ptr_lv_theme_win_t(&field) + +STATIC void mp_lv_theme_win_t_attr(mp_obj_t self_in, qstr attr, mp_obj_t *dest) +{ + mp_lv_struct_t *self = MP_OBJ_TO_PTR(self_in); + lv_theme_win_t *data = (lv_theme_win_t*)self->data; + + if (dest[0] == MP_OBJ_NULL) { + // load attribute + switch(attr) + { + case MP_QSTR_bg: dest[0] = mp_read_ptr_lv_style_t((void*)data->bg); break; // converting from lv_style_t*; + case MP_QSTR_sb: dest[0] = mp_read_ptr_lv_style_t((void*)data->sb); break; // converting from lv_style_t*; + case MP_QSTR_header: dest[0] = mp_read_ptr_lv_style_t((void*)data->header); break; // converting from lv_style_t*; + case MP_QSTR_content: dest[0] = mp_read_byref_lv_theme_win_content_t(data->content); break; // converting from lv_theme_win_content_t; + case MP_QSTR_btn: dest[0] = mp_read_byref_lv_theme_win_btn_t(data->btn); break; // converting from lv_theme_win_btn_t; + default: field_not_found(MP_QSTR_lv_theme_win_t, attr); + } + } else { + if (dest[1]) + { + // store attribute + switch(attr) + { + case MP_QSTR_bg: data->bg = (void*)mp_write_ptr_lv_style_t(dest[1]); break; // converting to lv_style_t*; + case MP_QSTR_sb: data->sb = (void*)mp_write_ptr_lv_style_t(dest[1]); break; // converting to lv_style_t*; + case MP_QSTR_header: data->header = (void*)mp_write_ptr_lv_style_t(dest[1]); break; // converting to lv_style_t*; + case MP_QSTR_content: data->content = mp_write_lv_theme_win_content_t(dest[1]); break; // converting to lv_theme_win_content_t; + case MP_QSTR_btn: data->btn = mp_write_lv_theme_win_btn_t(dest[1]); break; // converting to lv_theme_win_btn_t; + default: field_not_found(MP_QSTR_lv_theme_win_t, attr); + } + + dest[0] = MP_OBJ_NULL; // indicate success + } + } +} + +STATIC void mp_lv_theme_win_t_print(const mp_print_t *print, + mp_obj_t self_in, + mp_print_kind_t kind) +{ + mp_printf(print, "lvgl struct lv_theme_win_t"); +} + +STATIC const mp_rom_map_elem_t mp_lv_theme_win_t_locals_dict_table[] = { + { MP_ROM_QSTR(MP_QSTR_SIZE), MP_ROM_PTR(MP_ROM_INT(sizeof(lv_theme_win_t))) }, + { MP_ROM_QSTR(MP_QSTR_cast), MP_ROM_PTR(&mp_lv_cast_class_method) }, +}; + +STATIC MP_DEFINE_CONST_DICT(mp_lv_theme_win_t_locals_dict, mp_lv_theme_win_t_locals_dict_table); + +STATIC const mp_obj_type_t mp_lv_theme_win_t_type = { + { &mp_type_type }, + .name = MP_QSTR_lv_theme_win_t, + .print = mp_lv_theme_win_t_print, + .make_new = make_new_lv_struct, + .attr = mp_lv_theme_win_t_attr, + .locals_dict = (mp_obj_dict_t*)&mp_lv_theme_win_t_locals_dict, + .buffer_p = { .get_buffer = mp_blob_get_buffer } +}; + +STATIC inline const mp_obj_type_t *get_mp_lv_theme_win_t_type() +{ + return &mp_lv_theme_win_t_type; +} + + +/* + * Struct lv_theme_t + */ + +STATIC inline const mp_obj_type_t *get_mp_lv_theme_t_type(); + +STATIC inline lv_theme_t* mp_write_ptr_lv_theme_t(mp_obj_t self_in) +{ + mp_lv_struct_t *self = MP_OBJ_TO_PTR(cast(self_in, get_mp_lv_theme_t_type())); + return (lv_theme_t*)self->data; +} + +#define mp_write_lv_theme_t(struct_obj) *mp_write_ptr_lv_theme_t(struct_obj) + +STATIC inline mp_obj_t mp_read_ptr_lv_theme_t(lv_theme_t *field) +{ + return lv_to_mp_struct(get_mp_lv_theme_t_type(), field); +} + +#define mp_read_lv_theme_t(field) mp_read_ptr_lv_theme_t(copy_buffer(&field, sizeof(lv_theme_t))) +#define mp_read_byref_lv_theme_t(field) mp_read_ptr_lv_theme_t(&field) + +STATIC void mp_lv_theme_t_attr(mp_obj_t self_in, qstr attr, mp_obj_t *dest) +{ + mp_lv_struct_t *self = MP_OBJ_TO_PTR(self_in); + lv_theme_t *data = (lv_theme_t*)self->data; + + if (dest[0] == MP_OBJ_NULL) { + // load attribute + switch(attr) + { + case MP_QSTR_bg: dest[0] = mp_read_ptr_lv_style_t((void*)data->bg); break; // converting from lv_style_t*; + case MP_QSTR_panel: dest[0] = mp_read_ptr_lv_style_t((void*)data->panel); break; // converting from lv_style_t*; + case MP_QSTR_cont: dest[0] = mp_read_ptr_lv_style_t((void*)data->cont); break; // converting from lv_style_t*; + case MP_QSTR_btn: dest[0] = mp_read_byref_lv_theme_btn_t(data->btn); break; // converting from lv_theme_btn_t; + case MP_QSTR_imgbtn: dest[0] = mp_read_byref_lv_theme_imgbtn_t(data->imgbtn); break; // converting from lv_theme_imgbtn_t; + case MP_QSTR_label: dest[0] = mp_read_byref_lv_theme_label_t(data->label); break; // converting from lv_theme_label_t; + case MP_QSTR_img: dest[0] = mp_read_byref_lv_theme_img_t(data->img); break; // converting from lv_theme_img_t; + case MP_QSTR_line: dest[0] = mp_read_byref_lv_theme_line_t(data->line); break; // converting from lv_theme_line_t; + case MP_QSTR_led: dest[0] = mp_read_ptr_lv_style_t((void*)data->led); break; // converting from lv_style_t*; + case MP_QSTR_bar: dest[0] = mp_read_byref_lv_theme_bar_t(data->bar); break; // converting from lv_theme_bar_t; + case MP_QSTR_slider: dest[0] = mp_read_byref_lv_theme_slider_t(data->slider); break; // converting from lv_theme_slider_t; + case MP_QSTR_lmeter: dest[0] = mp_read_ptr_lv_style_t((void*)data->lmeter); break; // converting from lv_style_t*; + case MP_QSTR_gauge: dest[0] = mp_read_ptr_lv_style_t((void*)data->gauge); break; // converting from lv_style_t*; + case MP_QSTR_arc: dest[0] = mp_read_ptr_lv_style_t((void*)data->arc); break; // converting from lv_style_t*; + case MP_QSTR_preload: dest[0] = mp_read_ptr_lv_style_t((void*)data->preload); break; // converting from lv_style_t*; + case MP_QSTR_sw: dest[0] = mp_read_byref_lv_theme_sw_t(data->sw); break; // converting from lv_theme_sw_t; + case MP_QSTR_chart: dest[0] = mp_read_ptr_lv_style_t((void*)data->chart); break; // converting from lv_style_t*; + case MP_QSTR_calendar: dest[0] = mp_read_byref_lv_theme_calendar_t(data->calendar); break; // converting from lv_theme_calendar_t; + case MP_QSTR_cb: dest[0] = mp_read_byref_lv_theme_cb_t(data->cb); break; // converting from lv_theme_cb_t; + case MP_QSTR_btnm: dest[0] = mp_read_byref_lv_theme_btnm_t(data->btnm); break; // converting from lv_theme_btnm_t; + case MP_QSTR_kb: dest[0] = mp_read_byref_lv_theme_kb_t(data->kb); break; // converting from lv_theme_kb_t; + case MP_QSTR_mbox: dest[0] = mp_read_byref_lv_theme_mbox_t(data->mbox); break; // converting from lv_theme_mbox_t; + case MP_QSTR_page: dest[0] = mp_read_byref_lv_theme_page_t(data->page); break; // converting from lv_theme_page_t; + case MP_QSTR_ta: dest[0] = mp_read_byref_lv_theme_ta_t(data->ta); break; // converting from lv_theme_ta_t; + case MP_QSTR_spinbox: dest[0] = mp_read_byref_lv_theme_spinbox_t(data->spinbox); break; // converting from lv_theme_spinbox_t; + case MP_QSTR_list: dest[0] = mp_read_byref_lv_theme_list_t(data->list); break; // converting from lv_theme_list_t; + case MP_QSTR_ddlist: dest[0] = mp_read_byref_lv_theme_ddlist_t(data->ddlist); break; // converting from lv_theme_ddlist_t; + case MP_QSTR_roller: dest[0] = mp_read_byref_lv_theme_roller_t(data->roller); break; // converting from lv_theme_roller_t; + case MP_QSTR_tabview: dest[0] = mp_read_byref_lv_theme_tabview_t(data->tabview); break; // converting from lv_theme_tabview_t; + case MP_QSTR_tileview: dest[0] = mp_read_byref_lv_theme_tileview_t(data->tileview); break; // converting from lv_theme_tileview_t; + case MP_QSTR_table: dest[0] = mp_read_byref_lv_theme_table_t(data->table); break; // converting from lv_theme_table_t; + case MP_QSTR_win: dest[0] = mp_read_byref_lv_theme_win_t(data->win); break; // converting from lv_theme_win_t; + default: field_not_found(MP_QSTR_lv_theme_t, attr); + } + } else { + if (dest[1]) + { + // store attribute + switch(attr) + { + case MP_QSTR_bg: data->bg = (void*)mp_write_ptr_lv_style_t(dest[1]); break; // converting to lv_style_t*; + case MP_QSTR_panel: data->panel = (void*)mp_write_ptr_lv_style_t(dest[1]); break; // converting to lv_style_t*; + case MP_QSTR_cont: data->cont = (void*)mp_write_ptr_lv_style_t(dest[1]); break; // converting to lv_style_t*; + case MP_QSTR_btn: data->btn = mp_write_lv_theme_btn_t(dest[1]); break; // converting to lv_theme_btn_t; + case MP_QSTR_imgbtn: data->imgbtn = mp_write_lv_theme_imgbtn_t(dest[1]); break; // converting to lv_theme_imgbtn_t; + case MP_QSTR_label: data->label = mp_write_lv_theme_label_t(dest[1]); break; // converting to lv_theme_label_t; + case MP_QSTR_img: data->img = mp_write_lv_theme_img_t(dest[1]); break; // converting to lv_theme_img_t; + case MP_QSTR_line: data->line = mp_write_lv_theme_line_t(dest[1]); break; // converting to lv_theme_line_t; + case MP_QSTR_led: data->led = (void*)mp_write_ptr_lv_style_t(dest[1]); break; // converting to lv_style_t*; + case MP_QSTR_bar: data->bar = mp_write_lv_theme_bar_t(dest[1]); break; // converting to lv_theme_bar_t; + case MP_QSTR_slider: data->slider = mp_write_lv_theme_slider_t(dest[1]); break; // converting to lv_theme_slider_t; + case MP_QSTR_lmeter: data->lmeter = (void*)mp_write_ptr_lv_style_t(dest[1]); break; // converting to lv_style_t*; + case MP_QSTR_gauge: data->gauge = (void*)mp_write_ptr_lv_style_t(dest[1]); break; // converting to lv_style_t*; + case MP_QSTR_arc: data->arc = (void*)mp_write_ptr_lv_style_t(dest[1]); break; // converting to lv_style_t*; + case MP_QSTR_preload: data->preload = (void*)mp_write_ptr_lv_style_t(dest[1]); break; // converting to lv_style_t*; + case MP_QSTR_sw: data->sw = mp_write_lv_theme_sw_t(dest[1]); break; // converting to lv_theme_sw_t; + case MP_QSTR_chart: data->chart = (void*)mp_write_ptr_lv_style_t(dest[1]); break; // converting to lv_style_t*; + case MP_QSTR_calendar: data->calendar = mp_write_lv_theme_calendar_t(dest[1]); break; // converting to lv_theme_calendar_t; + case MP_QSTR_cb: data->cb = mp_write_lv_theme_cb_t(dest[1]); break; // converting to lv_theme_cb_t; + case MP_QSTR_btnm: data->btnm = mp_write_lv_theme_btnm_t(dest[1]); break; // converting to lv_theme_btnm_t; + case MP_QSTR_kb: data->kb = mp_write_lv_theme_kb_t(dest[1]); break; // converting to lv_theme_kb_t; + case MP_QSTR_mbox: data->mbox = mp_write_lv_theme_mbox_t(dest[1]); break; // converting to lv_theme_mbox_t; + case MP_QSTR_page: data->page = mp_write_lv_theme_page_t(dest[1]); break; // converting to lv_theme_page_t; + case MP_QSTR_ta: data->ta = mp_write_lv_theme_ta_t(dest[1]); break; // converting to lv_theme_ta_t; + case MP_QSTR_spinbox: data->spinbox = mp_write_lv_theme_spinbox_t(dest[1]); break; // converting to lv_theme_spinbox_t; + case MP_QSTR_list: data->list = mp_write_lv_theme_list_t(dest[1]); break; // converting to lv_theme_list_t; + case MP_QSTR_ddlist: data->ddlist = mp_write_lv_theme_ddlist_t(dest[1]); break; // converting to lv_theme_ddlist_t; + case MP_QSTR_roller: data->roller = mp_write_lv_theme_roller_t(dest[1]); break; // converting to lv_theme_roller_t; + case MP_QSTR_tabview: data->tabview = mp_write_lv_theme_tabview_t(dest[1]); break; // converting to lv_theme_tabview_t; + case MP_QSTR_tileview: data->tileview = mp_write_lv_theme_tileview_t(dest[1]); break; // converting to lv_theme_tileview_t; + case MP_QSTR_table: data->table = mp_write_lv_theme_table_t(dest[1]); break; // converting to lv_theme_table_t; + case MP_QSTR_win: data->win = mp_write_lv_theme_win_t(dest[1]); break; // converting to lv_theme_win_t; + default: field_not_found(MP_QSTR_lv_theme_t, attr); + } + + dest[0] = MP_OBJ_NULL; // indicate success + } + } +} + +STATIC void mp_lv_theme_t_print(const mp_print_t *print, + mp_obj_t self_in, + mp_print_kind_t kind) +{ + mp_printf(print, "lvgl struct lv_theme_t"); +} + +STATIC const mp_rom_map_elem_t mp_lv_theme_t_locals_dict_table[] = { + { MP_ROM_QSTR(MP_QSTR_SIZE), MP_ROM_PTR(MP_ROM_INT(sizeof(lv_theme_t))) }, + { MP_ROM_QSTR(MP_QSTR_cast), MP_ROM_PTR(&mp_lv_cast_class_method) }, +}; + +STATIC MP_DEFINE_CONST_DICT(mp_lv_theme_t_locals_dict, mp_lv_theme_t_locals_dict_table); + +STATIC const mp_obj_type_t mp_lv_theme_t_type = { + { &mp_type_type }, + .name = MP_QSTR_lv_theme_t, + .print = mp_lv_theme_t_print, + .make_new = make_new_lv_struct, + .attr = mp_lv_theme_t_attr, + .locals_dict = (mp_obj_dict_t*)&mp_lv_theme_t_locals_dict, + .buffer_p = { .get_buffer = mp_blob_get_buffer } +}; + +STATIC inline const mp_obj_type_t *get_mp_lv_theme_t_type() +{ + return &mp_lv_theme_t_type; +} + + +/* + * lvgl extension definition for: + * void lv_theme_set_current(lv_theme_t *th) + */ + +STATIC mp_obj_t mp_lv_theme_set_current(size_t n_args, const mp_obj_t *args) +{ + lv_theme_t *th = mp_write_ptr_lv_theme_t(args[0]); + lv_theme_set_current(th); + return mp_const_none; +} + +STATIC MP_DEFINE_CONST_FUN_OBJ_VAR_BETWEEN(mp_lv_theme_set_current_obj, 1, 1, mp_lv_theme_set_current); + + + +/* + * lvgl extension definition for: + * lv_theme_t *lv_theme_get_current(void) + */ + +STATIC mp_obj_t mp_lv_theme_get_current(size_t n_args, const mp_obj_t *args) +{ + + lv_theme_t* res = lv_theme_get_current(); + return mp_read_ptr_lv_theme_t((void*)res); +} + +STATIC MP_DEFINE_CONST_FUN_OBJ_VAR_BETWEEN(mp_lv_theme_get_current_obj, 0, 0, mp_lv_theme_get_current); + + + +/* + * lvgl extension definition for: + * lv_theme_t *lv_theme_default_init(uint16_t hue, lv_font_t *font) + */ + +STATIC mp_obj_t mp_lv_theme_default_init(size_t n_args, const mp_obj_t *args) +{ + uint16_t hue = (uint16_t)mp_obj_get_int(args[0]); + lv_font_t *font = mp_write_ptr_lv_font_t(args[1]); + lv_theme_t* res = lv_theme_default_init(hue, font); + return mp_read_ptr_lv_theme_t((void*)res); +} + +STATIC MP_DEFINE_CONST_FUN_OBJ_VAR_BETWEEN(mp_lv_theme_default_init_obj, 2, 2, mp_lv_theme_default_init); + + + +/* + * lvgl extension definition for: + * lv_theme_t *lv_theme_get_default(void) + */ + +STATIC mp_obj_t mp_lv_theme_get_default(size_t n_args, const mp_obj_t *args) +{ + + lv_theme_t* res = lv_theme_get_default(); + return mp_read_ptr_lv_theme_t((void*)res); +} + +STATIC MP_DEFINE_CONST_FUN_OBJ_VAR_BETWEEN(mp_lv_theme_get_default_obj, 0, 0, mp_lv_theme_get_default); + + + +/* + * lvgl extension definition for: + * lv_theme_t *lv_theme_alien_init(uint16_t hue, lv_font_t *font) + */ + +STATIC mp_obj_t mp_lv_theme_alien_init(size_t n_args, const mp_obj_t *args) +{ + uint16_t hue = (uint16_t)mp_obj_get_int(args[0]); + lv_font_t *font = mp_write_ptr_lv_font_t(args[1]); + lv_theme_t* res = lv_theme_alien_init(hue, font); + return mp_read_ptr_lv_theme_t((void*)res); +} + +STATIC MP_DEFINE_CONST_FUN_OBJ_VAR_BETWEEN(mp_lv_theme_alien_init_obj, 2, 2, mp_lv_theme_alien_init); + + + +/* + * lvgl extension definition for: + * lv_theme_t *lv_theme_get_alien(void) + */ + +STATIC mp_obj_t mp_lv_theme_get_alien(size_t n_args, const mp_obj_t *args) +{ + + lv_theme_t* res = lv_theme_get_alien(); + return mp_read_ptr_lv_theme_t((void*)res); +} + +STATIC MP_DEFINE_CONST_FUN_OBJ_VAR_BETWEEN(mp_lv_theme_get_alien_obj, 0, 0, mp_lv_theme_get_alien); + + + +/* + * lvgl extension definition for: + * lv_theme_t *lv_theme_night_init(uint16_t hue, lv_font_t *font) + */ + +STATIC mp_obj_t mp_lv_theme_night_init(size_t n_args, const mp_obj_t *args) +{ + uint16_t hue = (uint16_t)mp_obj_get_int(args[0]); + lv_font_t *font = mp_write_ptr_lv_font_t(args[1]); + lv_theme_t* res = lv_theme_night_init(hue, font); + return mp_read_ptr_lv_theme_t((void*)res); +} + +STATIC MP_DEFINE_CONST_FUN_OBJ_VAR_BETWEEN(mp_lv_theme_night_init_obj, 2, 2, mp_lv_theme_night_init); + + + +/* + * lvgl extension definition for: + * lv_theme_t *lv_theme_get_night(void) + */ + +STATIC mp_obj_t mp_lv_theme_get_night(size_t n_args, const mp_obj_t *args) +{ + + lv_theme_t* res = lv_theme_get_night(); + return mp_read_ptr_lv_theme_t((void*)res); +} + +STATIC MP_DEFINE_CONST_FUN_OBJ_VAR_BETWEEN(mp_lv_theme_get_night_obj, 0, 0, mp_lv_theme_get_night); + + + +/* + * lvgl extension definition for: + * lv_theme_t *lv_theme_zen_init(uint16_t hue, lv_font_t *font) + */ + +STATIC mp_obj_t mp_lv_theme_zen_init(size_t n_args, const mp_obj_t *args) +{ + uint16_t hue = (uint16_t)mp_obj_get_int(args[0]); + lv_font_t *font = mp_write_ptr_lv_font_t(args[1]); + lv_theme_t* res = lv_theme_zen_init(hue, font); + return mp_read_ptr_lv_theme_t((void*)res); +} + +STATIC MP_DEFINE_CONST_FUN_OBJ_VAR_BETWEEN(mp_lv_theme_zen_init_obj, 2, 2, mp_lv_theme_zen_init); + + + +/* + * lvgl extension definition for: + * lv_theme_t *lv_theme_get_zen(void) + */ + +STATIC mp_obj_t mp_lv_theme_get_zen(size_t n_args, const mp_obj_t *args) +{ + + lv_theme_t* res = lv_theme_get_zen(); + return mp_read_ptr_lv_theme_t((void*)res); +} + +STATIC MP_DEFINE_CONST_FUN_OBJ_VAR_BETWEEN(mp_lv_theme_get_zen_obj, 0, 0, mp_lv_theme_get_zen); + + + +/* + * lvgl extension definition for: + * lv_theme_t *lv_theme_mono_init(uint16_t hue, lv_font_t *font) + */ + +STATIC mp_obj_t mp_lv_theme_mono_init(size_t n_args, const mp_obj_t *args) +{ + uint16_t hue = (uint16_t)mp_obj_get_int(args[0]); + lv_font_t *font = mp_write_ptr_lv_font_t(args[1]); + lv_theme_t* res = lv_theme_mono_init(hue, font); + return mp_read_ptr_lv_theme_t((void*)res); +} + +STATIC MP_DEFINE_CONST_FUN_OBJ_VAR_BETWEEN(mp_lv_theme_mono_init_obj, 2, 2, mp_lv_theme_mono_init); + + + +/* + * lvgl extension definition for: + * lv_theme_t *lv_theme_get_mono(void) + */ + +STATIC mp_obj_t mp_lv_theme_get_mono(size_t n_args, const mp_obj_t *args) +{ + + lv_theme_t* res = lv_theme_get_mono(); + return mp_read_ptr_lv_theme_t((void*)res); +} + +STATIC MP_DEFINE_CONST_FUN_OBJ_VAR_BETWEEN(mp_lv_theme_get_mono_obj, 0, 0, mp_lv_theme_get_mono); + + + +/* + * lvgl extension definition for: + * lv_theme_t *lv_theme_nemo_init(uint16_t hue, lv_font_t *font) + */ + +STATIC mp_obj_t mp_lv_theme_nemo_init(size_t n_args, const mp_obj_t *args) +{ + uint16_t hue = (uint16_t)mp_obj_get_int(args[0]); + lv_font_t *font = mp_write_ptr_lv_font_t(args[1]); + lv_theme_t* res = lv_theme_nemo_init(hue, font); + return mp_read_ptr_lv_theme_t((void*)res); +} + +STATIC MP_DEFINE_CONST_FUN_OBJ_VAR_BETWEEN(mp_lv_theme_nemo_init_obj, 2, 2, mp_lv_theme_nemo_init); + + + +/* + * lvgl extension definition for: + * lv_theme_t *lv_theme_get_nemo(void) + */ + +STATIC mp_obj_t mp_lv_theme_get_nemo(size_t n_args, const mp_obj_t *args) +{ + + lv_theme_t* res = lv_theme_get_nemo(); + return mp_read_ptr_lv_theme_t((void*)res); +} + +STATIC MP_DEFINE_CONST_FUN_OBJ_VAR_BETWEEN(mp_lv_theme_get_nemo_obj, 0, 0, mp_lv_theme_get_nemo); + + + +/* + * lvgl extension definition for: + * lv_theme_t *lv_theme_material_init(uint16_t hue, lv_font_t *font) + */ + +STATIC mp_obj_t mp_lv_theme_material_init(size_t n_args, const mp_obj_t *args) +{ + uint16_t hue = (uint16_t)mp_obj_get_int(args[0]); + lv_font_t *font = mp_write_ptr_lv_font_t(args[1]); + lv_theme_t* res = lv_theme_material_init(hue, font); + return mp_read_ptr_lv_theme_t((void*)res); +} + +STATIC MP_DEFINE_CONST_FUN_OBJ_VAR_BETWEEN(mp_lv_theme_material_init_obj, 2, 2, mp_lv_theme_material_init); + + + +/* + * lvgl extension definition for: + * lv_theme_t *lv_theme_get_material(void) + */ + +STATIC mp_obj_t mp_lv_theme_get_material(size_t n_args, const mp_obj_t *args) +{ + + lv_theme_t* res = lv_theme_get_material(); + return mp_read_ptr_lv_theme_t((void*)res); +} + +STATIC MP_DEFINE_CONST_FUN_OBJ_VAR_BETWEEN(mp_lv_theme_get_material_obj, 0, 0, mp_lv_theme_get_material); + + + +/* + * lvgl extension definition for: + * void lv_indev_init(void) + */ + +STATIC mp_obj_t mp_lv_indev_init(size_t n_args, const mp_obj_t *args) +{ + + lv_indev_init(); + return mp_const_none; +} + +STATIC MP_DEFINE_CONST_FUN_OBJ_VAR_BETWEEN(mp_lv_indev_init_obj, 0, 0, mp_lv_indev_init); + + + +/* + * lvgl extension definition for: + * lv_indev_t *lv_indev_get_act(void) + */ + +STATIC mp_obj_t mp_lv_indev_get_act(size_t n_args, const mp_obj_t *args) +{ + + lv_indev_t* res = lv_indev_get_act(); + return mp_read_ptr_lv_indev_t((void*)res); +} + +STATIC MP_DEFINE_CONST_FUN_OBJ_VAR_BETWEEN(mp_lv_indev_get_act_obj, 0, 0, mp_lv_indev_get_act); + + + +/* + * lvgl extension definition for: + * lv_hal_indev_type_t lv_indev_get_type(const lv_indev_t *indev) + */ + +STATIC mp_obj_t mp_lv_indev_get_type(size_t n_args, const mp_obj_t *args) +{ + const lv_indev_t *indev = mp_write_ptr_lv_indev_t(args[0]); + lv_hal_indev_type_t res = lv_indev_get_type(indev); + return mp_obj_new_int_from_uint(res); +} + +STATIC MP_DEFINE_CONST_FUN_OBJ_VAR_BETWEEN(mp_lv_indev_get_type_obj, 1, 1, mp_lv_indev_get_type); + + + +/* + * lvgl extension definition for: + * void lv_indev_reset(lv_indev_t *indev) + */ + +STATIC mp_obj_t mp_lv_indev_reset(size_t n_args, const mp_obj_t *args) +{ + lv_indev_t *indev = mp_write_ptr_lv_indev_t(args[0]); + lv_indev_reset(indev); + return mp_const_none; +} + +STATIC MP_DEFINE_CONST_FUN_OBJ_VAR_BETWEEN(mp_lv_indev_reset_obj, 1, 1, mp_lv_indev_reset); + + + +/* + * lvgl extension definition for: + * void lv_indev_reset_lpr(lv_indev_t *indev) + */ + +STATIC mp_obj_t mp_lv_indev_reset_lpr(size_t n_args, const mp_obj_t *args) +{ + lv_indev_t *indev = mp_write_ptr_lv_indev_t(args[0]); + lv_indev_reset_lpr(indev); + return mp_const_none; +} + +STATIC MP_DEFINE_CONST_FUN_OBJ_VAR_BETWEEN(mp_lv_indev_reset_lpr_obj, 1, 1, mp_lv_indev_reset_lpr); + + + +/* + * lvgl extension definition for: + * void lv_indev_enable(lv_hal_indev_type_t type, bool enable) + */ + +STATIC mp_obj_t mp_lv_indev_enable(size_t n_args, const mp_obj_t *args) +{ + lv_hal_indev_type_t type = (uint8_t)mp_obj_get_int(args[0]); + bool enable = mp_obj_is_true(args[1]); + lv_indev_enable(type, enable); + return mp_const_none; +} + +STATIC MP_DEFINE_CONST_FUN_OBJ_VAR_BETWEEN(mp_lv_indev_enable_obj, 2, 2, mp_lv_indev_enable); + + + +/* + * lvgl extension definition for: + * void lv_indev_set_cursor(lv_indev_t *indev, lv_obj_t *cur_obj) + */ + +STATIC mp_obj_t mp_lv_indev_set_cursor(size_t n_args, const mp_obj_t *args) +{ + lv_indev_t *indev = mp_write_ptr_lv_indev_t(args[0]); + lv_obj_t *cur_obj = mp_to_lv(args[1]); + lv_indev_set_cursor(indev, cur_obj); + return mp_const_none; +} + +STATIC MP_DEFINE_CONST_FUN_OBJ_VAR_BETWEEN(mp_lv_indev_set_cursor_obj, 2, 2, mp_lv_indev_set_cursor); + + + +/* + * lvgl extension definition for: + * void lv_indev_set_group(lv_indev_t *indev, lv_group_t *group) + */ + +STATIC mp_obj_t mp_lv_indev_set_group(size_t n_args, const mp_obj_t *args) +{ + lv_indev_t *indev = mp_write_ptr_lv_indev_t(args[0]); + lv_group_t *group = mp_write_ptr_lv_group_t(args[1]); + lv_indev_set_group(indev, group); + return mp_const_none; +} + +STATIC MP_DEFINE_CONST_FUN_OBJ_VAR_BETWEEN(mp_lv_indev_set_group_obj, 2, 2, mp_lv_indev_set_group); + + + +/* + * lvgl extension definition for: + * void lv_indev_set_button_points(lv_indev_t *indev, const lv_point_t *points) + */ + +STATIC mp_obj_t mp_lv_indev_set_button_points(size_t n_args, const mp_obj_t *args) +{ + lv_indev_t *indev = mp_write_ptr_lv_indev_t(args[0]); + const lv_point_t *points = mp_write_ptr_lv_point_t(args[1]); + lv_indev_set_button_points(indev, points); + return mp_const_none; +} + +STATIC MP_DEFINE_CONST_FUN_OBJ_VAR_BETWEEN(mp_lv_indev_set_button_points_obj, 2, 2, mp_lv_indev_set_button_points); + + + +/* + * lvgl extension definition for: + * void lv_indev_set_feedback(lv_indev_t *indev, lv_indev_feedback_t feedback) + */ + +STATIC mp_obj_t mp_lv_indev_set_feedback(size_t n_args, const mp_obj_t *args) +{ + lv_indev_t *indev = mp_write_ptr_lv_indev_t(args[0]); + set_action(args[0], args[1]); + lv_indev_feedback_t feedback = &lv_indev_feedback_t_callback; + lv_indev_set_feedback(indev, feedback); + return mp_const_none; +} + +STATIC MP_DEFINE_CONST_FUN_OBJ_VAR_BETWEEN(mp_lv_indev_set_feedback_obj, 2, 2, mp_lv_indev_set_feedback); + + + +/* + * lvgl extension definition for: + * void lv_indev_get_point(const lv_indev_t *indev, lv_point_t *point) + */ + +STATIC mp_obj_t mp_lv_indev_get_point(size_t n_args, const mp_obj_t *args) +{ + const lv_indev_t *indev = mp_write_ptr_lv_indev_t(args[0]); + lv_point_t *point = mp_write_ptr_lv_point_t(args[1]); + lv_indev_get_point(indev, point); + return mp_const_none; +} + +STATIC MP_DEFINE_CONST_FUN_OBJ_VAR_BETWEEN(mp_lv_indev_get_point_obj, 2, 2, mp_lv_indev_get_point); + + + +/* + * lvgl extension definition for: + * uint32_t lv_indev_get_key(const lv_indev_t *indev) + */ + +STATIC mp_obj_t mp_lv_indev_get_key(size_t n_args, const mp_obj_t *args) +{ + const lv_indev_t *indev = mp_write_ptr_lv_indev_t(args[0]); + uint32_t res = lv_indev_get_key(indev); + return mp_obj_new_int_from_uint(res); +} + +STATIC MP_DEFINE_CONST_FUN_OBJ_VAR_BETWEEN(mp_lv_indev_get_key_obj, 1, 1, mp_lv_indev_get_key); + + + +/* + * lvgl extension definition for: + * bool lv_indev_is_dragging(const lv_indev_t *indev) + */ + +STATIC mp_obj_t mp_lv_indev_is_dragging(size_t n_args, const mp_obj_t *args) +{ + const lv_indev_t *indev = mp_write_ptr_lv_indev_t(args[0]); + bool res = lv_indev_is_dragging(indev); + return convert_to_bool(res); +} + +STATIC MP_DEFINE_CONST_FUN_OBJ_VAR_BETWEEN(mp_lv_indev_is_dragging_obj, 1, 1, mp_lv_indev_is_dragging); + + + +/* + * lvgl extension definition for: + * void lv_indev_get_vect(const lv_indev_t *indev, lv_point_t *point) + */ + +STATIC mp_obj_t mp_lv_indev_get_vect(size_t n_args, const mp_obj_t *args) +{ + const lv_indev_t *indev = mp_write_ptr_lv_indev_t(args[0]); + lv_point_t *point = mp_write_ptr_lv_point_t(args[1]); + lv_indev_get_vect(indev, point); + return mp_const_none; +} + +STATIC MP_DEFINE_CONST_FUN_OBJ_VAR_BETWEEN(mp_lv_indev_get_vect_obj, 2, 2, mp_lv_indev_get_vect); + + + +/* + * lvgl extension definition for: + * uint32_t lv_indev_get_inactive_time(const lv_indev_t *indev) + */ + +STATIC mp_obj_t mp_lv_indev_get_inactive_time(size_t n_args, const mp_obj_t *args) +{ + const lv_indev_t *indev = mp_write_ptr_lv_indev_t(args[0]); + uint32_t res = lv_indev_get_inactive_time(indev); + return mp_obj_new_int_from_uint(res); +} + +STATIC MP_DEFINE_CONST_FUN_OBJ_VAR_BETWEEN(mp_lv_indev_get_inactive_time_obj, 1, 1, mp_lv_indev_get_inactive_time); + + + +/* + * lvgl extension definition for: + * lv_indev_feedback_t lv_indev_get_feedback(const lv_indev_t *indev) + */ + +STATIC mp_obj_t mp_lv_indev_get_feedback(size_t n_args, const mp_obj_t *args) +{ + const lv_indev_t *indev = mp_write_ptr_lv_indev_t(args[0]); + lv_indev_feedback_t res = lv_indev_get_feedback(indev); + return ptr_to_mp(res); +} + +STATIC MP_DEFINE_CONST_FUN_OBJ_VAR_BETWEEN(mp_lv_indev_get_feedback_obj, 1, 1, mp_lv_indev_get_feedback); + + + +/* + * lvgl extension definition for: + * void lv_indev_wait_release(lv_indev_t *indev) + */ + +STATIC mp_obj_t mp_lv_indev_wait_release(size_t n_args, const mp_obj_t *args) +{ + lv_indev_t *indev = mp_write_ptr_lv_indev_t(args[0]); + lv_indev_wait_release(indev); + return mp_const_none; +} + +STATIC MP_DEFINE_CONST_FUN_OBJ_VAR_BETWEEN(mp_lv_indev_wait_release_obj, 1, 1, mp_lv_indev_wait_release); + + + +/* + * lvgl extension definition for: + * void lv_txt_get_size(lv_point_t *size_res, const char *text, const lv_font_t *font, lv_coord_t letter_space, lv_coord_t line_space, lv_coord_t max_width, lv_txt_flag_t flag) + */ + +STATIC mp_obj_t mp_lv_txt_get_size(size_t n_args, const mp_obj_t *args) +{ + lv_point_t *size_res = mp_write_ptr_lv_point_t(args[0]); + const char *text = (char*)mp_obj_str_get_str(args[1]); + const lv_font_t *font = mp_write_ptr_lv_font_t(args[2]); + lv_coord_t letter_space = (int16_t)mp_obj_get_int(args[3]); + lv_coord_t line_space = (int16_t)mp_obj_get_int(args[4]); + lv_coord_t max_width = (int16_t)mp_obj_get_int(args[5]); + lv_txt_flag_t flag = (uint8_t)mp_obj_get_int(args[6]); + lv_txt_get_size(size_res, text, font, letter_space, line_space, max_width, flag); + return mp_const_none; +} + +STATIC MP_DEFINE_CONST_FUN_OBJ_VAR_BETWEEN(mp_lv_txt_get_size_obj, 7, 7, mp_lv_txt_get_size); + + + +/* + * lvgl extension definition for: + * uint16_t lv_txt_get_next_line(const char *txt, const lv_font_t *font, lv_coord_t letter_space, lv_coord_t max_width, lv_txt_flag_t flag) + */ + +STATIC mp_obj_t mp_lv_txt_get_next_line(size_t n_args, const mp_obj_t *args) +{ + const char *txt = (char*)mp_obj_str_get_str(args[0]); + const lv_font_t *font = mp_write_ptr_lv_font_t(args[1]); + lv_coord_t letter_space = (int16_t)mp_obj_get_int(args[2]); + lv_coord_t max_width = (int16_t)mp_obj_get_int(args[3]); + lv_txt_flag_t flag = (uint8_t)mp_obj_get_int(args[4]); + uint16_t res = lv_txt_get_next_line(txt, font, letter_space, max_width, flag); + return mp_obj_new_int_from_uint(res); +} + +STATIC MP_DEFINE_CONST_FUN_OBJ_VAR_BETWEEN(mp_lv_txt_get_next_line_obj, 5, 5, mp_lv_txt_get_next_line); + + + +/* + * lvgl extension definition for: + * lv_coord_t lv_txt_get_width(const char *txt, uint16_t length, const lv_font_t *font, lv_coord_t letter_space, lv_txt_flag_t flag) + */ + +STATIC mp_obj_t mp_lv_txt_get_width(size_t n_args, const mp_obj_t *args) +{ + const char *txt = (char*)mp_obj_str_get_str(args[0]); + uint16_t length = (uint16_t)mp_obj_get_int(args[1]); + const lv_font_t *font = mp_write_ptr_lv_font_t(args[2]); + lv_coord_t letter_space = (int16_t)mp_obj_get_int(args[3]); + lv_txt_flag_t flag = (uint8_t)mp_obj_get_int(args[4]); + lv_coord_t res = lv_txt_get_width(txt, length, font, letter_space, flag); + return mp_obj_new_int(res); +} + +STATIC MP_DEFINE_CONST_FUN_OBJ_VAR_BETWEEN(mp_lv_txt_get_width_obj, 5, 5, mp_lv_txt_get_width); + + + +/* + * lvgl extension definition for: + * bool lv_txt_is_cmd(lv_txt_cmd_state_t *state, uint32_t c) + */ + +STATIC mp_obj_t mp_lv_txt_is_cmd(size_t n_args, const mp_obj_t *args) +{ + lv_txt_cmd_state_t *state = mp_to_ptr(args[0]); + uint32_t c = (uint32_t)mp_obj_get_int(args[1]); + bool res = lv_txt_is_cmd(state, c); + return convert_to_bool(res); +} + +STATIC MP_DEFINE_CONST_FUN_OBJ_VAR_BETWEEN(mp_lv_txt_is_cmd_obj, 2, 2, mp_lv_txt_is_cmd); + + + +/* + * lvgl extension definition for: + * void lv_txt_ins(char *txt_buf, uint32_t pos, const char *ins_txt) + */ + +STATIC mp_obj_t mp_lv_txt_ins(size_t n_args, const mp_obj_t *args) +{ + char *txt_buf = (char*)mp_obj_str_get_str(args[0]); + uint32_t pos = (uint32_t)mp_obj_get_int(args[1]); + const char *ins_txt = (char*)mp_obj_str_get_str(args[2]); + lv_txt_ins(txt_buf, pos, ins_txt); + return mp_const_none; +} + +STATIC MP_DEFINE_CONST_FUN_OBJ_VAR_BETWEEN(mp_lv_txt_ins_obj, 3, 3, mp_lv_txt_ins); + + + +/* + * lvgl extension definition for: + * void lv_txt_cut(char *txt, uint32_t pos, uint32_t len) + */ + +STATIC mp_obj_t mp_lv_txt_cut(size_t n_args, const mp_obj_t *args) +{ + char *txt = (char*)mp_obj_str_get_str(args[0]); + uint32_t pos = (uint32_t)mp_obj_get_int(args[1]); + uint32_t len = (uint32_t)mp_obj_get_int(args[2]); + lv_txt_cut(txt, pos, len); + return mp_const_none; +} + +STATIC MP_DEFINE_CONST_FUN_OBJ_VAR_BETWEEN(mp_lv_txt_cut_obj, 3, 3, mp_lv_txt_cut); + + + +/* + * lvgl extension definition for: + * lv_opa_t lv_draw_aa_get_opa(lv_coord_t seg, lv_coord_t px_id, lv_opa_t base_opa) + */ + +STATIC mp_obj_t mp_lv_draw_aa_get_opa(size_t n_args, const mp_obj_t *args) +{ + lv_coord_t seg = (int16_t)mp_obj_get_int(args[0]); + lv_coord_t px_id = (int16_t)mp_obj_get_int(args[1]); + lv_opa_t base_opa = (uint8_t)mp_obj_get_int(args[2]); + lv_opa_t res = lv_draw_aa_get_opa(seg, px_id, base_opa); + return mp_obj_new_int_from_uint(res); +} + +STATIC MP_DEFINE_CONST_FUN_OBJ_VAR_BETWEEN(mp_lv_draw_aa_get_opa_obj, 3, 3, mp_lv_draw_aa_get_opa); + + + +/* + * lvgl extension definition for: + * void lv_draw_aa_ver_seg(lv_coord_t x, lv_coord_t y, lv_coord_t length, const lv_area_t *mask, lv_color_t color, lv_opa_t opa) + */ + +STATIC mp_obj_t mp_lv_draw_aa_ver_seg(size_t n_args, const mp_obj_t *args) +{ + lv_coord_t x = (int16_t)mp_obj_get_int(args[0]); + lv_coord_t y = (int16_t)mp_obj_get_int(args[1]); + lv_coord_t length = (int16_t)mp_obj_get_int(args[2]); + const lv_area_t *mask = mp_write_ptr_lv_area_t(args[3]); + lv_color_t color = mp_write_lv_color16_t(args[4]); + lv_opa_t opa = (uint8_t)mp_obj_get_int(args[5]); + lv_draw_aa_ver_seg(x, y, length, mask, color, opa); + return mp_const_none; +} + +STATIC MP_DEFINE_CONST_FUN_OBJ_VAR_BETWEEN(mp_lv_draw_aa_ver_seg_obj, 6, 6, mp_lv_draw_aa_ver_seg); + + + +/* + * lvgl extension definition for: + * void lv_draw_aa_hor_seg(lv_coord_t x, lv_coord_t y, lv_coord_t length, const lv_area_t *mask, lv_color_t color, lv_opa_t opa) + */ + +STATIC mp_obj_t mp_lv_draw_aa_hor_seg(size_t n_args, const mp_obj_t *args) +{ + lv_coord_t x = (int16_t)mp_obj_get_int(args[0]); + lv_coord_t y = (int16_t)mp_obj_get_int(args[1]); + lv_coord_t length = (int16_t)mp_obj_get_int(args[2]); + const lv_area_t *mask = mp_write_ptr_lv_area_t(args[3]); + lv_color_t color = mp_write_lv_color16_t(args[4]); + lv_opa_t opa = (uint8_t)mp_obj_get_int(args[5]); + lv_draw_aa_hor_seg(x, y, length, mask, color, opa); + return mp_const_none; +} + +STATIC MP_DEFINE_CONST_FUN_OBJ_VAR_BETWEEN(mp_lv_draw_aa_hor_seg_obj, 6, 6, mp_lv_draw_aa_hor_seg); + + + +/* + * lvgl extension definition for: + * void lv_draw_rect(const lv_area_t *coords, const lv_area_t *mask, const lv_style_t *style, lv_opa_t opa_scale) + */ + +STATIC mp_obj_t mp_lv_draw_rect(size_t n_args, const mp_obj_t *args) +{ + const lv_area_t *coords = mp_write_ptr_lv_area_t(args[0]); + const lv_area_t *mask = mp_write_ptr_lv_area_t(args[1]); + const lv_style_t *style = mp_write_ptr_lv_style_t(args[2]); + lv_opa_t opa_scale = (uint8_t)mp_obj_get_int(args[3]); + lv_draw_rect(coords, mask, style, opa_scale); + return mp_const_none; +} + +STATIC MP_DEFINE_CONST_FUN_OBJ_VAR_BETWEEN(mp_lv_draw_rect_obj, 4, 4, mp_lv_draw_rect); + + + +/* + * lvgl extension definition for: + * void lv_draw_label(const lv_area_t *coords, const lv_area_t *mask, const lv_style_t *style, lv_opa_t opa_scale, const char *txt, lv_txt_flag_t flag, lv_point_t *offset) + */ + +STATIC mp_obj_t mp_lv_draw_label(size_t n_args, const mp_obj_t *args) +{ + const lv_area_t *coords = mp_write_ptr_lv_area_t(args[0]); + const lv_area_t *mask = mp_write_ptr_lv_area_t(args[1]); + const lv_style_t *style = mp_write_ptr_lv_style_t(args[2]); + lv_opa_t opa_scale = (uint8_t)mp_obj_get_int(args[3]); + const char *txt = (char*)mp_obj_str_get_str(args[4]); + lv_txt_flag_t flag = (uint8_t)mp_obj_get_int(args[5]); + lv_point_t *offset = mp_write_ptr_lv_point_t(args[6]); + lv_draw_label(coords, mask, style, opa_scale, txt, flag, offset); + return mp_const_none; +} + +STATIC MP_DEFINE_CONST_FUN_OBJ_VAR_BETWEEN(mp_lv_draw_label_obj, 7, 7, mp_lv_draw_label); + + + +/* + * lvgl extension definition for: + * void lv_draw_line(const lv_point_t *point1, const lv_point_t *point2, const lv_area_t *mask, const lv_style_t *style, lv_opa_t opa_scale) + */ + +STATIC mp_obj_t mp_lv_draw_line(size_t n_args, const mp_obj_t *args) +{ + const lv_point_t *point1 = mp_write_ptr_lv_point_t(args[0]); + const lv_point_t *point2 = mp_write_ptr_lv_point_t(args[1]); + const lv_area_t *mask = mp_write_ptr_lv_area_t(args[2]); + const lv_style_t *style = mp_write_ptr_lv_style_t(args[3]); + lv_opa_t opa_scale = (uint8_t)mp_obj_get_int(args[4]); + lv_draw_line(point1, point2, mask, style, opa_scale); + return mp_const_none; +} + +STATIC MP_DEFINE_CONST_FUN_OBJ_VAR_BETWEEN(mp_lv_draw_line_obj, 5, 5, mp_lv_draw_line); + + + +/* + * lvgl extension definition for: + * void lv_draw_triangle(const lv_point_t *points, const lv_area_t *mask, lv_color_t color) + */ + +STATIC mp_obj_t mp_lv_draw_triangle(size_t n_args, const mp_obj_t *args) +{ + const lv_point_t *points = mp_write_ptr_lv_point_t(args[0]); + const lv_area_t *mask = mp_write_ptr_lv_area_t(args[1]); + lv_color_t color = mp_write_lv_color16_t(args[2]); + lv_draw_triangle(points, mask, color); + return mp_const_none; +} + +STATIC MP_DEFINE_CONST_FUN_OBJ_VAR_BETWEEN(mp_lv_draw_triangle_obj, 3, 3, mp_lv_draw_triangle); + + + +/* + * lvgl extension definition for: + * void lv_draw_img(const lv_area_t *coords, const lv_area_t *mask, const void *src, const lv_style_t *style, lv_opa_t opa_scale) + */ + +STATIC mp_obj_t mp_lv_draw_img(size_t n_args, const mp_obj_t *args) +{ + const lv_area_t *coords = mp_write_ptr_lv_area_t(args[0]); + const lv_area_t *mask = mp_write_ptr_lv_area_t(args[1]); + const void *src = mp_to_ptr(args[2]); + const lv_style_t *style = mp_write_ptr_lv_style_t(args[3]); + lv_opa_t opa_scale = (uint8_t)mp_obj_get_int(args[4]); + lv_draw_img(coords, mask, src, style, opa_scale); + return mp_const_none; +} + +STATIC MP_DEFINE_CONST_FUN_OBJ_VAR_BETWEEN(mp_lv_draw_img_obj, 5, 5, mp_lv_draw_img); + + + +/* + * lvgl lv_font_dejavu_20 global definitions + */ + +STATIC const mp_lv_struct_t mp_lv_font_dejavu_20 = { + { &mp_lv_font_t_type }, + &lv_font_dejavu_20 +}; + + +/* + * lvgl lv_font_dejavu_20_latin_sup global definitions + */ + +STATIC const mp_lv_struct_t mp_lv_font_dejavu_20_latin_sup = { + { &mp_lv_font_t_type }, + &lv_font_dejavu_20_latin_sup +}; + + +/* + * lvgl lv_font_dejavu_20_cyrillic global definitions + */ + +STATIC const mp_lv_struct_t mp_lv_font_dejavu_20_cyrillic = { + { &mp_lv_font_t_type }, + &lv_font_dejavu_20_cyrillic +}; + + +/* + * lvgl lv_font_symbol_20 global definitions + */ + +STATIC const mp_lv_struct_t mp_lv_font_symbol_20 = { + { &mp_lv_font_t_type }, + &lv_font_symbol_20 +}; + + +/* + * lvgl lv_style_scr global definitions + */ + +STATIC const mp_lv_struct_t mp_lv_style_scr = { + { &mp_lv_style_t_type }, + &lv_style_scr +}; + + +/* + * lvgl lv_style_transp global definitions + */ + +STATIC const mp_lv_struct_t mp_lv_style_transp = { + { &mp_lv_style_t_type }, + &lv_style_transp +}; + + +/* + * lvgl lv_style_transp_fit global definitions + */ + +STATIC const mp_lv_struct_t mp_lv_style_transp_fit = { + { &mp_lv_style_t_type }, + &lv_style_transp_fit +}; + + +/* + * lvgl lv_style_transp_tight global definitions + */ + +STATIC const mp_lv_struct_t mp_lv_style_transp_tight = { + { &mp_lv_style_t_type }, + &lv_style_transp_tight +}; + + +/* + * lvgl lv_style_plain global definitions + */ + +STATIC const mp_lv_struct_t mp_lv_style_plain = { + { &mp_lv_style_t_type }, + &lv_style_plain +}; + + +/* + * lvgl lv_style_plain_color global definitions + */ + +STATIC const mp_lv_struct_t mp_lv_style_plain_color = { + { &mp_lv_style_t_type }, + &lv_style_plain_color +}; + + +/* + * lvgl lv_style_pretty global definitions + */ + +STATIC const mp_lv_struct_t mp_lv_style_pretty = { + { &mp_lv_style_t_type }, + &lv_style_pretty +}; + + +/* + * lvgl lv_style_pretty_color global definitions + */ + +STATIC const mp_lv_struct_t mp_lv_style_pretty_color = { + { &mp_lv_style_t_type }, + &lv_style_pretty_color +}; + + +/* + * lvgl lv_style_btn_rel global definitions + */ + +STATIC const mp_lv_struct_t mp_lv_style_btn_rel = { + { &mp_lv_style_t_type }, + &lv_style_btn_rel +}; + + +/* + * lvgl lv_style_btn_pr global definitions + */ + +STATIC const mp_lv_struct_t mp_lv_style_btn_pr = { + { &mp_lv_style_t_type }, + &lv_style_btn_pr +}; + + +/* + * lvgl lv_style_btn_tgl_rel global definitions + */ + +STATIC const mp_lv_struct_t mp_lv_style_btn_tgl_rel = { + { &mp_lv_style_t_type }, + &lv_style_btn_tgl_rel +}; + + +/* + * lvgl lv_style_btn_tgl_pr global definitions + */ + +STATIC const mp_lv_struct_t mp_lv_style_btn_tgl_pr = { + { &mp_lv_style_t_type }, + &lv_style_btn_tgl_pr +}; + + +/* + * lvgl lv_style_btn_ina global definitions + */ + +STATIC const mp_lv_struct_t mp_lv_style_btn_ina = { + { &mp_lv_style_t_type }, + &lv_style_btn_ina +}; + + + +/* + * lvgl module definitions + */ + +STATIC const mp_rom_map_elem_t lvgl_globals_table[] = { + { MP_ROM_QSTR(MP_QSTR___name__), MP_ROM_QSTR(MP_QSTR_lvgl) }, + { MP_ROM_QSTR(MP_QSTR_obj), MP_ROM_PTR(&mp_obj_type) }, + { MP_ROM_QSTR(MP_QSTR_cont), MP_ROM_PTR(&mp_cont_type) }, + { MP_ROM_QSTR(MP_QSTR_btn), MP_ROM_PTR(&mp_btn_type) }, + { MP_ROM_QSTR(MP_QSTR_imgbtn), MP_ROM_PTR(&mp_imgbtn_type) }, + { MP_ROM_QSTR(MP_QSTR_label), MP_ROM_PTR(&mp_label_type) }, + { MP_ROM_QSTR(MP_QSTR_img), MP_ROM_PTR(&mp_img_type) }, + { MP_ROM_QSTR(MP_QSTR_line), MP_ROM_PTR(&mp_line_type) }, + { MP_ROM_QSTR(MP_QSTR_page), MP_ROM_PTR(&mp_page_type) }, + { MP_ROM_QSTR(MP_QSTR_list), MP_ROM_PTR(&mp_list_type) }, + { MP_ROM_QSTR(MP_QSTR_chart), MP_ROM_PTR(&mp_chart_type) }, + { MP_ROM_QSTR(MP_QSTR_table), MP_ROM_PTR(&mp_table_type) }, + { MP_ROM_QSTR(MP_QSTR_cb), MP_ROM_PTR(&mp_cb_type) }, + { MP_ROM_QSTR(MP_QSTR_bar), MP_ROM_PTR(&mp_bar_type) }, + { MP_ROM_QSTR(MP_QSTR_slider), MP_ROM_PTR(&mp_slider_type) }, + { MP_ROM_QSTR(MP_QSTR_led), MP_ROM_PTR(&mp_led_type) }, + { MP_ROM_QSTR(MP_QSTR_btnm), MP_ROM_PTR(&mp_btnm_type) }, + { MP_ROM_QSTR(MP_QSTR_kb), MP_ROM_PTR(&mp_kb_type) }, + { MP_ROM_QSTR(MP_QSTR_ddlist), MP_ROM_PTR(&mp_ddlist_type) }, + { MP_ROM_QSTR(MP_QSTR_roller), MP_ROM_PTR(&mp_roller_type) }, + { MP_ROM_QSTR(MP_QSTR_ta), MP_ROM_PTR(&mp_ta_type) }, + { MP_ROM_QSTR(MP_QSTR_canvas), MP_ROM_PTR(&mp_canvas_type) }, + { MP_ROM_QSTR(MP_QSTR_win), MP_ROM_PTR(&mp_win_type) }, + { MP_ROM_QSTR(MP_QSTR_tabview), MP_ROM_PTR(&mp_tabview_type) }, + { MP_ROM_QSTR(MP_QSTR_tileview), MP_ROM_PTR(&mp_tileview_type) }, + { MP_ROM_QSTR(MP_QSTR_mbox), MP_ROM_PTR(&mp_mbox_type) }, + { MP_ROM_QSTR(MP_QSTR_lmeter), MP_ROM_PTR(&mp_lmeter_type) }, + { MP_ROM_QSTR(MP_QSTR_gauge), MP_ROM_PTR(&mp_gauge_type) }, + { MP_ROM_QSTR(MP_QSTR_sw), MP_ROM_PTR(&mp_sw_type) }, + { MP_ROM_QSTR(MP_QSTR_arc), MP_ROM_PTR(&mp_arc_type) }, + { MP_ROM_QSTR(MP_QSTR_preload), MP_ROM_PTR(&mp_preload_type) }, + { MP_ROM_QSTR(MP_QSTR_calendar), MP_ROM_PTR(&mp_calendar_type) }, + { MP_ROM_QSTR(MP_QSTR_spinbox), MP_ROM_PTR(&mp_spinbox_type) }, + { MP_ROM_QSTR(MP_QSTR_color_to1), MP_ROM_PTR(&mp_lv_color_to1_obj) }, + { MP_ROM_QSTR(MP_QSTR_color_to8), MP_ROM_PTR(&mp_lv_color_to8_obj) }, + { MP_ROM_QSTR(MP_QSTR_color_to16), MP_ROM_PTR(&mp_lv_color_to16_obj) }, + { MP_ROM_QSTR(MP_QSTR_color_to32), MP_ROM_PTR(&mp_lv_color_to32_obj) }, + { MP_ROM_QSTR(MP_QSTR_color_mix), MP_ROM_PTR(&mp_lv_color_mix_obj) }, + { MP_ROM_QSTR(MP_QSTR_color_brightness), MP_ROM_PTR(&mp_lv_color_brightness_obj) }, + { MP_ROM_QSTR(MP_QSTR_color_hex), MP_ROM_PTR(&mp_lv_color_hex_obj) }, + { MP_ROM_QSTR(MP_QSTR_color_hex3), MP_ROM_PTR(&mp_lv_color_hex3_obj) }, + { MP_ROM_QSTR(MP_QSTR_area_copy), MP_ROM_PTR(&mp_lv_area_copy_obj) }, + { MP_ROM_QSTR(MP_QSTR_area_get_width), MP_ROM_PTR(&mp_lv_area_get_width_obj) }, + { MP_ROM_QSTR(MP_QSTR_area_get_height), MP_ROM_PTR(&mp_lv_area_get_height_obj) }, + { MP_ROM_QSTR(MP_QSTR_font_get_height), MP_ROM_PTR(&mp_lv_font_get_height_obj) }, + { MP_ROM_QSTR(MP_QSTR_mem_init), MP_ROM_PTR(&mp_lv_mem_init_obj) }, + { MP_ROM_QSTR(MP_QSTR_mem_alloc), MP_ROM_PTR(&mp_lv_mem_alloc_obj) }, + { MP_ROM_QSTR(MP_QSTR_mem_free), MP_ROM_PTR(&mp_lv_mem_free_obj) }, + { MP_ROM_QSTR(MP_QSTR_mem_realloc), MP_ROM_PTR(&mp_lv_mem_realloc_obj) }, + { MP_ROM_QSTR(MP_QSTR_mem_defrag), MP_ROM_PTR(&mp_lv_mem_defrag_obj) }, + { MP_ROM_QSTR(MP_QSTR_mem_monitor), MP_ROM_PTR(&mp_lv_mem_monitor_obj) }, + { MP_ROM_QSTR(MP_QSTR_mem_get_size), MP_ROM_PTR(&mp_lv_mem_get_size_obj) }, + { MP_ROM_QSTR(MP_QSTR_ll_init), MP_ROM_PTR(&mp_lv_ll_init_obj) }, + { MP_ROM_QSTR(MP_QSTR_ll_ins_head), MP_ROM_PTR(&mp_lv_ll_ins_head_obj) }, + { MP_ROM_QSTR(MP_QSTR_ll_ins_prev), MP_ROM_PTR(&mp_lv_ll_ins_prev_obj) }, + { MP_ROM_QSTR(MP_QSTR_ll_ins_tail), MP_ROM_PTR(&mp_lv_ll_ins_tail_obj) }, + { MP_ROM_QSTR(MP_QSTR_ll_rem), MP_ROM_PTR(&mp_lv_ll_rem_obj) }, + { MP_ROM_QSTR(MP_QSTR_ll_clear), MP_ROM_PTR(&mp_lv_ll_clear_obj) }, + { MP_ROM_QSTR(MP_QSTR_ll_chg_list), MP_ROM_PTR(&mp_lv_ll_chg_list_obj) }, + { MP_ROM_QSTR(MP_QSTR_ll_get_head), MP_ROM_PTR(&mp_lv_ll_get_head_obj) }, + { MP_ROM_QSTR(MP_QSTR_ll_get_tail), MP_ROM_PTR(&mp_lv_ll_get_tail_obj) }, + { MP_ROM_QSTR(MP_QSTR_ll_get_next), MP_ROM_PTR(&mp_lv_ll_get_next_obj) }, + { MP_ROM_QSTR(MP_QSTR_ll_get_prev), MP_ROM_PTR(&mp_lv_ll_get_prev_obj) }, + { MP_ROM_QSTR(MP_QSTR_ll_move_before), MP_ROM_PTR(&mp_lv_ll_move_before_obj) }, + { MP_ROM_QSTR(MP_QSTR_task_init), MP_ROM_PTR(&mp_lv_task_init_obj) }, + { MP_ROM_QSTR(MP_QSTR_task_handler), MP_ROM_PTR(&mp_lv_task_handler_obj) }, + { MP_ROM_QSTR(MP_QSTR_task_create), MP_ROM_PTR(&mp_lv_task_create_obj) }, + { MP_ROM_QSTR(MP_QSTR_task_del), MP_ROM_PTR(&mp_lv_task_del_obj) }, + { MP_ROM_QSTR(MP_QSTR_task_set_prio), MP_ROM_PTR(&mp_lv_task_set_prio_obj) }, + { MP_ROM_QSTR(MP_QSTR_task_set_period), MP_ROM_PTR(&mp_lv_task_set_period_obj) }, + { MP_ROM_QSTR(MP_QSTR_task_ready), MP_ROM_PTR(&mp_lv_task_ready_obj) }, + { MP_ROM_QSTR(MP_QSTR_task_once), MP_ROM_PTR(&mp_lv_task_once_obj) }, + { MP_ROM_QSTR(MP_QSTR_task_reset), MP_ROM_PTR(&mp_lv_task_reset_obj) }, + { MP_ROM_QSTR(MP_QSTR_task_enable), MP_ROM_PTR(&mp_lv_task_enable_obj) }, + { MP_ROM_QSTR(MP_QSTR_task_get_idle), MP_ROM_PTR(&mp_lv_task_get_idle_obj) }, + { MP_ROM_QSTR(MP_QSTR_color_hsv_to_rgb), MP_ROM_PTR(&mp_lv_color_hsv_to_rgb_obj) }, + { MP_ROM_QSTR(MP_QSTR_color_rgb_to_hsv), MP_ROM_PTR(&mp_lv_color_rgb_to_hsv_obj) }, + { MP_ROM_QSTR(MP_QSTR_area_set), MP_ROM_PTR(&mp_lv_area_set_obj) }, + { MP_ROM_QSTR(MP_QSTR_area_set_width), MP_ROM_PTR(&mp_lv_area_set_width_obj) }, + { MP_ROM_QSTR(MP_QSTR_area_set_height), MP_ROM_PTR(&mp_lv_area_set_height_obj) }, + { MP_ROM_QSTR(MP_QSTR_area_set_pos), MP_ROM_PTR(&mp_lv_area_set_pos_obj) }, + { MP_ROM_QSTR(MP_QSTR_area_get_size), MP_ROM_PTR(&mp_lv_area_get_size_obj) }, + { MP_ROM_QSTR(MP_QSTR_area_intersect), MP_ROM_PTR(&mp_lv_area_intersect_obj) }, + { MP_ROM_QSTR(MP_QSTR_area_join), MP_ROM_PTR(&mp_lv_area_join_obj) }, + { MP_ROM_QSTR(MP_QSTR_area_is_point_on), MP_ROM_PTR(&mp_lv_area_is_point_on_obj) }, + { MP_ROM_QSTR(MP_QSTR_area_is_on), MP_ROM_PTR(&mp_lv_area_is_on_obj) }, + { MP_ROM_QSTR(MP_QSTR_area_is_in), MP_ROM_PTR(&mp_lv_area_is_in_obj) }, + { MP_ROM_QSTR(MP_QSTR_disp_drv_init), MP_ROM_PTR(&mp_lv_disp_drv_init_obj) }, + { MP_ROM_QSTR(MP_QSTR_disp_drv_register), MP_ROM_PTR(&mp_lv_disp_drv_register_obj) }, + { MP_ROM_QSTR(MP_QSTR_disp_set_active), MP_ROM_PTR(&mp_lv_disp_set_active_obj) }, + { MP_ROM_QSTR(MP_QSTR_disp_get_active), MP_ROM_PTR(&mp_lv_disp_get_active_obj) }, + { MP_ROM_QSTR(MP_QSTR_disp_next), MP_ROM_PTR(&mp_lv_disp_next_obj) }, + { MP_ROM_QSTR(MP_QSTR_disp_flush), MP_ROM_PTR(&mp_lv_disp_flush_obj) }, + { MP_ROM_QSTR(MP_QSTR_disp_fill), MP_ROM_PTR(&mp_lv_disp_fill_obj) }, + { MP_ROM_QSTR(MP_QSTR_disp_map), MP_ROM_PTR(&mp_lv_disp_map_obj) }, + { MP_ROM_QSTR(MP_QSTR_font_init), MP_ROM_PTR(&mp_lv_font_init_obj) }, + { MP_ROM_QSTR(MP_QSTR_font_add), MP_ROM_PTR(&mp_lv_font_add_obj) }, + { MP_ROM_QSTR(MP_QSTR_font_remove), MP_ROM_PTR(&mp_lv_font_remove_obj) }, + { MP_ROM_QSTR(MP_QSTR_font_is_monospace), MP_ROM_PTR(&mp_lv_font_is_monospace_obj) }, + { MP_ROM_QSTR(MP_QSTR_font_get_bitmap), MP_ROM_PTR(&mp_lv_font_get_bitmap_obj) }, + { MP_ROM_QSTR(MP_QSTR_font_get_width), MP_ROM_PTR(&mp_lv_font_get_width_obj) }, + { MP_ROM_QSTR(MP_QSTR_font_get_real_width), MP_ROM_PTR(&mp_lv_font_get_real_width_obj) }, + { MP_ROM_QSTR(MP_QSTR_font_get_bpp), MP_ROM_PTR(&mp_lv_font_get_bpp_obj) }, + { MP_ROM_QSTR(MP_QSTR_font_get_bitmap_continuous), MP_ROM_PTR(&mp_lv_font_get_bitmap_continuous_obj) }, + { MP_ROM_QSTR(MP_QSTR_font_get_bitmap_sparse), MP_ROM_PTR(&mp_lv_font_get_bitmap_sparse_obj) }, + { MP_ROM_QSTR(MP_QSTR_font_get_width_continuous), MP_ROM_PTR(&mp_lv_font_get_width_continuous_obj) }, + { MP_ROM_QSTR(MP_QSTR_font_get_width_sparse), MP_ROM_PTR(&mp_lv_font_get_width_sparse_obj) }, + { MP_ROM_QSTR(MP_QSTR_font_builtin_init), MP_ROM_PTR(&mp_lv_font_builtin_init_obj) }, + { MP_ROM_QSTR(MP_QSTR_anim_init), MP_ROM_PTR(&mp_lv_anim_init_obj) }, + { MP_ROM_QSTR(MP_QSTR_anim_create), MP_ROM_PTR(&mp_lv_anim_create_obj) }, + { MP_ROM_QSTR(MP_QSTR_anim_del), MP_ROM_PTR(&mp_lv_anim_del_obj) }, + { MP_ROM_QSTR(MP_QSTR_anim_count_running), MP_ROM_PTR(&mp_lv_anim_count_running_obj) }, + { MP_ROM_QSTR(MP_QSTR_anim_speed_to_time), MP_ROM_PTR(&mp_lv_anim_speed_to_time_obj) }, + { MP_ROM_QSTR(MP_QSTR_anim_path_linear), MP_ROM_PTR(&mp_lv_anim_path_linear_obj) }, + { MP_ROM_QSTR(MP_QSTR_anim_path_ease_in), MP_ROM_PTR(&mp_lv_anim_path_ease_in_obj) }, + { MP_ROM_QSTR(MP_QSTR_anim_path_ease_out), MP_ROM_PTR(&mp_lv_anim_path_ease_out_obj) }, + { MP_ROM_QSTR(MP_QSTR_anim_path_ease_in_out), MP_ROM_PTR(&mp_lv_anim_path_ease_in_out_obj) }, + { MP_ROM_QSTR(MP_QSTR_anim_path_overshoot), MP_ROM_PTR(&mp_lv_anim_path_overshoot_obj) }, + { MP_ROM_QSTR(MP_QSTR_anim_path_bounce), MP_ROM_PTR(&mp_lv_anim_path_bounce_obj) }, + { MP_ROM_QSTR(MP_QSTR_anim_path_step), MP_ROM_PTR(&mp_lv_anim_path_step_obj) }, + { MP_ROM_QSTR(MP_QSTR_style_init), MP_ROM_PTR(&mp_lv_style_init_obj) }, + { MP_ROM_QSTR(MP_QSTR_style_copy), MP_ROM_PTR(&mp_lv_style_copy_obj) }, + { MP_ROM_QSTR(MP_QSTR_style_mix), MP_ROM_PTR(&mp_lv_style_mix_obj) }, + { MP_ROM_QSTR(MP_QSTR_style_anim_create), MP_ROM_PTR(&mp_lv_style_anim_create_obj) }, + { MP_ROM_QSTR(MP_QSTR_init), MP_ROM_PTR(&mp_lv_init_obj) }, + { MP_ROM_QSTR(MP_QSTR_scr_load), MP_ROM_PTR(&mp_lv_scr_load_obj) }, + { MP_ROM_QSTR(MP_QSTR_scr_act), MP_ROM_PTR(&mp_lv_scr_act_obj) }, + { MP_ROM_QSTR(MP_QSTR_layer_top), MP_ROM_PTR(&mp_lv_layer_top_obj) }, + { MP_ROM_QSTR(MP_QSTR_layer_sys), MP_ROM_PTR(&mp_lv_layer_sys_obj) }, + { MP_ROM_QSTR(MP_QSTR_indev_drv_init), MP_ROM_PTR(&mp_lv_indev_drv_init_obj) }, + { MP_ROM_QSTR(MP_QSTR_indev_drv_register), MP_ROM_PTR(&mp_lv_indev_drv_register_obj) }, + { MP_ROM_QSTR(MP_QSTR_indev_next), MP_ROM_PTR(&mp_lv_indev_next_obj) }, + { MP_ROM_QSTR(MP_QSTR_indev_read), MP_ROM_PTR(&mp_lv_indev_read_obj) }, + { MP_ROM_QSTR(MP_QSTR_tick_inc), MP_ROM_PTR(&mp_lv_tick_inc_obj) }, + { MP_ROM_QSTR(MP_QSTR_tick_get), MP_ROM_PTR(&mp_lv_tick_get_obj) }, + { MP_ROM_QSTR(MP_QSTR_tick_elaps), MP_ROM_PTR(&mp_lv_tick_elaps_obj) }, + { MP_ROM_QSTR(MP_QSTR_group_create), MP_ROM_PTR(&mp_lv_group_create_obj) }, + { MP_ROM_QSTR(MP_QSTR_group_del), MP_ROM_PTR(&mp_lv_group_del_obj) }, + { MP_ROM_QSTR(MP_QSTR_group_add_obj), MP_ROM_PTR(&mp_lv_group_add_obj_obj) }, + { MP_ROM_QSTR(MP_QSTR_group_remove_obj), MP_ROM_PTR(&mp_lv_group_remove_obj_obj) }, + { MP_ROM_QSTR(MP_QSTR_group_focus_obj), MP_ROM_PTR(&mp_lv_group_focus_obj_obj) }, + { MP_ROM_QSTR(MP_QSTR_group_focus_next), MP_ROM_PTR(&mp_lv_group_focus_next_obj) }, + { MP_ROM_QSTR(MP_QSTR_group_focus_prev), MP_ROM_PTR(&mp_lv_group_focus_prev_obj) }, + { MP_ROM_QSTR(MP_QSTR_group_focus_freeze), MP_ROM_PTR(&mp_lv_group_focus_freeze_obj) }, + { MP_ROM_QSTR(MP_QSTR_group_send_data), MP_ROM_PTR(&mp_lv_group_send_data_obj) }, + { MP_ROM_QSTR(MP_QSTR_group_set_style_mod_cb), MP_ROM_PTR(&mp_lv_group_set_style_mod_cb_obj) }, + { MP_ROM_QSTR(MP_QSTR_group_set_style_mod_edit_cb), MP_ROM_PTR(&mp_lv_group_set_style_mod_edit_cb_obj) }, + { MP_ROM_QSTR(MP_QSTR_group_set_focus_cb), MP_ROM_PTR(&mp_lv_group_set_focus_cb_obj) }, + { MP_ROM_QSTR(MP_QSTR_group_set_editing), MP_ROM_PTR(&mp_lv_group_set_editing_obj) }, + { MP_ROM_QSTR(MP_QSTR_group_set_click_focus), MP_ROM_PTR(&mp_lv_group_set_click_focus_obj) }, + { MP_ROM_QSTR(MP_QSTR_group_set_wrap), MP_ROM_PTR(&mp_lv_group_set_wrap_obj) }, + { MP_ROM_QSTR(MP_QSTR_group_mod_style), MP_ROM_PTR(&mp_lv_group_mod_style_obj) }, + { MP_ROM_QSTR(MP_QSTR_group_get_focused), MP_ROM_PTR(&mp_lv_group_get_focused_obj) }, + { MP_ROM_QSTR(MP_QSTR_group_get_style_mod_cb), MP_ROM_PTR(&mp_lv_group_get_style_mod_cb_obj) }, + { MP_ROM_QSTR(MP_QSTR_group_get_style_mod_edit_cb), MP_ROM_PTR(&mp_lv_group_get_style_mod_edit_cb_obj) }, + { MP_ROM_QSTR(MP_QSTR_group_get_focus_cb), MP_ROM_PTR(&mp_lv_group_get_focus_cb_obj) }, + { MP_ROM_QSTR(MP_QSTR_group_get_editing), MP_ROM_PTR(&mp_lv_group_get_editing_obj) }, + { MP_ROM_QSTR(MP_QSTR_group_get_click_focus), MP_ROM_PTR(&mp_lv_group_get_click_focus_obj) }, + { MP_ROM_QSTR(MP_QSTR_group_get_wrap), MP_ROM_PTR(&mp_lv_group_get_wrap_obj) }, + { MP_ROM_QSTR(MP_QSTR_vdb_get), MP_ROM_PTR(&mp_lv_vdb_get_obj) }, + { MP_ROM_QSTR(MP_QSTR_vdb_flush), MP_ROM_PTR(&mp_lv_vdb_flush_obj) }, + { MP_ROM_QSTR(MP_QSTR_vdb_set_adr), MP_ROM_PTR(&mp_lv_vdb_set_adr_obj) }, + { MP_ROM_QSTR(MP_QSTR_flush_ready), MP_ROM_PTR(&mp_lv_flush_ready_obj) }, + { MP_ROM_QSTR(MP_QSTR_vdb_get_active), MP_ROM_PTR(&mp_lv_vdb_get_active_obj) }, + { MP_ROM_QSTR(MP_QSTR_vdb_get_inactive), MP_ROM_PTR(&mp_lv_vdb_get_inactive_obj) }, + { MP_ROM_QSTR(MP_QSTR_vdb_is_flushing), MP_ROM_PTR(&mp_lv_vdb_is_flushing_obj) }, + { MP_ROM_QSTR(MP_QSTR_refr_init), MP_ROM_PTR(&mp_lv_refr_init_obj) }, + { MP_ROM_QSTR(MP_QSTR_refr_now), MP_ROM_PTR(&mp_lv_refr_now_obj) }, + { MP_ROM_QSTR(MP_QSTR_inv_area), MP_ROM_PTR(&mp_lv_inv_area_obj) }, + { MP_ROM_QSTR(MP_QSTR_refr_set_monitor_cb), MP_ROM_PTR(&mp_lv_refr_set_monitor_cb_obj) }, + { MP_ROM_QSTR(MP_QSTR_refr_set_round_cb), MP_ROM_PTR(&mp_lv_refr_set_round_cb_obj) }, + { MP_ROM_QSTR(MP_QSTR_refr_get_buf_size), MP_ROM_PTR(&mp_lv_refr_get_buf_size_obj) }, + { MP_ROM_QSTR(MP_QSTR_refr_pop_from_buf), MP_ROM_PTR(&mp_lv_refr_pop_from_buf_obj) }, + { MP_ROM_QSTR(MP_QSTR_theme_set_current), MP_ROM_PTR(&mp_lv_theme_set_current_obj) }, + { MP_ROM_QSTR(MP_QSTR_theme_get_current), MP_ROM_PTR(&mp_lv_theme_get_current_obj) }, + { MP_ROM_QSTR(MP_QSTR_theme_default_init), MP_ROM_PTR(&mp_lv_theme_default_init_obj) }, + { MP_ROM_QSTR(MP_QSTR_theme_get_default), MP_ROM_PTR(&mp_lv_theme_get_default_obj) }, + { MP_ROM_QSTR(MP_QSTR_theme_alien_init), MP_ROM_PTR(&mp_lv_theme_alien_init_obj) }, + { MP_ROM_QSTR(MP_QSTR_theme_get_alien), MP_ROM_PTR(&mp_lv_theme_get_alien_obj) }, + { MP_ROM_QSTR(MP_QSTR_theme_night_init), MP_ROM_PTR(&mp_lv_theme_night_init_obj) }, + { MP_ROM_QSTR(MP_QSTR_theme_get_night), MP_ROM_PTR(&mp_lv_theme_get_night_obj) }, + { MP_ROM_QSTR(MP_QSTR_theme_zen_init), MP_ROM_PTR(&mp_lv_theme_zen_init_obj) }, + { MP_ROM_QSTR(MP_QSTR_theme_get_zen), MP_ROM_PTR(&mp_lv_theme_get_zen_obj) }, + { MP_ROM_QSTR(MP_QSTR_theme_mono_init), MP_ROM_PTR(&mp_lv_theme_mono_init_obj) }, + { MP_ROM_QSTR(MP_QSTR_theme_get_mono), MP_ROM_PTR(&mp_lv_theme_get_mono_obj) }, + { MP_ROM_QSTR(MP_QSTR_theme_nemo_init), MP_ROM_PTR(&mp_lv_theme_nemo_init_obj) }, + { MP_ROM_QSTR(MP_QSTR_theme_get_nemo), MP_ROM_PTR(&mp_lv_theme_get_nemo_obj) }, + { MP_ROM_QSTR(MP_QSTR_theme_material_init), MP_ROM_PTR(&mp_lv_theme_material_init_obj) }, + { MP_ROM_QSTR(MP_QSTR_theme_get_material), MP_ROM_PTR(&mp_lv_theme_get_material_obj) }, + { MP_ROM_QSTR(MP_QSTR_indev_init), MP_ROM_PTR(&mp_lv_indev_init_obj) }, + { MP_ROM_QSTR(MP_QSTR_indev_get_act), MP_ROM_PTR(&mp_lv_indev_get_act_obj) }, + { MP_ROM_QSTR(MP_QSTR_indev_get_type), MP_ROM_PTR(&mp_lv_indev_get_type_obj) }, + { MP_ROM_QSTR(MP_QSTR_indev_reset), MP_ROM_PTR(&mp_lv_indev_reset_obj) }, + { MP_ROM_QSTR(MP_QSTR_indev_reset_lpr), MP_ROM_PTR(&mp_lv_indev_reset_lpr_obj) }, + { MP_ROM_QSTR(MP_QSTR_indev_enable), MP_ROM_PTR(&mp_lv_indev_enable_obj) }, + { MP_ROM_QSTR(MP_QSTR_indev_set_cursor), MP_ROM_PTR(&mp_lv_indev_set_cursor_obj) }, + { MP_ROM_QSTR(MP_QSTR_indev_set_group), MP_ROM_PTR(&mp_lv_indev_set_group_obj) }, + { MP_ROM_QSTR(MP_QSTR_indev_set_button_points), MP_ROM_PTR(&mp_lv_indev_set_button_points_obj) }, + { MP_ROM_QSTR(MP_QSTR_indev_set_feedback), MP_ROM_PTR(&mp_lv_indev_set_feedback_obj) }, + { MP_ROM_QSTR(MP_QSTR_indev_get_point), MP_ROM_PTR(&mp_lv_indev_get_point_obj) }, + { MP_ROM_QSTR(MP_QSTR_indev_get_key), MP_ROM_PTR(&mp_lv_indev_get_key_obj) }, + { MP_ROM_QSTR(MP_QSTR_indev_is_dragging), MP_ROM_PTR(&mp_lv_indev_is_dragging_obj) }, + { MP_ROM_QSTR(MP_QSTR_indev_get_vect), MP_ROM_PTR(&mp_lv_indev_get_vect_obj) }, + { MP_ROM_QSTR(MP_QSTR_indev_get_inactive_time), MP_ROM_PTR(&mp_lv_indev_get_inactive_time_obj) }, + { MP_ROM_QSTR(MP_QSTR_indev_get_feedback), MP_ROM_PTR(&mp_lv_indev_get_feedback_obj) }, + { MP_ROM_QSTR(MP_QSTR_indev_wait_release), MP_ROM_PTR(&mp_lv_indev_wait_release_obj) }, + { MP_ROM_QSTR(MP_QSTR_txt_get_size), MP_ROM_PTR(&mp_lv_txt_get_size_obj) }, + { MP_ROM_QSTR(MP_QSTR_txt_get_next_line), MP_ROM_PTR(&mp_lv_txt_get_next_line_obj) }, + { MP_ROM_QSTR(MP_QSTR_txt_get_width), MP_ROM_PTR(&mp_lv_txt_get_width_obj) }, + { MP_ROM_QSTR(MP_QSTR_txt_is_cmd), MP_ROM_PTR(&mp_lv_txt_is_cmd_obj) }, + { MP_ROM_QSTR(MP_QSTR_txt_ins), MP_ROM_PTR(&mp_lv_txt_ins_obj) }, + { MP_ROM_QSTR(MP_QSTR_txt_cut), MP_ROM_PTR(&mp_lv_txt_cut_obj) }, + { MP_ROM_QSTR(MP_QSTR_draw_aa_get_opa), MP_ROM_PTR(&mp_lv_draw_aa_get_opa_obj) }, + { MP_ROM_QSTR(MP_QSTR_draw_aa_ver_seg), MP_ROM_PTR(&mp_lv_draw_aa_ver_seg_obj) }, + { MP_ROM_QSTR(MP_QSTR_draw_aa_hor_seg), MP_ROM_PTR(&mp_lv_draw_aa_hor_seg_obj) }, + { MP_ROM_QSTR(MP_QSTR_draw_rect), MP_ROM_PTR(&mp_lv_draw_rect_obj) }, + { MP_ROM_QSTR(MP_QSTR_draw_label), MP_ROM_PTR(&mp_lv_draw_label_obj) }, + { MP_ROM_QSTR(MP_QSTR_draw_line), MP_ROM_PTR(&mp_lv_draw_line_obj) }, + { MP_ROM_QSTR(MP_QSTR_draw_triangle), MP_ROM_PTR(&mp_lv_draw_triangle_obj) }, + { MP_ROM_QSTR(MP_QSTR_draw_img), MP_ROM_PTR(&mp_lv_draw_img_obj) }, + { MP_ROM_QSTR(MP_QSTR_TASK_PRIO), MP_ROM_PTR(&mp_LV_TASK_PRIO_type) }, + { MP_ROM_QSTR(MP_QSTR_OPA), MP_ROM_PTR(&mp_LV_OPA_type) }, + { MP_ROM_QSTR(MP_QSTR_SYMBOL), MP_ROM_PTR(&mp_LV_SYMBOL_type) }, + { MP_ROM_QSTR(MP_QSTR_BORDER), MP_ROM_PTR(&mp_LV_BORDER_type) }, + { MP_ROM_QSTR(MP_QSTR_SHADOW), MP_ROM_PTR(&mp_LV_SHADOW_type) }, + { MP_ROM_QSTR(MP_QSTR_DESIGN), MP_ROM_PTR(&mp_LV_DESIGN_type) }, + { MP_ROM_QSTR(MP_QSTR_RES), MP_ROM_PTR(&mp_LV_RES_type) }, + { MP_ROM_QSTR(MP_QSTR_SIGNAL), MP_ROM_PTR(&mp_LV_SIGNAL_type) }, + { MP_ROM_QSTR(MP_QSTR_ALIGN), MP_ROM_PTR(&mp_LV_ALIGN_type) }, + { MP_ROM_QSTR(MP_QSTR_PROTECT), MP_ROM_PTR(&mp_LV_PROTECT_type) }, + { MP_ROM_QSTR(MP_QSTR_ANIM), MP_ROM_PTR(&mp_LV_ANIM_type) }, + { MP_ROM_QSTR(MP_QSTR_INDEV_TYPE), MP_ROM_PTR(&mp_LV_INDEV_TYPE_type) }, + { MP_ROM_QSTR(MP_QSTR_INDEV_STATE), MP_ROM_PTR(&mp_LV_INDEV_STATE_type) }, + { MP_ROM_QSTR(MP_QSTR_LAYOUT), MP_ROM_PTR(&mp_LV_LAYOUT_type) }, + { MP_ROM_QSTR(MP_QSTR_TXT_FLAG), MP_ROM_PTR(&mp_LV_TXT_FLAG_type) }, + { MP_ROM_QSTR(MP_QSTR_TXT_CMD_STATE), MP_ROM_PTR(&mp_LV_TXT_CMD_STATE_type) }, + { MP_ROM_QSTR(MP_QSTR_SB_MODE), MP_ROM_PTR(&mp_LV_SB_MODE_type) }, + { MP_ROM_QSTR(MP_QSTR_CURSOR), MP_ROM_PTR(&mp_LV_CURSOR_type) }, + { MP_ROM_QSTR(MP_QSTR_mem_monitor_t), MP_ROM_PTR(&mp_lv_mem_monitor_t_type) }, + { MP_ROM_QSTR(MP_QSTR_ll_t), MP_ROM_PTR(&mp_lv_ll_t_type) }, + { MP_ROM_QSTR(MP_QSTR_task_t), MP_ROM_PTR(&mp_lv_task_t_type) }, + { MP_ROM_QSTR(MP_QSTR_color16_t), MP_ROM_PTR(&mp_lv_color16_t_type) }, + { MP_ROM_QSTR(MP_QSTR_color_hsv_t), MP_ROM_PTR(&mp_lv_color_hsv_t_type) }, + { MP_ROM_QSTR(MP_QSTR_point_t), MP_ROM_PTR(&mp_lv_point_t_type) }, + { MP_ROM_QSTR(MP_QSTR_area_t), MP_ROM_PTR(&mp_lv_area_t_type) }, + { MP_ROM_QSTR(MP_QSTR_disp_drv_t), MP_ROM_PTR(&mp_lv_disp_drv_t_type) }, + { MP_ROM_QSTR(MP_QSTR_disp_t), MP_ROM_PTR(&mp_lv_disp_t_type) }, + { MP_ROM_QSTR(MP_QSTR_font_glyph_dsc_t), MP_ROM_PTR(&mp_lv_font_glyph_dsc_t_type) }, + { MP_ROM_QSTR(MP_QSTR_font_t), MP_ROM_PTR(&mp_lv_font_t_type) }, + { MP_ROM_QSTR(MP_QSTR_anim_t), MP_ROM_PTR(&mp_lv_anim_t_type) }, + { MP_ROM_QSTR(MP_QSTR_style_t), MP_ROM_PTR(&mp_lv_style_t_type) }, + { MP_ROM_QSTR(MP_QSTR_style_anim_t), MP_ROM_PTR(&mp_lv_style_anim_t_type) }, + { MP_ROM_QSTR(MP_QSTR_indev_data_t), MP_ROM_PTR(&mp_lv_indev_data_t_type) }, + { MP_ROM_QSTR(MP_QSTR_indev_drv_t), MP_ROM_PTR(&mp_lv_indev_drv_t_type) }, + { MP_ROM_QSTR(MP_QSTR_indev_proc_t), MP_ROM_PTR(&mp_lv_indev_proc_t_type) }, + { MP_ROM_QSTR(MP_QSTR_indev_t), MP_ROM_PTR(&mp_lv_indev_t_type) }, + { MP_ROM_QSTR(MP_QSTR_group_t), MP_ROM_PTR(&mp_lv_group_t_type) }, + { MP_ROM_QSTR(MP_QSTR_vdb_t), MP_ROM_PTR(&mp_lv_vdb_t_type) }, + { MP_ROM_QSTR(MP_QSTR_theme_t), MP_ROM_PTR(&mp_lv_theme_t_type) }, + { MP_ROM_QSTR(MP_QSTR_img_header_t), MP_ROM_PTR(&mp_lv_img_header_t_type) }, + { MP_ROM_QSTR(MP_QSTR_chart_series_t), MP_ROM_PTR(&mp_lv_chart_series_t_type) }, + { MP_ROM_QSTR(MP_QSTR_calendar_date_t), MP_ROM_PTR(&mp_lv_calendar_date_t_type) }, + { MP_ROM_QSTR(MP_QSTR_color_t), MP_ROM_PTR(&mp_lv_color16_t_type) }, + { MP_ROM_QSTR(MP_QSTR_font_dejavu_20), MP_ROM_PTR(&mp_lv_font_dejavu_20) }, + { MP_ROM_QSTR(MP_QSTR_font_dejavu_20_latin_sup), MP_ROM_PTR(&mp_lv_font_dejavu_20_latin_sup) }, + { MP_ROM_QSTR(MP_QSTR_font_dejavu_20_cyrillic), MP_ROM_PTR(&mp_lv_font_dejavu_20_cyrillic) }, + { MP_ROM_QSTR(MP_QSTR_font_symbol_20), MP_ROM_PTR(&mp_lv_font_symbol_20) }, + { MP_ROM_QSTR(MP_QSTR_style_scr), MP_ROM_PTR(&mp_lv_style_scr) }, + { MP_ROM_QSTR(MP_QSTR_style_transp), MP_ROM_PTR(&mp_lv_style_transp) }, + { MP_ROM_QSTR(MP_QSTR_style_transp_fit), MP_ROM_PTR(&mp_lv_style_transp_fit) }, + { MP_ROM_QSTR(MP_QSTR_style_transp_tight), MP_ROM_PTR(&mp_lv_style_transp_tight) }, + { MP_ROM_QSTR(MP_QSTR_style_plain), MP_ROM_PTR(&mp_lv_style_plain) }, + { MP_ROM_QSTR(MP_QSTR_style_plain_color), MP_ROM_PTR(&mp_lv_style_plain_color) }, + { MP_ROM_QSTR(MP_QSTR_style_pretty), MP_ROM_PTR(&mp_lv_style_pretty) }, + { MP_ROM_QSTR(MP_QSTR_style_pretty_color), MP_ROM_PTR(&mp_lv_style_pretty_color) }, + { MP_ROM_QSTR(MP_QSTR_style_btn_rel), MP_ROM_PTR(&mp_lv_style_btn_rel) }, + { MP_ROM_QSTR(MP_QSTR_style_btn_pr), MP_ROM_PTR(&mp_lv_style_btn_pr) }, + { MP_ROM_QSTR(MP_QSTR_style_btn_tgl_rel), MP_ROM_PTR(&mp_lv_style_btn_tgl_rel) }, + { MP_ROM_QSTR(MP_QSTR_style_btn_tgl_pr), MP_ROM_PTR(&mp_lv_style_btn_tgl_pr) }, + { MP_ROM_QSTR(MP_QSTR_style_btn_ina), MP_ROM_PTR(&mp_lv_style_btn_ina) } +}; + + +STATIC MP_DEFINE_CONST_DICT ( + mp_module_lvgl_globals, + lvgl_globals_table +); + +const mp_obj_module_t mp_module_lvgl = { + .base = { &mp_type_module }, + .globals = (mp_obj_dict_t*)&mp_module_lvgl_globals +}; + diff --git a/ports/nxp/modpyb.c b/ports/nxp/modpyb.c new file mode 100644 index 000000000000..07c01b4162f1 --- /dev/null +++ b/ports/nxp/modpyb.c @@ -0,0 +1,76 @@ +/* + * The MIT License (MIT) + * + * Copyright (c) 2013-2019 Damien P. George + * + * Permission is hereby granted, free of charge, to any person obtaining a copy + * of this software and associated documentation files (the "Software"), to deal + * in the Software without restriction, including without limitation the rights + * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell + * copies of the Software, and to permit persons to whom the Software is + * furnished to do so, subject to the following conditions: + * + * The above copyright notice and this permission notice shall be included in + * all copies or substantial portions of the Software. + * + * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR + * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, + * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE + * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER + * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, + * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN + * THE SOFTWARE. + */ + +#include +#include + +#include "py/runtime.h" +#include "py/mphal.h" +#include "lib/utils/pyexec.h" + +#include "led.h" +#include "sdcard.h" +#include "extmod/vfs.h" +#include "pybi2c.h" +#include "pybpinmux.h" + +STATIC mp_obj_t pyb_main(size_t n_args, const mp_obj_t *pos_args, mp_map_t *kw_args) +{ + static const mp_arg_t allowed_args[] = { + { MP_QSTR_opt, MP_ARG_INT, {.u_int = 0} } + }; + + if(mp_obj_is_str(pos_args[0])) + { + MP_STATE_PORT(pyb_config_main) = pos_args[0]; + + /* parse args */ + mp_arg_val_t args[MP_ARRAY_SIZE(allowed_args)]; + mp_arg_parse_all(n_args - 1, pos_args+1, kw_args, MP_ARRAY_SIZE(allowed_args), allowed_args, args); + MP_STATE_VM(mp_optimise_value) = args[0].u_int; + } + return mp_const_none; +} +MP_DEFINE_CONST_FUN_OBJ_KW(pyb_main_obj, 1, pyb_main); + +STATIC const mp_rom_map_elem_t pyb_module_globals_table[] = { + { MP_ROM_QSTR(MP_QSTR___name__), MP_ROM_QSTR(MP_QSTR_pyb) }, + { MP_ROM_QSTR(MP_QSTR_Pin), MP_ROM_PTR(&pin_type) }, + { MP_ROM_QSTR(MP_QSTR_LED), MP_ROM_PTR(&pyb_led_type) }, + { MP_ROM_QSTR(MP_QSTR_Sdcard), MP_ROM_PTR(&pyb_sdcard_type) }, + { MP_ROM_QSTR(MP_QSTR_main), MP_ROM_PTR(&pyb_main_obj) }, + { MP_ROM_QSTR(MP_QSTR_mount), MP_ROM_PTR(&mp_vfs_mount_obj) }, + { MP_ROM_QSTR(MP_QSTR_LPI2C), MP_ROM_PTR(&pyb_i2c_type) }, + { MP_ROM_QSTR(MP_QSTR_port), MP_ROM_PTR(&port_type) }, + { MP_ROM_QSTR(MP_QSTR_pinmux), MP_ROM_PTR(&pinmux_type) }, +// { MP_ROM_QSTR(MP_QSTR_GPT), MP_ROM_PTR(&pyb_gpt_type) }, +}; + +STATIC MP_DEFINE_CONST_DICT(pyb_module_globals, pyb_module_globals_table); + +const mp_obj_module_t pyb_module = { + .base = { &mp_type_module }, + .globals = (mp_obj_dict_t*)&pyb_module_globals, +}; + diff --git a/ports/nxp/moduos.c b/ports/nxp/moduos.c new file mode 100644 index 000000000000..1166db44b486 --- /dev/null +++ b/ports/nxp/moduos.c @@ -0,0 +1,77 @@ +/* + * The MIT License (MIT) + * + * Copyright (c) 2013-2019 Damien P. George + * + * Permission is hereby granted, free of charge, to any person obtaining a copy + * of this software and associated documentation files (the "Software"), to deal + * in the Software without restriction, including without limitation the rights + * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell + * copies of the Software, and to permit persons to whom the Software is + * furnished to do so, subject to the following conditions: + * + * The above copyright notice and this permission notice shall be included in + * all copies or substantial portions of the Software. + * + * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR + * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, + * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE + * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER + * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, + * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN + * THE SOFTWARE. + */ + +#include +#include + +#include "py/runtime.h" +#include "py/objtuple.h" +#include "py/objstr.h" +#include "lib/timeutils/timeutils.h" +#include "lib/oofatfs/ff.h" +#include "lib/oofatfs/diskio.h" +#include "extmod/misc.h" +#include "extmod/vfs.h" +#include "extmod/vfs_fat.h" + +//STATIC mp_obj_t os_uname(void) { +// return MP_OBJ_FROM_PTR(&os_uname_info_obj); +//} +//STATIC MP_DEFINE_CONST_FUN_OBJ_0(os_uname_obj, os_uname); + +/// \function sync() +/// Sync all filesystems. + +STATIC const mp_rom_map_elem_t os_module_globals_table[] = { + { MP_ROM_QSTR(MP_QSTR___name__), MP_ROM_QSTR(MP_QSTR_uos) }, + { MP_ROM_QSTR(MP_QSTR_chdir), MP_ROM_PTR(&mp_vfs_chdir_obj) }, + { MP_ROM_QSTR(MP_QSTR_getcwd), MP_ROM_PTR(&mp_vfs_getcwd_obj) }, + { MP_ROM_QSTR(MP_QSTR_ilistdir), MP_ROM_PTR(&mp_vfs_ilistdir_obj) }, + { MP_ROM_QSTR(MP_QSTR_listdir), MP_ROM_PTR(&mp_vfs_listdir_obj) }, + { MP_ROM_QSTR(MP_QSTR_mkdir), MP_ROM_PTR(&mp_vfs_mkdir_obj) }, + { MP_ROM_QSTR(MP_QSTR_remove), MP_ROM_PTR(&mp_vfs_remove_obj) }, + { MP_ROM_QSTR(MP_QSTR_rename),MP_ROM_PTR(&mp_vfs_rename_obj)}, + { MP_ROM_QSTR(MP_QSTR_rmdir), MP_ROM_PTR(&mp_vfs_rmdir_obj) }, + { MP_ROM_QSTR(MP_QSTR_stat), MP_ROM_PTR(&mp_vfs_stat_obj) }, + { MP_ROM_QSTR(MP_QSTR_open), MP_ROM_PTR(&mp_vfs_open_obj) }, + { MP_ROM_QSTR(MP_QSTR_statvfs), MP_ROM_PTR(&mp_vfs_statvfs_obj) }, + { MP_ROM_QSTR(MP_QSTR_unlink), MP_ROM_PTR(&mp_vfs_remove_obj) }, // unlink aliases to remove + + /// \constant sep - separation character used in paths + { MP_ROM_QSTR(MP_QSTR_sep), MP_ROM_QSTR(MP_QSTR__slash_) }, + + // these are MicroPython extensions + { MP_ROM_QSTR(MP_QSTR_mount), MP_ROM_PTR(&mp_vfs_mount_obj) }, + { MP_ROM_QSTR(MP_QSTR_umount), MP_ROM_PTR(&mp_vfs_umount_obj) }, + #if MICROPY_VFS_FAT + { MP_ROM_QSTR(MP_QSTR_VfsFat), MP_ROM_PTR(&mp_fat_vfs_type) }, + #endif +}; + +STATIC MP_DEFINE_CONST_DICT(os_module_globals, os_module_globals_table); + +const mp_obj_module_t mp_module_uos = { + .base = { &mp_type_module }, + .globals = (mp_obj_dict_t*)&os_module_globals, +}; \ No newline at end of file diff --git a/ports/nxp/mpconfigport.h b/ports/nxp/mpconfigport.h new file mode 100644 index 000000000000..3916d6743f18 --- /dev/null +++ b/ports/nxp/mpconfigport.h @@ -0,0 +1,200 @@ +/* + * The MIT License (MIT) + * + * Copyright (c) 2013-2019 Damien P. George + * + * Permission is hereby granted, free of charge, to any person obtaining a copy + * of this software and associated documentation files (the "Software"), to deal + * in the Software without restriction, including without limitation the rights + * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell + * copies of the Software, and to permit persons to whom the Software is + * furnished to do so, subject to the following conditions: + * + * The above copyright notice and this permission notice shall be included in + * all copies or substantial portions of the Software. + * + * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR + * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, + * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE + * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER + * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, + * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN + * THE SOFTWARE. + */ + +#include +#include "mpconfigboard.h" +// options to control how MicroPython is built + +// You can disable the built-in MicroPython compiler by setting the following +// config option to 0. If you do this then you won't get a REPL prompt, but you +// will still be able to execute pre-compiled scripts, compiled with mpy-cross. +#define MICROPY_ENABLE_COMPILER (1) + +#define MICROPY_QSTR_BYTES_IN_HASH (1) +//#define MICROPY_QSTR_EXTRA_POOL mp_qstr_frozen_const_pool +#define MICROPY_ALLOC_PATH_MAX (128) +#define MICROPY_ALLOC_PARSE_CHUNK_INIT (16) +#define MICROPY_EMIT_X64 (0) +#define MICROPY_EMIT_THUMB (0) +#define MICROPY_EMIT_INLINE_THUMB (0) +#define MICROPY_COMP_MODULE_CONST (0) +#define MICROPY_COMP_CONST (0) +#define MICROPY_COMP_DOUBLE_TUPLE_ASSIGN (0) +#define MICROPY_COMP_TRIPLE_TUPLE_ASSIGN (0) +#define MICROPY_MEM_STATS (0) +#define MICROPY_DEBUG_PRINTERS (0) +#define MICROPY_ENABLE_GC (1) +#define MICROPY_GC_ALLOC_THRESHOLD (0) +#define MICROPY_ENABLE_FINALISER (1) +#define MICROPY_HELPER_REPL (1) +#define MICROPY_HELPER_LEXER_UNIX (0) +#define MICROPY_ENABLE_SOURCE_LINE (0) +#define MICROPY_ENABLE_DOC_STRING (0) +#define MICROPY_ERROR_REPORTING (MICROPY_ERROR_REPORTING_TERSE) +#define MICROPY_BUILTIN_METHOD_CHECK_SELF_ARG (0) +#define MICROPY_PY_ASYNC_AWAIT (0) +#define MICROPY_PY_BUILTINS_BYTEARRAY (1) +#define MICROPY_PY_BUILTINS_DICT_FROMKEYS (0) +#define MICROPY_PY_BUILTINS_MEMORYVIEW (0) +#define MICROPY_PY_BUILTINS_ENUMERATE (0) +#define MICROPY_PY_BUILTINS_FILTER (0) +#define MICROPY_PY_BUILTINS_FROZENSET (0) +#define MICROPY_PY_BUILTINS_REVERSED (0) +#define MICROPY_PY_BUILTINS_SET (0) +#define MICROPY_PY_BUILTINS_SLICE (0) +#define MICROPY_PY_BUILTINS_PROPERTY (0) +#define MICROPY_PY_BUILTINS_MIN_MAX (0) +#define MICROPY_PY_BUILTINS_STR_COUNT (0) +#define MICROPY_PY_BUILTINS_STR_OP_MODULO (0) +#define MICROPY_PY___FILE__ (0) +#define MICROPY_PY_GC (1) +#define MICROPY_PY_ARRAY (0) +#define MICROPY_PY_ATTRTUPLE (0) +#define MICROPY_PY_COLLECTIONS (0) +#define MICROPY_PY_MATH (0) + +/* module cmath */ +#define MICROPY_PY_CMATH (1) +#define MICROPY_FLOAT_IMPL (MICROPY_FLOAT_IMPL_FLOAT) + +#define MICROPY_MODULE_FROZEN_MPY (0) +#define MICROPY_CPYTHON_COMPAT (0) +#define MICROPY_LONGINT_IMPL (MICROPY_LONGINT_IMPL_NONE) + +#define MICROPY_PY_BUILTINS_HELP (1) + +#define MICROPY_ENABLE_SCHEDULER (1) + +/* VFS */ +#define MICROPY_READER_VFS (1) +#define MICROPY_VFS (1) + +#ifndef MICROPY_VFS_FAT +#define MICROPY_VFS_FAT (1) +#endif + +/* ubinascii module */ +#define MICROPY_PY_UBINASCII (1) + +/* json module */ +#define MICROPY_PY_UJSON (1) + +/* re module */ +#define MICROPY_PY_URE (1) + + +#define MICROPY_FATFS_ENABLE_LFN (1) +#define MICROPY_FATFS_USE_LABEL (1) +#define MICROPY_FATFS_RPATH (2) +#define MICROPY_FATFS_MULTI_PARTITION (1) + +/* IO */ +#define MICROPY_PY_IO (1) +#define MICROPY_PY_IO_IOBASE (1) +#define MICROPY_PY_IO_FILEIO (MICROPY_VFS_FAT) +#define MICROPY_PY_SYS_STDFILES (0) + +#define mp_type_fileio mp_type_vfs_fat_fileio +#define mp_type_textio mp_type_vfs_fat_textio + +#define MICROPY_STACK_CHECK (1) + +/* little VGL */ +#if defined(MICROPY_PY_LVGL) && MICROPY_PY_LVGL +#include "lib/nxplib/middleware/littlevgl/lv_misc/lv_gc.h" +#define MICROPY_PY_LVGL_DEF \ + { MP_OBJ_NEW_QSTR(MP_QSTR_lvgl), (mp_obj_t)&mp_module_lvgl }, \ + { MP_OBJ_NEW_QSTR(MP_QSTR_SDL), (mp_obj_t)&mp_module_SDL }, +#else +#define LV_ROOTS +#define MICROPY_PY_LVGL_DEF +#endif + + +/* IO */ +#define MICROPY_PY_IO (1) +#define MICROPY_PY_IO_IOBASE (1) + +#define MICROPY_GC_STACK_ENTRY_TYPE uint16_t +// type definitions for the specific machine + +#define MICROPY_MAKE_POINTER_CALLABLE(p) ((void*)((mp_uint_t)(p) | 1)) + +// This port is intended to be 32-bit, but unfortunately, int32_t for +// different targets may be defined in different ways - either as int +// or as long. This requires different printf formatting specifiers +// to print such value. So, we avoid int32_t and use int directly. +#define UINT_FMT "%u" +#define INT_FMT "%d" +typedef int mp_int_t; // must be pointer size +typedef unsigned mp_uint_t; // must be pointer size + +typedef long mp_off_t; + +#define MP_PLAT_PRINT_STRN(str, len) mp_hal_stdout_tx_strn_cooked(str, len) + +extern const struct _mp_obj_module_t pyb_module; +#if defined(MICROPY_PY_LVGL) && MICROPY_PY_LVGL +extern const struct _mp_obj_module_t mp_module_lvgl; +extern const struct _mp_obj_module_t mp_module_SDL; +#endif + +extern const struct _mp_obj_module_t mp_module_uos; +// extra built in names to add to the global namespace +#define MICROPY_PORT_BUILTINS \ + { MP_ROM_QSTR(MP_QSTR_open), MP_ROM_PTR(&mp_builtin_open_obj) }, + +#define MICROPY_PORT_BUILTIN_MODULES \ + { MP_ROM_QSTR(MP_QSTR_pyb), MP_ROM_PTR(&pyb_module) }, \ + { MP_ROM_QSTR(MP_QSTR_uos), MP_ROM_PTR(&mp_module_uos) }, \ + MICROPY_PY_LVGL_DEF \ + +#define mp_import_stat mp_vfs_import_stat + + +// extra constants + +#define MICROPY_PORT_CONSTANTS \ + { MP_ROM_QSTR(MP_QSTR_pyb), MP_ROM_PTR(&pyb_module) }, \ + +// We need to provide a declaration/definition of alloca() +#include + +#ifdef __thumb__ +#define MICROPY_MIN_USE_CORTEX_CPU (1) +#endif + +#define MP_STATE_PORT MP_STATE_VM + +#define MICROPY_PORT_ROOT_POINTERS \ + LV_ROOTS \ + const char *readline_hist[8]; \ + void *mmap_region_head; \ + mp_obj_t pyb_config_main; \ + mp_obj_t pin_class_mapper; \ + mp_obj_t pin_class_map_dict; \ + mp_obj_t pyb_lpi2c_callback[5]; \ + mp_obj_t pyb_gpt_callback[3]; \ + +static inline mp_uint_t mp_hal_ticks_ms(void) { return 0; } diff --git a/ports/nxp/mphalport.c b/ports/nxp/mphalport.c new file mode 100644 index 000000000000..45a82b70ad3a --- /dev/null +++ b/ports/nxp/mphalport.c @@ -0,0 +1,10 @@ +#include "mphalport.h" +//void mp_hal_delay_ms(mp_int_t delay_ms) +//{ + +//} + +//void mp_hal_delay_us(mp_int_t delay_us) +//{ + +//} diff --git a/ports/nxp/mphalport.h b/ports/nxp/mphalport.h new file mode 100644 index 000000000000..bf249223d059 --- /dev/null +++ b/ports/nxp/mphalport.h @@ -0,0 +1,48 @@ +/* + * The MIT License (MIT) + * + * Copyright (c) 2013-2019 Damien P. George + * + * Permission is hereby granted, free of charge, to any person obtaining a copy + * of this software and associated documentation files (the "Software"), to deal + * in the Software without restriction, including without limitation the rights + * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell + * copies of the Software, and to permit persons to whom the Software is + * furnished to do so, subject to the following conditions: + * + * The above copyright notice and this permission notice shall be included in + * all copies or substantial portions of the Software. + * + * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR + * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, + * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE + * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER + * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, + * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN + * THE SOFTWARE. + */ + +static inline void mp_hal_set_interrupt_char(char c) {} + + + +// C-leave pin +#include "pin.h" +#define mp_hal_pin_obj_t const pin_obj_t* + +/* + Use nxp fsl_gpio driver realize pin read and write + */ + +#define IS_GPIO_DIRECTION(d) (((d) == kGPIO_DigitalInput) || ((d) == kGPIO_DigitalOutput)) +#define mp_hal_pin_read(p) GPIO_PinRead(p->gpio, p->pin) +#define mp_hal_pin_write(p, v) GPIO_PinWrite(p->gpio, p->pin, v) + +#define mp_hal_pin_high(p) mp_hal_pin_write(p,1) +#define mp_hal_pin_low(p) mp_hal_pin_write(p,0) + +#define mp_hal_pin_toggle(p) GPIO_PortToggle(p->gpio, (1<pin)) + + +//void mp_hal_delay_ms(mp_int_t delay_ms); +//void mp_hal_delay_us(mp_int_t delay_ms); diff --git a/ports/nxp/pin.c b/ports/nxp/pin.c new file mode 100644 index 000000000000..df5dc7900413 --- /dev/null +++ b/ports/nxp/pin.c @@ -0,0 +1,301 @@ +/* + * The MIT License (MIT) + * + * Copyright (c) 2013-2019 Damien P. George + * + * Permission is hereby granted, free of charge, to any person obtaining a copy + * of this software and associated documentation files (the "Software"), to deal + * in the Software without restriction, including without limitation the rights + * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell + * copies of the Software, and to permit persons to whom the Software is + * furnished to do so, subject to the following conditions: + * + * The above copyright notice and this permission notice shall be included in + * all copies or substantial portions of the Software. + * + * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR + * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, + * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE + * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER + * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, + * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN + * THE SOFTWARE. + */ + +#include +#include +#include + +#include "py/runtime.h" +#include "py/mphal.h" +#include "extmod/virtpin.h" +#include "pin.h" + +#include "fsl_gpio.h" + +void pin_init0(void) +{ + MP_STATE_PORT(pin_class_mapper) = mp_const_none; + MP_STATE_PORT(pin_class_map_dict) = mp_const_none; +} + + +uint32_t pin_get_direction(const pin_obj_t *pin) +{ + GPIO_Type *gpio = pin->gpio; + + return ((gpio->GDIR) & (1<<(pin->pin))); +} + +/* convert a user-supplied pin name into an ordinal pin number. */ +const pin_obj_t *pin_find(mp_obj_t user_obj) +{ + const pin_obj_t *pin_obj; + + /* If a pin was provided, then use it */ + if(mp_obj_is_type(user_obj, &pin_type)) + { + pin_obj = MP_OBJ_TO_PTR(user_obj); + return pin_obj; + } + nlr_raise(mp_obj_new_exception_msg_varg(&mp_type_ValueError, "Pin(%s) doesn't exist", mp_obj_str_get_str(user_obj))); +} + +/* + * special method __str__() + * Return a string describing the pin object + */ +STATIC void pin_print(const mp_print_t *print, mp_obj_t self_in, mp_print_kind_t kind) +{ + pin_obj_t *self = MP_OBJ_TO_PTR(self_in); + + mp_printf(print, "Pin(%q, mode=Pin).",self->name); +} + +STATIC mp_obj_t pin_obj_init_helper(const pin_obj_t *pin, size_t n_args, const mp_obj_t *args, mp_map_t *kw_args); + +/* + * special method __init__() args[0] is pin name ,args[1] is direction, args[2] is outputlogic + * args[3] is interrupt mode + */ +mp_obj_t pin_make_new(const mp_obj_type_t *type, size_t n_args, size_t n_kw, const mp_obj_t *args) +{ + mp_arg_check_num(n_args, n_kw, 1, MP_OBJ_FUN_ARGS_MAX, true); + + /* Run an argument through the mapper and return the result. */ + const pin_obj_t *pin = pin_find(args[0]); + + if(n_args > 1 || n_kw >= 0) + { + /* pin mode given, so configure this gpio */ + mp_map_t kw_args; + mp_map_init_fixed_table(&kw_args, n_kw, args+n_args); + pin_obj_init_helper(pin, n_args-1, args+1, &kw_args); + } + return MP_OBJ_FROM_PTR(pin); +} + +/* + * sepcial method __call__() + */ +STATIC mp_obj_t pin_call(mp_obj_t self_in, size_t n_args, size_t n_kw, const mp_obj_t *args) +{ + mp_arg_check_num(n_args, n_kw, 0, 1, false); + pin_obj_t *self = MP_OBJ_TO_PTR(self_in); + + if(n_args == 0) + { + return MP_OBJ_NEW_SMALL_INT(mp_hal_pin_read(self)); + } + else + { + mp_hal_pin_write(self, mp_obj_is_true(args[0])); + return mp_const_none; + } +} + +/* + * classmethod mapper([fun]) + * Get or set the pin mapper function. + */ +STATIC mp_obj_t pin_mapper(size_t n_args, const mp_obj_t *args) +{ + if(n_args>1) + { + MP_STATE_PORT(pin_class_mapper) = args[1]; + return mp_const_none; + } + return MP_STATE_PORT(pin_class_mapper); +} +STATIC MP_DEFINE_CONST_FUN_OBJ_VAR_BETWEEN(pin_mapper_fun_obj, 1, 2, pin_mapper); +STATIC MP_DEFINE_CONST_CLASSMETHOD_OBJ(pin_mapper_obj, MP_ROM_PTR(&pin_mapper_fun_obj)); + +/* + * classmethod dict([dict]) + * Get or set the pin mapper dictionary. + */ +STATIC mp_obj_t pin_map_dict(size_t n_args, const mp_obj_t *args) +{ + if(n_args > 1) + { + MP_STATE_PORT(pin_class_map_dict) = args[1]; + return mp_const_none; + } + return MP_STATE_PORT(pin_class_mapper); +} +STATIC MP_DEFINE_CONST_FUN_OBJ_VAR_BETWEEN(pin_map_dict_fun_obj, 1, 2, pin_map_dict); +STATIC MP_DEFINE_CONST_CLASSMETHOD_OBJ(pin_map_dict_obj, MP_ROM_PTR(&pin_map_dict_fun_obj)); + +/* + * pin class init helper C API + * init(direction, value=0, interruptMode=None) + */ +STATIC mp_obj_t pin_obj_init_helper(const pin_obj_t *self, size_t n_args, const mp_obj_t *pos_args, mp_map_t *kw_args) +{ + static const mp_arg_t allowed_args[] = { + { MP_QSTR_direction, MP_ARG_INT}, + { MP_QSTR_value, MP_ARG_KW_ONLY | MP_ARG_OBJ, {.u_obj = MP_OBJ_NULL} }, + { MP_QSTR_interrupt_mode, MP_ARG_REQUIRED | MP_ARG_INT }, + + }; + + /* parse args */ + mp_arg_val_t args[MP_ARRAY_SIZE(allowed_args)]; + mp_arg_parse_all(n_args, pos_args, kw_args, MP_ARRAY_SIZE(allowed_args), allowed_args, args); + + /* get pin direction */ + gpio_pin_direction_t direction = (gpio_pin_direction_t)args[0].u_int; + if (!IS_GPIO_DIRECTION(direction)) + { + nlr_raise(mp_obj_new_exception_msg_varg(&mp_type_ValueError, "invalid pin direction: %d", direction)); + } + uint8_t value = (uint8_t)args[1].u_int; + + gpio_interrupt_mode_t interrupt_mode = kGPIO_NoIntmode; + + gpio_pin_config_t config; + /* sepcifies the pin direction */ + config.direction = direction; + /* Set a default output logic */ + config.outputLogic = value; + /* specifies the pin interrupt mode */ + config.interruptMode = interrupt_mode; + GPIO_PinInit(self->gpio, self->pin, &config); + + return mp_const_none; +} + +STATIC mp_obj_t pin_obj_init(size_t n_args, const mp_obj_t *args, mp_map_t *kw_args) +{ + return pin_obj_init_helper(MP_OBJ_TO_PTR(args[0]), n_args - 1, args + 1, kw_args); +} +MP_DEFINE_CONST_FUN_OBJ_KW(pin_init_obj, 1, pin_obj_init); + +/* method pin() + * Get the pin number of the instance. + */ +STATIC mp_obj_t pin_pin(mp_obj_t self_in) +{ + pin_obj_t *self = MP_OBJ_TO_PTR(self_in); + return MP_OBJ_NEW_SMALL_INT(self->pin); +} +STATIC MP_DEFINE_CONST_FUN_OBJ_1(pin_pin_obj, pin_pin); + +/* method gpio() + * Returns the base address of the GPIO associated with this pin instance + */ +STATIC mp_obj_t pin_gpio(mp_obj_t self_in) +{ + pin_obj_t *self = MP_OBJ_TO_PTR(self_in); + return MP_OBJ_NEW_SMALL_INT((intptr_t)self->gpio); +} +STATIC MP_DEFINE_CONST_FUN_OBJ_1(pin_gpio_obj, pin_gpio); + +/* + * method value() + * Get or set the digital logic level of the pin + */ +STATIC mp_obj_t pin_value(size_t n_args, const mp_obj_t *args) +{ + return pin_call(args[0], n_args-1, 0, args+1); +} +STATIC MP_DEFINE_CONST_FUN_OBJ_VAR_BETWEEN(pin_value_obj, 1, 2, pin_value); + +/* + * method interruptMode() + * Return the special pin's interrupt mode + */ +STATIC mp_obj_t pin_interruptMode(mp_obj_t self_in) +{ + pin_obj_t *pin = MP_OBJ_TO_PTR(self_in); + return MP_OBJ_NEW_SMALL_INT(GPIO_GetPinsInterruptFlags(pin->gpio)); +} +STATIC MP_DEFINE_CONST_FUN_OBJ_1(pin_interruptMode_obj, pin_interruptMode); + +/* + * method direction() + * Return special pin's direction + */ +STATIC mp_obj_t pin_direction(mp_obj_t self_in) +{ + return MP_OBJ_NEW_SMALL_INT(pin_get_direction(MP_OBJ_TO_PTR(self_in))); +} +STATIC MP_DEFINE_CONST_FUN_OBJ_1(pin_direction_obj, pin_direction); + +/* pin class local dict table */ +STATIC const mp_rom_map_elem_t pin_locals_dict_table[] = { + + /* instance method */ + { MP_ROM_QSTR(MP_QSTR_init), MP_ROM_PTR(&pin_init_obj) }, + + { MP_ROM_QSTR(MP_QSTR_value), MP_ROM_PTR(&pin_value_obj) }, + { MP_ROM_QSTR(MP_QSTR_interrupt_mode), MP_ROM_PTR(&pin_interruptMode_obj) }, + { MP_ROM_QSTR(MP_QSTR_direction), MP_ROM_PTR(&pin_direction_obj) }, + + /* Legacy names */ + { MP_ROM_QSTR(MP_QSTR_pin), MP_ROM_PTR(&pin_pin_obj) }, + { MP_ROM_QSTR(MP_QSTR_gpio), MP_ROM_PTR(&pin_gpio_obj) }, + + { MP_ROM_QSTR(MP_QSTR_mapper), MP_ROM_PTR(&pin_mapper_obj) }, + {MP_ROM_QSTR(MP_QSTR_dict), MP_ROM_PTR(&pin_map_dict_obj)}, + +}; + +STATIC MP_DEFINE_CONST_DICT(pin_locals_dict, pin_locals_dict_table); + +STATIC mp_uint_t pin_ioctl(mp_obj_t self_in, mp_uint_t request, uintptr_t arg, int *errcode) +{ + (void)errcode; + pin_obj_t *self = MP_OBJ_TO_PTR(self_in); + + switch (request) + { + case MP_PIN_READ:{ + return mp_hal_pin_read(self); + } + case MP_PIN_WRITE:{ + mp_hal_pin_write(self, arg); + return 0; + } + } + return -1; +} + +/* Pin protocol */ +STATIC const mp_pin_p_t pin_pin_p = { + .ioctl = pin_ioctl, +}; + + +/* define class pin */ +const mp_obj_type_t pin_type = { + {&mp_type_type}, + .name = MP_QSTR_Pin, + .print = pin_print, + .make_new = pin_make_new, + .call = pin_call, + .protocol = &pin_pin_p, + .locals_dict = (mp_obj_dict_t*)&pin_locals_dict, +}; + + diff --git a/ports/nxp/pin.h b/ports/nxp/pin.h new file mode 100644 index 000000000000..2015977382db --- /dev/null +++ b/ports/nxp/pin.h @@ -0,0 +1,57 @@ +/* + * The MIT License (MIT) + * + * Copyright (c) 2013-2019 Damien P. George + * + * Permission is hereby granted, free of charge, to any person obtaining a copy + * of this software and associated documentation files (the "Software"), to deal + * in the Software without restriction, including without limitation the rights + * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell + * copies of the Software, and to permit persons to whom the Software is + * furnished to do so, subject to the following conditions: + * + * The above copyright notice and this permission notice shall be included in + * all copies or substantial portions of the Software. + * + * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR + * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, + * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE + * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER + * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, + * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN + * THE SOFTWARE. + */ + +#ifndef _PIN_H_ +#define _PIN_H_ + +// This file requires pin_defs_xxx.h (which has port specific enums and +// defines, so we include it here. It should never be included directly + +#include "py/obj.h" + +#include "fsl_common.h" + + +typedef struct { + mp_obj_base_t base; + qstr name; + uint32_t pin; + GPIO_Type *gpio; +}pin_obj_t; + +extern const mp_obj_type_t pin_type; + +#define PIN(gpio_num, pin_num,gpio_base) \ +{\ + { &pin_type }, \ + .name = MP_QSTR_GPIO ## gpio_num ## _IO ## pin_num, \ + .pin = pin_num, \ + .gpio = gpio_base, \ +} + + +void pin_init0(void); +uint32_t pin_get_direction(const pin_obj_t *pin); + +#endif \ No newline at end of file diff --git a/ports/nxp/pybi2c.c b/ports/nxp/pybi2c.c new file mode 100644 index 000000000000..29c5d0a45558 --- /dev/null +++ b/ports/nxp/pybi2c.c @@ -0,0 +1,385 @@ +/* + * The MIT License (MIT) + * + * Copyright (c) 2013-2019 Damien P. George + * + * Permission is hereby granted, free of charge, to any person obtaining a copy + * of this software and associated documentation files (the "Software"), to deal + * in the Software without restriction, including without limitation the rights + * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell + * copies of the Software, and to permit persons to whom the Software is + * furnished to do so, subject to the following conditions: + * + * The above copyright notice and this permission notice shall be included in + * all copies or substantial portions of the Software. + * + * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR + * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, + * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE + * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER + * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, + * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN + * THE SOFTWARE. + */ +#include + +#include "py/runtime.h" +#include "py/obj.h" + +#include "pybi2c.h" + +#if defined(MICROPY_PY_LPI2C) && MICROPY_PY_LPI2C +typedef union _lpi2c_config +{ + hal_i2c_master_config_t master_config; + hal_i2c_slave_config_t slave_config; +}lpi2c_config; + +typedef union _lpi2c_handle_t +{ + hal_i2c_master_handle_t master_handle; + hal_i2c_slave_handle_t slave_handle; +}lpi2c_handle_t; + +typedef struct { + mp_obj_base_t base; + lpi2c_config config; + lpi2c_handle_t handle; +}lpi2c_obj_t; + +STATIC mp_obj_t Lpi2cCallbackArgs[4]; + +STATIC void lpi2c_master_transfer_callback(hal_i2c_master_handle_t handle, hal_i2c_status_t completionStatus, void *callbackParam) +{ + assert(handle); + lpi2c_obj_t *lpi2c_obj = (lpi2c_obj_t *)callbackParam; + mp_obj_t *cb = NULL; + mp_obj_t CallbackArgs; + if(lpi2c_obj->config.master_config.enableMaster) + { + cb = &MP_STATE_PORT(pyb_lpi2c_callback)[lpi2c_obj->config.master_config.instance]; + CallbackArgs = Lpi2cCallbackArgs[lpi2c_obj->config.master_config.instance]; + } + if(*cb != mp_const_none) + { + nlr_buf_t nlr; + if(nlr_push(&nlr) == 0) + { + mp_call_function_1(*cb, CallbackArgs); + nlr_pop(); + } + } +} + +STATIC void lpi2c_slave_transfer_callback(hal_i2c_slave_handle_t handle, hal_i2c_slave_transfer_t *transfer, void *callbackParam) +{ + assert(handle); + + lpi2c_obj_t *lpi2c_obj = (lpi2c_obj_t *)callbackParam; + mp_obj_t *cb = NULL; + mp_obj_t CallbackArgs; + if(lpi2c_obj->config.slave_config.enableSlave) + { + cb = &MP_STATE_PORT(pyb_lpi2c_callback)[lpi2c_obj->config.slave_config.instance]; + CallbackArgs = Lpi2cCallbackArgs[lpi2c_obj->config.slave_config.instance]; + } + if(*cb != mp_const_none) + { + nlr_buf_t nlr; + if(nlr_push(&nlr) == 0) + { + mp_call_function_1(*cb, CallbackArgs); + nlr_pop(); + } + } +} + + +STATIC const mp_arg_t pyb_lpi2c_make_new_args[] = { + { MP_QSTR_instance, MP_ARG_REQUIRED | MP_ARG_INT, {.u_int = 0} }, + { MP_QSTR_mode, MP_ARG_REQUIRED | MP_ARG_INT, {.u_int = 0} }, + { MP_QSTR_Baudrate_Address, MP_ARG_REQUIRED|MP_ARG_INT, {.u_int = 0} }, + { MP_QSTR_srcclockHz, MP_ARG_REQUIRED|MP_ARG_INT, {.u_int = 0} }, +}; + +#define PYB_LPI2C_MAKE_NEW_NUM_ARGS MP_ARRAY_SIZE(pyb_lpi2c_make_new_args) + +/* + * construct + * param: mode = MASTER, instance = 0, + */ +STATIC mp_obj_t pyb_lpi2c_make_new(const mp_obj_type_t *type, size_t n_args, size_t n_kw, const mp_obj_t *args) +{ + mp_arg_val_t vals[PYB_LPI2C_MAKE_NEW_NUM_ARGS]; + printf("n_args is %d n_kw is %d\r\n",n_args, n_kw); + mp_arg_parse_all_kw_array(n_args, n_kw, args, PYB_LPI2C_MAKE_NEW_NUM_ARGS, pyb_lpi2c_make_new_args, vals); + + lpi2c_obj_t* self = m_new_obj(lpi2c_obj_t); + uint8_t instance = vals[0].u_int; + + self->base.type = type; + if(vals[1].u_int == MASTER) + { + self->config.master_config.enableMaster = true; + self->config.master_config.baudRate_Bps = vals[2].u_int; + self->config.master_config.srcClock_Hz = vals[3].u_int; + self->config.master_config.instance = instance; + + hal_i2c_master_handle_t master_handle = m_malloc(sizeof(hal_i2c_master_handle_t)); + self->handle.master_handle = master_handle; + } + else if(vals[1].u_int == SLAVE) + { + self->config.slave_config.enableSlave = true; + self->config.slave_config.slaveAddress = vals[2].u_int; + self->config.slave_config.srcClock_Hz = vals[3].u_int; + self->config.slave_config.instance = instance; + + hal_i2c_slave_handle_t slave_handle = m_malloc(sizeof(hal_i2c_slave_handle_t)); + self->handle.slave_handle = slave_handle; + } + + return MP_OBJ_FROM_PTR(self); +} + +STATIC mp_obj_t pyb_lpi2c_init(mp_obj_t self_in) +{ + lpi2c_obj_t* self = MP_OBJ_TO_PTR(self_in); + uint8_t i = 0; + + if(self->config.master_config.enableMaster) + { + /* master mode */ + HAL_I2cMasterInit(self->handle.master_handle, &(self->config.master_config)); + } + else if(self->config.slave_config.enableSlave) + { + /* slave mode */ + HAL_I2cSlaveInit(self->handle.slave_handle, &(self->config.slave_config)); + } + + for(i=0; i<5; i++) + { + if(MP_STATE_PORT(pyb_lpi2c_callback)[i] == mp_const_none) + continue; + MP_STATE_PORT(pyb_lpi2c_callback)[i] = mp_const_none; + } + return mp_const_none; +} +STATIC MP_DEFINE_CONST_FUN_OBJ_1(pyb_lpi2c_init_obj, pyb_lpi2c_init); + +STATIC mp_obj_t pyb_lpi2c_deinit(mp_obj_t self_in) +{ + lpi2c_obj_t *self = MP_OBJ_TO_PTR(self_in); + + if(self->config.master_config.enableMaster) + { + /* master mode */ + HAL_I2cMasterDeinit(self->handle.master_handle); + } + else if(self->config.slave_config.enableSlave) + { + /* slave mode */ + HAL_I2cSlaveDeinit(self->handle.slave_handle); + } + + return mp_const_none; +} +STATIC MP_DEFINE_CONST_FUN_OBJ_1(pyb_lpi2c_deinit_obj, pyb_lpi2c_deinit); + +STATIC mp_obj_t pyb_lpi2c_install_callback(mp_obj_t self_in, mp_obj_t callback, mp_obj_t data) +{ + lpi2c_obj_t* self = MP_OBJ_TO_PTR(self_in); + hal_i2c_status_t status = kStatus_HAL_I2cSuccess; + + if(self->config.master_config.enableMaster) + { + /* master mode */ + MP_STATE_PORT(pyb_lpi2c_callback)[self->config.master_config.instance] = callback; + Lpi2cCallbackArgs[self->config.master_config.instance] = data; + status = HAL_I2cMasterTransferInstallCallback(self->handle.master_handle, lpi2c_master_transfer_callback, self); + } + else if(self->config.slave_config.enableSlave) + { + /* slave mode */ + MP_STATE_PORT(pyb_lpi2c_callback)[self->config.slave_config.instance] = callback; + Lpi2cCallbackArgs[self->config.slave_config.instance] = data; + status = HAL_I2cSlaveTransferInstallCallback(self->handle.slave_handle, lpi2c_slave_transfer_callback, self); + } + + if(status != kStatus_HAL_I2cSuccess) + { + mp_raise_msg(&mp_type_SyntaxError,"Fail to install callback"); + } + return mp_const_none; +} + +STATIC MP_DEFINE_CONST_FUN_OBJ_3(pyb_lpi2c_install_callback_obj, pyb_lpi2c_install_callback); + +STATIC const mp_arg_t master_transfer_allow_args[] = { + { MP_QSTR_flags, MP_ARG_REQUIRED | MP_ARG_INT, {.u_int = LPI2C_TransferDefaultFlag} }, + { MP_QSTR_slaveAddress, MP_ARG_REQUIRED | MP_ARG_INT, {.u_int = 0x00U} }, + { MP_QSTR_direction, MP_ARG_REQUIRED | MP_ARG_INT, {.u_int = LPI2C_Write } }, + { MP_QSTR_subaddress, MP_ARG_REQUIRED | MP_ARG_INT, {.u_int = 0x00U} }, + { MP_QSTR_data, MP_ARG_REQUIRED | MP_ARG_OBJ, {.u_obj = MP_OBJ_NULL} }, + { MP_QSTR_data_size, MP_ARG_REQUIRED | MP_ARG_INT, {.u_int = 0} }, + { MP_QSTR_transfer_mode, MP_ARG_REQUIRED | MP_ARG_BOOL, {.u_bool = false} }, +}; + +/* + * instance method master_tansfer + * param: + * flags + * slaveAddress + * direction + * subaddress + * data + * datasize + * transfermode: + * true --> noblocking + * false --> blocking + */ +STATIC mp_obj_t pyb_lpi2c_master_transfer(size_t n_args, const mp_obj_t *pos_args, mp_map_t *kw_args) +{ + lpi2c_obj_t* self = MP_OBJ_TO_PTR(pos_args[0]); + mp_arg_val_t args[MP_ARRAY_SIZE(master_transfer_allow_args)]; + mp_arg_parse_all(n_args-1, pos_args+1, kw_args, MP_ARRAY_SIZE(master_transfer_allow_args), master_transfer_allow_args, args); + + hal_i2c_status_t status; + + if(self->config.master_config.enableMaster) + { + /* master mode */ + hal_i2c_master_transfer_t master_xfer; + master_xfer.flags = args[0].u_int; + master_xfer.slaveAddress = args[1].u_int; + master_xfer.direction = args[2].u_int; + master_xfer.subaddress = args[3].u_int; + master_xfer.data = MP_OBJ_TO_PTR(args[4].u_obj); + master_xfer.dataSize = args[5].u_int; + master_xfer.subaddressSize = 1; + + if(args[6].u_bool) + { + /* make sure the related IRQ has been enabled */ + status = HAL_I2cMasterTransferNonBlocking(self->handle.master_handle, &master_xfer); + } + else if(!args[6].u_bool) + { + status = HAL_I2cMasterTransferBlocking(self->handle.master_handle, &master_xfer); + } + } + else + { + mp_raise_msg(&mp_type_ValueError, "The selected LPI2C work on slave mode!"); + } + if (status != kStatus_HAL_I2cSuccess) + { + mp_raise_msg(&mp_type_SyntaxError, "Master Transfer Failed"); + } + return mp_const_none; +} +STATIC MP_DEFINE_CONST_FUN_OBJ_KW(pyb_lpi2c_master_transfer_obj, 7, pyb_lpi2c_master_transfer); + +STATIC const mp_arg_t slave_transfer_args[]={ + { MP_QSTR_event, MP_ARG_REQUIRED|MP_ARG_INT, {.u_int = 0x01U} }, +}; + +STATIC mp_obj_t pyb_lpi2c_slave_tranfer(size_t n_args, const mp_obj_t *pos_args, mp_map_t *kw_args) +{ + lpi2c_obj_t* self = pos_args[0]; + mp_arg_val_t args[MP_ARRAY_SIZE(slave_transfer_args)]; + mp_arg_parse_all(n_args-1, pos_args+1, kw_args, MP_ARRAY_SIZE(slave_transfer_args), slave_transfer_args, args); + + uint32_t eventMask = mp_obj_get_int(&args[0].u_int); + hal_i2c_status_t status = kStatus_HAL_I2cSuccess; + if(self->config.slave_config.enableSlave) + { + status = HAL_I2cSlaveTransferNonBlocking(self->handle.slave_handle, eventMask); + } + if(status != kStatus_HAL_I2cSuccess) + mp_raise_msg(&mp_type_SyntaxError, "Slave Transfer Failed"); + return mp_const_none; +} +STATIC MP_DEFINE_CONST_FUN_OBJ_KW(pyb_lpi2c_slave_transfer_obj, 1, pyb_lpi2c_slave_tranfer); + +STATIC mp_obj_t pyb_lpi2c_TransferGetCount(mp_obj_t self_in) +{ + lpi2c_obj_t *self = MP_OBJ_TO_PTR(self_in); + size_t count; + + hal_i2c_status_t status = kStatus_HAL_I2cSuccess; + if(self->config.master_config.enableMaster) + { + /* master mode */ + status = HAL_I2cMasterTransferGetCount(self->handle.master_handle, &count); + } + else if(self->config.slave_config.enableSlave) + { + /* slave mode */ + status = HAL_I2cSlaveTransferGetCount(self->handle.slave_handle, &count); + } + if(status != kStatus_HAL_I2cSuccess) + { + mp_raise_msg(&mp_type_SyntaxError, "Get Transfer Count Failed"); + } + return MP_OBJ_TO_PTR(count); +} +STATIC MP_DEFINE_CONST_FUN_OBJ_1(pyb_lpi2c_TransferGetCount_obj, pyb_lpi2c_TransferGetCount); + +STATIC mp_obj_t pyb_lpi2c_TransferAbort(mp_obj_t self_in) +{ + lpi2c_obj_t *self = MP_OBJ_TO_PTR(self_in); + hal_i2c_status_t status = kStatus_HAL_I2cSuccess; + if(self->config.master_config.enableMaster) + { + /* master mode */ + status = HAL_I2cMasterTransferAbort(self->handle.master_handle); + } + else if(self->config.slave_config.enableSlave) + { + /* slave mode */ + status = HAL_I2cSlaveTransferAbort(self->handle.slave_handle); + } + if(status == kStatus_HAL_I2cSuccess) + { + mp_raise_msg(&mp_type_SyntaxError, "Transfer Abort Failed."); + } + return mp_const_none; +} +STATIC MP_DEFINE_CONST_FUN_OBJ_1(pyb_lpi2c_TransferAbort_obj, pyb_lpi2c_TransferAbort); + +STATIC const mp_rom_map_elem_t pyb_lpi2c_locals_dict_table[] = { + { MP_ROM_QSTR(MP_QSTR_Init), MP_ROM_PTR(&pyb_lpi2c_init_obj) }, + { MP_ROM_QSTR(MP_QSTR_Deinit), MP_ROM_PTR(&pyb_lpi2c_deinit_obj) }, + { MP_ROM_QSTR(MP_QSTR_InstallCallback), MP_ROM_PTR(&pyb_lpi2c_install_callback_obj) }, + { MP_ROM_QSTR(MP_QSTR_MasterTransfer), MP_ROM_PTR(&pyb_lpi2c_master_transfer_obj) }, + { MP_ROM_QSTR(MP_QSTR_SlaveTransfer), MP_ROM_PTR(&pyb_lpi2c_slave_transfer_obj) }, + { MP_ROM_QSTR(MP_QSTR_TransferAbort), MP_ROM_PTR(&pyb_lpi2c_TransferAbort_obj) }, + { MP_ROM_QSTR(MP_QSTR_TransferGetCount), MP_ROM_PTR(&pyb_lpi2c_TransferGetCount_obj) }, + + // class constants + { MP_ROM_QSTR(MP_QSTR_master), MP_ROM_INT(MASTER) }, + { MP_ROM_QSTR(MP_QSTR_slave), MP_ROM_INT(SLAVE) }, + { MP_ROM_QSTR(MP_QSTR_I2cWrite), MP_ROM_INT(kHAL_I2cWrite) }, + { MP_ROM_QSTR(MP_QSTR_I2cRead), MP_ROM_INT(kHAL_I2cRead) }, + { MP_ROM_QSTR(MP_QSTR_SlaveAddressMatchEvent), MP_ROM_INT(kHAL_I2cSlaveAddressMatchEvent) }, + { MP_ROM_QSTR(MP_QSTR_SlaveTransmitEvent), MP_ROM_INT(kHAL_I2cSlaveTransmitEvent) }, + { MP_ROM_QSTR(MP_QSTR_SlaveReceiveEvent), MP_ROM_INT(kHAL_I2cSlaveReceiveEvent) }, + { MP_ROM_QSTR(MP_QSTR_SlaveTransmitAckEvent), MP_ROM_INT(kHAL_I2cSlaveTransmitAckEvent) }, + { MP_ROM_QSTR(MP_QSTR_SlaveCompletionEvent), MP_ROM_INT(kHAL_I2cSlaveCompletionEvent) }, + { MP_ROM_QSTR(MP_QSTR_SlaveStartEvent), MP_ROM_INT(kHAL_I2cSlaveStartEvent) }, + { MP_ROM_QSTR(MP_QSTR_SlaveGenaralcallEvent), MP_ROM_INT(kHAL_I2cSlaveGenaralcallEvent) }, + { MP_ROM_QSTR(MP_QSTR_SlaveAllEvent), MP_ROM_INT(kHAL_I2cSlaveAllEvents) }, +}; + +STATIC MP_DEFINE_CONST_DICT(pyb_lpi2c_dict, pyb_lpi2c_locals_dict_table); + + +const mp_obj_type_t pyb_i2c_type = { + {&mp_type_type}, + .name = MP_QSTR_LPI2C, + .make_new = pyb_lpi2c_make_new, + .locals_dict = (mp_obj_dict_t*)&pyb_lpi2c_dict, +}; +#endif /* Endif MICROPY_PY_LPI2C*/ \ No newline at end of file diff --git a/ports/nxp/pybi2c.h b/ports/nxp/pybi2c.h new file mode 100644 index 000000000000..21663072dc14 --- /dev/null +++ b/ports/nxp/pybi2c.h @@ -0,0 +1,45 @@ +/* + * The MIT License (MIT) + * + * Copyright (c) 2013-2019 Damien P. George + * + * Permission is hereby granted, free of charge, to any person obtaining a copy + * of this software and associated documentation files (the "Software"), to deal + * in the Software without restriction, including without limitation the rights + * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell + * copies of the Software, and to permit persons to whom the Software is + * furnished to do so, subject to the following conditions: + * + * The above copyright notice and this permission notice shall be included in + * all copies or substantial portions of the Software. + * + * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR + * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, + * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE + * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER + * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, + * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN + * THE SOFTWARE. + */ +#ifndef _PYBI2C_H_ +#define _PYBI2C_H_ + +#if defined(MICROPY_PY_LPI2C) && MICROPY_PY_LPI2C +#include "fsl_common.h" +#include "i2c.h" + +#define MASTER (0) +#define SLAVE (1) + +#define LPI2C_Write (0) +#define LPI2C_Read (1) + +#define LPI2C_TransferDefaultFlag (0x0U) +#define LPI2C_TransferNoStartFlag (0x1U) +#define LPI2C_TransferRepeatedStartFlag (0x2U) +#define LPI2C_TransferNoStopFlag (0x4U) + +extern const mp_obj_type_t pyb_i2c_type; +#endif /*MICROPY_PY_LPI2C*/ + +#endif \ No newline at end of file diff --git a/ports/nxp/pybpinmux.c b/ports/nxp/pybpinmux.c new file mode 100644 index 000000000000..f2173f809101 --- /dev/null +++ b/ports/nxp/pybpinmux.c @@ -0,0 +1,164 @@ +/* + * The MIT License (MIT) + * + * Copyright (c) 2013-2019 Damien P. George + * + * Permission is hereby granted, free of charge, to any person obtaining a copy + * of this software and associated documentation files (the "Software"), to deal + * in the Software without restriction, including without limitation the rights + * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell + * copies of the Software, and to permit persons to whom the Software is + * furnished to do so, subject to the following conditions: + * + * The above copyright notice and this permission notice shall be included in + * all copies or substantial portions of the Software. + * + * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR + * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, + * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE + * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER + * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, + * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN + * THE SOFTWARE. + */ +#include "stdint.h" +#include "stdio.h" + +#include "py/runtime.h" +#include "py/obj.h" +#include "fsl_iomuxc.h" +#include "pybpinmux.h" + +const mp_obj_type_t board_ports_obj_type = { + {&mp_type_type}, + .name = MP_QSTR_board_ports, + .locals_dict = (mp_obj_dict_t*)&port_board_pinmux_locals_dict, +}; + +const port_obj_t* port_find_from_dict(const mp_obj_dict_t *dict_name, mp_obj_t port_name) +{ + const mp_map_t *dict_map = &(dict_name->map); + mp_map_elem_t * elem = mp_map_lookup((mp_map_t *)dict_map, port_name, MP_MAP_LOOKUP); + if(elem != NULL && elem->value != MP_OBJ_NULL ) + { + return MP_OBJ_TO_PTR(elem->value); + } + return NULL; +} + +const port_obj_t *port_find(mp_obj_t user_obj) +{ + const port_obj_t* port_obj; + if(MP_OBJ_IS_TYPE(user_obj, &port_type)) + { + port_obj = MP_OBJ_TO_PTR(user_obj); + } + else + { + port_obj = port_find_from_dict(&port_board_pinmux_locals_dict, user_obj); + } + if(port_obj != NULL) + return port_obj; + nlr_raise(mp_obj_new_exception_msg_varg(&mp_type_ValueError, "Port(%s) doesn't exist", mp_obj_str_get_str(user_obj))); +} + + +STATIC mp_obj_t port_make_new(const mp_obj_type_t *type, size_t n_args, size_t n_kw, const mp_obj_t *args) +{ + mp_arg_check_num(n_args, n_kw, 1, 1, false); + const port_obj_t *port = port_find(args[0]); + return MP_OBJ_FROM_PTR(port); +} + +STATIC void port_print(const mp_print_t *print, mp_obj_t self_in, mp_print_kind_t kind) +{ + port_obj_t* self = MP_OBJ_TO_PTR(self_in); + + mp_printf(print, "Port:%q, Pinmux number: %d.", self->port_name, self->pinmux_num); +} + +STATIC mp_obj_t port_list_pinmux(mp_obj_t self_in) +{ + port_obj_t *self = MP_OBJ_TO_PTR(self_in); + uint8_t i = 0; + mp_obj_t pinmux_list = mp_obj_new_list(0, NULL); + const pinmux_obj_t *pinmux = self->pinmux; + + for(i=0; ipinmux_num; i++, pinmux++) + { + mp_obj_list_append(pinmux_list, MP_OBJ_FROM_PTR(pinmux)); + } + return pinmux_list; +} +STATIC MP_DEFINE_CONST_FUN_OBJ_1(list_pinmux_obj, port_list_pinmux); + + +STATIC const mp_rom_map_elem_t port_locals_dict_table[] = { + { MP_ROM_QSTR(MP_QSTR_list_pinmux), MP_ROM_PTR(&list_pinmux_obj) }, +}; +STATIC MP_DEFINE_CONST_DICT(port_locals_dict, port_locals_dict_table); + +const mp_obj_type_t port_type = { + {&mp_type_type}, + .name = MP_QSTR_Port, + .make_new = port_make_new, + .print = port_print, + .locals_dict = (mp_obj_dict_t*)&port_locals_dict, +}; + +/* pinmux class */ + +STATIC void pinmux_print(const mp_print_t *print, mp_obj_t self_in, mp_print_kind_t kind) +{ + pinmux_obj_t *self = MP_OBJ_TO_PTR(self_in); + mp_printf(print, "%q", self->pinmux_name); +} + +/* instance method set */ +STATIC mp_obj_t pinmux_set(mp_obj_t self_in, mp_obj_t args) +{ + pinmux_obj_t *self = MP_OBJ_TO_PTR(self_in); + + uint32_t inputOnfield = mp_obj_get_int(args); + IOMUXC_SetPinMux(self->muxRegister, self->muxMode, self->inputRegister, self->inputDaisy, self->configRegister, inputOnfield); + + return mp_const_none; +} +STATIC MP_DEFINE_CONST_FUN_OBJ_2(set_obj, pinmux_set); + +/* instance method config */ +STATIC mp_obj_t pinmux_config(mp_obj_t self_in, mp_obj_t args) +{ + pinmux_obj_t *self = MP_OBJ_TO_PTR(self_in); + + uint32_t configValue = mp_obj_get_int(args); + IOMUXC_SetPinConfig(self->muxRegister, self->muxMode, self->inputRegister, self->inputDaisy, self->configRegister, configValue); + + return mp_const_none; +} +STATIC MP_DEFINE_CONST_FUN_OBJ_2(config_obj, pinmux_config); + +STATIC mp_obj_t pinmux_name(mp_obj_t self_in) +{ + pinmux_obj_t *self = MP_OBJ_TO_PTR(self_in); + return MP_OBJ_NEW_QSTR(self->pinmux_name); +} +STATIC MP_DEFINE_CONST_FUN_OBJ_1(name_obj, pinmux_name); + + +STATIC const mp_rom_map_elem_t pinmux_locals_dict_table[] = { + { MP_ROM_QSTR(MP_QSTR_Set), MP_ROM_PTR(&set_obj) }, + { MP_ROM_QSTR(MP_QSTR_Config), MP_ROM_PTR(&config_obj) }, + { MP_ROM_QSTR(MP_QSTR_Name), MP_ROM_PTR(&name_obj) }, +}; + +STATIC MP_DEFINE_CONST_DICT(pinmux_dict, pinmux_locals_dict_table); + + +/* define class pinmux */ +const mp_obj_type_t pinmux_type = { + {&mp_type_type}, + .name = MP_QSTR_pinmux, + .print = pinmux_print, + .locals_dict = (mp_obj_dict_t*)&pinmux_dict, +}; diff --git a/ports/nxp/pybpinmux.h b/ports/nxp/pybpinmux.h new file mode 100644 index 000000000000..ba16c97efb9e --- /dev/null +++ b/ports/nxp/pybpinmux.h @@ -0,0 +1,51 @@ +/* + * The MIT License (MIT) + * + * Copyright (c) 2013-2019 Damien P. George + * + * Permission is hereby granted, free of charge, to any person obtaining a copy + * of this software and associated documentation files (the "Software"), to deal + * in the Software without restriction, including without limitation the rights + * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell + * copies of the Software, and to permit persons to whom the Software is + * furnished to do so, subject to the following conditions: + * + * The above copyright notice and this permission notice shall be included in + * all copies or substantial portions of the Software. + * + * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR + * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, + * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE + * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER + * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, + * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN + * THE SOFTWARE. + */ +#ifndef _PYB_PINMUX_H_ +#define _PYB_PINMUX_H_ + +typedef struct _pinmux_obj_t { + mp_obj_base_t base; + qstr pinmux_name; + const uint32_t muxRegister; + const uint32_t muxMode; + const uint32_t inputRegister; + const uint32_t inputDaisy; + const uint32_t configRegister; +}pinmux_obj_t; + +typedef struct _port_t{ + mp_obj_base_t base; + qstr port_name; + uint8_t pinmux_num; + const pinmux_obj_t *pinmux; +}port_obj_t; + +#include "port-pad.h" + +extern const mp_obj_type_t pinmux_type; +extern const mp_obj_type_t port_type; +extern const mp_obj_type_t board_ports_obj_type; + +extern const mp_obj_dict_t port_board_pinmux_locals_dict; +#endif \ No newline at end of file diff --git a/ports/nxp/qstrdefsport.h b/ports/nxp/qstrdefsport.h new file mode 100644 index 000000000000..3ba897069bf7 --- /dev/null +++ b/ports/nxp/qstrdefsport.h @@ -0,0 +1 @@ +// qstrs specific to this port diff --git a/ports/nxp/sdcard.c b/ports/nxp/sdcard.c new file mode 100644 index 000000000000..61a5c36f45ce --- /dev/null +++ b/ports/nxp/sdcard.c @@ -0,0 +1,224 @@ +/* + * The MIT License (MIT) + * + * Copyright (c) 2013-2019 Damien P. George + * + * Permission is hereby granted, free of charge, to any person obtaining a copy + * of this software and associated documentation files (the "Software"), to deal + * in the Software without restriction, including without limitation the rights + * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell + * copies of the Software, and to permit persons to whom the Software is + * furnished to do so, subject to the following conditions: + * + * The above copyright notice and this permission notice shall be included in + * all copies or substantial portions of the Software. + * + * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR + * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, + * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE + * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER + * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, + * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN + * THE SOFTWARE. + */ + +#include +#include +#include + +#include "sdcard.h" + +sd_card_t g_sd; + +static const sdmmchost_detect_card_t s_sdCardDetect = { +#ifndef BOARD_SD_DETECT_TYPE + .cdType = kSDMMCHOST_DetectCardByGpioCD, +#else + .cdType = BOARD_SD_DETECT_TYPE, +#endif + .cdTimeOut_ms = (~0U), +}; + +status_t sdcard_WaitCardInsert(void) +{ + memset(&g_sd,0,sizeof(g_sd)); + g_sd.host.base = BOARD_SD_HOST_BASEADDR; + g_sd.host.sourceClock_Hz = BOARD_SD_HOST_CLK_FREQ; + g_sd.usrParam.cd = &s_sdCardDetect; + #if defined DEMO_SDCARD_POWER_CTRL_FUNCTION_EXIST + g_sd.usrParam.pwr = &s_sdCardPwrCtrl; + #endif + /* SD host init function */ + if (SD_HostInit(&g_sd) != kStatus_Success) + { + printf("SD host init fail\r\n"); + return kStatus_Fail; + } + /* power off card */ + SD_PowerOffCard(g_sd.host.base, g_sd.usrParam.pwr); + /* wait card insert */ + if (SD_WaitCardDetectStatus(SD_HOST_BASEADDR, &s_sdCardDetect, true) == kStatus_Success) + { + + /* power on the card */ + SD_PowerOnCard(g_sd.host.base, g_sd.usrParam.pwr); + } + else + { + printf("Card detect fail.\r\n"); + + return kStatus_Fail; + } + return kStatus_Success; +} + +status_t ReadBlocks(uint8_t *dest, uint32_t block_num, uint32_t num_blocks) +{ + return SD_ReadBlocks(&g_sd, dest, block_num, num_blocks); +} + +status_t WriteBlocks(const uint8_t *buffer, uint32_t startBlock, uint32_t blockCount) +{ + return SD_WriteBlocks(&g_sd, buffer, startBlock, blockCount); +} + +bool disk_initialize(void) +{ + if(g_sd.isHostReady) + { + SD_HostReset(&(g_sd.host)); + } + else + { + return 0; + } + if(kStatus_Success != SD_CardInit(&g_sd)) + { + SD_CardDeinit(&g_sd); + memset(&g_sd, 0U, sizeof(g_sd)); + return 0; + } + return 1; +} + +/* Micropython bindings */ +const mp_obj_base_t pyb_sdcard_obj = {&pyb_sdcard_type}; + +STATIC mp_obj_t pyb_sd_make_new(const mp_obj_type_t *type, size_t n_args, size_t n_kw, const mp_obj_t *args) +{ + mp_arg_check_num(n_args, n_kw, 0, 0, false); + return MP_OBJ_FROM_PTR(&pyb_sdcard_obj); +} + +STATIC mp_obj_t sd_read(mp_obj_t self, mp_obj_t block_num) +{ + uint8_t *buffer = m_new(uint8_t, 512); + status_t ret = SD_ReadBlocks(&g_sd, buffer, mp_obj_get_int(block_num), 1); + if (ret != kStatus_Success ) + { + m_del(uint8_t,buffer, 512); + nlr_raise(mp_obj_new_exception_msg_varg(&mp_type_Exception, "sdcard_read_blocks failed [%u]", ret)); + } + return mp_obj_new_bytearray_by_ref(512, buffer); +} +STATIC MP_DEFINE_CONST_FUN_OBJ_2(sd_read_obj, sd_read); + +STATIC mp_obj_t pyb_sd_readblocks(mp_obj_t self, mp_obj_t block_num, mp_obj_t buf) +{ + mp_buffer_info_t bufinfo; + mp_get_buffer_raise(buf, &bufinfo, MP_BUFFER_WRITE); + status_t ret = SD_ReadBlocks(&g_sd, bufinfo.buf, mp_obj_get_int(block_num), bufinfo.len/512); + return mp_obj_new_bool(ret == kStatus_Success); +} +STATIC MP_DEFINE_CONST_FUN_OBJ_3(pyb_sd_readblocks_obj, pyb_sd_readblocks); + +STATIC mp_obj_t sd_write(mp_obj_t self, mp_obj_t block_num, mp_obj_t data) +{ + mp_buffer_info_t bufinfo; + mp_get_buffer_raise(data, &bufinfo, MP_BUFFER_READ); + if(bufinfo.len % 512 != 0) + { + nlr_raise(mp_obj_new_exception_msg_varg(&mp_type_ValueError, "writes must be a multiple of %d bytes", 512)); + } + status_t ret = SD_WriteBlocks(&g_sd, bufinfo.buf, mp_obj_get_int(block_num), bufinfo.len/512); + + if(ret != kStatus_Success) + { + nlr_raise(mp_obj_new_exception_msg_varg(&mp_type_Exception, "sdcard_write_blocks failed [%u]", ret)); + } + return mp_const_none; +} +STATIC MP_DEFINE_CONST_FUN_OBJ_3(sd_write_obj, sd_write); + +STATIC mp_obj_t pyb_sd_writeblocks(mp_obj_t self, mp_obj_t block_num, mp_obj_t buf) +{ + mp_buffer_info_t bufinfo; + mp_get_buffer_raise(buf, &bufinfo, MP_BUFFER_READ); + status_t ret = SD_WriteBlocks(&g_sd, bufinfo.buf, mp_obj_get_int(block_num), bufinfo.len/512); + return mp_obj_new_bool(ret == kStatus_Success); +} +STATIC MP_DEFINE_CONST_FUN_OBJ_3(pyb_sd_writeblocks_obj, pyb_sd_writeblocks); + +STATIC mp_obj_t pyb_sd_ioctl(mp_obj_t self, mp_obj_t cmd_in, mp_obj_t arg_in) +{ + mp_int_t cmd = mp_obj_get_int(cmd_in); + switch (cmd) { + case BP_IOCTL_INIT: + if (disk_initialize() != 1) { + return MP_OBJ_NEW_SMALL_INT(-1); // error + } + return MP_OBJ_NEW_SMALL_INT(0); // success + + case BP_IOCTL_DEINIT: + SD_CardDeinit(&g_sd); + return MP_OBJ_NEW_SMALL_INT(0); // success + + case BP_IOCTL_SYNC: + // nothing to do + return MP_OBJ_NEW_SMALL_INT(0); // success + + case BP_IOCTL_SEC_COUNT: + return MP_OBJ_NEW_SMALL_INT(0); + + case BP_IOCTL_SEC_SIZE: + return MP_OBJ_NEW_SMALL_INT(512); + + default: // unknown command + return MP_OBJ_NEW_SMALL_INT(-1); // error + } +} +STATIC MP_DEFINE_CONST_FUN_OBJ_3(pyb_sd_ioctl_obj, pyb_sd_ioctl); + + +STATIC const mp_rom_map_elem_t pyb_sdcard_locals_table[] = { + { MP_ROM_QSTR(MP_QSTR_read), MP_ROM_PTR(&sd_read_obj) }, + { MP_ROM_QSTR(MP_QSTR_write), MP_ROM_PTR(&sd_write_obj) }, + { MP_ROM_QSTR(MP_QSTR_readblocks), MP_ROM_PTR(&pyb_sd_readblocks_obj) }, + { MP_ROM_QSTR(MP_QSTR_writeblocks), MP_ROM_PTR(&pyb_sd_writeblocks_obj) }, + { MP_ROM_QSTR(MP_QSTR_ioctl), MP_ROM_PTR(&pyb_sd_ioctl_obj) }, +}; + +MP_DEFINE_CONST_DICT(pyb_sdcard_locals_dict, pyb_sdcard_locals_table); + +const mp_obj_type_t pyb_sdcard_type = { + { &mp_type_type }, + .name = MP_QSTR_SDCard, + .make_new = pyb_sd_make_new, + .locals_dict = (mp_obj_dict_t*)&pyb_sdcard_locals_dict, +}; + +void sdcard_init_vfs(fs_user_mount_t *vfs, int part) +{ + vfs->base.type = &mp_fat_vfs_type; + vfs->flags |= FSUSER_NATIVE | FSUSER_HAVE_IOCTL; + vfs->fatfs.drv = vfs; + vfs->fatfs.part = part; + vfs->readblocks[0] = MP_OBJ_FROM_PTR(&pyb_sd_readblocks_obj); + vfs->readblocks[1] = MP_OBJ_FROM_PTR(&pyb_sdcard_obj); + vfs->readblocks[2] = MP_OBJ_FROM_PTR(ReadBlocks); /* native version */ + vfs->writeblocks[0] = MP_OBJ_FROM_PTR(&pyb_sd_writeblocks_obj); + vfs->writeblocks[1] = MP_OBJ_FROM_PTR(&pyb_sdcard_obj); + vfs->writeblocks[2] = MP_OBJ_FROM_PTR(WriteBlocks); /* native version */ + vfs->u.ioctl[0] = MP_OBJ_FROM_PTR(&pyb_sd_ioctl_obj); + vfs->u.ioctl[1] = MP_OBJ_FROM_PTR(&pyb_sdcard_obj); +} \ No newline at end of file diff --git a/ports/nxp/sdcard.h b/ports/nxp/sdcard.h new file mode 100644 index 000000000000..4a58a25507ee --- /dev/null +++ b/ports/nxp/sdcard.h @@ -0,0 +1,50 @@ +/* + * The MIT License (MIT) + * + * Copyright (c) 2013-2019 Damien P. George + * + * Permission is hereby granted, free of charge, to any person obtaining a copy + * of this software and associated documentation files (the "Software"), to deal + * in the Software without restriction, including without limitation the rights + * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell + * copies of the Software, and to permit persons to whom the Software is + * furnished to do so, subject to the following conditions: + * + * The above copyright notice and this permission notice shall be included in + * all copies or substantial portions of the Software. + * + * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR + * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, + * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE + * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER + * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, + * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN + * THE SOFTWARE. + */ + +#ifndef _SDCARD_H_ +#define _SDCARD_H_ + + +#include "py/runtime.h" +#include "py/mphal.h" +#include "py/obj.h" +#include "py/binary.h" + +#include "lib/oofatfs/ff.h" +#include "extmod/vfs_fat.h" + +#include "fsl_sd.h" +status_t ReadBlocks(uint8_t *dest, uint32_t block_num, uint32_t num_blocks); +status_t WriteBlocks(const uint8_t *buffer, uint32_t startBlock, uint32_t blockCount); +status_t sdcard_WaitCardInsert(void); +bool disk_initialize(void); + +extern const mp_obj_type_t pyb_sdcard_type; +extern const mp_obj_base_t pyb_sdcard_obj; +extern sd_card_t g_sd; + +struct _fs_user_mount_t; +void sdcard_init_vfs(struct _fs_user_mount_t *vfs, int part); + +#endif \ No newline at end of file diff --git a/ports/nxp/uart_core.c b/ports/nxp/uart_core.c new file mode 100644 index 000000000000..46defef62833 --- /dev/null +++ b/ports/nxp/uart_core.c @@ -0,0 +1,60 @@ +/* + * The MIT License (MIT) + * + * Copyright (c) 2013-2019 Damien P. George + * + * Permission is hereby granted, free of charge, to any person obtaining a copy + * of this software and associated documentation files (the "Software"), to deal + * in the Software without restriction, including without limitation the rights + * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell + * copies of the Software, and to permit persons to whom the Software is + * furnished to do so, subject to the following conditions: + * + * The above copyright notice and this permission notice shall be included in + * all copies or substantial portions of the Software. + * + * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR + * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, + * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE + * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER + * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, + * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN + * THE SOFTWARE. + */ + +#include +#include "py/mpconfig.h" +#include "fsl_lpuart.h" + +/* + * Core UART functions to implement for a port + */ +/* Be invoked in readline function in readline.c */ +int mp_hal_stdin_rx_chr(void) { + unsigned char c; + LPUART_ReadBlocking(LPUART1, &c, 1); + return (int)c; +} + +void mp_hal_stdout_tx_strn(const char *str, mp_uint_t len) +{ + uint8_t *str_uint8=(uint8_t *)str; + LPUART_WriteBlocking(LPUART1, str_uint8, len); +} + +void mp_hal_stdout_tx_str(const char *str) +{ + mp_hal_stdout_tx_strn(str, strlen(str)); +} + +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); + } +} \ No newline at end of file