|
Back to main page |
|---|
1. FOTA presentation
The application aims to demonstrate the FOTA feature over Wi-Fi® on the ST67W611M1.
Two application variants are provided:
| Project name | Description |
|---|---|
| ST67W6X_FOTA | the FOTA application based on the ST67W611M1 network services, where the network stack and TLS handling are provided on the module side. |
| ST67W6X_FOTA_LWIP | a dedicated NUCLEO-U575ZI-Q application where the network stack and TLS handling are provided on the STM32 host side through LwIP and MbedTLS. |
Both applications start in STA mode and connect to a local access point configured by the user in "Appli/App/app_config.h". Once connected, the host creates the FOTA task and waits for an event to trigger the update procedure. The FOTA options are configured in "Appli/App/fota.h".
On NUCLEO-U575ZI-Q, both applications can update:
- the ST67W611M1 firmware directly
- the STM32 application image through the FOTA header mechanism
For targets that do not use the FOTA header mechanism, only the ST67W611M1 firmware update flow is applicable.
2. Available applications
| Application | Architecture | Application layer protocol support | Required ST67W611M1 mission profile |
|---|---|---|---|
| ST67W6X_FOTA* | ST67W611M1 network services | HTTP, with module-side HTTPS constraints | st67w611m_mission_t01_v2.x.y.bin
|
| ST67W6X_FOTA_LWIP | STM32-hosted LwIP + MbedTLS | HTTP and HTTPS | st67w611m_mission_t02_v2.x.y.bin
|
(*) the FOTA feature is also available in the ST67W6X_CLI project
3. Requirements
3.1. Software and system requirements
The software requirements are as follows (minimum IDE versions):
- STM32CubeIDE toolchain V2.1.0 [1].
- IAR Embedded Workbench for Arm (EWARM) toolchain V9.30.1
- RealView Microcontroller Development Kit (MDK-ARM) toolchain V5.39
Programmer:
- STM32CubeProgrammer [2] to program the board with a pre-generated binary file
HyperTerminal:
- Use the application through the serial link
- Open a HyperTerminal client connected to the host ST-LINK COM port
The serial COM port must be configured as below:
| Baudrate | 921600 |
| Data | 8b |
| Stopbit | 1b |
| Parity | None |
| Flow control | None |
| Rx | LF |
| Tx | LF |
| Local Echo | Off |
For more details, refer to the HyperTerminal setup page.
Two Python scripts are provided in the "Projects/ST67W6X_Scripts/FOTA" folder:
- HTTP_Server.py: HTTP/HTTPS server used to expose the FOTA binaries on a local network.
- fota_header_gen.py: FOTA header generator for NUCLEO-U575ZI-Q projects supporting the STM32 application update flow.
Both Python scripts are written with Python 3.11 in mind.
3.2. Hardware requirements
This example runs on the NUCLEO-U575ZI-Q [3] board combined with the X-NUCLEO-67W61M1 board.
The X-NUCLEO-67W61M1 board is plugged to the NUCLEO-U575ZI-Q board through the Arduino connectors:
- The 5V, 3V3, GND through CN6
- The SPI (CLK, MOSI, MISO), SPI_CS and USER_BUTTON signals through CN5
- The BOOT, CHIP_EN and SPI_RDY signals through CN9
The USER_BUTTON refers to the button mounted on the X-NUCLEO-67W61M1. The user button on the STM32 Nucleo board is not used as an external interrupt because of EXTI conflicts. The external button must be defined with the user label USER_BUTTON in EXTI falling-edge mode.
4. ST67W6X_FOTA application description
4.1. Project directory
Both applications are available in the X-CUBE-ST67W61 Expansion Package.
Refer to the Project directory wiki page for the package structure.
4.2. Project description
4.2.1. Topology structure
The device (NUCLEO-U575ZI-Q + X-NUCLEO-67W61M1) operates in STA mode and connects to a local Wi-Fi® access point. The access point can provide internet access, or it can simply provide local network connectivity when the FOTA server is hosted on the same LAN.
4.2.2. Project initialization
The different steps of the application initialization are described below:
In light blue are listed the common initialization steps between all the applications. The other steps are specific to the FOTA application.
The main initialization steps are common to both applications:
- STM32 platform initialization
- ST67W611M1 middleware initialization
- Wi-Fi STA connection to the configured access point
- FOTA task creation
- Trigger of the FOTA procedure through a timer or the external USER_BUTTON
The user can trigger the FOTA procedure either automatically through a timer or manually through the USER_BUTTON callback if set.
4.3. Build and install
Refer to the build and load chapter for details on how to build and download on the device.
4.4. User setup
The Python server script "HTTP_Server.py" provided is given for practical reasons in order to test the FOTA feature on a local setup. A different HTTP server can be used to host the FOTA binaries, provided that it exposes the expected firmware files and URIs. A HTTP server is required in order to serve the FOTA binaries to the FOTA application.
The Python header generation script "fota_header_gen.py" is used for NUCLEO-U575ZI-Q FOTA-capable projects. It generates the FOTA header in JSON format used by the application to retrieve metadata about the STM32 and ST67W611M1 binaries. It can also generate a C header file for projects that parse the FOTA header structure.
4.4.1. ST67W6X default configuration
The default System configuration can be modified in "ST67W6X/Target/w6x_config.h":
/** NCP power save mode : 0: NCP stays always active / 1: NCP goes in low power mode when idle */ #define W6X_POWER_SAVE_AUTO 1 /** NCP clock mode : 1: Internal RC oscillator, 2: External passive crystal, 3: External active crystal */ #define W6X_CLOCK_MODE 1U
The default Wi-Fi® configuration can be modified in "ST67W6X/Target/w6x_config.h":
/** Boolean to enable/disable autoconnect functionality */ #define W6X_WIFI_AUTOCONNECT 0 /** Define the region code, supported values : [CN, JP, US, EU, 00] */ #define W6X_WIFI_COUNTRY_CODE "00" /** Define if the country code will match AP's one. * 0: match AP's country code, * 1: static country code */ #define W6X_WIFI_ADAPTIVE_COUNTRY_CODE 0
The default Net configuration can be modified in "ST67W6X/Target/w6x_config.h":
/** Define the DHCP configuration : 0: NO DHCP, 1: DHCP CLIENT STA, 2: DHCP SERVER AP, 3: DHCP STA+AP */ #define W6X_NET_DHCP 1U /** String defining Wi-Fi hostname */ #define W6X_NET_HOSTNAME "ST67W61_WiFi" /** Timeout in ticks when calling W6X_Net_Recv() */ #define W6X_NET_RECV_TIMEOUT 10000U /** Timeout in ticks when calling W6X_Net_Send() */ #define W6X_NET_SEND_TIMEOUT 10000U /** Default Net socket receive buffer size * @note In the NCP, the LWIP recv function is used with a static buffer with * a fixed length of 4608 (3 * 1536). The data is read in chunks of 4608 bytes * So in order to get optimal performances, the buffer on NCP side should be twice as big */ #define W6X_NET_RECV_BUFFER_SIZE 9216U
Additionally, other options can be modified in the "ST67W6X/Target" directory with the following configuration files:
logging_config.h: logging component configurationshell_config.h: shell component configurationw6x_config.h: W6X API configuration used during initializationw61_driver_config.h: W61 driver configuration
All available definitions are provided in the template directory "Middlewares/ST/ST67W6X_Network_Driver/Conf".
4.4.2. Application configuration
The Wi-Fi® configuration used by both applications is defined in "Appli/App/app_config.h":
/** SSID of the local Access Point */ #define WIFI_SSID "MY_SSID"
/** Password of the local Access Point */ #define WIFI_PASSWORD "MY_PASSWORD"
/** Define the default factor to apply to the AP DTIM interval when connected and power save mode is enabled */ #define WIFI_DTIM 1
The logging output mode can be modified in "Appli/App/app_config.h":
/** Select output log mode [0: printf / 1: UART / 2: ITM] */ #define LOG_OUTPUT_MODE 1
The host low-power mode can be modified in "Appli/App/app_config.h":
/** Low power configuration [0: disable / 1: sleep / 2: stop / 3: standby] */ #define LOW_POWER_MODE 1
The host debugger pins can be modified in "Appli/App/app_config.h":
/** * Enable/Disable MCU Debugger pins (dbg serial wires) * @note by HW serial wires are ON by default, need to put them OFF to save power */ #define DEBUGGER_ENABLED 1
4.4.3. ST67W6X_FOTA configuration
The original ST67W6X_FOTA application uses the following default FOTA URIs in "Appli/App/fota.h":
/** The folder containing the FOTA header, ST67 binary and the STM32 binary */ #define FOTA_HTTP_URI_TARGET "/STM32U575ZI_NUCLEO"
/** Root folder of interest on the HTTP server */ #define FOTA_HTTP_COMMON_URI "/download" FOTA_HTTP_URI_TARGET
/** Default URI for the ST67 binary, should be smaller in bytes size than the value defined by FOTA_URI_MAX_SIZE */ #define FOTA_HTTP_URI FOTA_HTTP_COMMON_URI "/st67w611m_mission_t01_v2.0.106.bin.ota"
/** Default URI for the STM32 binary, should be smaller in bytes size than the value defined by FOTA_URI_MAX_SIZE */ #define FOTA_HTTP_URI_STM32 FOTA_HTTP_COMMON_URI "/fota_ST67W6X_FOTA.bin"
/** Default URI for the FOTA header */ #define FOTA_HTTP_URI_HEADER FOTA_HTTP_COMMON_URI "/ST67W611_STM32U575ZI_NUCLEO.json"
4.4.4. ST67W6X_FOTA_LWIP configuration
The ST67W6X_FOTA_LWIP application is a dedicated NUCLEO-U575ZI-Q project. In addition to the common Wi-Fi and FOTA settings, it integrates host-side LwIP and MbedTLS components to support HTTP and HTTPS transfers.
The default FOTA URIs in "Appli/App/fota.h" are:
/** The folder containing the FOTA header, ST67 binary and the STM32 binary */ #define FOTA_HTTP_URI_TARGET "/STM32U575ZI_NUCLEO"
/** Root folder of interest on the HTTP server */ #define FOTA_HTTP_COMMON_URI "/download" FOTA_HTTP_URI_TARGET
/** Default URI for the ST67 binary, should be smaller in bytes size than the value defined by FOTA_URI_MAX_SIZE */ #define FOTA_HTTP_URI FOTA_HTTP_COMMON_URI "/st67w611m_mission_t02_v2.0.106.bin.ota"
/** Default URI for the STM32 binary, should be smaller in bytes size than the value defined by FOTA_URI_MAX_SIZE */ #define FOTA_HTTP_URI_STM32 FOTA_HTTP_COMMON_URI "/fota_ST67W6X_FOTA_LWIP.bin"
/** Default URI for the FOTA header */ #define FOTA_HTTP_URI_HEADER FOTA_HTTP_COMMON_URI "/ST67W611_STM32U575ZI_NUCLEO.json"
Compared to ST67W6X_FOTA, this application adds:
- host-side LwIP for TCP/IP, DNS and socket handling
- host-side MbedTLS for TLS support
- a dedicated HTTP/HTTPS client based on LwIP sockets
4.5. Python tooling
4.5.1. Python FOTA header generation script (NUCLEO-U575ZI-Q)
The Python script Projects/ST67W6X_Scripts/FOTA/fota_header_gen.py generates a FOTA header depending on the arguments provided, and all generated files are stored in a dedicated folder.
The folder is named according to the -b (board prefix) and -t (board name) arguments. The resulting folder name is <board_name>_<board_prefix>, and its location can be defined with the -o argument.
The script supports two modes:
install_header: generates the JSON header content and prepares the FOTA delivery setgen_header: generates the C header description file used at build time
usage: fota_header_gen.py [-h] {install_header,gen_header} ...
When using install_header, the following parameters are available:
usage: fota_header_gen.py install_header [-h] -i INPUT -n ST67 -t TARGET -r BOARD_REVISION -b PREFIX_BOARD -w FIRMWARE_TYPE [-o OUTPUT_DIR] [-f FORMAT] -v VERSION -c ST67_VERSION [-l]
Example:
python fota_header_gen.py install_header -v 1.2.0 -c 2.0.106 -t STM32U575ZI -b NUCLEO -r C05 -w NCP1 -n ../Binaries/NCP_Binaries/st67w611m_mission_t01_v2.0.106.bin.ota -i ../Binaries/NUCLEO-U575ZI-Q_Binaries/ST67W6X_FOTA.bin
The generated folder is similar to the following:
/STM32U575ZI_NUCLEO
Containing, for example:
├── fota_ST67W6X_FOTA.bin # STM32 application binary ├── ST67W611_STM32U575ZI_NUCLEO.json # File describing the FOTA binaries ├── st67w611m_mission_t01_v2.0.106.bin.ota # ST67W611M1 binary
These files must then be exposed by the HTTP or HTTPS server used.
For the ST67W6X_FOTA_LWIP application, the same generation flow applies, but the ST67W611M1 binary and STM32 application image names must match the LwIP-based project outputs.
| Parameter | Description | Example |
|---|---|---|
| -v <STM32 version> | Specify the version of the STM32 binary used for FOTA, in x.y.z format | -v 1.2.0 |
| -c <ST67W611M1 version> | Specify the version of the ST67W611M1 binary used for FOTA, in x.y.z format | -c 2.0.106 |
| -t <STM32 board name> | Specify the STM32 target name | -t STM32U575ZI |
| -b <STM32 board prefix> | Specify the STM32 board family or prefix | -b NUCLEO |
| -r <STM32 board revision> | Specify the STM32 board revision | -r C05 |
| -w <ST67W611M1 binary type> | Specify the ST67W611M1 firmware type | -w NCP1 |
| -n <ST67W611M1 binary path> | Path to the ST67W611M1 binary used for FOTA | -n ../Binaries/NCP_Binaries/st67w611m_mission_t01_v2.0.106.bin.ota |
| -i <STM32 binary path> | Path to the STM32 binary used for FOTA | -i ../Binaries/NUCLEO-U575ZI-Q_Binaries/ST67W6X_FOTA.bin |
| -o <output path> | Optional location of the generated files | -o ../Binaries/NCP_Binaries/ |
When using gen_header, the output directory can be selected to generate the header structure in C format. This mode is typically used during compilation for NUCLEO-U575ZI-Q applications supporting the STM32 update flow.
usage: fota_header_gen.py gen_header [-h] [-o OUTPUT_DIR] [-l]
4.5.2. Python HTTP server script (all targets supporting FOTA)
The Python script Projects/ST67W6X_Scripts/FOTA/HTTP_Server.py exposes a given directory defined by FIRMWARE_DIR and only serves files whose extensions are listed in FILE_EXTENSIONS_TO_SHOW.
By default, the script serves the files using the /download/ URI prefix followed by the requested file. This URI prefix can be overridden by changing HTTP_FIRMWARE_DIR_PATH.
If the Python HTTP server is used, it must be started before launching the FOTA application.
python HTTP_server.py
The script can be configured in "HTTP_Server.py":
# IP to use for the server
IP = ''
# Port to use for the server
PORT = 8000
HTTPS_PORT = 8443
# Directory where the firmware files are stored
FIRMWARE_DIR = "../Binaries/NCP_Binaries"
# Name of the file containing the firmware version information
FIRMWARE_VERSION_FILE = "NCP.json"
# Paths exposed by the server
HTTP_FIRMWARE_VERSION_FILE_PATH = "/check_update"
HTTP_FIRMWARE_DIR_PATH = "/download/"
INDEX_PAGE = "/"
BINARIES = "/binaries"
HTTP_DEFAULT_VERSION = "HTTP/1.1"
FILE_EXTENSIONS_TO_SHOW = [".bin", ".ota", ".xz", ".json"]
DEFAULT_LOGGING_LEVEL = "DEBUG"
DEFAULT_THREADING_OPTION = True
DEFAULT_SSL_CERTFILE = "cert.pem"
DEFAULT_SSL_KEYFILE = "key.pem"
The script can also be configured at runtime:
python HTTP_Server.py --port 8080 --ip 127.0.0.1 --firmware-dir STM32U575ZI_NUCLEO
When validating the ST67W6X_FOTA_LWIP application over HTTPS, TLS can be enabled with:
python HTTP_Server.py --enable_https --certfile cert.pem --keyfile key.pem --firmware-dir STM32U575ZI_NUCLEO
The help description of the script can be obtained with:
python HTTP_server.py --help
The relevant options are:
| Parameter | Description |
|---|---|
| -h or --help | Get the list of configurable parameters |
| -p <numeric value> or --port <numeric value> | Set the port of the HTTP server |
| -ps <numeric value> or --https-port <numeric value> | Set the port of the HTTPS server |
| -i <ip format x.x.x.x> or --ip <ip format x.x.x.x> | Set the IP address of the server |
| -l <DEBUG, INFO, WARNING, ERROR, CRITICAL> or --log-level <DEBUG, INFO, WARNING, ERROR, CRITICAL> | Select the logging level |
| -f <binary/folder/> or --firmware-dir <my/binary/folder/> | Directory containing the FOTA binaries to be exposed by the server |
| -s or --enable-https | Enable HTTPS alongside the HTTP server |
| -c <certificate/file.pem> or --certfile <certificate/file.pem> | Location of the certificate file for HTTPS |
| -k <key/file.pem> or --keyfile <key/file.pem> | Location of the key file for HTTPS |
4.6. How it works
4.6.1. FOTA application for ST67W611M1 only
The connection of the STA is done after a scan of the local AP, and the device receives an IP address from the DHCP server of the selected AP. The FOTA task is then created and launched, waiting for a specific event before starting the FOTA procedure.
A timer can be used to trigger the FOTA event after a defined amount of time:
SetFOTATimer(FOTA_TIMER_VALUE_IN_MS); StartFOTATimer();
It performs a callback when the timer expires:
void vFOTATimerCallback(TimerHandle_t xTimer)
{
(void)TriggerFOTAUpdate();
}
Another option is to use the external user button to trigger the FOTA event:
void HAL_GPIO_EXTI_Falling_Callback(uint16_t pin)
{
...
if (pin == USER_BUTTON_Pin)
{
TriggerFOTAUpdate();
Button_Falling_Callback();
}
}
Once triggered, the FOTA starts using the parameters specified in "Appli\App\fota.c" in order to establish a connection and retrieve data from the HTTP or HTTPS server.
The update of the ST67W611M1 is performed while retrieving data from the network communication.
Once all data is received from the server, it has been transferred to the ST67W611M1 device. A verification on the ST67W611M1 side validates that the received update can be used.
The ST67W611M1 then reboots on the new firmware. The FOTA application waits for the ready signal from the ST67W611M1 and then reinitializes the communication context.
Before the reboot sequence happens, a completion callback can be registered by the FOTA task:
/* Register the callback to be called when the FOTA process is completed */
Fota_RegisterCallbacks(Fota_CompletionCb, NULL);
Expected signs of success are the following:
- the STA connects successfully to the access point and receives an IP address
- the FOTA task starts and the HTTP request is sent successfully
- the ST67W611M1 binary is fully transferred
- the module applies the new binary and reports a successful completion
- after the update, the reported SDK version changes from the initial example version to the new target version
Representative output should be similar to the following:
Connection success
***************FOTA TEST ***************
Init FOTA callbacks for SHELL usage
IP Address from Hostname [192.168.179.104]: 192.168.179.104
FOTA update started: server=192.168.179.104, port=8000, uri=/download/STM32U575ZI_NUCLEO/st67w611m_mission_t01_v2.0.106.bin.ota
Socket creation done
Socket 0 connected
HTTP request send data success (144)
...
FOTA transfer done
Apply ST67 new binary...
ST67 binary installation completed
***************FOTA SHELL SUCCESS *******
#### Welcome to ST67W6X Wi-Fi FOTA Application #####
# build: 17:30:03 Mar 25 2026
--------------- Host info ---------------
Host FW Version: 1.3.0
--------------- ST67W6X info ------------
ST67W6X MW Version: 1.3.0
AT Version: 1.0.0
SDK Version: 2.0.106
Wi-Fi MAC Version: 1.6.44
BT Controller Version: 1.6.128
BT Stack Version: 1.10.83
Build Date: Mar 20 2026 09:32:19
...
Connection success
***************FOTA TEST ***************
Init FOTA callbacks for SHELL usage
IP Address from Hostname [192.168.179.104]: 192.168.179.104
FOTA update started: server=192.168.179.104, port=8000, uri=/download/STM32U575ZI_NUCLEO/st67w611m_mission_t01_v2.0.106.bin.ota
Socket creation done
Socket 0 connected
Socket 1 connected
Sending HTTP request, request size: (165)
total len 1486208
ST67 FWU header successfully transferred
FOTA data length 2048 xfer to ST67
...
FOTA data length 1299 xfer to ST67
FOTA data transfer to ST67 finished
FOTA transfer done
FOTA task waiting for application acknowledgment
Station disconnected from Access Point
Wi-Fi Disconnect success
FOTA task done
Apply ST67 new binary...
ST67 binary installation completed
***************FOTA SHELL SUCCESS *******
The following diagram summarizes the different steps performed when FOTA operation is triggered.
4.6.2. FOTA application for ST67W611M1 and STM32 (supported by NUCLEO-U575ZI-Q only)
The connection of the STA is done after a scan of the local AP, and the device receives an IP address from the DHCP server of the selected AP. The FOTA task is created and launched, awaiting a specific event before starting the FOTA process.
As with the ST67W611M1-only flow, the trigger can come from the timer or from the user button callback.
Once triggered, the FOTA starts using the parameters specified in "Appli\App\fota.c" in order to establish a connection and retrieve data from the server.
For NUCLEO-U575ZI-Q, the application first fetches the FOTA header to retrieve information about the binaries to be downloaded.
After the JSON header file is successfully retrieved, the application parses it and uses the information to determine whether the update process can continue. The header also carries the integrity information later used to validate the STM32 binary.
Once the verification steps have passed, the update of the ST67W611M1 is performed while retrieving data from the communication channel.
Once all data is received from the server, it means that the ST67W611M1 update has been fully transferred. After this step is completed, the STM32 binary is downloaded and stored in the NUCLEO-U575ZI-Q flash memory.
An integrity check is then launched to ensure that all operations were successful, using the SHA256 information provided by the FOTA header.
To apply the update, a verification on the ST67W611M1 side validates that the received image is valid. The ST67W611M1 then reboots on the new firmware, and the FOTA application waits for the ready signal from the ST67W611M1 before rebooting the NUCLEO-U575ZI-Q device.
The NUCLEO-U575ZI-Q is configured to boot from the flash bank containing the newly downloaded binary.
Expected signs of success are the following:
- the JSON FOTA header is downloaded and parsed successfully
- the ST67W611M1 binary transfer completes successfully
- the STM32 image is written to the alternate flash bank
- the integrity check passes before reboot
- the updated application starts from the new bank after reboot
- after the update, the reported SDK version changes from the initial example version to the new target version
Representative output should be similar to the following:
FOTA update started: server=192.168.179.104, port=8000, uri=/download/STM32U575ZI_NUCLEO/ST67W611_STM32U575ZI_NUCLEO.json
FOTA header fully received
FOTA update started: server=192.168.179.104, port=8000, uri=/download/STM32U575ZI_NUCLEO/st67w611m_mission_t01_v2.0.106.bin.ota
...
Mass erase done
FOTA update started: server=192.168.179.104, port=8000, uri=/download/STM32U575ZI_NUCLEO/fota_ST67W6X_FOTA.bin
...
STM32 integrity check passes
FOTA transfer done
Apply ST67 new binary...
ST67 binary installation completed
Application started from bank 2
#### Welcome to ST67W6X Wi-Fi FOTA Application #####
# build: 17:30:03 Mar 25 2026
--------------- Host info ---------------
Host FW Version: 1.3.0
--------------- ST67W6X info ------------
ST67W6X MW Version: 1.3.0
AT Version: 1.0.0
SDK Version: 2.0.106
Wi-Fi MAC Version: 1.6.44
BT Controller Version: 1.6.128
BT Stack Version: 1.10.83
Build Date: Mar 20 2026 09:32:19
...
Connection success
***************FOTA TEST ***************
Init FOTA callbacks for SHELL usage
IP Address from Hostname [192.168.179.104]: 192.168.179.104
FOTA update started: server=192.168.179.104, port=8000, uri=/download/STM32U575ZI_NUCLEO/ST67W611_STM32U575ZI_NUCLEO.json
Socket creation done
Socket 0 connected
Sending HTTP request, request size: (154)
Socket 0 disconnected
total len 358
Received 358 bytes of header data, total accumulated: 0 bytes
FOTA header fully received
FOTA header:
Magic number: ST67W611
Header protocol version: 1.0.0
Data type: STM32U575ZI
Firmware type: NCP1
...
FOTA update started: server=192.168.179.104, port=8000, uri=/download/STM32U575ZI_NUCLEO/st67w611m_mission_t01_v2.0.106.bin.ota
...
FOTA data transfer to ST67 finished
Mass erase done
FOTA update started: server=192.168.179.104, port=8000, uri=/download/STM32U575ZI_NUCLEO/fota_ST67W6X_FOTA.bin
Socket creation done
Socket 0 connected
Socket 2 connected
Sending HTTP request, request size: (142)
Total len 249600
Wrote 1264 bytes to flash at address 0x08100000
Wrote 1456 bytes to flash at address 0x081004f0
...
Finished writing FOTA STM32 binary into flash
STM32 binary integrity check passes
FOTA transfer done
FOTA task waiting for application acknowledgment
Station disconnected from Access Point
Reason: WLAN_FW_DISCONNECT_BY_USER_WITH_DEAUTH
Wi-Fi Disconnect success
FOTA task done
Apply ST67 new binary...
ST67 binary installation completed
#### Welcome to ST67W6X FOTA Application #####
...
--------------- Host info ---------------
Host FW Version: 1.3.0
--------------- ST67W6X info ------------
...
SDK Version: 2.0.106
...
Application started from bank 2
4.7. Comparison summary
The table below compares the application scope and architecture. The STM32 application update row applies only when the project runs on NUCLEO-U575ZI-Q.
| Feature | ST67W6X_FOTA | ST67W6X_FOTA_LWIP |
|---|---|---|
| ST67W611M1 mission profile | T01 | T02 |
| Network architecture | ST67W611M1 network services | STM32-hosted LwIP |
| TLS support | Module-side constraints apply | Host-side MbedTLS |
| HTTP support | Yes | Yes |
| HTTPS support | Limited by T01/module-side SSL behavior | Yes, through host-side LwIP and MbedTLS |
4.8. Memory footprint
| Module | Description |
|---|---|
| [Driver] HAL/CMSIS/BSP | STM32 CMSIS Cortex, HAL and LL, Board Specific Package drivers |
| [Project] Core | Native STM32 core components |
| [Project] App | Main part of the application |
| [Project] Target | Configuration files for ST67W6X_Network_Driver component |
| [MW] ST67W6X_Network_Driver | Core and API System, Wi-Fi®, Network, HTTP and FOTA components Util/Logging: Utility to process shell and trace messages onto the UART interface (can be changed by ITM) |
| [MW] FreeRTOS | FreeRTOS kernel source |
| [Utility] lpm | Tiny Low-Power Management |
| [Toolchain] Startup | Int_vect, init routines, init table, CSTACK and HEAP |
| [Toolchain] EWARM Libraries | Native compiler libraries |
These values depend on the chosen toolset and they can change in next releases.
4.8.1. ROM/Flash memory footprint
The picture below shows the sum of the read only memory (flash) of the FOTA and FOTA_LWIP applications.
The picture below shows the middleware ST67W6X_Network_Driver read-only memory (flash) used by the FOTA and FOTA_LWIP applications.
4.8.2. Read/Write (RW) memory footprint
The picture below shows only the sum of the static read/write memory (static RAM) of the FOTA and FOTA_LWIP applications.
