will/InfiniTime
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

Merge develop

Browse Source
This commit is contained in:
JF 2020-05-24 16:51:50 +02:00
commit 073717980f
57 changed files with 775 additions and 423 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
CMakeLists.txt
View File

@ -1,5 +1,5 @@
cmake_minimum_required(VERSION 3.10) cmake_minimum_required(VERSION 3.10)
project(pinetime VERSION 0.4.0 LANGUAGES C CXX ASM) project(pinetime VERSION 0.5.0 LANGUAGES C CXX ASM)
set(NRF_TARGET "nrf52") set(NRF_TARGET "nrf52")

12
README.md
View File

@ -27,7 +27,8 @@ I've tested this project on the actual PineTime hardware.
* Project builds and runs on the Pinetime; * Project builds and runs on the Pinetime;
* Logs available via JLink RTT; * Logs available via JLink RTT;
* SPI (DMA & IRQ based) LCD driver; * SPI (DMA & IRQ based) LCD driver;
* BLE advertising, connection and bonding; * Open source BLE stack : [NimBLE](https://github.com/apache/mynewt-nimble);
* BLE advertising and connection connection;
* BLE CTS client (retrieves the time from the connected device if it implements a CTS server); * BLE CTS client (retrieves the time from the connected device if it implements a CTS server);
* Push button to go to disable screen (and go to low power mode) / enable screen (and wake-up) and UI navigation * Push button to go to disable screen (and go to low power mode) / enable screen (and wake-up) and UI navigation
* Touch panel support; * Touch panel support;
@ -35,6 +36,7 @@ I've tested this project on the actual PineTime hardware.
* Digital watch face and 4 demo applications (spinning meter, analog gauche, push button and message box); * Digital watch face and 4 demo applications (spinning meter, analog gauche, push button and message box);
* Watchdog (automatic reset in case of firmware crash) and reset support (push and hold the button for 7 - 10s); * Watchdog (automatic reset in case of firmware crash) and reset support (push and hold the button for 7 - 10s);
* BLE Notification support (still Work-In-Progress, [companion app](https://github.com/JF002/gobbledegook) needed); * BLE Notification support (still Work-In-Progress, [companion app](https://github.com/JF002/gobbledegook) needed);
* Supported by companion app [Amazfish](https://openrepos.net/content/piggz/amazfish) (time synchronization and notifications are integrated).
* **[EXPERIMENTAL]** Firmware update (OTA) via BLE. * **[EXPERIMENTAL]** Firmware update (OTA) via BLE.
## Documentation ## Documentation
@ -79,10 +81,6 @@ See [this page](./doc/PinetimeStubWithNrf52DK.md)
- -DOPENOCD_BIN_PATH=[path to openocd] - -DOPENOCD_BIN_PATH=[path to openocd]
* Optionally, you can define MERGEHEX with the path to the ```mergehex``` tool from [NRF5X Command Line Tools](https://infocenter.nordicsemi.com/index.jsp?topic=%2Fug_nrf5x_cltools%2FUG%2Fcltools%2Fnrf5x_command_line_tools_lpage.html&cp=6_1) to be able to merge the application and softdevice into one HEX file. In this case the merged file is generated in src/pinetime-app-full.hex
- -DMERGEHEX=[Path to the mergehex executable]
JLINK JLINK
``` ```
$ mkdir build $ mkdir build
@ -203,7 +201,7 @@ $ JLinkRTTClient
- https://github.com/eliotstock/memory : display the memory usage (FLASH/RAM) using the .map file from GCC. - https://github.com/eliotstock/memory : display the memory usage (FLASH/RAM) using the .map file from GCC.
## BLE connection, bonding and time synchronization ## BLE connection and time synchronization
At runtime, BLE advertising is started. You can then use a smartphone or computer to connect and bond to your Pinetime. At runtime, BLE advertising is started. You can then use a smartphone or computer to connect and bond to your Pinetime.
As soon as a device is bonded, Pinetime will look for a **CTS** server (**C**urrent **T**ime **S**ervice) on the connected device. As soon as a device is bonded, Pinetime will look for a **CTS** server (**C**urrent **T**ime **S**ervice) on the connected device.
@ -218,7 +216,7 @@ Here is how to do it with an Android smartphone running NRFConnect:
- Select server configuration "Current Time Service" and tap OK - Select server configuration "Current Time Service" and tap OK
* Go back to the main screen and scan for BLE devices. A device called "PineTime" should appear * Go back to the main screen and scan for BLE devices. A device called "PineTime" should appear
* Tap the button "Connect" next to the PineTime device. It should connect to the PineTime and switch to a new tab. * Tap the button "Connect" next to the PineTime device. It should connect to the PineTime and switch to a new tab.
* On this tab, on the top right, there is a 3 dots button. Tap on it and select Bond. The bonding process begins, and if it is sucessful, the PineTime should update its time and display it on the screen. * If a CTS server is found, the Pinetime should update its time with the time provided by the server.
### Using Linux and bluetoothctl ### Using Linux and bluetoothctl
* Ensure that your bluetooth controller is enabled and working fine. I've tested this on a x86 Debian computer and on a RaspberryPi 3. * Ensure that your bluetooth controller is enabled and working fine. I've tested this on a x86 Debian computer and on a RaspberryPi 3.

124
cmake-nRF5x/CMake_nRF5x.cmake
View File

@ -5,10 +5,6 @@ if (NOT NRF5_SDK_PATH)
message(FATAL_ERROR "The path to the nRF5 SDK (NRF5_SDK_PATH) must be set.") message(FATAL_ERROR "The path to the nRF5 SDK (NRF5_SDK_PATH) must be set.")
endif () endif ()
#if (NOT NRFJPROG)
# message(FATAL_ERROR "The path to the nrfjprog utility (NRFJPROG) must be set.")
#endif ()
# convert toolchain path to bin path # convert toolchain path to bin path
if(DEFINED ARM_NONE_EABI_TOOLCHAIN_PATH) if(DEFINED ARM_NONE_EABI_TOOLCHAIN_PATH)
set(ARM_NONE_EABI_TOOLCHAIN_BIN_PATH ${ARM_NONE_EABI_TOOLCHAIN_PATH}/bin) set(ARM_NONE_EABI_TOOLCHAIN_BIN_PATH ${ARM_NONE_EABI_TOOLCHAIN_PATH}/bin)
@ -70,23 +66,15 @@ macro(nRF5x_setup)
endif() endif()
set(CPU_FLAGS "-mcpu=cortex-m4 -mfloat-abi=hard -mfpu=fpv4-sp-d16") set(CPU_FLAGS "-mcpu=cortex-m4 -mfloat-abi=hard -mfpu=fpv4-sp-d16")
add_definitions(-DNRF52 -DNRF52832 -DNRF52832_XXAA -DNRF52_PAN_74 -DNRF52_PAN_64 -DNRF52_PAN_12 -DNRF52_PAN_58 -DNRF52_PAN_54 -DNRF52_PAN_31 -DNRF52_PAN_51 -DNRF52_PAN_36 -DNRF52_PAN_15 -DNRF52_PAN_20 -DNRF52_PAN_55 -DBOARD_PCA10040) add_definitions(-DNRF52 -DNRF52832 -DNRF52832_XXAA -DNRF52_PAN_74 -DNRF52_PAN_64 -DNRF52_PAN_12 -DNRF52_PAN_58 -DNRF52_PAN_54 -DNRF52_PAN_31 -DNRF52_PAN_51 -DNRF52_PAN_36 -DNRF52_PAN_15 -DNRF52_PAN_20 -DNRF52_PAN_55 -DBOARD_PCA10040)
# add_definitions(-DSOFTDEVICE_PRESENT -DS132 -DSWI_DISABLE0 -DBLE_STACK_SUPPORT_REQD -DNRF_SD_BLE_API_VERSION=6)
add_definitions(-DFREERTOS) add_definitions(-DFREERTOS)
add_definitions(-DDEBUG_NRF_USER) add_definitions(-DDEBUG_NRF_USER)
# add_definitions(-D__STARTUP_CLEAR_BSS)
# add_definitions(-D__HEAP_SIZE=8192)
# add_definitions(-D__STACK_SIZE=2048)
include_directories( include_directories(
# "${NRF5_SDK_PATH}/components/softdevice/s132/headers"
# "${NRF5_SDK_PATH}/components/softdevice/s132/headers/nrf52"
"${NRF5_SDK_PATH}/components/drivers_nrf/nrf_soc_nosd" "${NRF5_SDK_PATH}/components/drivers_nrf/nrf_soc_nosd"
) )
list(APPEND SDK_SOURCE_FILES list(APPEND SDK_SOURCE_FILES
"${NRF5_SDK_PATH}/modules/nrfx/mdk/system_nrf52.c" "${NRF5_SDK_PATH}/modules/nrfx/mdk/system_nrf52.c"
"${NRF5_SDK_PATH}/modules/nrfx/mdk/gcc_startup_nrf52.S" "${NRF5_SDK_PATH}/modules/nrfx/mdk/gcc_startup_nrf52.S"
) )
# set(SOFTDEVICE_PATH "${NRF5_SDK_PATH}/components/softdevice/s132/hex/s132_nrf52_6.1.1_softdevice.hex")
endif () endif ()
set(COMMON_FLAGS "-MP -MD -mthumb -mabi=aapcs -Wall -g3 -ffunction-sections -fdata-sections -fno-strict-aliasing -fno-builtin --short-enums ${CPU_FLAGS} -Wreturn-type -Werror=return-type") set(COMMON_FLAGS "-MP -MD -mthumb -mabi=aapcs -Wall -g3 -ffunction-sections -fdata-sections -fno-strict-aliasing -fno-builtin --short-enums ${CPU_FLAGS} -Wreturn-type -Werror=return-type")
@ -243,7 +231,6 @@ macro(nRF5x_setup)
# Other external # Other external
include_directories( include_directories(
"${NRF5_SDK_PATH}/external/fprintf/" "${NRF5_SDK_PATH}/external/fprintf/"
# "${NRF5_SDK_PATH}/external/utf_converter/"
) )
list(APPEND SDK_SOURCE_FILES list(APPEND SDK_SOURCE_FILES
@ -255,103 +242,25 @@ macro(nRF5x_setup)
# LCD/GFX # LCD/GFX
include_directories( include_directories(
"${NRF5_SDK_PATH}/external/thedotfactory_fonts" "${NRF5_SDK_PATH}/external/thedotfactory_fonts"
# "${NRF5_SDK_PATH}/components/ble/ble_db_discovery"
) )
list(APPEND SDK_SOURCE_FILES
# "${NRF5_SDK_PATH}/components/ble/ble_db_discovery/ble_db_discovery.c"
# "${NRF5_SDK_PATH}/components/ble/ble_services/ble_cts_c/ble_cts_c.c"
# "${NRF5_SDK_PATH}/components/ble/ble_services/ble_ans_c/ble_ans_c.c"
# "${NRF5_SDK_PATH}/external/thedotfactory_fonts/orkney24pts.c"
)
#BLE S132
# include_directories(
# "${NRF5_SDK_PATH}/components/ble/common"
# "${NRF5_SDK_PATH}/components/ble/ble_advertising"
# "${NRF5_SDK_PATH}/components/ble/ble_services/ble_bas"
# "${NRF5_SDK_PATH}/components/ble/ble_services/ble_hrs"
# "${NRF5_SDK_PATH}/components/ble/ble_services/ble_dis"
# "${NRF5_SDK_PATH}/components/ble/nrf_ble_gatt"
# "${NRF5_SDK_PATH}/components/libraries/sensorsim"
# "${NRF5_SDK_PATH}/components/ble/peer_manager"
# "${NRF5_SDK_PATH}/components/ble/nrf_ble_qwr"
# )
LIST(APPEND SDK_SOURCE_FILES
# "${NRF5_SDK_PATH}//components/ble/common/ble_srv_common.c"
# "${NRF5_SDK_PATH}/components/ble/ble_advertising/ble_advertising.c"
# "${NRF5_SDK_PATH}/components/ble/common/ble_advdata.c"
# "${NRF5_SDK_PATH}/components/ble/ble_services/ble_bas/ble_bas.c"
# "${NRF5_SDK_PATH}/components/ble/ble_services/ble_hrs/ble_hrs.c"
# "${NRF5_SDK_PATH}/components/ble/ble_services/ble_dis/ble_dis.c"
# "${NRF5_SDK_PATH}/components/ble/nrf_ble_gatt/nrf_ble_gatt.c"
# "${NRF5_SDK_PATH}/components/libraries/sensorsim/sensorsim.c"
# "${NRF5_SDK_PATH}/components/ble/peer_manager/peer_manager.c"
# "${NRF5_SDK_PATH}/components/ble/nrf_ble_qwr/nrf_ble_qwr.c"
# "${NRF5_SDK_PATH}/components/ble/common/ble_conn_state.c"
# "${NRF5_SDK_PATH}/components/ble/peer_manager/auth_status_tracker.c"
# "${NRF5_SDK_PATH}/components/ble/peer_manager/gatt_cache_manager.c"
# "${NRF5_SDK_PATH}/components/ble/peer_manager/gatts_cache_manager.c"
# "${NRF5_SDK_PATH}/components/ble/peer_manager/id_manager.c"
# "${NRF5_SDK_PATH}/components/ble/peer_manager/peer_data_storage.c"
# "${NRF5_SDK_PATH}/components/ble/peer_manager/peer_database.c"
# "${NRF5_SDK_PATH}/components/ble/peer_manager/peer_id.c"
# "${NRF5_SDK_PATH}/components/ble/peer_manager/peer_manager.c"
# "${NRF5_SDK_PATH}/components/ble/peer_manager/peer_manager_handler.c"
# "${NRF5_SDK_PATH}/components/ble/peer_manager/pm_buffer.c"
# "${NRF5_SDK_PATH}/components/ble/peer_manager/security_dispatcher.c"
# "${NRF5_SDK_PATH}/components/ble/peer_manager/security_manager.c"
# "${NRF5_SDK_PATH}/components/ble/common/ble_conn_state.c"
# "${NRF5_SDK_PATH}/components/ble/common/ble_conn_params.c"
# "${NRF5_SDK_PATH}/components/ble/common/ble_conn_state.c"
# "${NRF5_SDK_PATH}/components/libraries/atomic_flags/nrf_atflags.c"
# "${NRF5_SDK_PATH}/components/libraries/fds/fds.c"
# "${NRF5_SDK_PATH}/components/libraries/fstorage/nrf_fstorage.c"
# "${NRF5_SDK_PATH}/components/libraries/fstorage/nrf_fstorage_sd.c"
# "${NRF5_SDK_PATH}/components/libraries/atomic_fifo/nrf_atfifo.c"
# "${NRF5_SDK_PATH}/components/softdevice/common/nrf_sdh.c"
# "${NRF5_SDK_PATH}/components/softdevice/common/nrf_sdh_ble.c"
# "${NRF5_SDK_PATH}/components/softdevice/common/nrf_sdh_freertos.c"
# "${NRF5_SDK_PATH}/components/softdevice/common/nrf_sdh_soc.c"
# "${NRF5_SDK_PATH}/components/libraries/experimental_section_vars/nrf_section_iter.c"
# "${NRF5_SDK_PATH}/components/libraries/bsp/bsp_btn_ble.c"
# "${NRF5_SDK_PATH}/components/libraries/hardfault/hardfault_implementation.c"
# "${NRF5_SDK_PATH}/components/libraries/hardfault/nrf52/handler/hardfault_handler_gcc.c"
)
LIST(APPEND SDK_SOURCE_FILES LIST(APPEND SDK_SOURCE_FILES
"${NRF5_SDK_PATH}/modules/nrfx/drivers/src/nrfx_twi.c" "${NRF5_SDK_PATH}/modules/nrfx/drivers/src/nrfx_twi.c"
) )
# adds target for erasing and flashing the board with a softdevice # adds target for erasing
if(USE_JLINK) if(USE_JLINK)
add_custom_target(FLASH_SOFTDEVICE
COMMAND ${NRFJPROG} --program ${SOFTDEVICE_PATH} -f ${NRF_TARGET} --sectorerase
COMMAND sleep 0.5s
COMMAND ${NRFJPROG} --reset -f ${NRF_TARGET}
COMMENT "flashing SoftDevice"
)
add_custom_target(FLASH_ERASE add_custom_target(FLASH_ERASE
COMMAND ${NRFJPROG} --eraseall -f ${NRF_TARGET} COMMAND ${NRFJPROG} --eraseall -f ${NRF_TARGET}
COMMENT "erasing flashing" COMMENT "erasing flashing"
) )
elseif(USE_GDB_CLIENT) elseif(USE_GDB_CLIENT)
add_custom_target(FLASH_SOFTDEVICE
COMMAND ${GDB_CLIENT_BIN_PATH} -nx --batch -ex 'target extended-remote ${GDB_CLIENT_TARGET_REMOTE}' -ex 'monitor swdp_scan' -ex 'attach 1' -ex 'load' -ex 'kill' ${SOFTDEVICE_PATH}
COMMENT "flashing SoftDevice"
)
add_custom_target(FLASH_ERASE add_custom_target(FLASH_ERASE
COMMAND ${GDB_CLIENT_BIN_PATH} -nx --batch -ex 'target extended-remote ${GDB_CLIENT_TARGET_REMOTE}' -ex 'monitor swdp_scan' -ex 'attach 1' -ex 'mon erase_mass' COMMAND ${GDB_CLIENT_BIN_PATH} -nx --batch -ex 'target extended-remote ${GDB_CLIENT_TARGET_REMOTE}' -ex 'monitor swdp_scan' -ex 'attach 1' -ex 'mon erase_mass'
COMMENT "erasing flashing" COMMENT "erasing flashing"
) )
elseif(USE_OPENOCD) elseif(USE_OPENOCD)
add_custom_target(FLASH_SOFTDEVICE add_custom_target(FLASH_ERASE
COMMAND ${OPENOCD_BIN_PATH} -c "tcl_port disabled" -c "gdb_port 3333" -c "telnet_port 4444" -f interface/stlink.cfg -c 'transport select hla_swd' -f target/nrf52.cfg -c "program \"${SOFTDEVICE_PATH}\"" -c reset -c shutdown
COMMENT "flashing SoftDevice"
)
add_custom_target(FLASH_ERASE
COMMAND ${OPENOCD_BIN_PATH} -f interface/stlink.cfg -c 'transport select hla_swd' -f target/nrf52.cfg -c init -c halt -c 'nrf5 mass_erase' -c reset -c shutdown COMMAND ${OPENOCD_BIN_PATH} -f interface/stlink.cfg -c 'transport select hla_swd' -f target/nrf52.cfg -c init -c halt -c 'nrf5 mass_erase' -c reset -c shutdown
COMMENT "erasing flashing" COMMENT "erasing flashing"
) )
@ -392,35 +301,6 @@ macro(nRF5x_addExecutable EXECUTABLE_NAME SOURCE_FILES)
COMMAND ${CMAKE_OBJCOPY} -O ihex ${EXECUTABLE_NAME}.out "${EXECUTABLE_NAME}.hex" COMMAND ${CMAKE_OBJCOPY} -O ihex ${EXECUTABLE_NAME}.out "${EXECUTABLE_NAME}.hex"
COMMENT "post build steps for ${EXECUTABLE_NAME}") COMMENT "post build steps for ${EXECUTABLE_NAME}")
if(MERGEHEX)
add_custom_command(TARGET ${EXECUTABLE_NAME}
POST_BUILD
COMMAND ${MERGEHEX} --merge ${EXECUTABLE_NAME}.hex ${NRF5_SDK_PATH}/components/softdevice/s132/hex/s132_nrf52_6.1.1_softdevice.hex --output ${EXECUTABLE_NAME}-full.hex
COMMENT "merging HEX files")
if(USE_JLINK)
add_custom_target("FLASH_MERGED_${EXECUTABLE_NAME}"
DEPENDS ${EXECUTABLE_NAME}
COMMAND ${NRFJPROG} --program ${EXECUTABLE_NAME}-full.hex -f ${NRF_TARGET} --sectorerase
COMMAND sleep 0.5s
COMMAND ${NRFJPROG} --reset -f ${NRF_TARGET}
COMMENT "flashing ${EXECUTABLE_NAME}-full.hex"
)
elseif(USE_GDB_CLIENT)
add_custom_target("FLASH_MERGED_${EXECUTABLE_NAME}"
DEPENDS ${EXECUTABLE_NAME}
COMMAND ${GDB_CLIENT_BIN_PATH} -nx --batch -ex 'target extended-remote ${GDB_CLIENT_TARGET_REMOTE}' -ex 'monitor swdp_scan' -ex 'attach 1' -ex 'load' -ex 'kill' ${EXECUTABLE_NAME}-full.hex
COMMENT "flashing ${EXECUTABLE_NAME}-full.hex"
)
elseif(USE_OPENOCD)
add_custom_target("FLASH_MERGED_${EXECUTABLE_NAME}"
DEPENDS ${EXECUTABLE_NAME}
COMMAND ${OPENOCD_BIN_PATH} -c "tcl_port disabled" -c "gdb_port 3333" -c "telnet_port 4444" -f interface/stlink.cfg -c 'transport select hla_swd' -f target/nrf52.cfg -c "program \"${EXECUTABLE_NAME}-full.hex\"" -c reset -c shutdown
COMMENT "flashing ${EXECUTABLE_NAME}-full.hex"
)
endif()
endif()
# custom target for flashing the board # custom target for flashing the board
if(USE_JLINK) if(USE_JLINK)
add_custom_target("FLASH_${EXECUTABLE_NAME}" add_custom_target("FLASH_${EXECUTABLE_NAME}"

7
doc/ble.md
View File

@ -19,9 +19,10 @@ If **CTS** is detected, it'll request the current time to the companion applicat
[List of standard BLE services](https://www.bluetooth.com/specifications/gatt/services/) [List of standard BLE services](https://www.bluetooth.com/specifications/gatt/services/)
### CTS ### CTS
[Current Time Service](https://www.bluetooth.com/wp-content/uploads/Sitecore-Media-Library/Gatt/Xml/Services/org.bluetooth.service.alert_notification.xml) [Current Time Service](https://www.bluetooth.com/wp-content/uploads/Sitecore-Media-Library/Gatt/Xml/Services/org.bluetooth.service.current_time.xml)
### ANS ### ANS
[Alert Notification Service](https://www.bluetooth.com/wp-content/uploads/Sitecore-Media-Library/Gatt/Xml/Services/org.bluetooth.service.current_time.xml) [Alert Notification Service](https://www.bluetooth.com/wp-content/uploads/Sitecore-Media-Library/Gatt/Xml/Services/org.bluetooth.service.alert_notification.xml)
![ANS sequence diagram](./ble/ans_sequence.png "ANS sequence diagram")
![ANS sequence diagram](./ble/ans_sequence.png "ANS sequence diagram")

2
src/CMakeLists.txt
View File

@ -352,6 +352,8 @@ list(APPEND SOURCE_FILES
Components/Ble/CurrentTimeClient.cpp Components/Ble/CurrentTimeClient.cpp
Components/Ble/AlertNotificationClient.cpp Components/Ble/AlertNotificationClient.cpp
Components/Ble/DfuService.cpp Components/Ble/DfuService.cpp
Components/Ble/CurrentTimeService.cpp
Components/Ble/AlertNotificationService.cpp
drivers/Cst816s.cpp drivers/Cst816s.cpp
FreeRTOS/port.c FreeRTOS/port.c
FreeRTOS/port_cmsis_systick.c FreeRTOS/port_cmsis_systick.c

73
src/Components/Ble/AlertNotificationService.cpp Normal file
View File

@ -0,0 +1,73 @@
#include <hal/nrf_rtc.h>
#include "NotificationManager.h"
#include <SystemTask/SystemTask.h>
#include "AlertNotificationService.h"
using namespace Pinetime::Controllers;
constexpr ble_uuid16_t AlertNotificationService::ansUuid;
constexpr ble_uuid16_t AlertNotificationService::ansCharUuid;
int AlertNotificationCallback(uint16_t conn_handle, uint16_t attr_handle, struct ble_gatt_access_ctxt *ctxt, void *arg) {
auto anService = static_cast<AlertNotificationService*>(arg);
return anService->OnAlert(conn_handle, attr_handle, ctxt);
}
void AlertNotificationService::Init() {
ble_gatts_count_cfg(serviceDefinition);
ble_gatts_add_svcs(serviceDefinition);
}
AlertNotificationService::AlertNotificationService ( Pinetime::System::SystemTask& systemTask, Pinetime::Controllers::NotificationManager& notificationManager ) : m_systemTask{systemTask}, m_notificationManager{notificationManager},
characteristicDefinition{
{
.uuid = (ble_uuid_t *) &ansCharUuid,
.access_cb = AlertNotificationCallback,
.arg = this,
.flags = BLE_GATT_CHR_F_WRITE
},
{
0
}
},
serviceDefinition{
{
/* Device Information Service */
.type = BLE_GATT_SVC_TYPE_PRIMARY,
.uuid = (ble_uuid_t *) &ansUuid,
.characteristics = characteristicDefinition
},
{
0
},
}
{
}
int AlertNotificationService::OnAlert(uint16_t conn_handle, uint16_t attr_handle,
struct ble_gatt_access_ctxt *ctxt) {
if (ctxt->op == BLE_GATT_ACCESS_OP_WRITE_CHR) {
size_t notifSize = OS_MBUF_PKTLEN(ctxt->om);
uint8_t data[notifSize + 1];
data[notifSize] = '\0';
os_mbuf_copydata(ctxt->om, 0, notifSize, data);
char *s = (char *) &data[3];
NRF_LOG_INFO("DATA : %s", s);
for(int i = 0; i <= notifSize; i++)
{
if(s[i] == 0x00)
{
s[i] = 0x0A;
}
}
m_notificationManager.Push(Pinetime::Controllers::NotificationManager::Categories::SimpleAlert, s, notifSize + 1);
m_systemTask.PushMessage(Pinetime::System::SystemTask::Messages::OnNewNotification);
}
return 0;
}

39
src/Components/Ble/AlertNotificationService.h Normal file
View File

@ -0,0 +1,39 @@
#pragma once
#include <cstdint>
#include <array>
#include <host/ble_gap.h>
namespace Pinetime {
namespace Controllers {
class AlertNotificationService {
public:
AlertNotificationService(Pinetime::System::SystemTask &systemTask,
Pinetime::Controllers::NotificationManager &notificationManager);
void Init();
int OnAlert(uint16_t conn_handle, uint16_t attr_handle,
struct ble_gatt_access_ctxt *ctxt);
private:
static constexpr uint16_t ansId {0x1811};
static constexpr uint16_t ansCharId {0x2a46};
static constexpr ble_uuid16_t ansUuid {
.u { .type = BLE_UUID_TYPE_16 },
.value = ansId
};
static constexpr ble_uuid16_t ansCharUuid {
.u { .type = BLE_UUID_TYPE_16 },
.value = ansCharId
};
struct ble_gatt_chr_def characteristicDefinition[2];
struct ble_gatt_svc_def serviceDefinition[2];
Pinetime::System::SystemTask &m_systemTask;
NotificationManager &m_notificationManager;
};
}
}

84
src/Components/Ble/CurrentTimeClient.cpp
View File

@ -10,64 +10,68 @@ CurrentTimeClient::CurrentTimeClient(DateTime& dateTimeController) : dateTimeCon
} }
bool CurrentTimeClient::OnDiscoveryEvent(uint16_t connectionHandle, const ble_gatt_error *error, const ble_gatt_svc *service) { void CurrentTimeClient::Init() {
if(service == nullptr && error->status == BLE_HS_EDONE) {
NRF_LOG_INFO("CTS Discovery complete");
return true;
}
if(service != nullptr && ble_uuid_cmp(((ble_uuid_t*)&ctsServiceUuid), &service->uuid.u) == 0) { }
NRF_LOG_INFO("CTS discovered : 0x%x", service->start_handle);
isDiscovered = true; bool CurrentTimeClient::OnDiscoveryEvent(uint16_t connectionHandle, const ble_gatt_error *error, const ble_gatt_svc *service) {
ctsStartHandle = service->start_handle; if(service == nullptr && error->status == BLE_HS_EDONE) {
ctsEndHandle = service->end_handle; NRF_LOG_INFO("CTS Discovery complete");
return true;
}
if(service != nullptr && ble_uuid_cmp(((ble_uuid_t*)&ctsServiceUuid), &service->uuid.u) == 0) {
NRF_LOG_INFO("CTS discovered : 0x%x", service->start_handle);
isDiscovered = true;
ctsStartHandle = service->start_handle;
ctsEndHandle = service->end_handle;
return false;
}
return false; return false;
}
return false;
} }
int CurrentTimeClient::OnCharacteristicDiscoveryEvent(uint16_t conn_handle, const ble_gatt_error *error, int CurrentTimeClient::OnCharacteristicDiscoveryEvent(uint16_t conn_handle, const ble_gatt_error *error,
const ble_gatt_chr *characteristic) { const ble_gatt_chr *characteristic) {
if(characteristic == nullptr && error->status == BLE_HS_EDONE) { if(characteristic == nullptr && error->status == BLE_HS_EDONE) {
NRF_LOG_INFO("CTS Characteristic discovery complete"); NRF_LOG_INFO("CTS Characteristic discovery complete");
return 0; return 0;
} }
if(characteristic != nullptr && ble_uuid_cmp(((ble_uuid_t*)&currentTimeCharacteristicUuid), &characteristic->uuid.u) == 0) { if(characteristic != nullptr && ble_uuid_cmp(((ble_uuid_t*)&currentTimeCharacteristicUuid), &characteristic->uuid.u) == 0) {
NRF_LOG_INFO("CTS Characteristic discovered : 0x%x", characteristic->val_handle); NRF_LOG_INFO("CTS Characteristic discovered : 0x%x", characteristic->val_handle);
currentTimeHandle = characteristic->val_handle; currentTimeHandle = characteristic->val_handle;
} }
return 0; return 0;
} }
int CurrentTimeClient::OnCurrentTimeReadResult(uint16_t conn_handle, const ble_gatt_error *error, const ble_gatt_attr *attribute) { int CurrentTimeClient::OnCurrentTimeReadResult(uint16_t conn_handle, const ble_gatt_error *error, const ble_gatt_attr *attribute) {
if(error->status == 0) { if(error->status == 0) {
// TODO check that attribute->handle equals the handle discovered in OnCharacteristicDiscoveryEvent // TODO check that attribute->handle equals the handle discovered in OnCharacteristicDiscoveryEvent
CtsData result; CtsData result;
os_mbuf_copydata(attribute->om, 0, sizeof(CtsData), &result); os_mbuf_copydata(attribute->om, 0, sizeof(CtsData), &result);
NRF_LOG_INFO("Received data: %d-%d-%d %d:%d:%d", result.year, NRF_LOG_INFO("Received data: %d-%d-%d %d:%d:%d", result.year,
result.month, result.dayofmonth, result.month, result.dayofmonth,
result.hour, result.minute, result.second); result.hour, result.minute, result.second);
dateTimeController.SetTime(result.year, result.month, result.dayofmonth, dateTimeController.SetTime(result.year, result.month, result.dayofmonth,
0, result.hour, result.minute, result.second, nrf_rtc_counter_get(portNRF_RTC_REG)); 0, result.hour, result.minute, result.second, nrf_rtc_counter_get(portNRF_RTC_REG));
} else { } else {
NRF_LOG_INFO("Error retrieving current time: %d", error->status); NRF_LOG_INFO("Error retrieving current time: %d", error->status);
} }
return 0; return 0;
} }
bool CurrentTimeClient::IsDiscovered() const { bool CurrentTimeClient::IsDiscovered() const {
return isDiscovered; return isDiscovered;
} }
uint16_t CurrentTimeClient::StartHandle() const { uint16_t CurrentTimeClient::StartHandle() const {
return ctsStartHandle; return ctsStartHandle;
} }
uint16_t CurrentTimeClient::EndHandle() const { uint16_t CurrentTimeClient::EndHandle() const {
return ctsEndHandle; return ctsEndHandle;
} }
uint16_t CurrentTimeClient::CurrentTimeHandle() const { uint16_t CurrentTimeClient::CurrentTimeHandle() const {
return currentTimeHandle; return currentTimeHandle;
} }

85
src/Components/Ble/CurrentTimeClient.h
View File

@ -5,50 +5,51 @@
#include <host/ble_gap.h> #include <host/ble_gap.h>
namespace Pinetime { namespace Pinetime {
namespace Controllers { namespace Controllers {
class CurrentTimeClient { class CurrentTimeClient {
public: public:
explicit CurrentTimeClient(DateTime& dateTimeController); explicit CurrentTimeClient(DateTime& dateTimeController);
bool OnDiscoveryEvent(uint16_t connectionHandle, const ble_gatt_error *error, const ble_gatt_svc *service); void Init();
int OnCharacteristicDiscoveryEvent(uint16_t conn_handle, const ble_gatt_error *error, bool OnDiscoveryEvent(uint16_t connectionHandle, const ble_gatt_error *error, const ble_gatt_svc *service);
const ble_gatt_chr *characteristic); int OnCharacteristicDiscoveryEvent(uint16_t conn_handle, const ble_gatt_error *error,
int OnCurrentTimeReadResult(uint16_t conn_handle, const ble_gatt_error *error, const ble_gatt_attr *attribute); const ble_gatt_chr *characteristic);
bool IsDiscovered() const; int OnCurrentTimeReadResult(uint16_t conn_handle, const ble_gatt_error *error, const ble_gatt_attr *attribute);
uint16_t StartHandle() const; bool IsDiscovered() const;
uint16_t EndHandle() const; uint16_t StartHandle() const;
uint16_t CurrentTimeHandle() const; uint16_t EndHandle() const;
static constexpr const ble_uuid16_t* Uuid() { return &CurrentTimeClient::ctsServiceUuid; } uint16_t CurrentTimeHandle() const;
static constexpr const ble_uuid16_t* CurrentTimeCharacteristicUuid() { return &CurrentTimeClient::currentTimeCharacteristicUuid; } static constexpr const ble_uuid16_t* Uuid() { return &CurrentTimeClient::ctsServiceUuid; }
private: static constexpr const ble_uuid16_t* CurrentTimeCharacteristicUuid() { return &CurrentTimeClient::currentTimeCharacteristicUuid; }
typedef struct __attribute__((packed)) { private:
uint16_t year; typedef struct __attribute__((packed)) {
uint8_t month; uint16_t year;
uint8_t dayofmonth; uint8_t month;
uint8_t hour; uint8_t dayofmonth;
uint8_t minute; uint8_t hour;
uint8_t second; uint8_t minute;
uint8_t millis; uint8_t second;
uint8_t reason; uint8_t millis;
} CtsData; uint8_t reason;
} CtsData;
static constexpr uint16_t ctsServiceId {0x1805}; static constexpr uint16_t ctsServiceId {0x1805};
static constexpr uint16_t currentTimeCharacteristicId {0x2a2b}; static constexpr uint16_t currentTimeCharacteristicId {0x2a2b};
static constexpr ble_uuid16_t ctsServiceUuid { static constexpr ble_uuid16_t ctsServiceUuid {
.u { .type = BLE_UUID_TYPE_16 }, .u { .type = BLE_UUID_TYPE_16 },
.value = ctsServiceId .value = ctsServiceId
};
static constexpr ble_uuid16_t currentTimeCharacteristicUuid {
.u { .type = BLE_UUID_TYPE_16 },
.value = currentTimeCharacteristicId
};
uint16_t currentTimeHandle;
DateTime& dateTimeController;
bool isDiscovered = false;
uint16_t ctsStartHandle;
uint16_t ctsEndHandle;
}; };
static constexpr ble_uuid16_t currentTimeCharacteristicUuid { }
.u { .type = BLE_UUID_TYPE_16 },
.value = currentTimeCharacteristicId
};
uint16_t currentTimeHandle;
DateTime& dateTimeController;
bool isDiscovered = false;
uint16_t ctsStartHandle;
uint16_t ctsEndHandle;
};
}
} }

83
src/Components/Ble/CurrentTimeService.cpp Normal file
View File

@ -0,0 +1,83 @@
#include "CurrentTimeService.h"
#include <hal/nrf_rtc.h>
using namespace Pinetime::Controllers;
constexpr ble_uuid16_t CurrentTimeService::ctsUuid;
constexpr ble_uuid16_t CurrentTimeService::ctChrUuid;
int CTSCallback(uint16_t conn_handle, uint16_t attr_handle, struct ble_gatt_access_ctxt *ctxt, void *arg) {
auto cts = static_cast<CurrentTimeService*>(arg);
return cts->OnTimeAccessed(conn_handle, attr_handle, ctxt);
}
void CurrentTimeService::Init() {
ble_gatts_count_cfg(serviceDefinition);
ble_gatts_add_svcs(serviceDefinition);
}
int CurrentTimeService::OnTimeAccessed(uint16_t conn_handle, uint16_t attr_handle,
struct ble_gatt_access_ctxt *ctxt) {
NRF_LOG_INFO("Setting time...");
if (ctxt->op == BLE_GATT_ACCESS_OP_WRITE_CHR) {
CtsData result;
os_mbuf_copydata(ctxt->om, 0, sizeof(CtsData), &result);
NRF_LOG_INFO("Received data: %d-%d-%d %d:%d:%d", result.year,
result.month, result.dayofmonth,
result.hour, result.minute, result.second);
m_dateTimeController.SetTime(result.year, result.month, result.dayofmonth,
0, result.hour, result.minute, result.second, nrf_rtc_counter_get(portNRF_RTC_REG));
} else if (ctxt->op == BLE_GATT_ACCESS_OP_READ_CHR) {
CtsData currentDateTime;
currentDateTime.year = m_dateTimeController.Year();
currentDateTime.month = static_cast<u_int8_t>(m_dateTimeController.Month());
currentDateTime.dayofmonth = m_dateTimeController.Day();
currentDateTime.hour = m_dateTimeController.Hours();
currentDateTime.minute = m_dateTimeController.Minutes();
currentDateTime.second = m_dateTimeController.Seconds();
currentDateTime.millis = 0;
int res = os_mbuf_append(ctxt->om, &currentDateTime, sizeof(CtsData));
return (res == 0) ? 0 : BLE_ATT_ERR_INSUFFICIENT_RES;
}
return 0;
}
CurrentTimeService::CurrentTimeService(DateTime &dateTimeController) : m_dateTimeController{dateTimeController},
characteristicDefinition{
{
.uuid = (ble_uuid_t *) &ctChrUuid,
.access_cb = CTSCallback,
.arg = this,
.flags = BLE_GATT_CHR_F_WRITE | BLE_GATT_CHR_F_READ
},
{
0
}
},
serviceDefinition{
{
/* Device Information Service */
.type = BLE_GATT_SVC_TYPE_PRIMARY,
.uuid = (ble_uuid_t *) &ctsUuid,
.characteristics = characteristicDefinition
},
{
0
},
}
{
}

48
src/Components/Ble/CurrentTimeService.h Normal file
View File

@ -0,0 +1,48 @@
#pragma once
#include <cstdint>
#include <array>
#include <Components/DateTime/DateTimeController.h>
#include <host/ble_gap.h>
namespace Pinetime {
namespace Controllers {
class CurrentTimeService {
public:
CurrentTimeService(DateTime &dateTimeController);
void Init();
int OnTimeAccessed(uint16_t conn_handle, uint16_t attr_handle,
struct ble_gatt_access_ctxt *ctxt);
private:
static constexpr uint16_t ctsId {0x1805};
static constexpr uint16_t ctsCharId {0x2a2b};
static constexpr ble_uuid16_t ctsUuid {
.u { .type = BLE_UUID_TYPE_16 },
.value = ctsId
};
static constexpr ble_uuid16_t ctChrUuid {
.u { .type = BLE_UUID_TYPE_16 },
.value = ctsCharId
};
struct ble_gatt_chr_def characteristicDefinition[2];
struct ble_gatt_svc_def serviceDefinition[2];
typedef struct __attribute__((packed)) {
uint16_t year;
uint8_t month;
uint8_t dayofmonth;
uint8_t hour;
uint8_t minute;
uint8_t second;
uint8_t millis;
uint8_t reason;
} CtsData;
DateTime &m_dateTimeController;
};
}
}

16
src/Components/Ble/NimbleController.cpp
View File

@ -33,7 +33,9 @@ NimbleController::NimbleController(Pinetime::System::SystemTask& systemTask,
spiNorFlash{spiNorFlash}, spiNorFlash{spiNorFlash},
dfuService{systemTask, bleController, spiNorFlash}, dfuService{systemTask, bleController, spiNorFlash},
currentTimeClient{dateTimeController}, currentTimeClient{dateTimeController},
alertNotificationClient{systemTask, notificationManager} { alertNotificationClient{systemTask, notificationManager},
anService{systemTask, notificationManager},
currentTimeService{dateTimeController} {
} }
@ -76,6 +78,11 @@ void NimbleController::Init() {
ble_svc_gatt_init(); ble_svc_gatt_init();
deviceInformationService.Init(); deviceInformationService.Init();
currentTimeClient.Init();
currentTimeService.Init();
anService.Init();
dfuService.Init(); dfuService.Init();
int res; int res;
res = ble_hs_util_ensure_addr(0); res = ble_hs_util_ensure_addr(0);
@ -131,7 +138,12 @@ void NimbleController::StartAdvertising() {
res = ble_gap_adv_start(addrType, NULL, 10000, res = ble_gap_adv_start(addrType, NULL, 10000,
&adv_params, GAPEventCallback, this); &adv_params, GAPEventCallback, this);
// ASSERT(res == 0); // ASSERT(res == 0);// TODO I've disabled these ASSERT as they sometime asserts and reset the mcu.
// For now, the advertising is restarted as soon as it ends. There may be a race condition
// that prevent the advertising from restarting reliably.
// I remove the assert to prevent this uncesseray crash, but in the long term, the management of
// the advertising should be improve (better error handling, and advertise for 3 minutes after
// the application has been woken up, for example.
} }
int OnAllSvrDisco(uint16_t conn_handle, int OnAllSvrDisco(uint16_t conn_handle,

5
src/Components/Ble/NimbleController.h
View File

@ -1,10 +1,12 @@
#pragma once #pragma once
#include <cstdint> #include <cstdint>
#include "AlertNotificationService.h"
#include "AlertNotificationClient.h" #include "AlertNotificationClient.h"
#include "DeviceInformationService.h" #include "DeviceInformationService.h"
#include "CurrentTimeClient.h" #include "CurrentTimeClient.h"
#include "DfuService.h" #include "DfuService.h"
#include "CurrentTimeService.h"
#include <host/ble_gap.h> #include <host/ble_gap.h>
namespace Pinetime { namespace Pinetime {
@ -44,7 +46,10 @@ namespace Pinetime {
DeviceInformationService deviceInformationService; DeviceInformationService deviceInformationService;
CurrentTimeClient currentTimeClient; CurrentTimeClient currentTimeClient;
AlertNotificationService anService;
AlertNotificationClient alertNotificationClient; AlertNotificationClient alertNotificationClient;
CurrentTimeService currentTimeService;
uint8_t addrType; uint8_t addrType;
uint16_t connectionHandle; uint16_t connectionHandle;

61
src/drivers/SpiMaster.cpp
View File

@ -84,6 +84,7 @@ void SpiMaster::SetupWorkaroundForFtpan58(NRF_SPIM_Type *spim, uint32_t ppi_chan
NRF_PPI->CH[ppi_channel].EEP = (uint32_t) &NRF_GPIOTE->EVENTS_IN[gpiote_channel]; NRF_PPI->CH[ppi_channel].EEP = (uint32_t) &NRF_GPIOTE->EVENTS_IN[gpiote_channel];
NRF_PPI->CH[ppi_channel].TEP = (uint32_t) &spim->TASKS_STOP; NRF_PPI->CH[ppi_channel].TEP = (uint32_t) &spim->TASKS_STOP;
NRF_PPI->CHENSET = 1U << ppi_channel; NRF_PPI->CHENSET = 1U << ppi_channel;
spiBaseAddress->EVENTS_END = 0;
// Disable IRQ // Disable IRQ
spim->INTENCLR = (1<<6); spim->INTENCLR = (1<<6);
@ -104,7 +105,6 @@ void SpiMaster::DisableWorkaroundForFtpan58(NRF_SPIM_Type *spim, uint32_t ppi_ch
void SpiMaster::OnEndEvent() { void SpiMaster::OnEndEvent() {
if(currentBufferAddr == 0) { if(currentBufferAddr == 0) {
asm("nop");
return; return;
} }
@ -119,20 +119,17 @@ void SpiMaster::OnEndEvent() {
} else { } else {
uint8_t* buffer = nullptr; uint8_t* buffer = nullptr;
size_t size = 0; size_t size = 0;
if(taskToNotify != nullptr) {
BaseType_t xHigherPriorityTaskWoken = pdFALSE;
vTaskNotifyGiveFromISR(taskToNotify, &xHigherPriorityTaskWoken);
portYIELD_FROM_ISR(xHigherPriorityTaskWoken);
}
nrf_gpio_pin_set(this->pinCsn);
currentBufferAddr = 0;
if(taskToNotify != nullptr) {
BaseType_t xHigherPriorityTaskWoken = pdFALSE; BaseType_t xHigherPriorityTaskWoken = pdFALSE;
vTaskNotifyGiveFromISR(taskToNotify, &xHigherPriorityTaskWoken); xSemaphoreGiveFromISR(mutex, &xHigherPriorityTaskWoken);
portYIELD_FROM_ISR(xHigherPriorityTaskWoken); portYIELD_FROM_ISR(xHigherPriorityTaskWoken);
}
nrf_gpio_pin_set(this->pinCsn);
currentBufferAddr = 0;
BaseType_t xHigherPriorityTaskWoken = pdFALSE;
xSemaphoreGiveFromISR(mutex, &xHigherPriorityTaskWoken);
portYIELD_FROM_ISR(xHigherPriorityTaskWoken);
} }
} }
@ -188,8 +185,6 @@ bool SpiMaster::Write(uint8_t pinCsn, const uint8_t *data, size_t size) {
if(size == 1) { if(size == 1) {
while (spiBaseAddress->EVENTS_END == 0); while (spiBaseAddress->EVENTS_END == 0);
nrf_gpio_pin_set(this->pinCsn);
currentBufferAddr = 0;
xSemaphoreGive(mutex); xSemaphoreGive(mutex);
} }
@ -197,35 +192,35 @@ bool SpiMaster::Write(uint8_t pinCsn, const uint8_t *data, size_t size) {
} }
bool SpiMaster::Read(uint8_t pinCsn, uint8_t* cmd, size_t cmdSize, uint8_t *data, size_t dataSize) { bool SpiMaster::Read(uint8_t pinCsn, uint8_t* cmd, size_t cmdSize, uint8_t *data, size_t dataSize) {
xSemaphoreTake(mutex, portMAX_DELAY); xSemaphoreTake(mutex, portMAX_DELAY);
taskToNotify = nullptr; taskToNotify = nullptr;
this->pinCsn = pinCsn; this->pinCsn = pinCsn;
DisableWorkaroundForFtpan58(spiBaseAddress, 0,0); DisableWorkaroundForFtpan58(spiBaseAddress, 0,0);
spiBaseAddress->INTENCLR = (1<<6); spiBaseAddress->INTENCLR = (1<<6);
spiBaseAddress->INTENCLR = (1<<1); spiBaseAddress->INTENCLR = (1<<1);
spiBaseAddress->INTENCLR = (1<<19); spiBaseAddress->INTENCLR = (1<<19);
nrf_gpio_pin_clear(this->pinCsn); nrf_gpio_pin_clear(this->pinCsn);
currentBufferAddr = 0; currentBufferAddr = 0;
currentBufferSize = 0; currentBufferSize = 0;
PrepareTx((uint32_t)cmd, cmdSize); PrepareTx((uint32_t)cmd, cmdSize);
spiBaseAddress->TASKS_START = 1; spiBaseAddress->TASKS_START = 1;
while (spiBaseAddress->EVENTS_END == 0); while (spiBaseAddress->EVENTS_END == 0);
PrepareRx((uint32_t)cmd, cmdSize, (uint32_t)data, dataSize); PrepareRx((uint32_t)cmd, cmdSize, (uint32_t)data, dataSize);
spiBaseAddress->TASKS_START = 1; spiBaseAddress->TASKS_START = 1;
while (spiBaseAddress->EVENTS_END == 0); while (spiBaseAddress->EVENTS_END == 0);
nrf_gpio_pin_set(this->pinCsn); nrf_gpio_pin_set(this->pinCsn);
xSemaphoreGive(mutex); xSemaphoreGive(mutex);
return true; return true;
} }

4
src/drivers/SpiMaster.h
View File

@ -8,6 +8,8 @@
#include <semphr.h> #include <semphr.h>
#include "BufferProvider.h" #include "BufferProvider.h"
#include <semphr.h>
namespace Pinetime { namespace Pinetime {
namespace Drivers { namespace Drivers {
class SpiMaster { class SpiMaster {
@ -55,11 +57,9 @@ namespace Pinetime {
SpiMaster::SpiModule spi; SpiMaster::SpiModule spi;
SpiMaster::Parameters params; SpiMaster::Parameters params;
// volatile bool busy = false;
volatile uint32_t currentBufferAddr = 0; volatile uint32_t currentBufferAddr = 0;
volatile size_t currentBufferSize = 0; volatile size_t currentBufferSize = 0;
volatile TaskHandle_t taskToNotify; volatile TaskHandle_t taskToNotify;
SemaphoreHandle_t mutex; SemaphoreHandle_t mutex;
}; };
} }

2
src/libs/lvgl/library.json
View File

@ -1,6 +1,6 @@
{ {
"name": "lvgl", "name": "lvgl",
"version": "6.1.1", "version": "v6.1.2",
"keywords": "graphics, gui, embedded, littlevgl", "keywords": "graphics, gui, embedded, littlevgl",
"description": "Graphics library to create embedded GUI with easy-to-use graphical elements, beautiful visual effects and low memory footprint. It offers anti-aliasing, opacity, and animations using only one frame buffer.", "description": "Graphics library to create embedded GUI with easy-to-use graphical elements, beautiful visual effects and low memory footprint. It offers anti-aliasing, opacity, and animations using only one frame buffer.",
"repository": "repository":

19
src/libs/lvgl/porting/lv_port_disp_template.c
View File

@ -9,7 +9,7 @@
/********************* /*********************
* INCLUDES * INCLUDES
*********************/ *********************/
#include "lv_port_disp_templ.h" #include "lv_port_disp_template.h"
/********************* /*********************
* DEFINES * DEFINES
@ -26,8 +26,9 @@ static void disp_init(void);
static void disp_flush(lv_disp_drv_t * disp_drv, const lv_area_t * area, lv_color_t * color_p); static void disp_flush(lv_disp_drv_t * disp_drv, const lv_area_t * area, lv_color_t * color_p);
#if LV_USE_GPU #if LV_USE_GPU
static void gpu_blend(lv_color_t * dest, const lv_color_t * src, uint32_t length, lv_opa_t opa); static void gpu_blend(lv_disp_drv_t * disp_drv, lv_color_t * dest, const lv_color_t * src, uint32_t length, lv_opa_t opa);
static void gpu_fill(lv_color_t * dest, uint32_t length, lv_color_t color); static void gpu_fill(lv_disp_drv_t * disp_drv, lv_color_t * dest_buf, lv_coord_t dest_width,
const lv_area_t * fill_area, lv_color_t color);
#endif #endif
/********************** /**********************
@ -112,10 +113,10 @@ void lv_port_disp_init(void)
/*Optionally add functions to access the GPU. (Only in buffered mode, LV_VDB_SIZE != 0)*/ /*Optionally add functions to access the GPU. (Only in buffered mode, LV_VDB_SIZE != 0)*/
/*Blend two color array using opacity*/ /*Blend two color array using opacity*/
disp_drv.gpu_blend = gpu_blend; disp_drv.gpu_blend_cb = gpu_blend;
/*Fill a memory array with a color*/ /*Fill a memory array with a color*/
disp_drv.gpu_fill = gpu_fill; disp_drv.gpu_fill_cb = gpu_fill;
#endif #endif
/*Finally register the driver*/ /*Finally register the driver*/
@ -151,7 +152,7 @@ static void disp_flush(lv_disp_drv_t * disp_drv, const lv_area_t * area, lv_colo
/* IMPORTANT!!! /* IMPORTANT!!!
* Inform the graphics library that you are ready with the flushing*/ * Inform the graphics library that you are ready with the flushing*/
lv_disp_flush_ready(disp); lv_disp_flush_ready(disp_drv);
} }
@ -171,11 +172,11 @@ static void gpu_blend(lv_disp_drv_t * disp_drv, lv_color_t * dest, const lv_colo
/* If your MCU has hardware accelerator (GPU) then you can use it to fill a memory with a color /* If your MCU has hardware accelerator (GPU) then you can use it to fill a memory with a color
* It can be used only in buffered mode (LV_VDB_SIZE != 0 in lv_conf.h)*/ * It can be used only in buffered mode (LV_VDB_SIZE != 0 in lv_conf.h)*/
static void gpu_fill_cb(lv_disp_drv_t * disp_drv, lv_color_t * dest_buf, lv_coord_t dest_width, static void gpu_fill(lv_disp_drv_t * disp_drv, lv_color_t * dest_buf, lv_coord_t dest_width,
const lv_area_t * fill_area, lv_color_t color); const lv_area_t * fill_area, lv_color_t color)
{ {
/*It's an example code which should be done by your GPU*/ /*It's an example code which should be done by your GPU*/
uint32_t x, y; int32_t x, y;
dest_buf += dest_width * fill_area->y1; /*Go to the first line*/ dest_buf += dest_width * fill_area->y1; /*Go to the first line*/
for(y = fill_area->y1; y < fill_area->y2; y++) { for(y = fill_area->y1; y < fill_area->y2; y++) {

38
src/libs/lvgl/porting/lv_port_fs_template.c
View File

@ -9,7 +9,7 @@
/********************* /*********************
* INCLUDES * INCLUDES
*********************/ *********************/
#include "lv_port_fs_templ.h" #include "lv_port_fs_template.h"
/********************* /*********************
* DEFINES * DEFINES
@ -85,30 +85,30 @@ void lv_port_fs_init(void)
*--------------------------------------------------*/ *--------------------------------------------------*/
/* Add a simple drive to open images */ /* Add a simple drive to open images */
lv_fs_drv_t fs_drv; /*A driver descriptor*/ lv_fs_drv_t fs_drv;
memset(&fs_drv, 0, sizeof(lv_fs_drv_t)); /*Initialization*/ lv_fs_drv_init(&fs_drv);
/*Set up fields...*/ /*Set up fields...*/
fs_drv.file_size = sizeof(file_t); fs_drv.file_size = sizeof(file_t);
fs_drv.letter = 'P'; fs_drv.letter = 'P';
fs_drv.open = fs_open; fs_drv.open_cb = fs_open;
fs_drv.close = fs_close; fs_drv.close_cb = fs_close;
fs_drv.read = fs_read; fs_drv.read_cb = fs_read;
fs_drv.write = fs_write; fs_drv.write_cb = fs_write;
fs_drv.seek = fs_seek; fs_drv.seek_cb = fs_seek;
fs_drv.tell = fs_tell; fs_drv.tell_cb = fs_tell;
fs_drv.free = fs_free; fs_drv.free_space_cb = fs_free;
fs_drv.size = fs_size; fs_drv.size_cb = fs_size;
fs_drv.remove = fs_remove; fs_drv.remove_cb = fs_remove;
fs_drv.rename = fs_rename; fs_drv.rename_cb = fs_rename;
fs_drv.trunc = fs_trunc; fs_drv.trunc_cb = fs_trunc;
fs_drv.rddir_size = sizeof(dir_t); fs_drv.rddir_size = sizeof(dir_t);
fs_drv.dir_close = fs_dir_close; fs_drv.dir_close_cb = fs_dir_close;
fs_drv.dir_open = fs_dir_open; fs_drv.dir_open_cb = fs_dir_open;
fs_drv.dir_read = fs_dir_read; fs_drv.dir_read_cb = fs_dir_read;
lv_fs_add_drv(&fs_drv); lv_fs_drv_register(&fs_drv);
} }
/********************** /**********************
@ -315,7 +315,7 @@ static lv_fs_res_t fs_rename (lv_fs_drv_t * drv, const char * oldname, const cha
* @param free_p pointer to store the free size [kB] * @param free_p pointer to store the free size [kB]
* @return LV_FS_RES_OK or any error from lv_fs_res_t enum * @return LV_FS_RES_OK or any error from lv_fs_res_t enum
*/ */
static lv_fs_res_t fs_free (uint32_t * total_p, uint32_t * free_p) static lv_fs_res_t fs_free (lv_fs_drv_t * drv, uint32_t * total_p, uint32_t * free_p)
{ {
lv_fs_res_t res = LV_FS_RES_NOT_IMP; lv_fs_res_t res = LV_FS_RES_NOT_IMP;

2
src/libs/lvgl/porting/lv_port_indev_template.c
View File

@ -9,7 +9,7 @@
/********************* /*********************
* INCLUDES * INCLUDES
*********************/ *********************/
#include "lv_port_indev_templ.h" #include "lv_port_indev_template.h"
/********************* /*********************
* DEFINES * DEFINES

8
src/libs/lvgl/scripts/Doxyfile
View File

@ -724,7 +724,7 @@ CITE_BIB_FILES =
# messages are off. # messages are off.
# The default value is: NO. # The default value is: NO.
QUIET = NO QUIET = YES
# The WARNINGS tag can be used to turn on/off the warning messages that are # The WARNINGS tag can be used to turn on/off the warning messages that are
# generated to standard error (stderr) by doxygen. If WARNINGS is set to YES # generated to standard error (stderr) by doxygen. If WARNINGS is set to YES
@ -733,14 +733,14 @@ QUIET = NO
# Tip: Turn warnings on while writing the documentation. # Tip: Turn warnings on while writing the documentation.
# The default value is: YES. # The default value is: YES.
WARNINGS = YES WARNINGS = NO
# If the WARN_IF_UNDOCUMENTED tag is set to YES then doxygen will generate # If the WARN_IF_UNDOCUMENTED tag is set to YES then doxygen will generate
# warnings for undocumented members. If EXTRACT_ALL is set to YES then this flag # warnings for undocumented members. If EXTRACT_ALL is set to YES then this flag
# will automatically be disabled. # will automatically be disabled.
# The default value is: YES. # The default value is: YES.
WARN_IF_UNDOCUMENTED = YES WARN_IF_UNDOCUMENTED = NO
# If the WARN_IF_DOC_ERROR tag is set to YES, doxygen will generate warnings for # If the WARN_IF_DOC_ERROR tag is set to YES, doxygen will generate warnings for
# potential errors in the documentation, such as not documenting some parameters # potential errors in the documentation, such as not documenting some parameters
@ -748,7 +748,7 @@ WARN_IF_UNDOCUMENTED = YES
# markup commands wrongly. # markup commands wrongly.
# The default value is: YES. # The default value is: YES.
WARN_IF_DOC_ERROR = YES WARN_IF_DOC_ERROR = NO
# This WARN_NO_PARAMDOC option can be enabled to get warnings for functions that # This WARN_NO_PARAMDOC option can be enabled to get warnings for functions that
# are documented, but have no documentation for their parameters or return # are documented, but have no documentation for their parameters or return

2
src/libs/lvgl/src/lv_core/lv_debug.h
View File

@ -49,7 +49,7 @@ void lv_debug_log_error(const char * msg, uint64_t value);
{ \ { \
if(!(expr)) { \ if(!(expr)) { \
LV_LOG_ERROR(__func__); \ LV_LOG_ERROR(__func__); \
lv_debug_log_error(msg, (uint64_t)value); \ lv_debug_log_error(msg, (uint64_t)((uintptr_t)value)); \
while(1); \ while(1); \
} \ } \
} }

79
src/libs/lvgl/src/lv_core/lv_obj.c
View File

@ -121,6 +121,20 @@ void lv_init(void)
LV_LOG_INFO("lv_init ready"); LV_LOG_INFO("lv_init ready");
} }
#if LV_ENABLE_GC || !LV_MEM_CUSTOM
void lv_deinit(void)
{
lv_gc_clear_roots();
#if LV_USE_LOG
lv_log_register_print_cb(NULL);
#endif
lv_disp_set_default(NULL);
lv_mem_deinit();
lv_initialized = false;
LV_LOG_INFO("lv_deinit done");
}
#endif
/*-------------------- /*--------------------
* Create and delete * Create and delete
*-------------------*/ *-------------------*/
@ -507,10 +521,12 @@ void lv_obj_clean(lv_obj_t * obj)
} }
/** /**
* Mark the object as invalid therefore its current position will be redrawn by 'lv_refr_task' * Mark an area of an object as invalid.
* This area will be redrawn by 'lv_refr_task'
* @param obj pointer to an object * @param obj pointer to an object
* @param area the area to redraw
*/ */
void lv_obj_invalidate(const lv_obj_t * obj) void lv_obj_invalidate_area(const lv_obj_t * obj, const lv_area_t * area)
{ {
LV_ASSERT_OBJ(obj, LV_OBJX_NAME); LV_ASSERT_OBJ(obj, LV_OBJX_NAME);
@ -521,31 +537,56 @@ void lv_obj_invalidate(const lv_obj_t * obj)
lv_disp_t * disp = lv_obj_get_disp(obj_scr); lv_disp_t * disp = lv_obj_get_disp(obj_scr);
if(obj_scr == lv_disp_get_scr_act(disp) || obj_scr == lv_disp_get_layer_top(disp) || if(obj_scr == lv_disp_get_scr_act(disp) || obj_scr == lv_disp_get_layer_top(disp) ||
obj_scr == lv_disp_get_layer_sys(disp)) { obj_scr == lv_disp_get_layer_sys(disp)) {
/*Truncate recursively to the parents*/
lv_area_t area_trunc;
lv_obj_t * par = lv_obj_get_parent(obj);
bool union_ok = true;
/*Start with the original coordinates*/
lv_coord_t ext_size = obj->ext_draw_pad;
lv_area_copy(&area_trunc, &obj->coords);
area_trunc.x1 -= ext_size;
area_trunc.y1 -= ext_size;
area_trunc.x2 += ext_size;
area_trunc.y2 += ext_size;
/*Check through all parents*/ /*Truncate the area to the object*/
lv_area_t obj_coords;
lv_coord_t ext_size = obj->ext_draw_pad;
lv_area_copy(&obj_coords, &obj->coords);
obj_coords.x1 -= ext_size;
obj_coords.y1 -= ext_size;
obj_coords.x2 += ext_size;
obj_coords.y2 += ext_size;
bool is_common;
lv_area_t area_trunc;
is_common = lv_area_intersect(&area_trunc, area, &obj_coords);
if(is_common == false) return; /*The area is not on the object*/
/*Truncate recursively to the parents*/
lv_obj_t * par = lv_obj_get_parent(obj);
while(par != NULL) { while(par != NULL) {
union_ok = lv_area_intersect(&area_trunc, &area_trunc, &par->coords); is_common = lv_area_intersect(&area_trunc, &area_trunc, &par->coords);
if(union_ok == false) break; /*If no common parts with parent break;*/ if(is_common == false) break; /*If no common parts with parent break;*/
if(lv_obj_get_hidden(par)) return; /*If the parent is hidden then the child is hidden and won't be drawn*/ if(lv_obj_get_hidden(par)) return; /*If the parent is hidden then the child is hidden and won't be drawn*/
par = lv_obj_get_parent(par); par = lv_obj_get_parent(par);
} }
if(union_ok) lv_inv_area(disp, &area_trunc); if(is_common) lv_inv_area(disp, &area_trunc);
} }
} }
/**
* Mark the object as invalid therefore its current position will be redrawn by 'lv_refr_task'
* @param obj pointer to an object
*/
void lv_obj_invalidate(const lv_obj_t * obj)
{
LV_ASSERT_OBJ(obj, LV_OBJX_NAME);
/*Truncate the area to the object*/
lv_area_t obj_coords;
lv_coord_t ext_size = obj->ext_draw_pad;
lv_area_copy(&obj_coords, &obj->coords);
obj_coords.x1 -= ext_size;
obj_coords.y1 -= ext_size;
obj_coords.x2 += ext_size;
obj_coords.y2 += ext_size;
lv_obj_invalidate_area(obj, &obj_coords);
}
/*===================== /*=====================
* Setter functions * Setter functions
*====================*/ *====================*/
@ -1458,7 +1499,9 @@ lv_res_t lv_event_send(lv_obj_t * obj, lv_event_t event, const void * data)
*/ */
lv_res_t lv_event_send_func(lv_event_cb_t event_xcb, lv_obj_t * obj, lv_event_t event, const void * data) lv_res_t lv_event_send_func(lv_event_cb_t event_xcb, lv_obj_t * obj, lv_event_t event, const void * data)
{ {
LV_ASSERT_OBJ(obj, LV_OBJX_NAME); if(obj != NULL) {
LV_ASSERT_OBJ(obj, LV_OBJX_NAME);
}
/* Build a simple linked list from the objects used in the events /* Build a simple linked list from the objects used in the events
* It's important to know if an this object was deleted by a nested event * It's important to know if an this object was deleted by a nested event

18
src/libs/lvgl/src/lv_core/lv_obj.h
View File

@ -269,6 +269,15 @@ typedef struct
*/ */
void lv_init(void); void lv_init(void);
/**
* Deinit the 'lv' library
* Currently only implemented when not using custorm allocators, or GC is enabled.
*/
#if LV_ENABLE_GC || !LV_MEM_CUSTOM
void lv_deinit(void);
#endif
/*-------------------- /*--------------------
* Create and delete * Create and delete
*-------------------*/ *-------------------*/
@ -303,6 +312,15 @@ void lv_obj_del_async(struct _lv_obj_t *obj);
*/ */
void lv_obj_clean(lv_obj_t * obj); void lv_obj_clean(lv_obj_t * obj);
/**
* Mark an area of an object as invalid.
* This area will be redrawn by 'lv_refr_task'
* @param obj pointer to an object
* @param area the area to redraw
*/
void lv_obj_invalidate_area(const lv_obj_t * obj, const lv_area_t * area);
/** /**
* Mark the object as invalid therefore its current position will be redrawn by 'lv_refr_task' * Mark the object as invalid therefore its current position will be redrawn by 'lv_refr_task'
* @param obj pointer to an object * @param obj pointer to an object

1
src/libs/lvgl/src/lv_draw/lv_draw_label.c
View File

@ -179,6 +179,7 @@ void lv_draw_label(const lv_area_t * coords, const lv_area_t * mask, const lv_st
char *bidi_txt = lv_draw_get_buf(line_end - line_start + 1); char *bidi_txt = lv_draw_get_buf(line_end - line_start + 1);
lv_bidi_process_paragraph(txt + line_start, bidi_txt, line_end - line_start, bidi_dir, NULL, 0); lv_bidi_process_paragraph(txt + line_start, bidi_txt, line_end - line_start, bidi_dir, NULL, 0);
#else #else
(void)bidi_dir;
const char *bidi_txt = txt + line_start; const char *bidi_txt = txt + line_start;
#endif #endif

2
src/libs/lvgl/src/lv_draw/lv_img_cache.c
View File

@ -85,7 +85,7 @@ lv_img_cache_entry_t * lv_img_cache_open(const void * src, const lv_style_t * st
bool match = false; bool match = false;
lv_img_src_t src_type = lv_img_src_get_type(cache[i].dec_dsc.src); lv_img_src_t src_type = lv_img_src_get_type(cache[i].dec_dsc.src);
if(src_type == LV_IMG_SRC_VARIABLE) { if(src_type == LV_IMG_SRC_VARIABLE) {
if(cache[i].dec_dsc.src == src) match = true; if(cache[i].dec_dsc.src == src && cache[i].dec_dsc.style == style) match = true;
} else if(src_type == LV_IMG_SRC_FILE) { } else if(src_type == LV_IMG_SRC_FILE) {
if(strcmp(cache[i].dec_dsc.src, src) == 0) match = true; if(strcmp(cache[i].dec_dsc.src, src) == 0) match = true;
} }

1
src/libs/lvgl/src/lv_draw/lv_img_decoder.c
View File

@ -509,6 +509,7 @@ void lv_img_decoder_built_in_close(lv_img_decoder_t * decoder, lv_img_decoder_ds
} }
#endif #endif
if(user_data->palette) lv_mem_free(user_data->palette); if(user_data->palette) lv_mem_free(user_data->palette);
if(user_data->opa) lv_mem_free(user_data->opa);
lv_mem_free(user_data); lv_mem_free(user_data);

2
src/libs/lvgl/src/lv_font/lv_font.h
View File

@ -75,7 +75,7 @@ typedef struct _lv_font_struct
/*Pointer to the font in a font pack (must have the same line height)*/ /*Pointer to the font in a font pack (must have the same line height)*/
uint8_t line_height; /**< The real line height where any text fits*/ uint8_t line_height; /**< The real line height where any text fits*/
uint8_t base_line; /**< Base line measured from the top of the line_height*/ int8_t base_line; /**< Base line measured from the top of the line_height*/
uint8_t subpx :2; /**< An element of `lv_font_subpx_t`*/ uint8_t subpx :2; /**< An element of `lv_font_subpx_t`*/
void * dsc; /**< Store implementation specific or run_time data or caching here*/ void * dsc; /**< Store implementation specific or run_time data or caching here*/
#if LV_USE_USER_DATA #if LV_USE_USER_DATA

4
src/libs/lvgl/src/lv_font/lv_font_fmt_txt.c
View File

@ -257,7 +257,7 @@ static int8_t get_kern_value(const lv_font_t * font, uint32_t gid_left, uint32_t
/*Kern classes*/ /*Kern classes*/
const lv_font_fmt_txt_kern_classes_t * kdsc = fdsc->kern_dsc; const lv_font_fmt_txt_kern_classes_t * kdsc = fdsc->kern_dsc;
uint8_t left_class = kdsc->left_class_mapping[gid_left]; uint8_t left_class = kdsc->left_class_mapping[gid_left];
uint8_t right_class = kdsc->left_class_mapping[gid_right]; uint8_t right_class = kdsc->right_class_mapping[gid_right];
/* If class = 0, kerning not exist for that glyph /* If class = 0, kerning not exist for that glyph
* else got the value form `class_pair_values` 2D array*/ * else got the value form `class_pair_values` 2D array*/
@ -475,5 +475,5 @@ static uint8_t rle_next(void)
*/ */
static int32_t unicode_list_compare(const void * ref, const void * element) static int32_t unicode_list_compare(const void * ref, const void * element)
{ {
return (*(uint16_t *)ref) - (*(uint16_t *)element); return ((int32_t)(*(uint16_t *)ref)) - ((int32_t)(*(uint16_t *)element));
} }

21
src/libs/lvgl/src/lv_font/lv_symbol_def.h
View File

@ -12,12 +12,12 @@ extern "C" {
#endif #endif
/* In the font converter use this list as range: /* In the font converter use this list as range:
61441, 61448, 61451, 61452, 61452, 61453, 61457, 61459, 61461, 61465, 61441, 61448, 61451, 61452, 61453, 61457, 61459, 61461, 61465, 61468,
61468, 61473, 61478, 61479, 61480, 61502, 61512, 61515, 61516, 61517, 61473, 61478, 61479, 61480, 61502, 61512, 61515, 61516, 61517, 61521,
61521, 61522, 61523, 61524, 61543, 61544, 61550, 61552, 61553, 61556, 61522, 61523, 61524, 61543, 61544, 61550, 61552, 61553, 61556, 61559,
61559, 61560, 61561, 61563, 61587, 61589, 61636, 61637, 61639, 61671, 61560, 61561, 61563, 61587, 61589, 61636, 61637, 61639, 61671, 61674,
61674, 61683, 61724, 61732, 61787, 61931, 62016, 62017, 62018, 62019, 61683, 61724, 61732, 61787, 61931, 62016, 62017, 62018, 62019, 62020,
62020, 62087, 62099, 62212, 62189, 62810, 63426, 63650 62087, 62099, 62212, 62189, 62810, 63426, 63650
*/ */
#define LV_SYMBOL_AUDIO "\xef\x80\x81" /*61441, 0xF001*/ #define LV_SYMBOL_AUDIO "\xef\x80\x81" /*61441, 0xF001*/
@ -93,7 +93,6 @@ enum {
_LV_STR_SYMBOL_CLOSE, _LV_STR_SYMBOL_CLOSE,
_LV_STR_SYMBOL_POWER, _LV_STR_SYMBOL_POWER,
_LV_STR_SYMBOL_SETTINGS, _LV_STR_SYMBOL_SETTINGS,
_LV_STR_SYMBOL_TRASH,
_LV_STR_SYMBOL_HOME, _LV_STR_SYMBOL_HOME,
_LV_STR_SYMBOL_DOWNLOAD, _LV_STR_SYMBOL_DOWNLOAD,
_LV_STR_SYMBOL_DRIVE, _LV_STR_SYMBOL_DRIVE,
@ -113,6 +112,8 @@ enum {
_LV_STR_SYMBOL_RIGHT, _LV_STR_SYMBOL_RIGHT,
_LV_STR_SYMBOL_PLUS, _LV_STR_SYMBOL_PLUS,
_LV_STR_SYMBOL_MINUS, _LV_STR_SYMBOL_MINUS,
_LV_STR_SYMBOL_EYE_OPEN,
_LV_STR_SYMBOL_EYE_CLOSE,
_LV_STR_SYMBOL_WARNING, _LV_STR_SYMBOL_WARNING,
_LV_STR_SYMBOL_SHUFFLE, _LV_STR_SYMBOL_SHUFFLE,
_LV_STR_SYMBOL_UP, _LV_STR_SYMBOL_UP,
@ -125,6 +126,7 @@ enum {
_LV_STR_SYMBOL_COPY, _LV_STR_SYMBOL_COPY,
_LV_STR_SYMBOL_SAVE, _LV_STR_SYMBOL_SAVE,
_LV_STR_SYMBOL_CHARGE, _LV_STR_SYMBOL_CHARGE,
_LV_STR_SYMBOL_PASTE,
_LV_STR_SYMBOL_BELL, _LV_STR_SYMBOL_BELL,
_LV_STR_SYMBOL_KEYBOARD, _LV_STR_SYMBOL_KEYBOARD,
_LV_STR_SYMBOL_GPS, _LV_STR_SYMBOL_GPS,
@ -135,7 +137,12 @@ enum {
_LV_STR_SYMBOL_BATTERY_2, _LV_STR_SYMBOL_BATTERY_2,
_LV_STR_SYMBOL_BATTERY_1, _LV_STR_SYMBOL_BATTERY_1,
_LV_STR_SYMBOL_BATTERY_EMPTY, _LV_STR_SYMBOL_BATTERY_EMPTY,
_LV_STR_SYMBOL_USB,
_LV_STR_SYMBOL_BLUETOOTH, _LV_STR_SYMBOL_BLUETOOTH,
_LV_STR_SYMBOL_TRASH,
_LV_STR_SYMBOL_BACKSPACE,
_LV_STR_SYMBOL_SD_CARD,
_LV_STR_SYMBOL_NEW_LINE,
_LV_STR_SYMBOL_DUMMY, _LV_STR_SYMBOL_DUMMY,
}; };

1
src/libs/lvgl/src/lv_hal/lv_hal_disp.c
View File

@ -127,6 +127,7 @@ lv_disp_t * lv_disp_drv_register(lv_disp_drv_t * driver)
memset(&disp->inv_area_joined, 0, sizeof(disp->inv_area_joined)); memset(&disp->inv_area_joined, 0, sizeof(disp->inv_area_joined));
memset(&disp->inv_areas, 0, sizeof(disp->inv_areas)); memset(&disp->inv_areas, 0, sizeof(disp->inv_areas));
lv_ll_init(&disp->scr_ll, sizeof(lv_obj_t)); lv_ll_init(&disp->scr_ll, sizeof(lv_obj_t));
disp->last_activity_time = 0;
if(disp_def == NULL) disp_def = disp; if(disp_def == NULL) disp_def = disp;

12
src/libs/lvgl/src/lv_misc/lv_bidi.c
View File

@ -148,9 +148,11 @@ bool lv_bidi_letter_is_neutral(uint32_t letter)
uint16_t lv_bidi_get_logical_pos(const char * str_in, char **bidi_txt, uint32_t len, lv_bidi_dir_t base_dir, uint32_t visual_pos, bool *is_rtl) uint16_t lv_bidi_get_logical_pos(const char * str_in, char **bidi_txt, uint32_t len, lv_bidi_dir_t base_dir, uint32_t visual_pos, bool *is_rtl)
{ {
uint32_t pos_conv_len = get_txt_len(str_in, len); uint32_t pos_conv_len = get_txt_len(str_in, len);
void *buf = lv_draw_get_buf(len + pos_conv_len * sizeof(uint16_t)); uint32_t txt_buf_size = len + 1;
txt_buf_size = (txt_buf_size + 3) & (~0x3);
void *buf = lv_draw_get_buf(txt_buf_size + pos_conv_len * sizeof(uint16_t));
if (bidi_txt) *bidi_txt = buf; if (bidi_txt) *bidi_txt = buf;
uint16_t *pos_conv_buf = (uint16_t*) ((char*)buf + len); uint16_t *pos_conv_buf = (uint16_t*) ((char*)buf + txt_buf_size);
lv_bidi_process_paragraph(str_in, bidi_txt? *bidi_txt: NULL, len, base_dir, pos_conv_buf, pos_conv_len); lv_bidi_process_paragraph(str_in, bidi_txt? *bidi_txt: NULL, len, base_dir, pos_conv_buf, pos_conv_len);
if (is_rtl) *is_rtl = IS_RTL_POS(pos_conv_buf[visual_pos]); if (is_rtl) *is_rtl = IS_RTL_POS(pos_conv_buf[visual_pos]);
return GET_POS(pos_conv_buf[visual_pos]); return GET_POS(pos_conv_buf[visual_pos]);
@ -159,9 +161,11 @@ uint16_t lv_bidi_get_logical_pos(const char * str_in, char **bidi_txt, uint32_t
uint16_t lv_bidi_get_visual_pos(const char * str_in, char **bidi_txt, uint16_t len, lv_bidi_dir_t base_dir, uint32_t logical_pos, bool *is_rtl) uint16_t lv_bidi_get_visual_pos(const char * str_in, char **bidi_txt, uint16_t len, lv_bidi_dir_t base_dir, uint32_t logical_pos, bool *is_rtl)
{ {
uint32_t pos_conv_len = get_txt_len(str_in, len); uint32_t pos_conv_len = get_txt_len(str_in, len);
void *buf = lv_draw_get_buf(len + pos_conv_len * sizeof(uint16_t)); uint32_t txt_buf_size = len + 1;
txt_buf_size = (txt_buf_size + 3) & (~0x3);
void *buf = lv_draw_get_buf(txt_buf_size + pos_conv_len * sizeof(uint16_t));
if (bidi_txt) *bidi_txt = buf; if (bidi_txt) *bidi_txt = buf;
uint16_t *pos_conv_buf = (uint16_t*) ((char*)buf + len); uint16_t *pos_conv_buf = (uint16_t*) ((char*)buf + txt_buf_size);
lv_bidi_process_paragraph(str_in, bidi_txt? *bidi_txt: NULL, len, base_dir, pos_conv_buf, pos_conv_len); lv_bidi_process_paragraph(str_in, bidi_txt? *bidi_txt: NULL, len, base_dir, pos_conv_buf, pos_conv_len);
for (uint16_t i = 0; i < pos_conv_len; i++){ for (uint16_t i = 0; i < pos_conv_len; i++){
if (GET_POS(pos_conv_buf[i]) == logical_pos){ if (GET_POS(pos_conv_buf[i]) == logical_pos){

25
src/libs/lvgl/src/lv_misc/lv_color.h
View File

@ -104,9 +104,9 @@ enum {
# define LV_COLOR_GET_B1(c) (c).ch.blue # define LV_COLOR_GET_B1(c) (c).ch.blue
# define LV_COLOR_GET_A1(c) 1 # define LV_COLOR_GET_A1(c) 1
# define LV_COLOR_SET_R8(c, v) (c).ch.red = (uint8_t)((v) & 0x7); # define LV_COLOR_SET_R8(c, v) (c).ch.red = (uint8_t)(v) & 0x7U;
# define LV_COLOR_SET_G8(c, v) (c).ch.green = (uint8_t)((v) & 0x7); # define LV_COLOR_SET_G8(c, v) (c).ch.green = (uint8_t)(v) & 0x7U;
# define LV_COLOR_SET_B8(c, v) (c).ch.blue = (uint8_t)((v) & 0x3); # define LV_COLOR_SET_B8(c, v) (c).ch.blue = (uint8_t)(v) & 0x3U;
# define LV_COLOR_SET_A8(c, v) do {} while(0) # define LV_COLOR_SET_A8(c, v) do {} while(0)
# define LV_COLOR_GET_R8(c) (c).ch.red # define LV_COLOR_GET_R8(c) (c).ch.red
@ -114,10 +114,10 @@ enum {
# define LV_COLOR_GET_B8(c) (c).ch.blue # define LV_COLOR_GET_B8(c) (c).ch.blue
# define LV_COLOR_GET_A8(c) 0xFF # define LV_COLOR_GET_A8(c) 0xFF
# define LV_COLOR_SET_R16(c, v) (c).ch.red = (uint8_t)(((uint8_t)(v)) & 0x1F); # define LV_COLOR_SET_R16(c, v) (c).ch.red = (uint8_t)(v) & 0x1FU;
# define LV_COLOR_SET_G16(c, v) (c).ch.green = (uint8_t)((v) & 0x3F); # define LV_COLOR_SET_G16(c, v) (c).ch.green = (uint8_t)(v) & 0x3FU;
# define LV_COLOR_SET_G16_SWAP(c, v) {(c).ch.green_h = (uint8_t)(((v) >> 3) & 0x7); (c).ch.green_l = (uint8_t)((v) & 0x7);} # define LV_COLOR_SET_G16_SWAP(c, v) {(c).ch.green_h = (uint8_t)(((v) >> 3) & 0x7); (c).ch.green_l = (uint8_t)((v) & 0x7);}
# define LV_COLOR_SET_B16(c, v) (c).ch.blue = (uint8_t)((v) & 0x1F); # define LV_COLOR_SET_B16(c, v) (c).ch.blue = (uint8_t)(v) & 0x1FU;
# define LV_COLOR_SET_A16(c, v) do {} while(0) # define LV_COLOR_SET_A16(c, v) do {} while(0)
# define LV_COLOR_GET_R16(c) (c).ch.red # define LV_COLOR_GET_R16(c) (c).ch.red
@ -344,7 +344,6 @@ static inline uint8_t lv_color_to8(lv_color_t color)
static inline uint16_t lv_color_to16(lv_color_t color) static inline uint16_t lv_color_to16(lv_color_t color)
{ {
#if LV_COLOR_DEPTH == 1 #if LV_COLOR_DEPTH == 1
if(color.full == 0) if(color.full == 0)
return 0; return 0;
@ -373,9 +372,7 @@ static inline uint16_t lv_color_to16(lv_color_t color)
#endif #endif
LV_COLOR_SET_B16(ret, LV_COLOR_GET_B(color) >> 3); /* 8 - 5 = 3*/ LV_COLOR_SET_B16(ret, LV_COLOR_GET_B(color) >> 3); /* 8 - 5 = 3*/
return ret.full; return ret.full;
#endif #endif
return 0;
} }
static inline uint32_t lv_color_to32(lv_color_t color) static inline uint32_t lv_color_to32(lv_color_t color)
@ -464,14 +461,14 @@ static inline uint8_t lv_color_brightness(lv_color_t color)
/* The most simple macro to create a color from R,G and B values */ /* The most simple macro to create a color from R,G and B values */
#if LV_COLOR_DEPTH == 1 #if LV_COLOR_DEPTH == 1
#define LV_COLOR_MAKE(r8, g8, b8) ((lv_color_t){.full = (b8 >> 7 | g8 >> 7 | r8 >> 7)}) #define LV_COLOR_MAKE(r8, g8, b8) ((lv_color_t){.full = (uint8_t)((b8 >> 7) | (g8 >> 7) | (r8 >> 7))})
#elif LV_COLOR_DEPTH == 8 #elif LV_COLOR_DEPTH == 8
#define LV_COLOR_MAKE(r8, g8, b8) ((lv_color_t){{b8 >> 6, g8 >> 5, r8 >> 5}}) #define LV_COLOR_MAKE(r8, g8, b8) ((lv_color_t){{(uint8_t)((b8 >> 6) & 0x3U), (uint8_t)((g8 >> 5) & 0x7U), (uint8_t)((r8 >> 5) & 0x7U)}})
#elif LV_COLOR_DEPTH == 16 #elif LV_COLOR_DEPTH == 16
#if LV_COLOR_16_SWAP == 0 #if LV_COLOR_16_SWAP == 0
#define LV_COLOR_MAKE(r8, g8, b8) ((lv_color_t){{b8 >> 3, g8 >> 2, r8 >> 3}}) #define LV_COLOR_MAKE(r8, g8, b8) ((lv_color_t){{(uint16_t)((b8 >> 3) & 0x1FU), (uint16_t)((g8 >> 2) & 0x3FU), (uint16_t)((r8 >> 3) & 0x1FU)}})
#else #else
#define LV_COLOR_MAKE(r8, g8, b8) ((lv_color_t){{g8 >> 5, r8 >> 3, b8 >> 3, (g8 >> 2) & 0x7}}) #define LV_COLOR_MAKE(r8, g8, b8) ((lv_color_t){{(uint16_t)((g8 >> 5) & 0x7U), (uint16_t)((r8 >> 3) & 0x1FU), (uint16_t)((b8 >> 3) & 0x1FU), (uint16_t)((g8 >> 2) & 0x7U)}})
#endif #endif
#elif LV_COLOR_DEPTH == 32 #elif LV_COLOR_DEPTH == 32
#define LV_COLOR_MAKE(r8, g8, b8) ((lv_color_t){{b8, g8, r8, 0xff}}) /*Fix 0xff alpha*/ #define LV_COLOR_MAKE(r8, g8, b8) ((lv_color_t){{b8, g8, r8, 0xff}}) /*Fix 0xff alpha*/

11
src/libs/lvgl/src/lv_misc/lv_gc.c
View File

@ -8,6 +8,11 @@
*********************/ *********************/
#include "lv_gc.h" #include "lv_gc.h"
#include "string.h"
#if defined(LV_GC_INCLUDE)
#include LV_GC_INCLUDE
#endif /* LV_ENABLE_GC */
/********************* /*********************
* DEFINES * DEFINES
@ -35,6 +40,12 @@ LV_ROOTS
* GLOBAL FUNCTIONS * GLOBAL FUNCTIONS
**********************/ **********************/
void lv_gc_clear_roots(void)
{
#define LV_CLEAR_ROOT(root_type, root_name) memset(&LV_GC_ROOT(root_name), 0, sizeof(LV_GC_ROOT(root_name)));
LV_ITERATE_ROOTS(LV_CLEAR_ROOT)
}
/********************** /**********************
* STATIC FUNCTIONS * STATIC FUNCTIONS
**********************/ **********************/

33
src/libs/lvgl/src/lv_misc/lv_gc.h
View File

@ -30,21 +30,21 @@ extern "C" {
* DEFINES * DEFINES
*********************/ *********************/
#define LV_GC_ROOTS(prefix) \ #define LV_ITERATE_ROOTS(f) \
prefix lv_ll_t _lv_task_ll; /*Linked list to store the lv_tasks*/ \ f(lv_ll_t, _lv_task_ll) /*Linked list to store the lv_tasks*/ \
prefix lv_ll_t _lv_disp_ll; /*Linked list of screens*/ \ f(lv_ll_t, _lv_disp_ll) /*Linked list of screens*/ \
prefix lv_ll_t _lv_indev_ll; /*Linked list of screens*/ \ f(lv_ll_t, _lv_indev_ll) /*Linked list of screens*/ \
prefix lv_ll_t _lv_drv_ll; \ f(lv_ll_t, _lv_drv_ll) \
prefix lv_ll_t _lv_file_ll; \ f(lv_ll_t, _lv_file_ll) \
prefix lv_ll_t _lv_anim_ll; \ f(lv_ll_t, _lv_anim_ll) \
prefix lv_ll_t _lv_group_ll; \ f(lv_ll_t, _lv_group_ll) \
prefix lv_ll_t _lv_img_defoder_ll; \ f(lv_ll_t, _lv_img_defoder_ll) \
prefix lv_img_cache_entry_t * _lv_img_cache_array; \ f(lv_img_cache_entry_t*, _lv_img_cache_array) \
prefix void * _lv_task_act; \ f(void*, _lv_task_act) \
prefix void * _lv_draw_buf; f(void*, _lv_draw_buf)
#define LV_NO_PREFIX #define LV_DEFINE_ROOT(root_type, root_name) root_type root_name;
#define LV_ROOTS LV_GC_ROOTS(LV_NO_PREFIX) #define LV_ROOTS LV_ITERATE_ROOTS(LV_DEFINE_ROOT)
#if LV_ENABLE_GC == 1 #if LV_ENABLE_GC == 1
#if LV_MEM_CUSTOM != 1 #if LV_MEM_CUSTOM != 1
@ -52,7 +52,8 @@ extern "C" {
#endif /* LV_MEM_CUSTOM */ #endif /* LV_MEM_CUSTOM */
#else /* LV_ENABLE_GC */ #else /* LV_ENABLE_GC */
#define LV_GC_ROOT(x) x #define LV_GC_ROOT(x) x
LV_GC_ROOTS(extern) #define LV_EXTERN_ROOT(root_type, root_name) extern root_type root_name;
LV_ITERATE_ROOTS(LV_EXTERN_ROOT)
#endif /* LV_ENABLE_GC */ #endif /* LV_ENABLE_GC */
/********************** /**********************
@ -63,6 +64,8 @@ LV_GC_ROOTS(extern)
* GLOBAL PROTOTYPES * GLOBAL PROTOTYPES
**********************/ **********************/
void lv_gc_clear_roots(void);
/********************** /**********************
* MACROS * MACROS
**********************/ **********************/

5
src/libs/lvgl/src/lv_misc/lv_math.h
View File

@ -22,6 +22,11 @@ extern "C" {
#define LV_MATH_MAX(a, b) ((a) > (b) ? (a) : (b)) #define LV_MATH_MAX(a, b) ((a) > (b) ? (a) : (b))
#define LV_MATH_ABS(x) ((x) > 0 ? (x) : (-(x))) #define LV_MATH_ABS(x) ((x) > 0 ? (x) : (-(x)))
#define LV_IS_SIGNED(t) (((t)(-1)) < ((t) 0))
#define LV_UMAX_OF(t) (((0x1ULL << ((sizeof(t) * 8ULL) - 1ULL)) - 1ULL) | (0xFULL << ((sizeof(t) * 8ULL) - 4ULL)))
#define LV_SMAX_OF(t) (((0x1ULL << ((sizeof(t) * 8ULL) - 1ULL)) - 1ULL) | (0x7ULL << ((sizeof(t) * 8ULL) - 4ULL)))
#define LV_MAX_OF(t) ((unsigned long) (LV_IS_SIGNED(t) ? LV_SMAX_OF(t) : LV_UMAX_OF(t)))
#define LV_TRIGO_SIN_MAX 32767 #define LV_TRIGO_SIN_MAX 32767
#define LV_TRIGO_SHIFT 15 /**< >> LV_TRIGO_SHIFT to normalize*/ #define LV_TRIGO_SHIFT 15 /**< >> LV_TRIGO_SHIFT to normalize*/

27
src/libs/lvgl/src/lv_misc/lv_mem.c
View File

@ -23,7 +23,7 @@
#define LV_MEM_ADD_JUNK 0 #define LV_MEM_ADD_JUNK 0
#endif #endif
#ifdef LV_MEM_ENV64 #ifdef LV_ARCH_64
#define MEM_UNIT uint64_t #define MEM_UNIT uint64_t
#else #else
#define MEM_UNIT uint32_t #define MEM_UNIT uint32_t
@ -102,6 +102,21 @@ void lv_mem_init(void)
#endif #endif
} }
/**
* Clean up the memory buffer which frees all the allocated memories.
* @note It work only if `LV_MEM_CUSTOM == 0`
*/
void lv_mem_deinit(void)
{
#if LV_MEM_CUSTOM == 0
memset(work_mem, 0x00, (LV_MEM_SIZE / sizeof(MEM_UNIT)) * sizeof(MEM_UNIT));
lv_mem_ent_t * full = (lv_mem_ent_t *)work_mem;
full->header.s.used = 0;
/*The total mem size id reduced by the first header and the close patterns */
full->header.s.d_size = LV_MEM_SIZE - sizeof(lv_mem_header_t);
#endif
}
/** /**
* Allocate a memory dynamically * Allocate a memory dynamically
* @param size size of the memory to allocate in bytes * @param size size of the memory to allocate in bytes
@ -113,7 +128,7 @@ void * lv_mem_alloc(size_t size)
return &zero_mem; return &zero_mem;
} }
#ifdef LV_MEM_ENV64 #ifdef LV_ARCH_64
/*Round the size up to 8*/ /*Round the size up to 8*/
if(size & 0x7) { if(size & 0x7) {
size = size & (~0x7); size = size & (~0x7);
@ -262,7 +277,7 @@ void * lv_mem_realloc(void * data_p, size_t new_size)
#else /* LV_ENABLE_GC */ #else /* LV_ENABLE_GC */
void * lv_mem_realloc(void * data_p, uint32_t new_size) void * lv_mem_realloc(void * data_p, size_t new_size)
{ {
void * new_p = LV_MEM_CUSTOM_REALLOC(data_p, new_size); void * new_p = LV_MEM_CUSTOM_REALLOC(data_p, new_size);
if(new_p == NULL) LV_LOG_WARN("Couldn't allocate memory"); if(new_p == NULL) LV_LOG_WARN("Couldn't allocate memory");
@ -432,7 +447,7 @@ static void * ent_alloc(lv_mem_ent_t * e, size_t size)
*/ */
static void ent_trunc(lv_mem_ent_t * e, size_t size) static void ent_trunc(lv_mem_ent_t * e, size_t size)
{ {
#ifdef LV_MEM_ENV64 #ifdef LV_ARCH_64
/*Round the size up to 8*/ /*Round the size up to 8*/
if(size & 0x7) { if(size & 0x7) {
size = size & (~0x7); size = size & (~0x7);
@ -456,11 +471,11 @@ static void ent_trunc(lv_mem_ent_t * e, size_t size)
uint8_t * e_data = &e->first_data; uint8_t * e_data = &e->first_data;
lv_mem_ent_t * after_new_e = (lv_mem_ent_t *)&e_data[size]; lv_mem_ent_t * after_new_e = (lv_mem_ent_t *)&e_data[size];
after_new_e->header.s.used = 0; after_new_e->header.s.used = 0;
after_new_e->header.s.d_size = e->header.s.d_size - size - sizeof(lv_mem_header_t); after_new_e->header.s.d_size = (uint32_t)e->header.s.d_size - size - sizeof(lv_mem_header_t);
} }
/* Set the new size for the original entry */ /* Set the new size for the original entry */
e->header.s.d_size = size; e->header.s.d_size = (uint32_t)size;
} }
#endif #endif

6
src/libs/lvgl/src/lv_misc/lv_mem.h
View File

@ -55,6 +55,12 @@ typedef struct
*/ */
void lv_mem_init(void); void lv_mem_init(void);
/**
* Clean up the memory buffer which frees all the allocated memories.
* @note It work only if `LV_MEM_CUSTOM == 0`
*/
void lv_mem_deinit(void);
/** /**
* Allocate a memory dynamically * Allocate a memory dynamically
* @param size size of the memory to allocate in bytes * @param size size of the memory to allocate in bytes

22
src/libs/lvgl/src/lv_misc/lv_txt.c
View File

@ -8,6 +8,7 @@
*********************/ *********************/
#include "lv_txt.h" #include "lv_txt.h"
#include "lv_math.h" #include "lv_math.h"
#include "lv_log.h"
/********************* /*********************
* DEFINES * DEFINES
@ -108,8 +109,14 @@ void lv_txt_get_size(lv_point_t * size_res, const char * text, const lv_font_t *
/*Calc. the height and longest line*/ /*Calc. the height and longest line*/
while(text[line_start] != '\0') { while(text[line_start] != '\0') {
new_line_start += lv_txt_get_next_line(&text[line_start], font, letter_space, max_width, flag); new_line_start += lv_txt_get_next_line(&text[line_start], font, letter_space, max_width, flag);
size_res->y += letter_height;
size_res->y += line_space; if ((unsigned long)size_res->y + (unsigned long)letter_height + (unsigned long)line_space > LV_MAX_OF(lv_coord_t)) {
LV_LOG_WARN("lv_txt_get_size: integer overflow while calculating text height");
return;
} else {
size_res->y += letter_height;
size_res->y += line_space;
}
/*Calculate the the longest line*/ /*Calculate the the longest line*/
act_line_length = lv_txt_get_width(&text[line_start], new_line_start - line_start, font, letter_space, flag); act_line_length = lv_txt_get_width(&text[line_start], new_line_start - line_start, font, letter_space, flag);
@ -118,7 +125,7 @@ void lv_txt_get_size(lv_point_t * size_res, const char * text, const lv_font_t *
line_start = new_line_start; line_start = new_line_start;
} }
/*Ma ke the text one line taller if the last character is '\n' or '\r'*/ /*Make the text one line taller if the last character is '\n' or '\r'*/
if((line_start != 0) && (text[line_start - 1] == '\n' || text[line_start - 1] == '\r')) { if((line_start != 0) && (text[line_start - 1] == '\n' || text[line_start - 1] == '\r')) {
size_res->y += letter_height + line_space; size_res->y += letter_height + line_space;
} }
@ -200,8 +207,12 @@ static uint16_t lv_txt_get_next_word(const char * txt, const lv_font_t * font,
letter_w = lv_font_get_glyph_width(font, letter, letter_next); letter_w = lv_font_get_glyph_width(font, letter, letter_next);
cur_w += letter_w; cur_w += letter_w;
if(letter_w > 0) {
cur_w += letter_space;
}
/* Test if this character fits within max_width */ /* Test if this character fits within max_width */
if(break_index == NO_BREAK_FOUND && cur_w > max_width) { if(break_index == NO_BREAK_FOUND && (cur_w - letter_space) > max_width) {
break_index = i; break_index = i;
break_letter_count = word_len - 1; break_letter_count = word_len - 1;
/* break_index is now pointing at the character that doesn't fit */ /* break_index is now pointing at the character that doesn't fit */
@ -219,9 +230,6 @@ static uint16_t lv_txt_get_next_word(const char * txt, const lv_font_t * font,
/* Update the output width */ /* Update the output width */
if( word_w_ptr != NULL && break_index == NO_BREAK_FOUND ) *word_w_ptr = cur_w; if( word_w_ptr != NULL && break_index == NO_BREAK_FOUND ) *word_w_ptr = cur_w;
if(letter_w > 0) {
cur_w += letter_space;
}
i = i_next; i = i_next;
i_next = i_next_next; i_next = i_next_next;

2
src/libs/lvgl/src/lv_misc/lv_types.h
View File

@ -18,7 +18,7 @@ extern "C" {
* DEFINES * DEFINES
*********************/ *********************/
// Check windows // Check windows
#ifdef __WIN64 #ifdef _WIN64
#define LV_ARCH_64 #define LV_ARCH_64
#endif #endif

12
src/libs/lvgl/src/lv_objx/lv_btnm.c
View File

@ -815,7 +815,8 @@ static lv_res_t lv_btnm_signal(lv_obj_t * btnm, lv_signal_t sign, void * param)
} else if(sign == LV_SIGNAL_RELEASED) { } else if(sign == LV_SIGNAL_RELEASED) {
if(ext->btn_id_pr != LV_BTNM_BTN_NONE) { if(ext->btn_id_pr != LV_BTNM_BTN_NONE) {
/*Toggle the button if enabled*/ /*Toggle the button if enabled*/
if(button_is_tgl_enabled(ext->ctrl_bits[ext->btn_id_pr])) { if(button_is_tgl_enabled(ext->ctrl_bits[ext->btn_id_pr]) &&
!button_is_inactive(ext->ctrl_bits[ext->btn_id_pr])) {
if(button_get_tgl_state(ext->ctrl_bits[ext->btn_id_pr])) { if(button_get_tgl_state(ext->ctrl_bits[ext->btn_id_pr])) {
ext->ctrl_bits[ext->btn_id_pr] &= (~LV_BTNM_CTRL_TGL_STATE); ext->ctrl_bits[ext->btn_id_pr] &= (~LV_BTNM_CTRL_TGL_STATE);
} else { } else {
@ -863,9 +864,10 @@ static lv_res_t lv_btnm_signal(lv_obj_t * btnm, lv_signal_t sign, void * param)
lv_indev_type_t indev_type = lv_indev_get_type(indev); lv_indev_type_t indev_type = lv_indev_get_type(indev);
/*If not focused by an input device assume the last input device*/ /*If not focused by an input device assume the last input device*/
if(indev_type == LV_INDEV_TYPE_NONE) { if(indev == NULL) {
indev_type = lv_indev_get_type(lv_indev_get_next(NULL)); indev = lv_indev_get_next(NULL);
} indev_type = lv_indev_get_type(indev);
}
if(indev_type == LV_INDEV_TYPE_POINTER) { if(indev_type == LV_INDEV_TYPE_POINTER) {
/*Select the clicked button*/ /*Select the clicked button*/
@ -1082,7 +1084,7 @@ static void invalidate_button_area(const lv_obj_t * btnm, uint16_t btn_idx)
btn_area.x2 += btnm_area.x1; btn_area.x2 += btnm_area.x1;
btn_area.y2 += btnm_area.y1; btn_area.y2 += btnm_area.y1;
lv_inv_area(lv_obj_get_disp(btnm), &btn_area); lv_obj_invalidate_area(btnm, &btn_area);
} }
/** /**

10
src/libs/lvgl/src/lv_objx/lv_chart.c
View File

@ -816,7 +816,7 @@ static void lv_chart_draw_div(lv_obj_t * chart, const lv_area_t * mask)
} }
p1.x = 0 + x_ofs; p1.x = 0 + x_ofs;
p2.x = w + x_ofs; p2.x = w - 1 + x_ofs;
for(div_i = div_i_start; div_i <= div_i_end; div_i++) { for(div_i = div_i_start; div_i <= div_i_end; div_i++) {
p1.y = (int32_t)((int32_t)(h - style->line.width) * div_i) / (ext->hdiv_cnt + 1); p1.y = (int32_t)((int32_t)(h - style->line.width) * div_i) / (ext->hdiv_cnt + 1);
p1.y += y_ofs; p1.y += y_ofs;
@ -836,7 +836,7 @@ static void lv_chart_draw_div(lv_obj_t * chart, const lv_area_t * mask)
} }
p1.y = 0 + y_ofs; p1.y = 0 + y_ofs;
p2.y = h + y_ofs; p2.y = h + y_ofs - 1;
for(div_i = div_i_start; div_i <= div_i_end; div_i++) { for(div_i = div_i_start; div_i <= div_i_end; div_i++) {
p1.x = (int32_t)((int32_t)(w - style->line.width) * div_i) / (ext->vdiv_cnt + 1); p1.x = (int32_t)((int32_t)(w - style->line.width) * div_i) / (ext->vdiv_cnt + 1);
p1.x += x_ofs; p1.x += x_ofs;
@ -951,7 +951,7 @@ static void lv_chart_draw_points(lv_obj_t * chart, const lv_area_t * mask)
y_tmp = (int32_t)((int32_t)ser->points[p_act] - ext->ymin) * h; y_tmp = (int32_t)((int32_t)ser->points[p_act] - ext->ymin) * h;
y_tmp = y_tmp / (ext->ymax - ext->ymin); y_tmp = y_tmp / (ext->ymax - ext->ymin);
cir_a.y1 = h - y_tmp + y_ofs; cir_a.y1 = h - y_tmp + y_ofs - 1;
cir_a.y2 = cir_a.y1 + style_point.body.radius; cir_a.y2 = cir_a.y1 + style_point.body.radius;
cir_a.y1 -= style_point.body.radius; cir_a.y1 -= style_point.body.radius;
@ -1496,13 +1496,13 @@ static void lv_chart_inv_lines(lv_obj_t * chart, uint16_t i)
if(i < ext->point_cnt - 1) { if(i < ext->point_cnt - 1) {
coords.x1 = ((w * i) / (ext->point_cnt - 1)) + x_ofs - ext->series.width; coords.x1 = ((w * i) / (ext->point_cnt - 1)) + x_ofs - ext->series.width;
coords.x2 = ((w * (i + 1)) / (ext->point_cnt - 1)) + x_ofs + ext->series.width; coords.x2 = ((w * (i + 1)) / (ext->point_cnt - 1)) + x_ofs + ext->series.width;
lv_inv_area(lv_obj_get_disp(chart), &coords); lv_obj_invalidate_area(chart, &coords);
} }
if(i > 0) { if(i > 0) {
coords.x1 = ((w * (i - 1)) / (ext->point_cnt - 1)) + x_ofs - ext->series.width; coords.x1 = ((w * (i - 1)) / (ext->point_cnt - 1)) + x_ofs - ext->series.width;
coords.x2 = ((w * i) / (ext->point_cnt - 1)) + x_ofs + ext->series.width; coords.x2 = ((w * i) / (ext->point_cnt - 1)) + x_ofs + ext->series.width;
lv_inv_area(lv_obj_get_disp(chart), &coords); lv_obj_invalidate_area(chart, &coords);
} }
} }
} }

2
src/libs/lvgl/src/lv_objx/lv_cpicker.c
View File

@ -750,7 +750,7 @@ static void invalidate_indic(lv_obj_t * cpicker)
{ {
lv_area_t indic_area = get_indic_area(cpicker); lv_area_t indic_area = get_indic_area(cpicker);
lv_inv_area(lv_obj_get_disp(cpicker), &indic_area); lv_obj_invalidate_area(cpicker, &indic_area);
} }
static lv_area_t get_indic_area(lv_obj_t * cpicker) static lv_area_t get_indic_area(lv_obj_t * cpicker)

5
src/libs/lvgl/src/lv_objx/lv_ddlist.c
View File

@ -775,6 +775,7 @@ static lv_res_t lv_ddlist_scrl_signal(lv_obj_t * scrl, lv_signal_t sign, void *
/* Include the ancient signal function */ /* Include the ancient signal function */
res = ancestor_scrl_signal(scrl, sign, param); res = ancestor_scrl_signal(scrl, sign, param);
if(res != LV_RES_OK) return res; if(res != LV_RES_OK) return res;
if(sign == LV_SIGNAL_GET_TYPE) return lv_obj_handle_get_type_signal(param, "");
lv_obj_t * ddlist = lv_obj_get_parent(scrl); lv_obj_t * ddlist = lv_obj_get_parent(scrl);
@ -806,6 +807,10 @@ static lv_res_t release_handler(lv_obj_t * ddlist)
{ {
lv_ddlist_ext_t * ext = lv_obj_get_ext_attr(ddlist); lv_ddlist_ext_t * ext = lv_obj_get_ext_attr(ddlist);
/*Only deal with clickable drop down lists*/
if(!lv_obj_get_click(ddlist))
return LV_RES_OK;
if(ext->opened == 0) { /*Open the list*/ if(ext->opened == 0) { /*Open the list*/
ext->opened = 1; ext->opened = 1;
lv_obj_set_drag(lv_page_get_scrl(ddlist), true); lv_obj_set_drag(lv_page_get_scrl(ddlist), true);

2
src/libs/lvgl/src/lv_objx/lv_gauge.h
View File

@ -193,7 +193,7 @@ uint8_t lv_gauge_get_label_count(const lv_obj_t * gauge);
* @param gauge pointer to a gauge object * @param gauge pointer to a gauge object
* @return number of the scale units * @return number of the scale units
*/ */
static inline uint8_t lv_gauge_get_line_count(const lv_obj_t * gauge) static inline uint16_t lv_gauge_get_line_count(const lv_obj_t * gauge)
{ {
return lv_lmeter_get_line_count(gauge); return lv_lmeter_get_line_count(gauge);
} }

3
src/libs/lvgl/src/lv_objx/lv_img.c
View File

@ -355,6 +355,9 @@ static bool lv_img_design(lv_obj_t * img, const lv_area_t * mask, lv_design_mode
if(ext->cf == LV_IMG_CF_TRUE_COLOR || ext->cf == LV_IMG_CF_RAW) cover = lv_area_is_in(mask, &img->coords); if(ext->cf == LV_IMG_CF_TRUE_COLOR || ext->cf == LV_IMG_CF_RAW) cover = lv_area_is_in(mask, &img->coords);
const lv_style_t * style = lv_img_get_style(img, LV_IMG_STYLE_MAIN);
if(style->image.opa < LV_OPA_MAX) return false;
return cover; return cover;
} else if(mode == LV_DESIGN_DRAW_MAIN) { } else if(mode == LV_DESIGN_DRAW_MAIN) {
if(ext->h == 0 || ext->w == 0) return true; if(ext->h == 0 || ext->w == 0) return true;

13
src/libs/lvgl/src/lv_objx/lv_label.c
View File

@ -308,7 +308,6 @@ void lv_label_set_array_text(lv_obj_t * label, const char * array, uint16_t size
void lv_label_set_static_text(lv_obj_t * label, const char * text) void lv_label_set_static_text(lv_obj_t * label, const char * text)
{ {
LV_ASSERT_OBJ(label, LV_OBJX_NAME); LV_ASSERT_OBJ(label, LV_OBJX_NAME);
LV_ASSERT_STR(text);
lv_label_ext_t * ext = lv_obj_get_ext_attr(label); lv_label_ext_t * ext = lv_obj_get_ext_attr(label);
if(ext->static_txt == 0 && ext->text != NULL) { if(ext->static_txt == 0 && ext->text != NULL) {
@ -1303,10 +1302,18 @@ static void lv_label_refr_text(lv_obj_t * label)
p.y -= style->text.line_space; /*Trim the last line space*/ p.y -= style->text.line_space; /*Trim the last line space*/
uint32_t letter_id = lv_label_get_letter_on(label, &p); uint32_t letter_id = lv_label_get_letter_on(label, &p);
/*Save letters under the dots and replace them with dots*/
uint32_t i; /*Be sure there is space for the dots*/
size_t txt_len = strlen(ext->text);
uint32_t byte_id = lv_txt_encoded_get_byte_id(ext->text, letter_id); uint32_t byte_id = lv_txt_encoded_get_byte_id(ext->text, letter_id);
while(byte_id + LV_LABEL_DOT_NUM > txt_len) {
byte_id -= lv_txt_encoded_size(&ext->text[byte_id]);
letter_id--;
}
/*Save letters under the dots and replace them with dots*/
uint32_t byte_id_ori = byte_id; uint32_t byte_id_ori = byte_id;
uint32_t i;
uint8_t len = 0; uint8_t len = 0;
for(i = 0; i <= LV_LABEL_DOT_NUM; i++) { for(i = 0; i <= LV_LABEL_DOT_NUM; i++) {
len += lv_txt_encoded_size(&ext->text[byte_id]); len += lv_txt_encoded_size(&ext->text[byte_id]);

37
src/libs/lvgl/src/lv_objx/lv_list.c
View File

@ -179,6 +179,13 @@ lv_obj_t * lv_list_add_btn(lv_obj_t * list, const void * img_src, const char * t
{ {
LV_ASSERT_OBJ(list, LV_OBJX_NAME); LV_ASSERT_OBJ(list, LV_OBJX_NAME);
lv_obj_t * last_btn = lv_list_get_prev_btn(list, NULL);
/*The coordinates may changed due to autofit so revert them at the end*/
lv_coord_t pos_x_ori = lv_obj_get_x(list);
lv_coord_t pos_y_ori = lv_obj_get_y(list);
lv_list_ext_t * ext = lv_obj_get_ext_attr(list); lv_list_ext_t * ext = lv_obj_get_ext_attr(list);
ext->size++; ext->size++;
/*Create a list element with the image an the text*/ /*Create a list element with the image an the text*/
@ -197,7 +204,22 @@ lv_obj_t * lv_list_add_btn(lv_obj_t * list, const void * img_src, const char * t
lv_page_glue_obj(liste, true); lv_page_glue_obj(liste, true);
lv_btn_set_layout(liste, LV_LAYOUT_ROW_M); lv_btn_set_layout(liste, LV_LAYOUT_ROW_M);
lv_btn_set_fit2(liste, LV_FIT_FLOOD, LV_FIT_TIGHT);
lv_layout_t list_layout = lv_list_get_layout(list);
bool layout_ver = false;
if(list_layout == LV_LAYOUT_COL_M || list_layout == LV_LAYOUT_COL_L || list_layout == LV_LAYOUT_COL_R) {
layout_ver = true;
}
if(layout_ver) {
lv_btn_set_fit2(liste, LV_FIT_FLOOD, LV_FIT_TIGHT);
} else {
lv_coord_t w = last_btn ? lv_obj_get_width(last_btn) : (LV_DPI * 3) / 2;
lv_btn_set_fit2(liste, LV_FIT_NONE, LV_FIT_TIGHT);
lv_obj_set_width(liste, w);
}
lv_obj_set_protect(liste, LV_PROTECT_PRESS_LOST); lv_obj_set_protect(liste, LV_PROTECT_PRESS_LOST);
lv_obj_set_signal_cb(liste, lv_list_btn_signal); lv_obj_set_signal_cb(liste, lv_list_btn_signal);
@ -233,6 +255,8 @@ lv_obj_t * lv_list_add_btn(lv_obj_t * list, const void * img_src, const char * t
} }
#endif #endif
lv_obj_set_pos(list, pos_x_ori, pos_y_ori);
return liste; return liste;
} }
@ -399,16 +423,23 @@ void lv_list_set_style(lv_obj_t * list, lv_list_style_t type, const lv_style_t *
while(btn != NULL) { while(btn != NULL) {
/*If a column layout set the buttons' width to list width*/ /*If a column layout set the buttons' width to list width*/
if(layout == LV_LAYOUT_COL_M || layout == LV_LAYOUT_COL_L || layout == LV_LAYOUT_COL_R) { if(layout == LV_LAYOUT_COL_M || layout == LV_LAYOUT_COL_L || layout == LV_LAYOUT_COL_R) {
lv_btn_set_fit2(list, LV_FIT_FLOOD, LV_FIT_TIGHT); lv_btn_set_fit2(btn, LV_FIT_FLOOD, LV_FIT_TIGHT);
} }
/*If a row layout set the buttons' width according to the content*/ /*If a row layout set the buttons' width according to the content*/
else if (layout == LV_LAYOUT_ROW_M || layout == LV_LAYOUT_ROW_T || layout == LV_LAYOUT_ROW_B) { else if (layout == LV_LAYOUT_ROW_M || layout == LV_LAYOUT_ROW_T || layout == LV_LAYOUT_ROW_B) {
lv_btn_set_fit(list, LV_FIT_TIGHT); lv_btn_set_fit(btn, LV_FIT_TIGHT);
} }
btn = lv_list_get_prev_btn(list, btn); btn = lv_list_get_prev_btn(list, btn);
} }
if(layout == LV_LAYOUT_COL_M || layout == LV_LAYOUT_COL_L || layout == LV_LAYOUT_COL_R) {
lv_page_set_scrl_fit2(list, LV_FIT_FLOOD, LV_FIT_TIGHT);
} else if (layout == LV_LAYOUT_ROW_M || layout == LV_LAYOUT_ROW_T || layout == LV_LAYOUT_ROW_B) {
lv_page_set_scrl_fit2(list, LV_FIT_TIGHT, LV_FIT_TIGHT);
lv_cont_set_fit2(list, LV_FIT_NONE, LV_FIT_TIGHT);
}
lv_page_set_scrl_layout(list, layout); lv_page_set_scrl_layout(list, layout);
} }

27
src/libs/lvgl/src/lv_objx/lv_page.c
View File

@ -150,16 +150,16 @@ lv_obj_t * lv_page_create(lv_obj_t * par, const lv_obj_t * copy)
ext->scrl = lv_cont_create(new_page, copy_ext->scrl); ext->scrl = lv_cont_create(new_page, copy_ext->scrl);
lv_obj_set_signal_cb(ext->scrl, lv_page_scrollable_signal); lv_obj_set_signal_cb(ext->scrl, lv_page_scrollable_signal);
lv_page_set_sb_mode(new_page, copy_ext->sb.mode); /* Add the signal function only if 'scrolling' is created
* because everything has to be ready before any signal is received*/
lv_obj_set_signal_cb(new_page, lv_page_signal);
lv_obj_set_design_cb(new_page, lv_page_design);
lv_page_set_style(new_page, LV_PAGE_STYLE_BG, lv_page_get_style(copy, LV_PAGE_STYLE_BG)); lv_page_set_style(new_page, LV_PAGE_STYLE_BG, lv_page_get_style(copy, LV_PAGE_STYLE_BG));
lv_page_set_style(new_page, LV_PAGE_STYLE_SCRL, lv_page_get_style(copy, LV_PAGE_STYLE_SCRL)); lv_page_set_style(new_page, LV_PAGE_STYLE_SCRL, lv_page_get_style(copy, LV_PAGE_STYLE_SCRL));
lv_page_set_style(new_page, LV_PAGE_STYLE_SB, lv_page_get_style(copy, LV_PAGE_STYLE_SB)); lv_page_set_style(new_page, LV_PAGE_STYLE_SB, lv_page_get_style(copy, LV_PAGE_STYLE_SB));
/* Add the signal function only if 'scrolling' is created lv_page_set_sb_mode(new_page, copy_ext->sb.mode);
* because everything has to be ready before any signal is received*/
lv_obj_set_signal_cb(new_page, lv_page_signal);
lv_obj_set_design_cb(new_page, lv_page_design);
/*Refresh the style with new signal function*/ /*Refresh the style with new signal function*/
lv_obj_refresh_style(new_page); lv_obj_refresh_style(new_page);
@ -828,6 +828,7 @@ static lv_res_t lv_page_signal(lv_obj_t * page, lv_signal_t sign, void * param)
lv_page_ext_t * ext = lv_obj_get_ext_attr(page); lv_page_ext_t * ext = lv_obj_get_ext_attr(page);
lv_obj_t * child; lv_obj_t * child;
if(sign == LV_SIGNAL_CHILD_CHG) { /*Automatically move children to the scrollable object*/ if(sign == LV_SIGNAL_CHILD_CHG) { /*Automatically move children to the scrollable object*/
if(ext->scrl == NULL) return LV_RES_OK;
const lv_style_t * style_bg = lv_page_get_style(page, LV_PAGE_STYLE_BG); const lv_style_t * style_bg = lv_page_get_style(page, LV_PAGE_STYLE_BG);
const lv_style_t * style_scrl = lv_page_get_style(page, LV_PAGE_STYLE_SCRL); const lv_style_t * style_scrl = lv_page_get_style(page, LV_PAGE_STYLE_SCRL);
lv_fit_t fit_left = lv_page_get_scrl_fit_left(page); lv_fit_t fit_left = lv_page_get_scrl_fit_left(page);
@ -1073,7 +1074,6 @@ static lv_res_t lv_page_scrollable_signal(lv_obj_t * scrl, lv_signal_t sign, voi
/*Hide scrollbars if required*/ /*Hide scrollbars if required*/
if(page_ext->sb.mode == LV_SB_MODE_DRAG) { if(page_ext->sb.mode == LV_SB_MODE_DRAG) {
lv_disp_t * disp = lv_obj_get_disp(page);
lv_area_t sb_area_tmp; lv_area_t sb_area_tmp;
if(page_ext->sb.hor_draw) { if(page_ext->sb.hor_draw) {
lv_area_copy(&sb_area_tmp, &page_ext->sb.hor_area); lv_area_copy(&sb_area_tmp, &page_ext->sb.hor_area);
@ -1081,7 +1081,7 @@ static lv_res_t lv_page_scrollable_signal(lv_obj_t * scrl, lv_signal_t sign, voi
sb_area_tmp.y1 += page->coords.y1; sb_area_tmp.y1 += page->coords.y1;
sb_area_tmp.x2 += page->coords.x1; sb_area_tmp.x2 += page->coords.x1;
sb_area_tmp.y2 += page->coords.y1; sb_area_tmp.y2 += page->coords.y1;
lv_inv_area(disp, &sb_area_tmp); lv_obj_invalidate_area(page, &sb_area_tmp);
page_ext->sb.hor_draw = 0; page_ext->sb.hor_draw = 0;
} }
if(page_ext->sb.ver_draw) { if(page_ext->sb.ver_draw) {
@ -1090,10 +1090,12 @@ static lv_res_t lv_page_scrollable_signal(lv_obj_t * scrl, lv_signal_t sign, voi
sb_area_tmp.y1 += page->coords.y1; sb_area_tmp.y1 += page->coords.y1;
sb_area_tmp.x2 += page->coords.x1; sb_area_tmp.x2 += page->coords.x1;
sb_area_tmp.y2 += page->coords.y1; sb_area_tmp.y2 += page->coords.y1;
lv_inv_area(disp, &sb_area_tmp); lv_obj_invalidate_area(page, &sb_area_tmp);
page_ext->sb.ver_draw = 0; page_ext->sb.ver_draw = 0;
} }
} }
} else if(sign == LV_SIGNAL_CLEANUP) {
page_ext->scrl = NULL;
} }
return res; return res;
@ -1150,7 +1152,6 @@ static void lv_page_sb_refresh(lv_obj_t * page)
} }
/*Invalidate the current (old) scrollbar areas*/ /*Invalidate the current (old) scrollbar areas*/
lv_disp_t * disp = lv_obj_get_disp(page);
lv_area_t sb_area_tmp; lv_area_t sb_area_tmp;
if(ext->sb.hor_draw != 0) { if(ext->sb.hor_draw != 0) {
lv_area_copy(&sb_area_tmp, &ext->sb.hor_area); lv_area_copy(&sb_area_tmp, &ext->sb.hor_area);
@ -1158,7 +1159,7 @@ static void lv_page_sb_refresh(lv_obj_t * page)
sb_area_tmp.y1 += page->coords.y1; sb_area_tmp.y1 += page->coords.y1;
sb_area_tmp.x2 += page->coords.x1; sb_area_tmp.x2 += page->coords.x1;
sb_area_tmp.y2 += page->coords.y1; sb_area_tmp.y2 += page->coords.y1;
lv_inv_area(disp, &sb_area_tmp); lv_obj_invalidate_area(page, &sb_area_tmp);
} }
if(ext->sb.ver_draw != 0) { if(ext->sb.ver_draw != 0) {
lv_area_copy(&sb_area_tmp, &ext->sb.ver_area); lv_area_copy(&sb_area_tmp, &ext->sb.ver_area);
@ -1166,7 +1167,7 @@ static void lv_page_sb_refresh(lv_obj_t * page)
sb_area_tmp.y1 += page->coords.y1; sb_area_tmp.y1 += page->coords.y1;
sb_area_tmp.x2 += page->coords.x1; sb_area_tmp.x2 += page->coords.x1;
sb_area_tmp.y2 += page->coords.y1; sb_area_tmp.y2 += page->coords.y1;
lv_inv_area(disp, &sb_area_tmp); lv_obj_invalidate_area(page, &sb_area_tmp);
} }
if(ext->sb.mode == LV_SB_MODE_DRAG && lv_indev_is_dragging(lv_indev_get_act()) == false) { if(ext->sb.mode == LV_SB_MODE_DRAG && lv_indev_is_dragging(lv_indev_get_act()) == false) {
@ -1228,7 +1229,7 @@ static void lv_page_sb_refresh(lv_obj_t * page)
sb_area_tmp.y1 += page->coords.y1; sb_area_tmp.y1 += page->coords.y1;
sb_area_tmp.x2 += page->coords.x1; sb_area_tmp.x2 += page->coords.x1;
sb_area_tmp.y2 += page->coords.y1; sb_area_tmp.y2 += page->coords.y1;
lv_inv_area(disp, &sb_area_tmp); lv_obj_invalidate_area(page, &sb_area_tmp);
} }
if(ext->sb.ver_draw != 0) { if(ext->sb.ver_draw != 0) {
lv_area_copy(&sb_area_tmp, &ext->sb.ver_area); lv_area_copy(&sb_area_tmp, &ext->sb.ver_area);
@ -1236,7 +1237,7 @@ static void lv_page_sb_refresh(lv_obj_t * page)
sb_area_tmp.y1 += page->coords.y1; sb_area_tmp.y1 += page->coords.y1;
sb_area_tmp.x2 += page->coords.x1; sb_area_tmp.x2 += page->coords.x1;
sb_area_tmp.y2 += page->coords.y1; sb_area_tmp.y2 += page->coords.y1;
lv_inv_area(disp, &sb_area_tmp); lv_obj_invalidate_area(page, &sb_area_tmp);
} }
} }

4
src/libs/lvgl/src/lv_objx/lv_roller.c
View File

@ -149,8 +149,9 @@ void lv_roller_set_options(lv_obj_t * roller, const char * options, lv_roller_mo
/* Make sure the roller's height and the scrollable's height is refreshed. /* Make sure the roller's height and the scrollable's height is refreshed.
* They are refreshed in `LV_SIGNAL_COORD_CHG` but if the new options has the same width * They are refreshed in `LV_SIGNAL_COORD_CHG` but if the new options has the same width
* that signal won't be called. (It called because LV_FIT_TIGHT hor fit)*/ * that signal won't be called. (It's called because of LV_FIT_TIGHT hor fit)*/
refr_height(roller); refr_height(roller);
refr_position(roller, LV_ANIM_OFF);
} else { } else {
ext->mode = LV_ROLLER_MODE_INIFINITE; ext->mode = LV_ROLLER_MODE_INIFINITE;
@ -508,6 +509,7 @@ static lv_res_t lv_roller_scrl_signal(lv_obj_t * roller_scrl, lv_signal_t sign,
/* Include the ancient signal function */ /* Include the ancient signal function */
res = ancestor_scrl_signal(roller_scrl, sign, param); res = ancestor_scrl_signal(roller_scrl, sign, param);
if(res != LV_RES_OK) return res; if(res != LV_RES_OK) return res;
if(sign == LV_SIGNAL_GET_TYPE) return lv_obj_handle_get_type_signal(param, LV_OBJX_NAME);
lv_indev_t * indev = lv_indev_get_act(); lv_indev_t * indev = lv_indev_get_act();
int32_t id = -1; int32_t id = -1;

6
src/libs/lvgl/src/lv_objx/lv_spinbox.c
View File

@ -405,11 +405,15 @@ static void lv_spinbox_updatevalue(lv_obj_t * spinbox)
char buf[LV_SPINBOX_MAX_DIGIT_COUNT + 8]; char buf[LV_SPINBOX_MAX_DIGIT_COUNT + 8];
memset(buf, 0, sizeof(buf)); memset(buf, 0, sizeof(buf));
char * buf_p = buf; char * buf_p = buf;
uint8_t cur_shift_left = 0;
if (ext->range_min < 0) { // hide sign if there are only positive values if (ext->range_min < 0) { // hide sign if there are only positive values
/*Add the sign*/ /*Add the sign*/
(*buf_p) = ext->value >= 0 ? '+' : '-'; (*buf_p) = ext->value >= 0 ? '+' : '-';
buf_p++; buf_p++;
} else {
/*Cursor need shift to left*/
cur_shift_left++;
} }
int32_t i; int32_t i;
@ -467,7 +471,7 @@ static void lv_spinbox_updatevalue(lv_obj_t * spinbox)
if(cur_pos > intDigits) cur_pos++; /*Skip teh decimal point*/ if(cur_pos > intDigits) cur_pos++; /*Skip teh decimal point*/
cur_pos += ext->digit_padding_left; cur_pos += (ext->digit_padding_left - cur_shift_left);
lv_ta_set_cursor_pos(spinbox, cur_pos); lv_ta_set_cursor_pos(spinbox, cur_pos);
} }

10
src/libs/lvgl/src/lv_objx/lv_sw.c
View File

@ -275,6 +275,13 @@ uint16_t lv_sw_get_anim_time(const lv_obj_t * sw)
*/ */
static lv_res_t lv_sw_signal(lv_obj_t * sw, lv_signal_t sign, void * param) static lv_res_t lv_sw_signal(lv_obj_t * sw, lv_signal_t sign, void * param)
{ {
lv_res_t res;
if(sign == LV_SIGNAL_GET_TYPE) {
res = ancestor_signal(sw, sign, param);
if(res != LV_RES_OK) return res;
return lv_obj_handle_get_type_signal(param, LV_OBJX_NAME);
}
lv_sw_ext_t * ext = lv_obj_get_ext_attr(sw); lv_sw_ext_t * ext = lv_obj_get_ext_attr(sw);
/*Save the current (old) value before slider signal modifies it. It will be required in the /*Save the current (old) value before slider signal modifies it. It will be required in the
@ -289,12 +296,9 @@ static lv_res_t lv_sw_signal(lv_obj_t * sw, lv_signal_t sign, void * param)
lv_event_cb_t event_cb = sw->event_cb; lv_event_cb_t event_cb = sw->event_cb;
sw->event_cb = NULL; sw->event_cb = NULL;
lv_res_t res;
/* Include the ancient signal function */ /* Include the ancient signal function */
res = ancestor_signal(sw, sign, param); res = ancestor_signal(sw, sign, param);
if(res != LV_RES_OK) return res; if(res != LV_RES_OK) return res;
if(sign == LV_SIGNAL_GET_TYPE) return lv_obj_handle_get_type_signal(param, LV_OBJX_NAME);
sw->event_cb = event_cb; sw->event_cb = event_cb;

17
src/libs/lvgl/src/lv_objx/lv_ta.c
View File

@ -484,7 +484,9 @@ void lv_ta_set_text(lv_obj_t * ta, const char * txt)
if(lv_ta_get_accepted_chars(ta) || lv_ta_get_max_length(ta)) { if(lv_ta_get_accepted_chars(ta) || lv_ta_get_max_length(ta)) {
lv_label_set_text(ext->label, ""); lv_label_set_text(ext->label, "");
lv_ta_set_cursor_pos(ta, LV_TA_CURSOR_LAST); lv_ta_set_cursor_pos(ta, LV_TA_CURSOR_LAST);
if(ext->pwd_mode != 0) {
ext->pwd_tmp[0] = '\0'; /*Clear the password too*/
}
uint32_t i = 0; uint32_t i = 0;
while(txt[i] != '\0') { while(txt[i] != '\0') {
uint32_t c = lv_txt_encoded_next(txt, &i); uint32_t c = lv_txt_encoded_next(txt, &i);
@ -731,6 +733,7 @@ void lv_ta_set_one_line(lv_obj_t * ta, bool en)
lv_ta_ext_t * ext = lv_obj_get_ext_attr(ta); lv_ta_ext_t * ext = lv_obj_get_ext_attr(ta);
if(ext->one_line == en) return; if(ext->one_line == en) return;
lv_label_align_t old_align = lv_label_get_align(ext->label);
if(en) { if(en) {
const lv_style_t * style_ta = lv_obj_get_style(ta); const lv_style_t * style_ta = lv_obj_get_style(ta);
@ -758,7 +761,8 @@ void lv_ta_set_one_line(lv_obj_t * ta, bool en)
} }
placeholder_update(ta); placeholder_update(ta);
refr_cursor_area(ta); /* `refr_cursor_area` is called at the end of lv_ta_set_text_align */
lv_ta_set_text_align(ta, old_align);
} }
/** /**
@ -943,6 +947,7 @@ void lv_ta_set_cursor_blink_time(lv_obj_t * ta, uint16_t time)
a.path_cb = lv_anim_path_step; a.path_cb = lv_anim_path_step;
lv_anim_create(&a); lv_anim_create(&a);
} else { } else {
lv_anim_del(ta, (lv_anim_exec_xcb_t)cursor_blink_anim);
ext->cursor.state = 1; ext->cursor.state = 1;
} }
#else #else
@ -1589,14 +1594,13 @@ static void cursor_blink_anim(lv_obj_t * ta, lv_anim_value_t show)
if(show != ext->cursor.state) { if(show != ext->cursor.state) {
ext->cursor.state = show == 0 ? 0 : 1; ext->cursor.state = show == 0 ? 0 : 1;
if(ext->cursor.type != LV_CURSOR_NONE && (ext->cursor.type & LV_CURSOR_HIDDEN) == 0) { if(ext->cursor.type != LV_CURSOR_NONE && (ext->cursor.type & LV_CURSOR_HIDDEN) == 0) {
lv_disp_t * disp = lv_obj_get_disp(ta);
lv_area_t area_tmp; lv_area_t area_tmp;
lv_area_copy(&area_tmp, &ext->cursor.area); lv_area_copy(&area_tmp, &ext->cursor.area);
area_tmp.x1 += ext->label->coords.x1; area_tmp.x1 += ext->label->coords.x1;
area_tmp.y1 += ext->label->coords.y1; area_tmp.y1 += ext->label->coords.y1;
area_tmp.x2 += ext->label->coords.x1; area_tmp.x2 += ext->label->coords.x1;
area_tmp.y2 += ext->label->coords.y1; area_tmp.y2 += ext->label->coords.y1;
lv_inv_area(disp, &area_tmp); lv_obj_invalidate_area(ta, &area_tmp);
} }
} }
} }
@ -1791,14 +1795,13 @@ static void refr_cursor_area(lv_obj_t * ta)
} }
/*Save the new area*/ /*Save the new area*/
lv_disp_t * disp = lv_obj_get_disp(ta);
lv_area_t area_tmp; lv_area_t area_tmp;
lv_area_copy(&area_tmp, &ext->cursor.area); lv_area_copy(&area_tmp, &ext->cursor.area);
area_tmp.x1 += ext->label->coords.x1; area_tmp.x1 += ext->label->coords.x1;
area_tmp.y1 += ext->label->coords.y1; area_tmp.y1 += ext->label->coords.y1;
area_tmp.x2 += ext->label->coords.x1; area_tmp.x2 += ext->label->coords.x1;
area_tmp.y2 += ext->label->coords.y1; area_tmp.y2 += ext->label->coords.y1;
lv_inv_area(disp, &area_tmp); lv_obj_invalidate_area(ta, &area_tmp);
lv_area_copy(&ext->cursor.area, &cur_area); lv_area_copy(&ext->cursor.area, &cur_area);
@ -1807,7 +1810,7 @@ static void refr_cursor_area(lv_obj_t * ta)
area_tmp.y1 += ext->label->coords.y1; area_tmp.y1 += ext->label->coords.y1;
area_tmp.x2 += ext->label->coords.x1; area_tmp.x2 += ext->label->coords.x1;
area_tmp.y2 += ext->label->coords.y1; area_tmp.y2 += ext->label->coords.y1;
lv_inv_area(disp, &area_tmp); lv_obj_invalidate_area(ta, &area_tmp);
} }
static void placeholder_update(lv_obj_t * ta) static void placeholder_update(lv_obj_t * ta)

25
src/libs/lvgl/src/lv_objx/lv_tabview.c
View File

@ -114,8 +114,17 @@ lv_obj_t * lv_tabview_create(lv_obj_t * par, const lv_obj_t * copy)
/* Set a size which fits into the parent. /* Set a size which fits into the parent.
* Don't use `par` directly because if the tabview is created on a page it is moved to the * Don't use `par` directly because if the tabview is created on a page it is moved to the
* scrollable so the parent has changed */ * scrollable so the parent has changed */
lv_obj_set_size(new_tabview, lv_obj_get_width_fit(lv_obj_get_parent(new_tabview)), lv_coord_t w;
lv_obj_get_height_fit(lv_obj_get_parent(new_tabview))); lv_coord_t h;
if(par) {
w = lv_obj_get_width_fit(lv_obj_get_parent(new_tabview));
h = lv_obj_get_height_fit(lv_obj_get_parent(new_tabview));
} else {
w = lv_disp_get_hor_res(NULL);
h = lv_disp_get_ver_res(NULL);
}
lv_obj_set_size(new_tabview, w, h);
ext->content = lv_cont_create(new_tabview, NULL); ext->content = lv_cont_create(new_tabview, NULL);
ext->btns = lv_btnm_create(new_tabview, NULL); ext->btns = lv_btnm_create(new_tabview, NULL);
@ -914,12 +923,14 @@ static void tabpage_pressing_handler(lv_obj_t * tabview, lv_obj_t * tabpage)
p = ((tabpage->coords.x1 - tabview->coords.x1) * (indic_size + tabs_style->body.padding.inner)) / p = ((tabpage->coords.x1 - tabview->coords.x1) * (indic_size + tabs_style->body.padding.inner)) /
lv_obj_get_width(tabview); lv_obj_get_width(tabview);
uint16_t id = ext->tab_cur; {
if(lv_obj_get_base_dir(tabview) == LV_BIDI_DIR_RTL) { uint16_t id = ext->tab_cur;
id = (ext->tab_cnt - (id + 1)); if(lv_obj_get_base_dir(tabview) == LV_BIDI_DIR_RTL) {
id = (ext->tab_cnt - (id + 1));
}
lv_obj_set_x(ext->indic, indic_size * id + tabs_style->body.padding.inner * id +
indic_style->body.padding.left - p);
} }
lv_obj_set_x(ext->indic, indic_size * id + tabs_style->body.padding.inner * id +
indic_style->body.padding.left - p);
break; break;
case LV_TABVIEW_BTNS_POS_LEFT: case LV_TABVIEW_BTNS_POS_LEFT:
case LV_TABVIEW_BTNS_POS_RIGHT: case LV_TABVIEW_BTNS_POS_RIGHT:

16
src/libs/lvgl/src/lv_objx/lv_tileview.c
View File

@ -97,8 +97,17 @@ lv_obj_t * lv_tileview_create(lv_obj_t * par, const lv_obj_t * copy)
/* Set a size which fits into the parent. /* Set a size which fits into the parent.
* Don't use `par` directly because if the tileview is created on a page it is moved to the * Don't use `par` directly because if the tileview is created on a page it is moved to the
* scrollable so the parent has changed */ * scrollable so the parent has changed */
lv_obj_set_size(new_tileview, lv_obj_get_width_fit(lv_obj_get_parent(new_tileview)), lv_coord_t w;
lv_obj_get_height_fit(lv_obj_get_parent(new_tileview))); lv_coord_t h;
if(par) {
w = lv_obj_get_width_fit(lv_obj_get_parent(new_tileview));
h = lv_obj_get_height_fit(lv_obj_get_parent(new_tileview));
} else {
w = lv_disp_get_hor_res(NULL);
h = lv_disp_get_ver_res(NULL);
}
lv_obj_set_size(new_tileview, w, h);
lv_obj_set_drag_throw(lv_page_get_scrl(new_tileview), false); lv_obj_set_drag_throw(lv_page_get_scrl(new_tileview), false);
lv_page_set_scrl_fit(new_tileview, LV_FIT_TIGHT); lv_page_set_scrl_fit(new_tileview, LV_FIT_TIGHT);
@ -216,6 +225,7 @@ void lv_tileview_set_tile_act(lv_obj_t * tileview, lv_coord_t x, lv_coord_t y, l
for(tile_id = 0; tile_id < ext->valid_pos_cnt; tile_id++) { for(tile_id = 0; tile_id < ext->valid_pos_cnt; tile_id++) {
if(ext->valid_pos[tile_id].x == x && ext->valid_pos[tile_id].y == y) { if(ext->valid_pos[tile_id].x == x && ext->valid_pos[tile_id].y == y) {
valid = true; valid = true;
break;
} }
} }
@ -486,9 +496,9 @@ static void tileview_scrl_event_cb(lv_obj_t * scrl, lv_event_t event)
lv_tileview_ext_t * ext = lv_obj_get_ext_attr(tileview); lv_tileview_ext_t * ext = lv_obj_get_ext_attr(tileview);
if(lv_indev_is_dragging(indev) && (ext->drag_hor || ext->drag_ver)) { if(lv_indev_is_dragging(indev) && (ext->drag_hor || ext->drag_ver)) {
indev->proc.types.pointer.drag_in_prog = 0; indev->proc.types.pointer.drag_in_prog = 0;
drag_end_handler(tileview);
} }
drag_end_handler(tileview);
} }
} }

14
src/libs/lvgl/src/lv_objx/lv_win.c
View File

@ -75,10 +75,18 @@ lv_obj_t * lv_win_create(lv_obj_t * par, const lv_obj_t * copy)
/* Set a size which fits into the parent. /* Set a size which fits into the parent.
* Don't use `par` directly because if the window is created on a page it is moved to the * Don't use `par` directly because if the window is created on a page it is moved to the
* scrollable so the parent has changed */ * scrollable so the parent has changed */
lv_obj_set_size(new_win, lv_obj_get_width_fit(lv_obj_get_parent(new_win)), lv_coord_t w;
lv_obj_get_height_fit(lv_obj_get_parent(new_win))); lv_coord_t h;
if(par) {
w = lv_obj_get_width_fit(lv_obj_get_parent(new_win));
h = lv_obj_get_height_fit(lv_obj_get_parent(new_win));
} else {
w = lv_disp_get_hor_res(NULL);
h = lv_disp_get_ver_res(NULL);
}
lv_obj_set_size(new_win, w, h);
lv_obj_set_pos(new_win, 0, 0);
lv_obj_set_style(new_win, &lv_style_pretty); lv_obj_set_style(new_win, &lv_style_pretty);
ext->page = lv_page_create(new_win, NULL); ext->page = lv_page_create(new_win, NULL);

1
src/main.cpp
View File

@ -201,7 +201,6 @@ void nimble_port_init(void) {
} }
void nimble_port_ll_task_func(void *args) { void nimble_port_ll_task_func(void *args) {
// extern void ble_ll_task(void *arg);
ble_ll_task(args); ble_ll_task(args);
} }
} }

6
src/sdk_config.h
View File

@ -8460,15 +8460,15 @@
// <e> NRF_LOG_ENABLED - nrf_log - Logger // <e> NRF_LOG_ENABLED - nrf_log - Logger
//========================================================== //==========================================================
#ifndef NRF_LOG_ENABLED #ifndef NRF_LOG_ENABLED
#define NRF_LOG_ENABLED 1 #define NRF_LOG_ENABLED 0
#endif #endif
#ifndef NRF_LOG_BACKEND_RTT_ENABLED #ifndef NRF_LOG_BACKEND_RTT_ENABLED
#define NRF_LOG_BACKEND_RTT_ENABLED 1 #define NRF_LOG_BACKEND_RTT_ENABLED 0
#endif #endif
#ifndef NRF_LOG_BACKEND_SERIAL_USES_RTT #ifndef NRF_LOG_BACKEND_SERIAL_USES_RTT
#define NRF_LOG_BACKEND_SERIAL_USES_RTT 1 #define NRF_LOG_BACKEND_SERIAL_USES_RTT 0
#endif #endif
// <h> Log message pool - Configuration of log message pool // <h> Log message pool - Configuration of log message pool