LibreTiny

https://docs.libretiny.eu
Admin
LibreTiny is a PlatformIO development platform providing Arduino-compatible cores for IoT chips...
Tokens:334,250
Snippets:2,676
Trust Score:3.3
Update:6 months ago
Show doc for...
Tokens:
Raw
### Example PlatformIO Configuration

Source: https://docs.libretiny.eu/docs/contrib/porting

Use a pure PlatformIO project with `framework = base` in `platformio.ini`. This example shows a basic setup for a generic board.

```ini
[env:generic]
platform = toolchain-xtensa-esp32
board = esp32dev
framework = base
```

--------------------------------

### Install MkDoxy Manually

Source: https://docs.libretiny.eu/src/mkdoxy

Install MkDoxy manually by cloning the repository and running the setup script. This is an alternative to using pip.

```bash
git clone https://github.com/JakubAndrysek/mkdocs-doxygen-snippets-plugin.git
cd mkdocs-doxygen-snippets-plugin
python setup.py install

```

--------------------------------

### Start WebServer

Source: https://docs.libretiny.eu/ltapi/_web_server_8cpp_source

Methods to start the web server, optionally specifying a port.

```cpp
void WebServer::begin() {
    close();
    _server.begin();
    _server.setNoDelay(true);
}
```

```cpp
void WebServer::begin(uint16_t port) {
    close();
    _server.begin(port);
    _server.setNoDelay(true);
}
```

--------------------------------

### Install ltchiptool with GUI extras

Source: https://docs.libretiny.eu/docs/flashing/tools/ltchiptool

Installation command including dependencies required for the graphical interface.

```bash
pip install ltchiptool[gui]
```

--------------------------------

### Install Git

Source: https://docs.libretiny.eu/docs/flashing/tools/cloudcutter

Installs the Git version control system if it is not already present.

```bash
sudo apt-get install git
```

--------------------------------

### LwIPServer::begin

Source: https://docs.libretiny.eu/ltapi/class_lw_i_p_server

Starts the server listening on the specified port.

```APIDOC
## LwIPServer::begin

### Description
Starts the server to begin listening for incoming connections.

### Parameters
- **port** (uint16_t) - Optional - The port to listen on.
- **reuseAddr** (bool) - Optional - Whether to allow address reuse (default true).

### Response
- **bool** - Returns true if the server started successfully, false otherwise.
```

--------------------------------

### Start main task

Source: https://docs.libretiny.eu/ltapi/wiring__custom_8h

Initializes the main system task.

```cpp
bool startMainTask (
    void
) 
```

--------------------------------

### Install ltchiptool via pip

Source: https://docs.libretiny.eu/docs/flashing/tools/ltchiptool

Standard installation command for the CLI version of the tool.

```bash
pip install ltchiptool
```

--------------------------------

### PlatformIO Package Workflow Example

Source: https://docs.libretiny.eu/docs/contrib/porting

This example references a GitHub Actions workflow file used for creating PlatformIO packages by removing specific files and adding a `package.json`.

```yaml
# framework-beken-bdk/.github/workflows/platformio-package.yml
# Example workflow for creating PlatformIO packages
```

--------------------------------

### UF2 File Information

Source: https://docs.libretiny.eu/docs/flashing/tools/ltchiptool

Example of how to get information about a UF2 file using the `ltchiptool uf2 info` command.

```APIDOC
## UF2 File Information

This command provides details about a UF2 file, including family, tags, and binary size.

### Command Example

```
$ ltchiptool uf2 info ./arduinotest_22.08.01_wb2l_BK7231T_lt0.8.0.uf2
```

### Output Example

```
Family: BK7231T / Beken 7231T
Tags:
 - BOARD: wb2l
 - DEVICE_ID: d80e20c2
 - LT_VERSION: 0.8.0
 - FIRMWARE: arduinotest
 - VERSION: 22.08.01
 - OTA_VERSION: 01
 - DEVICE: LibreTiny
 - BUILD_DATE: 6d08e862
 - LT_HAS_OTA1: 01
 - LT_HAS_OTA2: 00
 - LT_PART_1: app
 - LT_PART_2:
Data chunks: 1871
Total binary size: 478788
```
```

--------------------------------

### Install MkDoxy using Pip

Source: https://docs.libretiny.eu/src/mkdoxy

Install the MkDoxy plugin using pip for easy integration with your MkDocs project.

```bash
pip install mkdocs-doxygen-snippets-plugin

```

--------------------------------

### Install Docker

Source: https://docs.libretiny.eu/docs/flashing/tools/cloudcutter

Installs Docker on Debian-based systems. After installation, add your user to the docker group and reboot.

```bash
sudo apt-get install docker.io
sudo adduser <your username> docker
```

--------------------------------

### Launch ltchiptool GUI

Source: https://docs.libretiny.eu/docs/flashing/tools/ltchiptool

Commands to start the graphical user interface.

```bash
ltchiptool gui
```

```bash
python -m ltchiptool gui
```

--------------------------------

### Run ltchiptool CLI

Source: https://docs.libretiny.eu/docs/flashing/tools/ltchiptool

Commands to execute the CLI utility after installation.

```bash
python -m ltchiptool
```

```bash
ltchiptool
```

--------------------------------

### Get Full Version String

Source: https://docs.libretiny.eu/ltapi/class_esp_class

Retrieves the full version string of the SDK.

```cpp
inline String EspClass::getFullVersion () 


```

--------------------------------

### begin (IPAddress, uint16_t)

Source: https://docs.libretiny.eu/ltapi/class_i_wi_fi_u_d_p

Starts the UDP connection to a specific IP address and port.

```APIDOC
## begin (IPAddress ip, uint16_t port)

### Description

Starts the UDP connection to a specific IP address and port.

### Method

POST

### Endpoint

N/A

### Parameters

#### Path Parameters

N/A

#### Query Parameters

N/A

#### Request Body

- **ip** (IPAddress) - Required - The IP address to connect to.
- **port** (uint16_t) - Required - The port number to connect to.

### Response

#### Success Response (200)

- **uint8_t** - Returns 1 on success, 0 on failure.
```

--------------------------------

### beginMulticastPacket

Source: https://docs.libretiny.eu/ltapi/class_i_wi_fi_u_d_p

Starts building a multicast UDP packet.

```APIDOC
## beginMulticastPacket

### Description

Starts building a multicast UDP packet. Call write() to send data, and endPacket() to send the packet.

### Method

POST

### Endpoint

N/A

### Parameters

N/A

### Response

#### Success Response (200)

- **int** - Returns 1 if the packet was created successfully, 0 otherwise.
```

--------------------------------

### LwIPServer begin()

Source: https://docs.libretiny.eu/ltapi/class_lw_i_p_server

Starts the server listening on the specified port. Optionally allows reusing the address. Implements IWiFiServer::begin.

```cpp
virtual bool LwIPServer::begin (
    uint16_t port=0,
    bool reuseAddr=true
)


```

--------------------------------

### Get Total RAM Size

Source: https://docs.libretiny.eu/ltapi/lt__mem_8h_source

Retrieves the total size of the system's RAM in bytes. No specific setup is required.

```c
#include <libretiny.h>

uint32_t lt_ram_get_size();
```

--------------------------------

### Server Control and Configuration

Source: https://docs.libretiny.eu/ltapi/class_web_server

Functions for starting, stopping, and configuring the web server.

```APIDOC
## Server Control and Configuration

### Description
Methods to control the lifecycle of the WebServer and configure its behavior, including CORS and authentication.

### Methods
- **begin()**: Starts the web server.
- **begin(uint16_t port)**: Starts the web server on a specific port.
- **client()**: Returns the current WiFiClient.
- **close()**: Closes the web server connection.
- **collectHeaders(const char * headerKeys, const size_t headerKeysCount)**: Collects specified headers.
- **enableCORS(boolean value=true)**: Enables or disables Cross-Origin Resource Sharing.
- **enableCrossOrigin(boolean value=true)**: Alias for enableCORS.
- **enableDelay(boolean value)**: Enables or disables delay functionality.
- **handleClient()**: Handles an incoming client request.
- **authenticate(const char * username, const char * password)**: Authenticates a user.
- **requestAuthentication(HTTPAuthMethod mode=BASIC_AUTH, const char * realm=NULL, const String & authFailMsg=String(""))**: Requests authentication from the client.
- **stop()**: Stops the web server.
```

--------------------------------

### Get Free Heap Size

Source: https://docs.libretiny.eu/ltapi/lt__mem_8h

Retrieves the currently available free memory in the heap. No specific setup is required beyond including the library.

```c
uint32_t lt_heap_get_free () 


```

--------------------------------

### beginPacket

Source: https://docs.libretiny.eu/ltapi/class_i_wi_fi_u_d_p

Starts building a UDP packet to be sent to the last remote host and port.

```APIDOC
## beginPacket

### Description

Starts building a UDP packet to be sent to the last remote host and port. Call write() to send data, and endPacket() to send the packet.

### Method

POST

### Endpoint

N/A

### Parameters

N/A

### Response

#### Success Response (200)

- **int** - Returns 1 if the packet was created successfully, 0 otherwise.
```

--------------------------------

### Get Minimum Free Heap Level

Source: https://docs.libretiny.eu/ltapi/lt__mem_8h

Returns the lowest recorded level of free heap memory. This can indicate potential memory pressure or the point at which allocations might start failing.

```c
uint32_t lt_heap_get_min_free () 


```

--------------------------------

### begin()

Source: https://docs.libretiny.eu/ltapi/class_serial_class

Initializes serial communication with the specified baud rate, configuration, and optional RX/TX pins.

```APIDOC
## begin(baudrate, config, rx, tx)

### Description
Initializes serial communication with the specified baud rate, configuration, and optional RX/TX pins.

### Method
POST

### Endpoint
/serial/begin

### Parameters
#### Path Parameters
None

#### Query Parameters
None

#### Request Body
- **baudrate** (unsigned long) - Required - The baud rate for serial communication.
- **config** (uint16_t) - Required - The configuration for serial communication.
- **rx** (pin_size_t) - Optional - The RX pin.
- **tx** (pin_size_t) - Optional - The TX pin.

### Request Example
```json
{
  "baudrate": 9600,
  "config": 1,
  "rx": 0,
  "tx": 1
}
```

### Response
#### Success Response (200)
None (void function)
```

```APIDOC
## begin(baudrate, config)

### Description
Initializes serial communication with the specified baud rate and configuration.

### Method
POST

### Endpoint
/serial/begin

### Parameters
#### Path Parameters
None

#### Query Parameters
None

#### Request Body
- **baudrate** (unsigned long) - Required - The baud rate for serial communication.
- **config** (uint16_t) - Required - The configuration for serial communication.

### Request Example
```json
{
  "baudrate": 9600,
  "config": 1
}
```

### Response
#### Success Response (200)
None (void function)
```

```APIDOC
## begin(baudrate)

### Description
Initializes serial communication with the specified baud rate.

### Method
POST

### Endpoint
/serial/begin

### Parameters
#### Path Parameters
None

#### Query Parameters
None

#### Request Body
- **baudrate** (unsigned long) - Required - The baud rate for serial communication.

### Request Example
```json
{
  "baudrate": 9600
}
```

### Response
#### Success Response (200)
None (void function)
```

--------------------------------

### HTTPClient::begin with WiFiClient and URL

Source: https://docs.libretiny.eu/ltapi/_h_t_t_p_client_8cpp_source

Initializes the HTTP client with a WiFiClient instance and a URL, parsing the protocol (HTTP/HTTPS) and setting up the connection parameters.

```cpp
bool HTTPClient::begin(WiFiClient &client, String url) {
#ifdef HTTPCLIENT_1_1_COMPATIBLE
    if (_tcpDeprecated) {
        log_d("mix up of new and deprecated api");
        _canReuse = false;
        end();
    }
#endif

    _client = &client;

    // check for : (http: or https:)
    int index = url.indexOf(':');
    if (index < 0) {
        log_d("failed to parse protocol");
        return false;
    }

    String protocol = url.substring(0, index);
    if (protocol != "http" && protocol != "https") {
        log_d("unknown protocol '%s'", protocol.c_str());
        return false;
    }

    _port   = (protocol == "https" ? 443 : 80);
    _secure = (protocol == "https");
    return beginInternal(url, protocol.c_str());
}
```

--------------------------------

### GET /

Source: https://docs.libretiny.eu/ltapi/class_h_t_t_p_client

Sends an HTTP GET request to the configured URL.

```APIDOC
## GET /

### Description
Sends an HTTP GET request to the previously configured URL.

### Method
GET

### Response
- **int** - Returns the HTTP response code.
```

--------------------------------

### Initialize and Run Arduino Framework

Source: https://docs.libretiny.eu/ltapi/main_8c_source

Initializes the Arduino framework and starts the main task loop. Requires the LibreTiny Arduino environment.

```c
/* Copyright (c) Kuba Szczodrzyński 2023-02-27. */

#include <Arduino.h>

int main() {
    // initialize Arduino framework
    lt_init_arduino();
    // start the main task and OS kernel
    if (!startMainTask()) {
        LT_F("Couldn't start the main task");
        return 1;
    }
    return 0;
}

void mainTask(const void *arg) {
    setup();

    for (;;) {
        loop();
        yield();
    }
}
```

--------------------------------

### WebServer Initialization

Source: https://docs.libretiny.eu/ltapi/class_web_server

Methods to initialize the WebServer instance.

```APIDOC
## WebServer Constructor

### Description
Initializes a new instance of the WebServer.

### Parameters
- **addr** (IPAddress) - Optional - The IP address to bind to.
- **port** (int) - Optional - The port to listen on (default 80).
```

--------------------------------

### HTTPClient GET Method

Source: https://docs.libretiny.eu/ltapi/class_members

Documentation for the GET method within the HTTPClient class.

```APIDOC
## GET (HTTPClient)

### Description
Performs an HTTP GET request using the HTTPClient class.

### Method
GET

### Endpoint
HTTPClient::GET
```

--------------------------------

### Initialize LibreTiny System

Source: https://docs.libretiny.eu/ltapi/lt__main_8c_source

The lt_main function serves as the primary entry point for system initialization, setting up the environment before calling the main application.

```c
/* Copyright (c) Kuba Szczodrzyński 2022-06-19. */

#include <libretiny.h>

#include <fal.h>

fal_partition_t fal_root_part = NULL;

// Initialize C library
void __libc_init_array(void);
// Main app entrypoint
int main(void);

int lt_main(void) {
    // early initialize the family and variant
    lt_init_family();
    lt_init_variant();
    // print a startup banner
    LT_BANNER();
    // initialize C library
    __libc_init_array();
    // inform about the reset reason
    LT_I("Reset reason: %s", lt_get_reboot_reason_name(0));
    // initialize FAL
    fal_init();
    // provide root partition
    fal_root_part = (fal_partition_t)fal_partition_find("root");

    // run the application
    return main();
}
```

--------------------------------

### mainTask()

Source: https://docs.libretiny.eu/ltapi/main_8c

The main task responsible for executing the Arduino setup() and loop() functions.

```APIDOC
## mainTask(const void * arg)

### Description
This function handles the main setup() and loop() execution cycle. It is intended for internal use and should not be called directly.

### Parameters
#### Arguments
- **arg** (const void *) - Required - Argument passed to the task.
```

--------------------------------

### Initialize SoftwareSerial (Basic)

Source: https://docs.libretiny.eu/ltapi/class_software_serial

Begins serial communication at the specified baud rate. This is the basic version of the begin function.

```cpp
inline void SoftwareSerial::begin (
    unsigned long baudrate
)


```

--------------------------------

### Basic Hello World Program

Source: https://docs.libretiny.eu/docs/contrib/porting

A simple C 'Hello World' program with a `main()` function and a `while(1)` loop, suitable for initial testing during porting.

```c
int main() {
    printf("Hello World\n");
    while(1);
}
```

--------------------------------

### HTTPClient GET Request

Source: https://docs.libretiny.eu/ltapi/class_h_t_t_p_client

Initiates an HTTP GET request. This method is used when retrieving data from a server.

```cpp
int HTTPClient::GET ()


```

--------------------------------

### begin (uint16_t)

Source: https://docs.libretiny.eu/ltapi/class_i_wi_fi_u_d_p

Starts the UDP connection to a specific port, listening on any available network interface.

```APIDOC
## begin (uint16_t port)

### Description

Starts the UDP connection to a specific port, listening on any available network interface.

### Method

POST

### Endpoint

N/A

### Parameters

#### Path Parameters

N/A

#### Query Parameters

N/A

#### Request Body

- **port** (uint16_t) - Required - The port number to listen on.

### Response

#### Success Response (200)

- **uint8_t** - Returns 1 on success, 0 on failure.
```

--------------------------------

### Get WiFi Channel

Source: https://docs.libretiny.eu/ltapi/class_wi_fi_class

Returns the current WiFi channel. Use the overloaded version to get the channel for a specific network item from a scan.

```cpp
int32_t WiFiClass::channel ()

```

```cpp
int32_t WiFiClass::channel (
    uint8_t networkItem
)

```

--------------------------------

### Initialize WebServer

Source: https://docs.libretiny.eu/ltapi/_web_server_8cpp_source

Constructors for the WebServer class, allowing initialization with either an IP address and port or just a port.

```cpp
WebServer::WebServer(IPAddress addr, int port)
    : _corsEnabled(false), _server(addr, port), _currentMethod(HTTP_ANY), _currentVersion(0), _currentStatus(HC_NONE),
      _statusChange(0), _nullDelay(true), _currentHandler(nullptr), _firstHandler(nullptr), _lastHandler(nullptr),
      _currentArgCount(0), _currentArgs(nullptr), _postArgsLen(0), _postArgs(nullptr), _headerKeysCount(0),
      _currentHeaders(nullptr), _contentLength(0), _chunked(false) {
    log_v("WebServer::Webserver(addr=%s, port=%d)", ipToString(addr).c_str(), port);
}
```

```cpp
WebServer::WebServer(int port)
    : _corsEnabled(false), _server(port), _currentMethod(HTTP_ANY), _currentVersion(0), _currentStatus(HC_NONE),
      _statusChange(0), _nullDelay(true), _currentHandler(nullptr), _firstHandler(nullptr), _lastHandler(nullptr),
      _currentArgCount(0), _currentArgs(nullptr), _postArgsLen(0), _postArgs(nullptr), _headerKeysCount(0),
      _currentHeaders(nullptr), _contentLength(0), _chunked(false) {
    log_v("WebServer::Webserver(port=%d)", port);
}
```

--------------------------------

### Get DNS IP Address

Source: https://docs.libretiny.eu/ltapi/class_wi_fi_class

Retrieves the IP address of a configured DNS server. Specify the DNS server number (0 or 1) to get the corresponding IP.

```cpp
IPAddress WiFiClass::dnsIP (
    uint8_t dns_no=0
)

```

--------------------------------

### beginMulticast

Source: https://docs.libretiny.eu/ltapi/class_i_wi_fi_u_d_p

Starts listening for multicast UDP packets on a specific IP address and port.

```APIDOC
## beginMulticast (IPAddress ip, uint16_t port)

### Description

Starts listening for multicast UDP packets on a specific IP address and port.

### Method

POST

### Endpoint

N/A

### Parameters

#### Path Parameters

N/A

#### Query Parameters

N/A

#### Request Body

- **ip** (IPAddress) - Required - The multicast IP address to join.
- **port** (uint16_t) - Required - The port number to listen on.

### Response

#### Success Response (200)

- **uint8_t** - Returns 1 on success, 0 on failure.
```

--------------------------------

### mDNS::begin

Source: https://docs.libretiny.eu/ltapi/classm_d_n_s

Initializes the mDNS client with a specified hostname.

```APIDOC
## POST Initialize mDNS

### Description
Initializes the mDNS functionality with a given hostname for the local device.

### Method
POST

### Endpoint
`/mdns/begin`

### Parameters
#### Request Body
- **hostname** (const char*) - Required - The hostname to be used for mDNS announcements.

### Response
#### Success Response (200)
- **success** (bool) - True if mDNS initialization was successful, false otherwise.
```

--------------------------------

### IWiFiClient Constructor (Default)

Source: https://docs.libretiny.eu/ltapi/class_i_wi_fi_client

Default constructor for the IWiFiClient class. No specific setup is required.

```cpp
inline IWiFiClient::IWiFiClient () 


```

--------------------------------

### HTTPClient::begin with WiFiClient, Host, Port, URI, and HTTPS flag

Source: https://docs.libretiny.eu/ltapi/_h_t_t_p_client_8cpp_source

Initializes the HTTP client with explicit host, port, URI, and an HTTPS flag, using a provided WiFiClient instance.

```cpp
bool HTTPClient::begin(WiFiClient &client, String host, uint16_t port, String uri, bool https) {
#ifdef HTTPCLIENT_1_1_COMPATIBLE
    if (_tcpDeprecated) {
        log_d("mix up of new and deprecated api");
        _canReuse = false;
        end();
    }
#endif

    _client = &client;

    clear();
    _host     = host;
    _port     = port;
    _uri      = uri;
    _protocol = (https ? "https" : "http");
    _secure   = https;
    return true;
}
```

--------------------------------

### Get Encryption Type

Source: https://docs.libretiny.eu/ltapi/class_wi_fi_class

Returns the encryption type of a specific WiFi network from a scan result. Use the overloaded version to get the encryption type of the currently connected network.

```cpp
WiFiAuthMode WiFiClass::encryptionType (
    uint8_t networkItem
)

```

--------------------------------

### Get SSID (Current Network)

Source: https://docs.libretiny.eu/ltapi/class_wi_fi_class

Returns the SSID (network name) of the currently connected WiFi network. Use the overloaded version to get the SSID for a specific network item from a scan.

```cpp
const String WiFiClass::SSID ()

```

```cpp
String WiFiClass::SSID (
    uint8_t networkItem
)

```

--------------------------------

### System Information Methods

Source: https://docs.libretiny.eu/ltapi/class_esp_class

Methods to retrieve boot, chip, and flash configuration details.

```cpp
inline uint8_t EspClass::getBootMode () 
```

```cpp
inline uint8_t EspClass::getBootVersion () 
```

```cpp
inline uint32_t EspClass::getChipId () 
```

```cpp
inline String EspClass::getCoreVersion () 
```

```cpp
inline uint8_t EspClass::getCpuFreqMHz () 
```

```cpp
inline uint32_t EspClass::getCycleCount () 
```

```cpp
inline uint32_t EspClass::getFlashChipId () 
```

```cpp
inline uint32_t EspClass::getFlashChipMode () 
```

```cpp
inline uint32_t EspClass::getFlashChipRealSize () 
```

```cpp
inline uint32_t EspClass::getFlashChipSize () 
```

--------------------------------

### Get BSSID (Current Network)

Source: https://docs.libretiny.eu/ltapi/class_wi_fi_class

Returns a pointer to the BSSID (MAC address) of the currently connected WiFi network. Use the overloaded version to get the BSSID for a specific network item from a scan.

```cpp
uint8_t * WiFiClass::BSSID ()

```

```cpp
uint8_t * WiFiClass::BSSID (
    uint8_t networkItem
)

```

--------------------------------

### Get RSSI (Current Network)

Source: https://docs.libretiny.eu/ltapi/class_wi_fi_class

Returns the Received Signal Strength Indicator (RSSI) of the currently connected WiFi network. Use the overloaded version to get the RSSI for a specific network item from a scan.

```cpp
int8_t WiFiClass::RSSI ()

```

```cpp
int32_t WiFiClass::RSSI (
    uint8_t networkItem
)

```

--------------------------------

### lt_deep_sleep_enter

Source: https://docs.libretiny.eu/ltapi/lt__sleep_8h

Start deep sleep.

```APIDOC
## void lt_deep_sleep_enter

### Description
Start deep sleep.
```

--------------------------------

### LwIPServer Class Overview

Source: https://docs.libretiny.eu/ltapi/_lw_i_p_server_8h_source

This section provides an overview of the LwIPServer class, its constructors, and its public methods.

```APIDOC
## LwIPServer Class

This class implements the `IWiFiServer<WiFiClient>` interface, providing server functionality using the LwIP networking stack.

### Constructors

- `LwIPServer(uint32_t addr, uint16_t port = 80, uint8_t maxClients = 4)`: Private constructor for internal use.
- `LwIPServer(uint16_t port = 80, uint8_t maxClients = 4)`: Constructs a server listening on any address.
- `LwIPServer(int port = 80, uint8_t maxClients = 4)`: Constructs a server listening on any address (overload for int port).
- `LwIPServer(const IPAddress &addr, uint16_t port = 80, uint8_t maxClients = 4)`: Constructs a server listening on a specific IP address.

### Methods

- **`operator bool()`**: Converts the server object to a boolean, indicating if it is active.
- **`begin(uint16_t port = 0, bool reuseAddr = true)`**: Initializes and starts the server. Returns `true` if successful, `false` otherwise.
- **`end()`**: Stops and cleans up the server.
- **`accept()`**: Accepts an incoming client connection and returns a `WiFiClient` object representing the connection.
- **`write(const uint8_t *buffer, size_t size)`**: Writes data to the server (currently returns 0).
- **`stopAll()`**: Stops all active client connections (currently a no-op).
- **`setTimeout(uint32_t seconds)`**: Sets the timeout for client connections in seconds.
- **`setNoDelay(bool noDelay)`**: Enables or disables the Nagle algorithm.
- **`getNoDelay()`**: Returns the current state of the Nagle algorithm setting.
- **`hasClient()`**: Checks if there are any connected clients.
```

--------------------------------

### Get BSSID String (Current Network)

Source: https://docs.libretiny.eu/ltapi/class_wi_fi_class

Returns the BSSID (MAC address) of the currently connected WiFi network as a String. Use the overloaded version to get the BSSID string for a specific network item from a scan.

```cpp
String WiFiClass::BSSIDstr ()

```

```cpp
String WiFiClass::BSSIDstr (
    uint8_t networkItem
)

```

--------------------------------

### GET /lt_get_version

Source: https://docs.libretiny.eu/ltapi/lt__device_8c

Retrieves the LibreTiny version string.

```APIDOC
## GET /lt_get_version

### Description
Get LibreTiny version string.

### Method
GET

### Response
#### Success Response (200)
- **string** - The version string.
```

--------------------------------

### Connect to Server (Hostname, Default Timeout)

Source: https://docs.libretiny.eu/ltapi/_lw_i_p_client_8cpp_source

Initiates a connection to a server using a hostname and port with the default timeout value.

```cpp
int LwIPClient::connect(const char *host, uint16_t port) {
    return connect(host, port, _timeout);
}
```

--------------------------------

### Display ltchiptool help information

Source: https://docs.libretiny.eu/docs/flashing/tools/ltchiptool

Displays the main help menu and available commands for the ltchiptool CLI.

```bash
$ ltchiptool --help
Usage: ltchiptool [OPTIONS] COMMAND [ARGS]...

  Tools for working with LT-supported IoT chips

Options:
  -v, --verbose         Output debugging messages (repeat to output more)
  -T, --traceback       Print complete exception traceback
  -t, --timed           Prepend log lines with timing info
  -r, --raw-log         Output logging messages with no additional styling
  -i, --indent INTEGER  Indent log messages using graph lines
  -V, --version         Show the version and exit.
  -h, --help            Show this message and exit.

Commands:
  dump      Capture or process device dumps
  elf2bin   Generate firmware binaries from ELF file
  flash     Flashing tool - reading/writing
  link2bin  Link code to binary format
  list      List boards, families, etc.
  soc       Run SoC-specific tools
  uf2       Work with UF2 files
```

--------------------------------

### GET /lt_get_device_name

Source: https://docs.libretiny.eu/ltapi/lt__device_8c

Retrieves the device friendly name.

```APIDOC
## GET /lt_get_device_name

### Description
Get device friendly name in format "LT-<chip model>-<MAC ID>". Can be used as hostname.

### Method
GET

### Response
#### Success Response (200)
- **string** - The device friendly name.
```

--------------------------------

### fs::File::name

Source: https://docs.libretiny.eu/ltapi/classfs_1_1_file

Gets the name of the file.

```APIDOC
### function name

```cpp
const char * fs::File::name () const

```

#### Description
Returns the name of the file as a C-style string.
```

--------------------------------

### Get file name

Source: https://docs.libretiny.eu/ltapi/classfs_1_1_file_impl

Returns the name of the file.

```cpp
virtual const char * fs::FileImpl::name () const = 0
```

--------------------------------

### Connect to Server (Default Timeout)

Source: https://docs.libretiny.eu/ltapi/_lw_i_p_client_8cpp_source

Initiates a connection to a server using an IP address and port with the default timeout value.

```cpp
int LwIPClient::connect(IPAddress ip, uint16_t port) {
    return connect(ip, port, _timeout);
}
```

--------------------------------

### Get pin index

Source: https://docs.libretiny.eu/ltapi/wiring__custom_8h

Retrieves the index of the provided pin.

```cpp
uint32_t pinIndex (
    PinInfo * pin
) 
```

--------------------------------

### Create directory

Source: https://docs.libretiny.eu/ltapi/classfs_1_1_f_s

Creates a new directory at the specified path.

```cpp
bool fs::FS::mkdir (
    const char * path
) 
```

```cpp
bool fs::FS::mkdir (
    const String & path
) 
```

--------------------------------

### Get Hostname

Source: https://docs.libretiny.eu/ltapi/class_wi_fi_class

Retrieves the current hostname of the device on the network.

```cpp
const char * WiFiClass::getHostname ()

```

--------------------------------

### LwIPServer Constructor (uint16_t port)

Source: https://docs.libretiny.eu/ltapi/class_lw_i_p_server

Initializes a new instance of the LwIPServer class with a specified port and maximum number of clients. Defaults to port 80 and 4 clients.

```cpp
inline LwIPServer::LwIPServer (
    uint16_t port=80,
    uint8_t maxClients=4
)


```

--------------------------------

### GET /lt_get_reboot_reason_name

Source: https://docs.libretiny.eu/ltapi/lt__device_8c

Retrieves the textual representation of a reboot reason.

```APIDOC
## GET /lt_get_reboot_reason_name

### Description
Get a textual representation of a reboot reason.

### Method
GET

### Parameters
#### Query Parameters
- **reason** (lt_reboot_reason_t) - Required - Value to convert to text, pass 0 to read from lt_reboot_get_reason().

### Response
#### Success Response (200)
- **string** - The textual representation of the reboot reason.
```

--------------------------------

### Initialization and Cleanup

Source: https://docs.libretiny.eu/ltapi/class_i_preferences

Functions to begin and end the preferences session.

```APIDOC
## Initialization and Cleanup

### begin

Initializes the preferences. Call this before using any other preferences functions.

- **Method**: `bool begin(const char * name, bool readOnly = false, const char * partition_label = NULL)`
- **Parameters**:
  - `name` (const char *) - The name of the preferences namespace.
  - `readOnly` (bool) - Optional. If true, the preferences will be opened in read-only mode. Defaults to false.
  - `partition_label` (const char *) - Optional. The label of the partition to use. Defaults to NULL.
- **Returns**: `true` if initialization was successful, `false` otherwise.

### end

Closes the preferences. Call this when you are finished with preferences.

- **Method**: `void end()`

```

--------------------------------

### Initialize SoftwareSerial (with Config)

Source: https://docs.libretiny.eu/ltapi/class_software_serial

Begins serial communication at the specified baud rate with additional configuration options. The config parameter allows for custom settings like data bits, parity, and stop bits.

```cpp
void SoftwareSerial::begin (
    unsigned long baudrate,
    uint16_t config
)


```

--------------------------------

### GET /lt_get_board_code

Source: https://docs.libretiny.eu/ltapi/lt__device_8c

Retrieves the board code for the current device.

```APIDOC
## GET /lt_get_board_code

### Description
Get the board code of the device.

### Method
GET

### Response
#### Success Response (200)
- **string** - The board code string.
```

--------------------------------

### fs::File::path

Source: https://docs.libretiny.eu/ltapi/classfs_1_1_file

Gets the full path of the file.

```APIDOC
### function path

```cpp
const char * fs::File::path () const

```

#### Description
Returns the full path of the file as a C-style string.
```

--------------------------------

### Configure WR3LE in PlatformIO

Source: https://docs.libretiny.eu/boards/wr3le

Use this configuration in platformio.ini to set up the WR3LE board with the LibreTiny framework.

```ini
[env:wr3le]
platform = libretiny
board = wr3le
framework = arduino
```

--------------------------------

### Get update size

Source: https://docs.libretiny.eu/ltapi/class_update_class

Returns the total size of the update.

```cpp
inline size_t UpdateClass::size () 
```

--------------------------------

### Get file path

Source: https://docs.libretiny.eu/ltapi/classfs_1_1_file_impl

Returns the full path of the file.

```cpp
virtual const char * fs::FileImpl::path () const = 0
```

--------------------------------

### LwIPServer Constructor (IPAddress addr)

Source: https://docs.libretiny.eu/ltapi/class_lw_i_p_server

Initializes a new instance of the LwIPServer class bound to a specific IP address, port, and maximum number of clients. Defaults to port 80 and 4 clients.

```cpp
inline LwIPServer::LwIPServer (
    const IPAddress & addr,
    uint16_t port=80,
    uint8_t maxClients=4
)


```

--------------------------------

### LwIPServer Constructor

Source: https://docs.libretiny.eu/ltapi/class_lw_i_p_server

Initializes a new instance of the LwIPServer class with specified port and client limits.

```APIDOC
## LwIPServer Constructor

### Description
Initializes the server instance. Multiple overloads are available to specify port, maximum clients, and optional IP address binding.

### Parameters
- **port** (uint16_t/int) - Optional - The port to listen on (default 80).
- **maxClients** (uint8_t) - Optional - Maximum number of concurrent clients (default 4).
- **addr** (IPAddress) - Optional - Specific IP address to bind to.
```

--------------------------------

### Get cbuf size

Source: https://docs.libretiny.eu/ltapi/classcbuf

Returns the total capacity of the buffer.

```cpp
size_t cbuf::size () 
```

--------------------------------

### Display uf2ota.py help

Source: https://docs.libretiny.eu/docs/contrib/ota/uf2ota

View the command-line usage and required arguments for the tool.

```bash
$ python uf2ota.py
usage: uf2ota [-h] [--output OUTPUT] [--family FAMILY] [--board BOARD] [--version VERSION] [--fw FW] {info,dump,write} inputs [inputs ...]
uf2ota: error: the following arguments are required: action, inputs
```

--------------------------------

### Preference Information

Source: https://docs.libretiny.eu/ltapi/class_i_preferences

Functions to get information about the stored preferences.

```APIDOC
## Preference Information

### freeEntries

Returns the amount of free entries available in the preferences storage.

- **Method**: `size_t freeEntries()`
- **Returns**: The number of free entries.

### isKey

Checks if a given key exists in the preferences.

- **Method**: `bool isKey(const char * key)`
- **Parameters**:
  - `key` (const char *) - The key to check.
- **Returns**: `true` if the key exists, `false` otherwise.

### getType

Returns the type of the value associated with a given key.

- **Method**: `PreferenceType getType(const char * key)`
- **Parameters**:
  - `key` (const char *) - The key to query.
- **Returns**: The `PreferenceType` of the value.

```

--------------------------------

### Get SDK Version

Source: https://docs.libretiny.eu/ltapi/class_esp_class

Retrieves the version string of the SDK.

```cpp
inline const char * EspClass::getSdkVersion () 


```

--------------------------------

### Connect to Server (IP, Custom Timeout)

Source: https://docs.libretiny.eu/ltapi/_lw_i_p_client_8cpp_source

Initiates a connection to a server using an IP address, port, and a custom connection timeout. Configures socket options like timeouts and TCP_NODELAY.

```cpp
int LwIPClient::connect(IPAddress ip, uint16_t port, int32_t timeout) {
    if (_connected)
        stop();
    int sock = lwip_socket(AF_INET, SOCK_STREAM, IPPROTO_TCP);
    if (sock < 0) {
        LT_DM(CLIENT, "socket failed");
        return -1;
    }

    if (timeout <= 0)
        timeout = _timeout; // use default when -1 passed as timeout

    lwip_fcntl(sock, F_SETFL, lwip_fcntl(sock, F_GETFL, 0) | O_NONBLOCK);

    LT_ERRNO();

    struct sockaddr_in addr;
    memset(&addr, 0, sizeof(addr));
    addr.sin_family      = AF_INET;
    addr.sin_addr.s_addr = ip;
    addr.sin_port        = htons(port);
    fd_set fdset;
    struct timeval tv;
    FD_ZERO(&fdset);
    FD_SET(sock, &fdset);
    tv.tv_sec  = 0;
    tv.tv_usec = timeout * 1000; // millis -> micros

    int res = lwip_connect(sock, (struct sockaddr *)&addr, sizeof(addr));
    if (res < 0 && errno != EINPROGRESS) {
        LT_EM(CLIENT, "Connect failed; errno=%d", errno);
        lwip_close(sock);
        return -1;
    }

    res = lwip_select(sock + 1, NULL, &fdset, NULL, timeout < 0 ? NULL : &tv);
    if (res < 0) {
        LT_EM(CLIENT, "Select failed; errno=%d", errno);
        lwip_close(sock);
        return 0;
    }
    if (res == 0) {
        LT_EM(CLIENT, "Select timeout; errno=%d", errno);
        lwip_close(sock);
        return 0;
    }

    int sockerr;
    socklen_t len = (socklen_t)sizeof(sockerr);
    res           = lwip_getsockopt(sock, SOL_SOCKET, SO_ERROR, &sockerr, &len);

    if (res < 0 || sockerr != 0) {
        LT_EM(CLIENT, "Socket error; res=%d, sockerr=%d", res, sockerr);
        lwip_close(sock);
        return 0;
    }

    int enable = 1;
    lwip_setsockopt(sock, SOL_SOCKET, SO_RCVTIMEO, &timeout, sizeof(timeout));
    lwip_setsockopt(sock, SOL_SOCKET, SO_SNDTIMEO, &timeout, sizeof(timeout));
    lwip_setsockopt(sock, IPPROTO_TCP, TCP_NODELAY, &enable, sizeof(enable));
    lwip_setsockopt(sock, SOL_SOCKET, SO_KEEPALIVE, &enable, sizeof(enable));

    LT_ERRNO();

    lwip_fcntl(sock, F_SETFL, lwip_fcntl(sock, F_GETFL, 0) & ~O_NONBLOCK);

    LT_ERRNO();

    _connected = true;
    _sock      = std::make_shared<SocketHandle>(sock);
    _rxBuffer  = std::make_shared<LwIPRxBuffer>(sock);
    return 1;
}
```

--------------------------------

### main()

Source: https://docs.libretiny.eu/ltapi/main_8c

The primary entry point function for the application.

```APIDOC
## main()

### Description
The main entry point function for the application.

### Method
N/A (Internal Function)

### Response
- **int** - Returns the execution status.
```

--------------------------------

### Begin Multicast UDP

Source: https://docs.libretiny.eu/ltapi/_lw_i_p_udp_8cpp_source

Starts a UDP server for multicast communication on a given IP address and port. Joins the multicast group using IGMP. Requires the LT_ARD_HAS_WIFI and LT_HAS_LWIP configurations to be enabled.

```cpp
uint8_t LwIPUDP::beginMulticast(IPAddress a, uint16_t p) {
    if (begin(IPAddress((uint32_t)INADDR_ANY), p)) {
        if ((uint32_t)a != 0) {
            struct ip_mreq mreq;
            mreq.imr_multiaddr.s_addr = (in_addr_t)a;
            mreq.imr_interface.s_addr = INADDR_ANY;
            if (setsockopt(udp_server, IPPROTO_IP, IP_ADD_MEMBERSHIP, &mreq, sizeof(mreq)) < 0) {
                log_e("could not join igmp: %d", errno);
                stop();
                return 0;
            }
            multicast_ip = a;
        }
        return 1;
    }
    return 0;
}

```

--------------------------------

### LwIPServer Constructor (int port)

Source: https://docs.libretiny.eu/ltapi/class_lw_i_p_server

Initializes a new instance of the LwIPServer class with a specified integer port and maximum number of clients. Defaults to port 80 and 4 clients.

```cpp
inline LwIPServer::LwIPServer (
    int port=80,
    uint8_t maxClients=4
)


```

--------------------------------

### Time Functions

Source: https://docs.libretiny.eu/ltapi/time_8c

Public functions for getting and setting the system time.

```APIDOC
## Public Functions

### function __wrap_gettimeofday

```c
int __wrap_gettimeofday (
    struct timeval * tv,
    void * tz
)
```

### function __wrap_settimeofday

```c
int __wrap_settimeofday (
    const struct timeval * tv,
    const struct timezone * tz
)
```

### function _gettimeofday

```c
int _gettimeofday (
    struct timeval * tv,
    void * tz
)
```

### function _settimeofday

```c
int _settimeofday (
    const struct timeval * tv,
    const struct timezone * tz
)
```

### function gettimeofday

```c
int gettimeofday (
    struct timeval * tv,
    void * tz
)
```

### function settimeofday

```c
int settimeofday (
    const struct timeval * tv,
    const struct timezone * tz
)
```
```

--------------------------------

### Begin serial communication

Source: https://docs.libretiny.eu/ltapi/class_serial_class

Initializes serial communication with various parameter configurations.

```cpp
void SerialClass::begin (
    unsigned long baudrate,
    uint16_t config,
    pin_size_t rx,
    pin_size_t tx
) 
```

```cpp
inline void SerialClass::begin (
    unsigned long baudrate,
    uint16_t config
) 
```

```cpp
inline void SerialClass::begin (
    unsigned long baudrate
) 
```

--------------------------------

### Get Buffer Size

Source: https://docs.libretiny.eu/ltapi/lt__ota_8c

Returns the total size of the OTA buffer.

```c
static inline size_t lt_ota_buf_size (
    lt_ota_ctx_t * ctx
) 
```

--------------------------------

### Connect to Server (Hostname, Custom Timeout)

Source: https://docs.libretiny.eu/ltapi/_lw_i_p_client_8cpp_source

Initiates a connection to a server using a hostname, port, and a custom connection timeout. Resolves the hostname to an IP address first.

```cpp
int LwIPClient::connect(const char *host, uint16_t port, int32_t timeout) {
    IPAddress ip = WiFi.hostByName(host);
    if (!ip)
        return 0;
    return connect(ip, port, timeout);
}
```

--------------------------------

### Get Version String

Source: https://docs.libretiny.eu/ltapi/lt__device_8c

Retrieves the current LibreTiny version string.

```c
const char * lt_get_version () 
```

--------------------------------

### Get Board Code

Source: https://docs.libretiny.eu/ltapi/lt__device_8c

Retrieves the unique board code string.

```c
const char * lt_get_board_code () 
```

--------------------------------

### Create UF2 Package for OpenBeken

Source: https://docs.libretiny.eu/docs/flashing/esphome

Convert an OpenBeken RBL file into a UF2 package compatible with the ESPHome web server dashboard.

```bash
ltchiptool uf2 write -b generic-bk7231n-qfn32-tuya -o OpenBeken.uf2 "OpenBK7231N_1.17.205.rbl=device:download"
```

--------------------------------

### fs::File::size

Source: https://docs.libretiny.eu/ltapi/classfs_1_1_file

Gets the total size of the file in bytes.

```APIDOC
### function size

```cpp
size_t fs::File::size () const

```

#### Description
Returns the total size of the file in bytes.
```

--------------------------------

### MD5Init

Source: https://docs.libretiny.eu/ltapi/libraries_2common_2_m_d5_2_m_d5_8h

Initializes the MD5 context structure.

```APIDOC
## MD5Init

### Description
Initializes the MD5 context structure before starting a hash calculation.

### Parameters
#### Parameters
- **context** (LT_MD5_CTX_T*) - Required - Pointer to the MD5 context structure.
```

--------------------------------

### fs::File::position

Source: https://docs.libretiny.eu/ltapi/classfs_1_1_file

Gets the current position within the file.

```APIDOC
### function position

```cpp
size_t fs::File::position () const

```

#### Description
Returns the current read/write position within the file.
```

--------------------------------

### LwIPUDP begin

Source: https://docs.libretiny.eu/ltapi/class_lw_i_p_u_d_p

Initializes the UDP socket on a specific port, optionally bound to a specific IP address.

```cpp
virtual uint8_t LwIPUDP::begin (
    IPAddress ip,
    uint16_t port
)
```

```cpp
virtual uint8_t LwIPUDP::begin (
    uint16_t port
)
```

--------------------------------

### Get current position

Source: https://docs.libretiny.eu/ltapi/classfs_1_1_file

Returns the current read/write position in the file.

```cpp
size_t fs::File::position () const
```

--------------------------------

### HTTPClient::begin with URL (HTTP)

Source: https://docs.libretiny.eu/ltapi/_h_t_t_p_client_8cpp_source

Initializes the HTTP client for HTTP requests using a URL. This is a deprecated API.

```cpp
#ifdef HTTPCLIENT_1_1_COMPATIBLE
bool HTTPClient::begin(String url) {
    if (_client && !_tcpDeprecated) {
        log_d("mix up of new and deprecated api");
        _canReuse = false;
        end();
    }

    clear();
    _port = 80;
    if (!beginInternal(url, "http")) {
        return begin(url, (const char *)NULL);
    }
    _transportTraits = TransportTraitsPtr(new TransportTraits());
    if (!_transportTraits) {
        log_e("could not create transport traits");
        return false;
    }

    return true;
}
#endif // HTTPCLIENT_1_1_COMPATIBLE
```

--------------------------------

### Get remaining bytes

Source: https://docs.libretiny.eu/ltapi/class_update_class

Returns the number of bytes remaining to be written.

```cpp
inline size_t UpdateClass::remaining () 
```

--------------------------------

### Initialize fs::File

Source: https://docs.libretiny.eu/ltapi/classfs_1_1_file

Constructor for the File class.

```cpp
inline fs::File::File (
    FileImplPtr p=FileImplPtr()
) 
```

--------------------------------

### Get update progress

Source: https://docs.libretiny.eu/ltapi/class_update_class

Returns the number of bytes processed so far.

```cpp
inline size_t UpdateClass::progress () 
```

--------------------------------

### Initialize HTTPClient (HTTP/1.1 Compatible)

Source: https://docs.libretiny.eu/ltapi/_h_t_t_p_client_8h_source

Initializes the HTTPClient for HTTP/1.1 compatible requests. Overloads allow specifying URL, host, port, URI, and SSL certificate details.

```cpp
#ifdef HTTPCLIENT_1_1_COMPATIBLE
    bool begin(String url);
    bool begin(String url, const char *CAcert);
    bool begin(String host, uint16_t port, String uri = "/");
    bool begin(String host, uint16_t port, String uri, const char *CAcert);
    bool begin(String host, uint16_t port, String uri, const char *CAcert, const char *cli_cert, const char *cli_key);
#endif
```

--------------------------------

### Get file size

Source: https://docs.libretiny.eu/ltapi/classfs_1_1_file_impl

Returns the total size of the file in bytes.

```cpp
virtual size_t fs::FileImpl::size () const = 0
```

--------------------------------

### Get current position

Source: https://docs.libretiny.eu/ltapi/classfs_1_1_file_impl

Returns the current read/write offset in the file.

```cpp
virtual size_t fs::FileImpl::position () const = 0
```

--------------------------------

### HTTPClient Initialization and Connection

Source: https://docs.libretiny.eu/ltapi/_h_t_t_p_client_8h_source

Methods for initializing and establishing an HTTP connection.

```APIDOC
## HTTPClient Initialization and Connection

### Description
Methods for initializing and establishing an HTTP connection.

### Methods
- `bool begin(WiFiClient &client, String url)`
- `bool begin(WiFiClient &client, String host, uint16_t port, String uri = "/", bool https = false)`
- `bool begin(String url)` (Requires HTTPCLIENT_1_1_COMPATIBLE)
- `bool begin(String url, const char *CAcert)` (Requires HTTPCLIENT_1_1_COMPATIBLE)
- `bool begin(String host, uint16_t port, String uri = "/")` (Requires HTTPCLIENT_1_1_COMPATIBLE)
- `bool begin(String host, uint16_t port, String uri, const char *CAcert)` (Requires HTTPCLIENT_1_1_COMPATIBLE)
- `bool begin(String host, uint16_t port, String uri, const char *CAcert, const char *cli_cert, const char *cli_key)` (Requires HTTPCLIENT_1_1_COMPATIBLE)
- `void end(void)`
- `bool connected(void)`

### Parameters
#### Path Parameters
None

#### Query Parameters
None

#### Request Body
None

### Request Example
None

### Response
#### Success Response (200)
None

#### Response Example
None
```

--------------------------------

### Get Firmware Version

Source: https://docs.libretiny.eu/ltapi/class_update_class

Retrieves the firmware version from the UF2 information.

```cpp
inline const char * UpdateClass::getFirmwareVersion ()
```
Tokens:
Raw