[release] v0.12.3

* [beken-72xx] Added support for ANY_EDGE interrupts

* clang format

* PR comments

* Update wiring_irq.c

Co-authored-by: Kuba Szczodrzyński <kuba@szczodrzynski.pl>

.clang-format

@@ -0,0 +1,29 @@
+Language: Cpp
+BasedOnStyle: LLVM
+AlignAfterOpenBracket: BlockIndent
+AlignArrayOfStructures: Left
+AlignConsecutiveAssignments: true
+AlignConsecutiveMacros: AcrossComments
+AlignTrailingComments: true
+AllowAllArgumentsOnNextLine: false
+AllowShortBlocksOnASingleLine: Empty
+AllowShortFunctionsOnASingleLine: Empty
+AlwaysBreakTemplateDeclarations: Yes
+BinPackArguments: false
+BinPackParameters: false
+BreakBeforeTernaryOperators: true
+ColumnLimit: 120
+ContinuationIndentWidth: 4
+EmptyLineBeforeAccessModifier: Always
+FixNamespaceComments: true
+IndentAccessModifiers: false
+IndentCaseLabels: true
+IndentWidth: 4
+LambdaBodyIndentation: Signature
+MaxEmptyLinesToKeep: 1
+# PointerAlignment: Left # TODO enable this and reformat project
+QualifierAlignment: Left
+ReflowComments: true
+SeparateDefinitionBlocks: Always
+TabWidth: 4
+UseTab: Always

.github/FUNDING.yml

@@ -0,0 +1,3 @@
+ko_fi: kuba2k2
+custom:
+  - "https://paypal.me/kuba2k2"

.github/workflows/docs.yml

@@ -0,0 +1,42 @@
+name: Deploy docs on GitHub Pages
+
+on:
+  push:
+    branches:
+      - master
+
+jobs:
+  docs:
+    name: Deploy docs
+    runs-on: ubuntu-latest
+    steps:
+      - name: Checkout main
+        uses: actions/checkout@v2
+
+      - name: Setup Python
+        uses: actions/setup-python@v4
+        with:
+          python-version: '3.10'
+
+      - name: Install ltchiptool
+        run: pip install ltchiptool
+
+      - name: Generate static JSON files
+        run: |
+          mkdir -p site/
+          python docs/build_json.py
+          cp *.json site/
+
+      - name: Set custom domain
+        run: |
+          mkdir -p site/
+          echo docs.libretuya.ml > site/CNAME
+
+      - name: Deploy docs
+        uses: libretuya/mkdocs-deploy-gh-pages@master
+        env:
+          GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
+          CONFIG_FILE: mkdocs.yml
+          EXTRA_PACKAGES: build-base doxygen
+          REQUIREMENTS: docs/requirements.txt
+          CUSTOM_DOMAIN: docs.libretuya.ml

.github/workflows/lint.yml

@@ -0,0 +1,35 @@
+name: Lint check
+
+on: [push, pull_request]
+
+jobs:
+  lint-clang-format:
+    name: Lint with clang-format
+    runs-on: ubuntu-latest
+    steps:
+      - name: Checkout
+        uses: actions/checkout@v2
+      - name: Check code with clang-format
+        uses: jidicula/clang-format-action@v4.5.0
+        with:
+          clang-format-version: "14"
+  lint-black:
+    name: Lint with black
+    runs-on: ubuntu-latest
+    steps:
+      - name: Checkout
+        uses: actions/checkout@v2
+      - name: Set up Python
+        uses: actions/setup-python@v2
+        with:
+          python-version: "3.9"
+      - name: Install test dependencies
+        uses: BSFishy/pip-action@v1
+        with:
+          packages: |
+            black
+            isort
+      - name: Check code with black
+        run: black --check .
+      - name: Check code with isort
+        run: isort --profile black . --check-only

.gitignore

@@ -252,3 +252,10 @@ cython_debug/
 # End of https://www.toptal.com/developers/gitignore/api/c,c++,visualstudiocode,python
 
 .vscode/settings.json
+
+# mkdocs
+xml/
+ltapi/
+ltambz/
+hashChanges.yaml
+.piopm

.gitmodules

@@ -0,0 +1,2 @@
+[submodule "tools/boardgen"]
+	url = https://github.com/kuba2k2/boardgen

README.md

@@ -1,197 +1,90 @@
 # LibreTuya
 
-<div align="center">
+<div align="center" markdown>
+
+[![GitHub Workflow Status](https://img.shields.io/github/workflow/status/kuba2k2/libretuya/Deploy%20docs%20on%20GitHub%20Pages?label=docs&logo=markdown)](https://kuba2k2.github.io/libretuya/)
+![GitHub last commit](https://img.shields.io/github/last-commit/kuba2k2/libretuya?logo=github)
+
+[![Code style: clang-format](https://img.shields.io/badge/code%20style-clang--format-purple.svg)](.clang-format)
+[![Code style: black](https://img.shields.io/badge/code%20style-black-000000.svg)](https://github.com/psf/black)
 
 [![Discord](https://img.shields.io/discord/967863521511608370?color=%235865F2&label=Discord&logo=discord&logoColor=white)](https://discord.gg/SyGCB9Xwtf)
 [![PlatformIO Registry](https://badges.registry.platformio.org/packages/kuba2k2/platform/libretuya.svg)](https://registry.platformio.org/platforms/kuba2k2/libretuya)
-![GitHub last commit](https://img.shields.io/github/last-commit/kuba2k2/libretuya)
 
 ![RTL8710BN](https://img.shields.io/badge/-rtl8710bn-blue)
+![BK7231](https://img.shields.io/badge/-bk7231-blue)
 
 </div>
 
 PlatformIO development platform for IoT modules manufactured by Tuya Inc.
 
 The main goal of this project is to provide a usable build environment for IoT developers. While also providing vendor SDKs as PlatformIO cores,
-the project focuses on developing working Arduino-compatible cores for supported platforms. The cores are inspired by Espressif's official core for ESP32,
-which should make it easier to port/run existing ESP apps on Tuya IoT (and 3-rd party) platforms.
+the project focuses on developing working Arduino-compatible cores for supported families. The cores are inspired by Espressif's official core for ESP32,
+which should make it easier to port/run existing ESP apps on Tuya IoT (and 3-rd party) modules.
 
-LibreTuya also provides a common interface for all platform implementations. The interface is based on ESP32 official libraries.
+LibreTuya also provides a common interface for all family implementations. The interface is based on ESP32 official libraries.
 
 **Note:** this project is work-in-progress.
 
 ## Usage
 
 1. [Install PlatformIO](https://platformio.org/platformio-ide)
-2. `platformio platform install libretuya`
+2. `platformio platform install https://github.com/kuba2k2/libretuya`
 3. Create a project, build it and upload!
-4. See the [docs](docs/README.md) for any questions/problems.
+4. See the [docs](https://kuba2k2.github.io/libretuya/) for any questions/problems.
 
 ## Board List
 
-A (mostly) complete* list of Tuya wireless module boards.
-
-&nbsp;                        | Module Name                                                                                    | MCU                     | Flash | RAM      | Pins**      | Wi-Fi | BLE | Platform name
-------------------------------|------------------------------------------------------------------------------------------------|-------------------------|-------|----------|-------------|-------|-----|---------------
-❌                             | [WB1S](https://developer.tuya.com/en/docs/iot/wb1s?id=K9duevbj3ol4x)                           | BK7231T @ 120 MHz       | 2 MiB | 256 KiB  | 18 (11 I/O) | ✔️    | ✔️  | -
-❌                             | [WB2L](https://developer.tuya.com/en/docs/iot/wb2l-datasheet?id=K9duegc9bualu)                 | BK7231T @ 120 MHz       | 2 MiB | 256 KiB  | 7 (5 I/O)   | ✔️    | ✔️  | -
-❌                             | [WB2S](https://developer.tuya.com/en/docs/iot/wb2s-module-datasheet?id=K9ghecl7kc479)          | BK7231T @ 120 MHz       | 2 MiB | 256 KiB  | 11 (8 I/O)  | ✔️    | ✔️  | -
-❌                             | [WB3L](https://developer.tuya.com/en/docs/iot/wb3l-module-datasheet?id=K9duiggw2v8sp)          | BK7231T @ 120 MHz       | 2 MiB | 256 KiB  | 16 (12 I/O) | ✔️    | ✔️  | -
-❌                             | [WB3S](https://developer.tuya.com/en/docs/iot/wb3s-module-datasheet?id=K9dx20n6hz5n4)          | BK7231T @ 120 MHz       | 2 MiB | 256 KiB  | 16 (11 I/O) | ✔️    | ✔️  | -
-❌                             | [WB3S-IPEX](https://developer.tuya.com/en/docs/iot/wb3sipex-module-datasheet?id=K9irq0laun21z) | BK7231T @ 120 MHz       | 2 MiB | 256 KiB  | 16 (11 I/O) | ✔️    | ✔️  | -
-❌                             | [WB8P](https://developer.tuya.com/en/docs/iot/wb8p-module-datasheet?id=K9fwx4f89tvzd)          | BK7231T @ 120 MHz       | 2 MiB | 256 KiB  | 10 (8 I/O)  | ✔️    | ✔️  | -
-❌                             | [WBLC5](https://developer.tuya.com/en/docs/iot/wblc5-module-datasheet?id=K9duilns1f3gi)        | BK7231T @ 120 MHz       | 2 MiB | 256 KiB  | 6 (3 I/O)   | ✔️    | ✔️  | -
-❌                             | [WBLC9](https://developer.tuya.com/en/docs/iot/wblc9-module-datasheet?id=K9hgglry2jp5h)        | BK7231T @ 120 MHz       | 2 MiB | 256 KiB  | 8 (6 I/O)   | ✔️    | ✔️  | -
-❌                             | [CB1S](https://developer.tuya.com/en/docs/iot/cb1s-module-datasheet?id=Kaij1abmwyjq2)          | BK7231N @ 120 MHz       | 2 MiB | 256 KiB  | 18 (11 I/O) | ✔️    | ✔️  | -
-❌                             | [CB2L](https://developer.tuya.com/en/docs/iot/cb2l-module-datasheet?id=Kai2eku1m3pyl)          | BK7231N @ 120 MHz       | 2 MiB | 256 KiB  | 7 (5 I/O)   | ✔️    | ✔️  | -
-❌                             | [CB2S](https://developer.tuya.com/en/docs/iot/cb2s-module-datasheet?id=Kafgfsa2aaypq)          | BK7231N @ 120 MHz       | 2 MiB | 256 KiB  | 11 (8 I/O)  | ✔️    | ✔️  | -
-❌                             | [CB3L](https://developer.tuya.com/en/docs/iot/cb3l-module-datasheet?id=Kai51ngmrh3qm)          | BK7231N @ 120 MHz       | 2 MiB | 256 KiB  | 16 (11 I/O) | ✔️    | ✔️  | -
-❌                             | [CB3S](https://developer.tuya.com/en/docs/iot/cb3s?id=Kai94mec0s076)                           | BK7231N @ 120 MHz       | 2 MiB | 256 KiB  | 22 (14 I/O) | ✔️    | ✔️  | -
-❌                             | [CB3S-NL](https://developer.tuya.com/en/docs/iot/CB3S-NL-module-datasheet?id=Kbaesan0vyoms)    | BK7231NL (?) @ 120 MHz  | 2 MiB | 256 KiB  | 22 (14 I/O) | ✔️    | ✔️  | -
-❌                             | [CB3SE](https://developer.tuya.com/en/docs/iot/CB3SE-Module-Datasheet?id=Kanoiluul7nl2)        | BK7231N @ 120 MHz       | 2 MiB | 256 KiB  | 22 (17 I/O) | ✔️    | ✔️  | -
-❌                             | [CB8P](https://developer.tuya.com/en/docs/iot/cb8p-module-datasheet?id=Kahvig14r1yk9)          | BK7231N @ 120 MHz       | 2 MiB | 256 KiB  | 10 (8 I/O)  | ✔️    | ✔️  | -
-❌                             | [CBLC5](https://developer.tuya.com/en/docs/iot/cblc5-module-datasheet?id=Ka07iqyusq1wm)        | BK7231N @ 120 MHz       | 2 MiB | 256 KiB  | 6 (3 I/O)   | ✔️    | ✔️  | -
-❌                             | [CBLC9](https://developer.tuya.com/en/docs/iot/cblc9-module-datasheet?id=Ka42cqnj9r0i5)        | BK7231N @ 120 MHz       | 2 MiB | 256 KiB  | 8 (6 I/O)   | ✔️    | ✔️  | -
-❌                             | [CBU](https://developer.tuya.com/en/docs/iot/cbu-module-datasheet?id=Ka07pykl5dk4u)            | BK7231N @ 120 MHz       | 2 MiB | 256 KiB  | 21 (18 I/O) | ✔️    | ✔️  | -
-❌                             | [CBU-IPEX](https://developer.tuya.com/en/docs/iot/cbuipex-module-datasheet?id=Kaedsyurckrhu)   | BK7231N @ 120 MHz       | 2 MiB | 256 KiB  | 21 (18 I/O) | ✔️    | ✔️  | -
-❌                             | [CBU-NL](https://developer.tuya.com/en/docs/iot/CBU-NL-module-datasheet?id=Kbaeq6j53y0yg)      | BK7231N (?) @ 120 MHz   | 2 MiB | 256 KiB  | 21 (18 I/O) | ✔️    | ✔️  | -
-❌                             | [WR1](https://developer.tuya.com/en/docs/iot/wifiwr1module?id=K9605tc0k90t3)                   | RTL8710BN @ 125 MHz     | 1 MiB | 256 KiB  | 18 (11 I/O) | ✔️    | ❌   | -
-❌                             | [WR1-IPEX](https://developer.tuya.com/en/docs/iot/wifiwr1ipexmodule?id=K9605t977tx5u)          | RTL8710BN @ 125 MHz     | 1 MiB | 256 KiB  | 18 (11 I/O) | ✔️    | ❌   | -
-❌                             | [WR1E](https://developer.tuya.com/en/docs/iot/wr1e?id=K96smbbeycxtf)                           | RTL8710BN @ 125 MHz     | 2 MiB | 256 KiB  | 18 (11 I/O) | ✔️    | ❌   | -
-❌                             | [WR2](https://developer.tuya.com/en/docs/iot/wifiwr2module?id=K9605tko0juc3)                   | RTL8710BN @ 125 MHz     | 2 MiB | 256 KiB  | 11 (8 I/O)  | ✔️    | ❌   | -
-❌                             | [WR2E](https://developer.tuya.com/en/docs/iot/wr2e?id=K97scnsjhue4h)                           | RTL8710BN @ 125 MHz     | 2 MiB | 256 KiB  | 11 (8 I/O)  | ✔️    | ❌   | -
-❌                             | [WR2L](https://developer.tuya.com/en/docs/iot/wifiwr2lmodule?id=K9605tnbj7gva)                 | RTL8710BX @ 62.5 MHz    | 2 MiB | 256 KiB  | 7 (5 I/O)   | ✔️    | ❌   | -
-❌                             | [WR2LE](https://developer.tuya.com/en/docs/iot/wr2le?id=K9eio9y9e8i8c)                         | RTL8710BX @ 62.5 MHz    | 2 MiB | 256 KiB  | 7 (5 I/O)   | ✔️    | ❌   | -
-[`wr3`](boards/wr3/README.md) | [WR3](https://developer.tuya.com/en/docs/iot/wr3-module-datasheet?id=K9g3ainzbj9z1)            | RTL8710BN @ 125 MHz     | 2 MiB | 256 KiB  | 16 (12 I/O) | ✔️    | ❌   | `realtek-ambz`
-❌                             | [WR3E](https://developer.tuya.com/en/docs/iot/wr3e-module-datasheet?id=K9elwlqbfosbc)          | RTL8710BN @ 125 MHz     | 2 MiB | 256 KiB  | 16 (12 I/O) | ✔️    | ❌   | -
-❌                             | [WR3L](https://developer.tuya.com/en/docs/iot/wifiwr3lmodule?id=K9605tt0kveqm)                 | RTL8710BX @ 125 MHz (?) | 2 MiB | 256 KiB  | 16 (12 I/O) | ✔️    | ❌   | -
-❌                             | [WR3LE](https://developer.tuya.com/en/docs/iot/wr3le?id=K986l7a1ha8tm)                         | RTL8710BX @ 62.5 MHz    | 2 MiB | 256 KiB  | 16 (12 I/O) | ✔️    | ❌   | -
-❌                             | [WR3N](https://developer.tuya.com/en/docs/iot/wr3n-datasheet?id=K98zdx31ztdge)                 | RTL8710BN @ 125 MHz     | 2 MiB | 256 KiB  | 16 (10 I/O) | ✔️    | ❌   | -
-❌                             | [WR4](https://developer.tuya.com/en/docs/iot/wifiwr4module?id=K9605tvu78p3e)                   | RTL8710BN @ 125 MHz     | 1 MiB | 256 KiB  | 16 (12 I/O) | ✔️    | ❌   | -
-❌                             | [WR5E](https://developer.tuya.com/en/docs/iot/wr5e?id=K986r9pxqxa8i)                           | RTL8710BX @ 62.5 MHz    | 2 MiB | 256 KiB  | 15 (12 I/O) | ✔️    | ❌   | -
-❌                             | [WR6-H](https://developer.tuya.com/en/docs/iot/wr6h-module-datasheet?id=K9pork8eeowgl)         | RTL8710BN @ 125 MHz     | 2 MiB | 256 KiB  | 18 (12 I/O) | ✔️    | ❌   | -
-❌                             | [WR6](https://developer.tuya.com/en/docs/iot/wr6-datasheet?id=K97rp45u6gff9)                   | RTL8710BN @ 125 MHz     | 2 MiB | 256 KiB  | 18 (12 I/O) | ✔️    | ❌   | -
-❌                             | [WRG1](https://developer.tuya.com/en/docs/iot/wr6-datasheet?id=K97rp45u6gff9)                  | RTL8711AM @ 166 MHz     | 4 MiB | 2048 KiB | 25 (20 I/O) | ✔️    | ❌   | -
-❌                             | [XR1](https://developer.tuya.com/en/docs/iot/xr1?id=K9lq3y9xo0zkx)                             | XR809 @ 160 MHz         | 2 MiB | 384 KiB  | 18 (11 I/O) | ✔️    | ❌   | -
-❌                             | [XR1-IPEX](https://developer.tuya.com/en/docs/iot/xr1ipex-module-datasheet?id=K9razqu9gqele)   | XR809 @ 160 MHz         | 2 MiB | 384 KiB  | 18 (11 I/O) | ✔️    | ❌   | -
-❌                             | [XR3](https://developer.tuya.com/en/docs/iot/xr3-datasheet?id=K98s9168qi49g)                   | XR809 @ 160 MHz         | 2 MiB | 384 KiB  | 22 (17 I/O) | ✔️    | ❌   | -
-❌                             | [WE1S](https://developer.tuya.com/en/docs/iot/wifie1smodule?id=K9605thnvg3e7)                  | ESP8266EX @ 80/160 MHz  | 2 MiB | 36 KiB   | 18 (11 I/O) | ✔️    | ❌   | -
-❌                             | [WE2L](https://developer.tuya.com/en/docs/iot/wifie2lmodule?id=K9605ud0gkjmh)                  | ESP8285 @ 80/160 MHz    | 1 MiB | 50 KiB   | 7 (5 I/O)   | ✔️    | ❌   | -
-❌                             | [WE2S](https://developer.tuya.com/en/docs/iot/wifie2smodule?id=K9605u79tgxug)                  | ESP8285 @ 80/160 MHz    | 1 MiB | 50 KiB   | 11 (8 I/O)  | ✔️    | ❌   | -
-❌                             | [WE3L](https://developer.tuya.com/en/docs/iot/wifie3lpinmodule?id=K9605uj1ar87n)               | ESP8266 @ 80/160 MHz    | 2 MiB | 50 KiB   | 16 (12 I/O) | ✔️    | ❌   | -
-❌                             | [WE3S](https://developer.tuya.com/en/docs/iot/wifie3smodule?id=K9605ua1cx9tv)                  | ESP8266 @ 80/160 MHz    | 2 MiB | 50 KiB   | 16 (12 I/O) | ✔️    | ❌   | -
-❌                             | [WE3SE](https://developer.tuya.com/en/docs/iot/we3se?id=K97qv6ab7oh8d)                         | ESP32 @ 240 MHz         | 4 MiB | 520 KiB  | 22 (17 I/O) | ✔️    | ✔️  | -
-❌                             | [WE5P](https://developer.tuya.com/en/docs/iot/wifie5pmodule?id=K9605um3dtjbx)                  | ESP8266 @ 80/160 MHz    | 1 MiB | 50 KiB   | 15 (11 I/O) | ✔️    | ❌   | -
-
-\* Only modules featuring at least Wi-Fi. WBR, JWBR, CR, (TY)JW and (TY)LC Series are not included here
-
-** I/O count includes GPIOs, ADCs, PWM outputs and UART, but doesn't count CEN/RST and power pins.
-
-## Project structure
-
-```
-arduino/
-├─ <platform name>/             Arduino Core for specific platform
-│  ├─ cores/                        Core files
-│  ├─ libraries/                    Supported built-in libraries
-├─ libretuya/
-│  ├─ api/                      LibreTuya API for Arduino frameworks
-│  ├─ compat/                   Fixes for compatibility with ESP32 framework
-│  ├─ libraries/                Built-in platform-independent libraries
-boards/
-├─ <board name>/                Board-specific code
-│  ├─ variant.cpp                   Arduino variant initialization
-│  ├─ variant.h                     Arduino variant pin configs
-├─ <board name>.json            PlatformIO board description
-builder/
-├─ frameworks/                  Framework builders for PlatformIO
-│  ├─ <platform name>-sdk.py        Vanilla SDK build system
-│  ├─ <platform name>-arduino.py    Arduino Core build system
-├─ arduino-common.py            Builder to provide ArduinoCore-API and LibreTuya APIs
-├─ main.py                      Main PlatformIO builder
-docs/                           Project documentation, guides, tips, etc.
-platform/
-├─ <platform name>/             Platform-specific configurations
-│  ├─ bin/                          Binary blobs (bootloaders, etc.)
-│  ├─ fixups/                       Code fix-ups to replace SDK parts
-│  ├─ ld/                           Linker scripts
-│  ├─ openocd/                      OpenOCD configuration files
-tools/
-├─ <tool name>/                 Tools used during the build
-platform.json                   PlatformIO manifest
-platform.py                     Custom PlatformIO script
-```
-
-## Platforms
-
-A list of platforms currently available in this project.
-
-Platform name  | Supported MCU(s)                                                       | Arduino Core | Source SDK (PIO framework)
----------------|------------------------------------------------------------------------|--------------|--------------------------------------------------------------------------
-`realtek-ambz` | Realtek [AmebaZ](https://www.amebaiot.com/en/amebaz/) SoC (`RTL87xxB`) | ✔️           | `framework-realtek-amb1` ([amb1_sdk](https://github.com/ambiot/amb1_sdk))
-
-### Realtek Ameba
-
-The logic behind naming of Realtek chips and their series took me some time to figure out:
-- RTL8xxxA - Ameba1/Ameba Series
-- RTL8xxxB - AmebaZ Series
-- RTL8xxxC - AmebaZ2/ZII Series
-- RTL8xxxD - AmebaD Series
-
-As such, there are numerous CPUs with the same numbers but different series, which makes them require different code and SDKs.
-- [RTL8195AM](https://www.realtek.com/en/products/communications-network-ics/item/rtl8195am)
-- RTL8710AF (found in amb1_arduino)
-- [RTL8711AM](https://www.realtek.com/en/products/communications-network-ics/item/rtl8711am)
-- [RTL8710BN](https://www.realtek.com/en/products/communications-network-ics/item/rtl8710bn)
-- RTL8710BX (found in Tuya product pages)
-- RTL8710B? (found in amb1_sdk)
-- RTL8711B? (found in amb1_sdk)
-- [RTL8710CM](https://www.realtek.com/en/products/communications-network-ics/item/rtl8710cm)
-- RTL8722CSM (found in ambd_arduino)
-- RTL8720DN (found in ambd_arduino)
-- [RTL8721DM](https://www.realtek.com/en/products/communications-network-ics/item/rtl8721dm)
-- RTL8722DM (found in ambd_arduino)
-- and probably many more
-
-Different Ameba series are not compatible with each other. Apparently, there isn't an official public SDK for AmebaZ that can support C++ properly.
+See [Boards & CPU list](https://kuba2k2.github.io/libretuya/docs/status/supported/).
 
 ## Arduino Core support status
 
 Note: this list will probably change with each functionality update.
 
-&nbsp;              | `realtek-ambz`
---------------------|---------------
-Core functions      | ✔️
-GPIO/PWM/IRQ        | ✔️/❓/✔️
-Analog input        | ❓
-UART I/O            | ✔️
-Flash I/O           | ❓
-**CORE LIBRARIES**  |
-SoftwareSerial      | ❌
-SPI                 | ❌
-Wire                | ❌
-**OTHER LIBRARIES** |
-Wi-Fi Station       | ✔️
-Wi-Fi Access Point  | ✔️
-Wi-Fi Events        | ❌
-Wi-Fi Client (SSL)  | ✔️ (❌)
-Wi-Fi Server        | ✔️
-SPIFFS              | ❌
-BLE                 | -
-HTTP                | ❌
-NTP                 | ❌
-OTA                 | ❌
-MDNS                | ❌
-MQTT                | ❌
-SD                  | ❌
+&nbsp;              | `realtek-ambz` | `beken-72xx`
+--------------------|----------------|-------------
+Core functions      | ✔️             | ✔️
+GPIO/PWM/IRQ        | ✔️/✔️/✔️       | ✔️/✔️/✔️
+Analog input (ADC)  | ✔️             | ✔️
+Serial              | ✔️             | ✔️
+Serial (extra)      | 0, 1, 2        | 1, 2
+Flash I/O           | ✔️             | ✔️
+**CORE LIBRARIES**  |                |
+SoftwareSerial      | ✔️             | ❌
+SPI                 | ❌              | ❌
+Wire                | ❗              | ❌
+**OTHER LIBRARIES** |                |
+Wi-Fi STA/AP/Mixed  | ✔️             | ✔️
+Wi-Fi Events        | ✔️             | ✔️
+TCP Client (SSL)    | ✔️ (✔️)        | ✔️ (❗)
+TCP Server          | ✔️             | ✔️
+IPv6                | ❌              | ❌
+HTTP Client (SSL)   | ✔️ (✔️)        | ❓
+HTTP Server         | ✔️             | ✔️
+NVS / Preferences   | ❌              | ❌
+SPIFFS              | ❌              | ❌
+BLE                 | -              | ❌
+NTP                 | ❌              | ❌
+OTA                 | ✔️             | ✔️
+MDNS                | ✔️             | ✔️
+MQTT                | ✅              | ❌
+SD                  | ❌              | ❌
+
+Symbols:
 
-Legend:
 - ✔️ working
-- ❗ broken
+- ✅ tested, external library
 - ❓ untested
+- ❗ broken
 - ❌ not implemented (yet?)
 - \- not applicable
 
+Names:
+
+- Core functions - stuff like delay(), millis(), yield(), etc.
+- **CORE LIBRARIES** - included normally in all Arduino cores
+- **OTHER LIBRARIES** - included in ESP32 core or downloadable
+
 ## License
 
 See [LICENSE](LICENSE). Project is licensed under MIT License.

SUMMARY.md

@@ -0,0 +1,69 @@
+* [Home](README.md)
+* 😊 Getting started
+	* [Start here](docs/getting-started/README.md)
+	* [Uploading](docs/getting-started/uploading.md)
+	* [Options & config](docs/reference/config.md)
+	* Examples
+		* [PinScan](examples/PinScan/README.md)
+	* [ESPHome port](docs/projects/esphome.md)
+	* [Using tuya-cloudcutter](docs/getting-started/cloudcutter.md)
+	* [Auto-download-reboot](docs/getting-started/adr.md)
+* [💻 Boards & CPU list](docs/status/supported.md)
+* [✔️ Implementation status](docs/status/arduino.md)
+* Supported chip families
+	* Beken BK72xx
+		* [General info](docs/platform/beken-72xx/README.md)
+		* [Flashing](docs/platform/beken-72xx/flashing.md)
+		* [Dumping](docs/platform/beken-72xx/dumping.md)
+	* Realtek AmebaZ Series
+		* [General info](docs/platform/realtek/README.md)
+		* [Flashing (AmebaZ)](docs/platform/realtek-ambz/flashing.md)
+		* [Dumping (AmebaZ)](docs/platform/realtek-ambz/dumping.md)
+		* [Debugging](docs/platform/realtek/debugging.md)
+		* [Exception decoder](docs/platform/realtek/exception-decoder.md)
+		* C library
+			* [Built-in functions](docs/platform/realtek-ambz/stdlib.md)
+			* [Memory management](docs/platform/realtek-ambz/memory-management.md)
+	* [All supported boards](boards/)
+* API & libraries
+	* [Options & config](docs/reference/config.md)
+	* [LibreTuya API](docs/reference/lt-api.md)
+		* [LT class reference](ltapi/class_libre_tuya.md)
+		* [Common methods](ltapi/_libre_tuya_a_p_i_8h.md)
+		* [Wiring custom methods](ltapi/_libre_tuya_custom_8h.md)
+		* [Logger](ltapi/lt__logger_8h.md)
+		* [Chip & family IDs](ltapi/_chip_type_8h_source.md)
+		* [POSIX utilities](ltapi/lt__posix__api_8h.md)
+	* Common API
+		* [FS](ltapi/classfs_1_1_f_s.md)
+		* [Preferences](ltapi/class_i_preferences.md)
+		* [SoftwareSerial](ltapi/class_software_serial.md)
+		* [WiFi API](ltapi/class_wi_fi_class.md)
+			* [TCP Client](ltapi/class_i_wi_fi_client.md)
+			* [SSL Client](ltapi/class_i_wi_fi_client_secure.md)
+			* [TCP Server](ltapi/class_i_wi_fi_server.md)
+	* [LibreTuya libraries](docs/libs-built-in.md)
+		* [base64](ltapi/classbase64.md)
+		* [Flash](ltapi/class_flash_class.md)
+		* [HTTPClient](ltapi/class_h_t_t_p_client.md)
+		* [mDNS](ltapi/classm_d_n_s.md)
+		* NetUtils
+			* [ssl/MbedTLSClient](ltapi/class_mbed_t_l_s_client.md)
+			* [IPv6Address](ltapi/classarduino_1_1_i_pv6_address.md)
+			* [LwIPRxBuffer](ltapi/class_lw_i_p_rx_buffer.md)
+		* [Update](ltapi/class_update_class.md)
+		* [WebServer](ltapi/class_web_server.md)
+		* [WiFiMulti](ltapi/class_wi_fi_multi.md)
+	* [Third party libraries](docs/libs-3rd-party.md)
+	* Full documentation
+		* [Classes](ltapi/classes.md)
+		* [Functions](ltapi/functions.md)
+		* [Macros](ltapi/macros.md)
+		* [File list](ltapi/files.md)
+	* [📁 Project structure](docs/reference/project-structure.md)
+	* [✈️ OTA format](docs/ota/README.md)
+		* [uf2ota.py tool](docs/ota/uf2ota.md)
+		* [uf2ota.h library](docs/ota/library.md)
+		* [uf2ota.h reference](ltapi/uf2ota_8h.md)
+* [📓 TODO](TODO.md)
+* [🔗 Resources](docs/resources.md)

TODO.md

@@ -0,0 +1,53 @@
+# TODO list
+
+## General
+
+### Environment stability
+
+Do not publish *any* SDK functions, macros, defines and includes. Define only what's needed in LT's public headers (like `Arduino.h`). Everything else is taken from `sdk_extern.h` or `WVariant.h` (TODO decide whether to keep WV public / make both private / get rid of WV and use sdk_extern only). Private headers are included by LT's .cpp units (maybe a dedicated private header that would include sdk_extern + Arduino.h).
+
+Developers wanting to use SDK functions need to include them.
+
+Explicit is better than implicit.
+
+- consider moving to C++17 (GNU)? or any newer than C++11
+
+### New families
+
+- BL602
+- RTL8710A
+- RTL8720C
+- RTL8720D
+- W600 and/or W800
+- LN8825
+- BK7231Q
+- host-native family
+
+### Tools
+
+- write OpenOCD flashers, using uf2ota library + FAL for partitions (in ltchiptool repository)
+
+### Serial
+
+- configuration of RX/TX pins
+- SoftwareSerial library - receiving + Beken family
+
+### Other
+
+- watchdog API
+- `Preferences` library
+- test/fix IPv6 on different families
+- what is `PowerManagement` at all? probably useless -> remove
+
+## BK7231
+
+- fix WiFi on BK7231N, test other functionality
+- fix SSL (mbedTLS)
+- I2C (Wire)
+- SPI
+- BLE
+
+## RTL8710B
+
+- take all stdio functions from stdio.h
+- rewrite most of Wiring (it was copied from `ambd_arduino`, and is ugly)

arduino/beken-72xx/cores/arduino/Arduino.h

@@ -0,0 +1,32 @@
+/* Copyright (c) Kuba Szczodrzyński 2022-06-14. */
+
+#pragma once
+
+#ifdef __cplusplus
+#include "WCharacterFixup.h"
+#endif
+
+#define delay delayMilliseconds // change delay()'s signature - it's defined as static inline in WVariant.h
+#include <api/ArduinoAPI.h>
+#include <core/LibreTuyaAPI.h>
+#undef delay
+
+// Include family-specific code
+#include "WVariant.h"
+// Include board variant
+#include "variant.h"
+
+// Choose the main UART output port
+#ifndef LT_UART_DEFAULT_PORT
+#if defined(PIN_SERIAL2_TX)
+#define LT_UART_DEFAULT_PORT 2
+#else
+#define LT_UART_DEFAULT_PORT 1
+#endif
+#endif
+
+// Define available serial ports
+#ifdef __cplusplus
+#include "SerialClass.h"
+#include <core/SerialExtern.h>
+#endif

arduino/beken-72xx/cores/arduino/LibreTuyaAPI.cpp

@@ -0,0 +1,208 @@
+/* Copyright (c) Kuba Szczodrzyński 2022-06-19. */
+
+#include <LibreTuyaAPI.h>
+#include <libraries/Flash/Flash.h>
+
+// can't include <flash.h> as it collides with <Flash.h> on Windows -_-
+#define REG_FLASH_BASE		 0x00803000
+#define REG_FLASH_OPERATE_SW (REG_FLASH_BASE + 0 * 4)
+#define REG_FLASH_RDID		 (REG_FLASH_BASE + 4 * 4)
+#define FLASH_BUSY_SW		 (0x01UL << 31)
+#define FLASH_WP_VALUE		 (0x01UL << 30)
+#define FLASH_OP_SW			 (0x01UL << 29)
+#define FLASH_OP_TYPE_POS	 24
+#define FLASH_OP_RDID		 20
+
+extern "C" {
+
+#include <flash_pub.h>
+#include <param_config.h>
+#include <start_type_pub.h>
+#include <sys_ctrl.h>
+#include <sys_rtos.h>
+#include <wdt_pub.h>
+#include <wlan_ui_pub.h>
+
+extern uint8_t system_mac[];
+extern uint32_t wdt_ctrl(uint32_t cmd, void *param);
+
+} // extern "C"
+
+void LibreTuya::restart() {
+	bk_reboot();
+}
+
+void LibreTuya::restartDownloadMode() {
+	bk_reboot();
+}
+
+ResetReason LibreTuya::getResetReason() {
+	switch (bk_misc_get_start_type()) {
+		case RESET_SOURCE_POWERON:
+			return RESET_REASON_POWER;
+
+		case RESET_SOURCE_REBOOT:
+			return RESET_REASON_SOFTWARE;
+
+		case RESET_SOURCE_WATCHDOG:
+			return RESET_REASON_WATCHDOG;
+
+		case RESET_SOURCE_CRASH_XAT0:
+		case RESET_SOURCE_CRASH_UNDEFINED:
+		case RESET_SOURCE_CRASH_PREFETCH_ABORT:
+		case RESET_SOURCE_CRASH_DATA_ABORT:
+		case RESET_SOURCE_CRASH_UNUSED:
+		case RESET_SOURCE_CRASH_PER_XAT0:
+			return RESET_REASON_CRASH;
+
+		case RESET_SOURCE_DEEPPS_GPIO:
+		case RESET_SOURCE_DEEPPS_RTC:
+			return RESET_REASON_SLEEP;
+	}
+	return RESET_REASON_UNKNOWN;
+}
+
+/* CPU-related */
+
+ChipType LibreTuya::getChipType() {
+	uint8_t chipId = *(uint8_t *)(SCTRL_CHIP_ID);
+	return CHIP_TYPE_ENUM(FAMILY, chipId);
+}
+
+const char *LibreTuya::getChipModel() {
+	return STRINGIFY_MACRO(MCU);
+}
+
+uint32_t LibreTuya::getChipId() {
+	uint8_t mac[6];
+	cfg_load_mac(mac); // force loading MAC from TLV (ignore user-set WiFi MAC)
+	return (mac[3]) | (mac[4] << 8) | (mac[5] << 16);
+}
+
+uint8_t LibreTuya::getChipCores() {
+	return 1;
+}
+
+const char *LibreTuya::getChipCoreType() {
+	return "ARM968E-S";
+}
+
+uint32_t LibreTuya::getCpuFreq() {
+	return configCPU_CLOCK_HZ;
+}
+
+uint32_t LibreTuya::getCycleCount() {
+	// TODO
+	return 0;
+}
+
+/* Flash memory utilities */
+
+FlashId LibreTuya::getFlashChipId() {
+	uint32_t data = (FLASH_OP_RDID << FLASH_OP_TYPE_POS) | FLASH_OP_SW | FLASH_WP_VALUE;
+	REG_WRITE(REG_FLASH_OPERATE_SW, data);
+	while (REG_READ(REG_FLASH_OPERATE_SW) & FLASH_BUSY_SW) {}
+	FlashId id = {
+		.manufacturerId = REG_RD8(REG_FLASH_RDID, 2),
+		.chipId			= REG_RD8(REG_FLASH_RDID, 1),
+		.chipSizeId		= REG_RD8(REG_FLASH_RDID, 0),
+	};
+	return id;
+}
+
+/* Memory management */
+
+uint32_t LibreTuya::getRamSize() {
+	return 256 * 1024;
+}
+
+uint32_t LibreTuya::getHeapSize() {
+#if configDYNAMIC_HEAP_SIZE
+	extern unsigned char _empty_ram;
+#if CFG_SOC_NAME == SOC_BK7231N
+	return (0x00400000 + 192 * 1024) - (uint32_t)(&_empty_ram);
+#else
+	return (0x00400000 + 256 * 1024) - (uint32_t)(&_empty_ram);
+#endif
+#else
+	return configTOTAL_HEAP_SIZE;
+#endif
+}
+
+uint32_t LibreTuya::getFreeHeap() {
+	return xPortGetFreeHeapSize();
+}
+
+uint32_t LibreTuya::getMinFreeHeap() {
+	return xPortGetMinimumEverFreeHeapSize();
+}
+
+uint32_t LibreTuya::getMaxAllocHeap() {
+	return 0;
+}
+
+/* OTA-related */
+
+static int8_t otaImage2Valid = -1;
+
+uint8_t LibreTuya::otaGetRunning() {
+	// Beken has bootloader-based OTA, running app is always index 1
+	return 1;
+}
+
+uint8_t LibreTuya::otaGetStoredIndex() {
+	return otaHasImage2() ? 2 : 1;
+}
+
+bool LibreTuya::otaSupportsDual() {
+	return true;
+}
+
+bool LibreTuya::otaHasImage1() {
+	return true;
+}
+
+bool LibreTuya::otaHasImage2() {
+	if (otaImage2Valid != -1)
+		return otaImage2Valid;
+	// check download RBL
+	// TODO: maybe check header CRC or even binary hashes
+	uint32_t magic;
+	Flash.readBlock(FLASH_DOWNLOAD_OFFSET, (uint8_t *)&magic, 4);
+	otaImage2Valid = magic == 0x004C4252; // "RBL\0", little-endian
+	return otaImage2Valid;
+}
+
+bool LibreTuya::otaSwitch(bool force) {
+	// no need to check otaGetStoredIndex() as it does the same as otaHasImage2()
+
+	// force checking validity again
+	otaImage2Valid = -1;
+
+	if (otaHasImage2() && force) {
+		// "rollback" - abort bootloader upgrade operation by wiping first sector
+		return Flash.eraseSector(FLASH_DOWNLOAD_OFFSET);
+	}
+
+	return otaHasImage2(); // false if second image is not valid
+}
+
+/* Watchdog */
+
+bool LibreTuya::wdtEnable(uint32_t timeout) {
+	wdt_ctrl(WCMD_SET_PERIOD, &timeout);
+	wdt_ctrl(WCMD_POWER_UP, NULL);
+}
+
+void LibreTuya::wdtDisable() {
+	wdt_ctrl(WCMD_POWER_DOWN, NULL);
+}
+
+void LibreTuya::wdtFeed() {
+	wdt_ctrl(WCMD_RELOAD_PERIOD, NULL);
+}
+
+/* Global instance */
+
+LibreTuya LT;
+LibreTuya ESP = LT;

arduino/beken-72xx/cores/arduino/SerialClass.cpp

@@ -0,0 +1,109 @@
+/* Copyright (c) Kuba Szczodrzyński 2022-06-23. */
+
+#include "SerialClass.h"
+
+extern "C" {
+
+#include <uart_pub.h>
+
+extern void bk_send_byte(uint8_t uport, uint8_t data);
+extern void uart_hw_set_change(uint8_t uport, bk_uart_config_t *uart_config);
+extern int uart_rx_callback_set(int uport, uart_callback callback, void *param);
+
+} // extern "C"
+
+#ifdef PIN_SERIAL1_TX
+SerialClass Serial1(UART1_PORT);
+#endif
+#ifdef PIN_SERIAL2_TX
+SerialClass Serial2(UART2_PORT);
+#endif
+
+SerialClass::SerialClass(uint8_t port) {
+	this->port = port;
+	this->buf  = NULL;
+}
+
+#if LT_AUTO_DOWNLOAD_REBOOT
+static uint8_t adrState		  = 0;
+static const uint8_t adrCmd[] = {0x01, 0xE0, 0xFC, 0x01, 0x00};
+
+static void adrParse(uint8_t c) {
+	// parse and respond to link check command (CMD_LinkCheck=0)
+	adrState = (adrState + 1) * (c == adrCmd[adrState]);
+	if (adrState == 5) {
+		LT_I("Auto download mode: rebooting");
+		LT.restart();
+	}
+}
+#endif
+
+static void callback(int port, void *param) {
+	RingBuffer *buf = (RingBuffer *)param;
+	int ch;
+	while ((ch = uart_read_byte(port)) != -1) {
+#if LT_AUTO_DOWNLOAD_REBOOT && defined(PIN_SERIAL1_RX)
+		// parse UART protocol commands on UART1
+		if (port == UART1_PORT)
+			adrParse(ch);
+#endif
+		buf->store_char(ch);
+	}
+}
+
+void SerialClass::begin(unsigned long baudrate, uint16_t config) {
+	uint8_t dataWidth = ((config & SERIAL_DATA_MASK) >> 8) - 1;				  // 0x100..0x400 -> 0..3
+	uint8_t parity	  = 3 - (config & SERIAL_PARITY_MASK);					  // 0x3..0x1 -> 0..2
+	uint8_t stopBits  = (config & SERIAL_STOP_BIT_MASK) == SERIAL_STOP_BIT_2; // 0x10..0x30 -> 0..1
+
+	bk_uart_config_t cfg = {
+		.baud_rate	  = baudrate,
+		.data_width	  = (uart_data_width_t)dataWidth,
+		.parity		  = (uart_parity_t)parity,
+		.stop_bits	  = (uart_stop_bits_t)stopBits,
+		.flow_control = FLOW_CTRL_DISABLED,
+	};
+
+	if (this->buf) {
+		this->buf->clear();
+	} else {
+		this->buf = new RingBuffer();
+	}
+
+	uart_hw_set_change(port, &cfg);
+	uart_rx_callback_set(port, callback, this->buf);
+}
+
+void SerialClass::end() {
+	uart_rx_callback_set(port, NULL, NULL);
+	switch (port) {
+		case 1:
+			uart1_exit();
+			break;
+		case 2:
+			uart2_exit();
+			break;
+	}
+	delete this->buf;
+}
+
+int SerialClass::available() {
+	return buf->available();
+}
+
+int SerialClass::peek() {
+	return buf->peek();
+}
+
+int SerialClass::read() {
+	return buf->read_char();
+}
+
+void SerialClass::flush() {
+	uart_wait_tx_over();
+}
+
+size_t SerialClass::write(uint8_t c) {
+	bk_send_byte(port, c);
+	return 1;
+}

arduino/beken-72xx/cores/arduino/SerialClass.h

@@ -0,0 +1,38 @@
+/* Copyright (c) Kuba Szczodrzyński 2022-06-23. */
+
+#pragma once
+
+#include <Arduino.h>
+#include <api/HardwareSerial.h>
+#include <api/RingBuffer.h>
+
+using namespace arduino;
+
+class SerialClass : public HardwareSerial {
+  private:
+	uint8_t port;
+	RingBuffer *buf;
+
+  public:
+	SerialClass(uint8_t port);
+
+	inline void begin(unsigned long baudrate) {
+		begin(baudrate, SERIAL_8N1);
+	}
+
+	void begin(unsigned long baudrate, uint16_t config);
+	void end();
+	int available();
+	int peek();
+	int read();
+	void flush();
+	size_t write(uint8_t c);
+
+	operator bool() {
+		return !!buf;
+	}
+
+	using Print::write;
+};
+
+#define HAS_SERIAL_CLASS 1

arduino/beken-72xx/cores/arduino/WVariant.h

@@ -0,0 +1,22 @@
+/* Copyright (c) Kuba Szczodrzyński 2022-06-18. */
+
+#pragma once
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#include "sdk_extern.h"
+#include "sdk_mem.h"
+
+// define an inline delay() which overrides BDK's delay()
+static inline __attribute__((always_inline)) void delay(unsigned long ms) {
+	delayMilliseconds(ms);
+}
+
+// from fixups/arch_main.c
+extern unsigned char __bk_rf_is_init;
+
+#ifdef __cplusplus
+} // extern "C"
+#endif

arduino/beken-72xx/cores/arduino/main.cpp

@@ -0,0 +1,38 @@
+/* Copyright (c) Kuba Szczodrzyński 2022-06-19. */
+
+#include <Arduino.h>
+
+extern "C" {
+
+#include <rtos_pub.h>
+#include <sys_rtos.h>
+
+extern int uart_print_port;
+
+} // extern "C"
+
+beken_thread_t mainThread;
+
+void initArduino() {
+	// set default UART output port
+	uart_print_port = LT_UART_DEFAULT_PORT - 1;
+#if LT_AUTO_DOWNLOAD_REBOOT && defined(PIN_SERIAL1_RX) && defined(PIN_SERIAL1_TX)
+	// initialize auto-download-reboot parser
+	Serial1.begin(115200);
+#endif
+}
+
+bool startMainTask() {
+	OSStatus ret = rtos_create_thread(
+		&mainThread,
+		THD_APPLICATION_PRIORITY,
+		"main",
+		(beken_thread_function_t)mainTask,
+		8192,
+		NULL
+	);
+	if (ret != kNoErr)
+		return false;
+	vTaskStartScheduler();
+	return true;
+}

arduino/beken-72xx/cores/arduino/sdk_extern.h

@@ -0,0 +1,30 @@
+/* Copyright (c) Kuba Szczodrzyński 2022-06-18. */
+
+#pragma once
+
+// for printf() etc (they are wrapped anyway)
+#include <stdio.h>
+
+// most stuff is here
+#include <include.h>
+// for os_printf
+#include <uart_pub.h>
+// for GPIO names
+#include <gpio_pub.h>
+
+// conflict with stl_algobase.h
+#undef min
+#undef max
+
+// include printf() wrapper disable methods
+#include <printf_port.h>
+
+// make non-SDK code call the proper printf()
+#undef bk_printf
+#undef os_printf
+#undef warning_prf
+#undef fatal_prf
+#define bk_printf	printf
+#define os_printf	printf
+#define warning_prf printf
+#define fatal_prf	printf

arduino/beken-72xx/cores/arduino/sdk_mem.h

@@ -0,0 +1,20 @@
+/* Copyright (c) Kuba Szczodrzyński 2022-06-18. */
+
+#pragma once
+
+#include <stddef.h>
+
+// Beken SDK is actually pretty good, in terms of declaring
+// stdlib functions properly! So no need for any #define hell.
+#include <mem_pub.h>
+
+// All the MemMang functions are in stdlib, just wrapped
+// during linking.
+#include <stdlib.h>
+// for memcpy etc.
+#include <string.h>
+
+// ...except zalloc, which is apparently not in the stdlib
+#define zalloc os_zalloc
+
+#define LT_HEAP_FUNC xPortGetFreeHeapSize

arduino/beken-72xx/cores/arduino/wiring.c

@@ -0,0 +1,109 @@
+/* Copyright (c) Kuba Szczodrzyński 2022-06-19. */
+
+#include <Arduino.h>
+#include <arm_arch.h>
+#include <bk_timer.h>
+#include <bk_timer_pub.h>
+#include <rtos_pub.h>
+#include <sys_rtos.h>
+
+#define TICKS_PER_US	   (CFG_XTAL_FREQUENCE / 1000 / 1000)
+#define US_PER_OVERFLOW	   (portTICK_PERIOD_MS * 1000)
+#define TICKS_PER_OVERFLOW (TICKS_PER_US * US_PER_OVERFLOW)
+
+void delayMilliseconds(unsigned long ms) {
+	rtos_delay_milliseconds(ms);
+}
+
+static uint32_t getTicksCount() {
+	// copied from bk_timer_ctrl(), for speeds
+	uint32_t timeout = 0;
+	REG_WRITE(TIMER0_2_READ_CTL, (BKTIMER0 << 2) | 1);
+	while (REG_READ(TIMER0_2_READ_CTL) & 1) {
+		timeout++;
+		if (timeout > (120 * 1000))
+			return 0;
+	}
+	return REG_READ(TIMER0_2_READ_VALUE);
+}
+
+void delayMicroseconds(unsigned int us) {
+#if LT_MICROS_HIGH_RES
+	if (us == 0)
+		return;
+	us--;
+	uint32_t startTick = getTicksCount();
+	/* startTick2 accounts for the case where the timer counter overflows */
+	uint32_t startTick2 = startTick - TICKS_PER_OVERFLOW;
+	uint32_t delayTicks = TICKS_PER_US * us;
+	while (delayTicks > TICKS_PER_OVERFLOW) {
+		// The delay is longer than what the timer can count.
+		// Let it overflow until only a fraction of TICKS_PER_OVERFLOW remain.
+		while (getTicksCount() > startTick) {}
+		while (getTicksCount() < startTick) {}
+		delayTicks -= TICKS_PER_OVERFLOW;
+	}
+	while ((getTicksCount() - startTick < delayTicks) || // normal case
+		   (getTicksCount() - startTick2 < delayTicks)	 // counter overflow case
+	) {}
+#else
+	volatile uint32_t i, j;
+	for (i = 0; i < us; i++) {
+		for (j = 0; j < 6; j++) {}
+	}
+#endif
+}
+
+unsigned long millis() {
+	return xTaskGetTickCount() * portTICK_PERIOD_MS;
+}
+
+unsigned long micros() {
+#if (CFG_SOC_NAME == SOC_BK7231)
+#error "Not implemented"
+#endif
+
+#if LT_MICROS_HIGH_RES
+	static uint32_t lastMillis		= 0;
+	static uint32_t correctedMillis = 0;
+	static uint32_t lastTicks		= 0;
+	uint32_t nowMillis				= millis();
+	uint32_t nowTicks				= getTicksCount();
+	bool tickOverflow				= nowTicks < lastTicks;
+	bool millisUpdated				= nowMillis != lastMillis;
+	if (millisUpdated) {
+		/* reset artificially corrected millis */
+		correctedMillis = nowMillis;
+	} else if (tickOverflow) {
+		/*
+		This can happen if micros is called from within a interruptLock block (interrupts disabled).
+		In this case, if the tick counter rolls over, millis() won't be updated, and micros will
+		lag by US_PER_OVERFLOW milliseconds (one rollover).
+		The workaround only works as long as micros() calls happen within 2ms of eachother.
+		WARNING: if interrupts are disabled for more than 2ms, micros() and millis() will temporarily get out of sync.
+		*/
+		correctedMillis += portTICK_PERIOD_MS;
+	}
+	lastMillis = nowMillis;
+	lastTicks  = nowTicks;
+	return correctedMillis * 1000 + nowTicks / (CFG_XTAL_FREQUENCE / 1000 / 1000);
+#else
+#if 0
+	uint32_t timeout = 0;
+	REG_WRITE(TIMER3_5_READ_CTL, (BKTIMER3 << 2) | 1);
+	while (REG_READ(TIMER3_5_READ_CTL) & 1) {
+		timeout++;
+		if (timeout > (120 * 1000))
+			return 0;
+	}
+	return millis() * 1000 + REG_READ(TIMER3_5_READ_VALUE) / 32;
+#endif
+	return millis() * 1000;
+#endif
+}
+
+void yield() {
+	runPeriodicTasks();
+	vTaskDelay(1);
+	taskYIELD();
+}

arduino/beken-72xx/cores/arduino/wiring_analog.c

@@ -0,0 +1,143 @@
+/* Copyright (c) Kuba Szczodrzyński 2022-06-20. */
+
+#include <Arduino.h>
+#include <pwm_pub.h>
+#include <saradc_pub.h>
+
+static GPIO_INDEX pwmToGpio[] = {
+	GPIO6,	// PWM0
+	GPIO7,	// PWM1
+	GPIO8,	// PWM2
+	GPIO9,	// PWM3
+	GPIO24, // PWM4
+	GPIO26, // PWM5
+};
+
+#if CFG_SOC_NAME == SOC_BK7231N
+static GPIO_INDEX adcToGpio[] = {
+	-1,		 // ADC0 - VBAT
+	GPIONUM, // ADC1
+	GPIONUM, // ADC2
+	GPIO23,	 // ADC3
+	GPIONUM, // ADC4
+	GPIONUM, // ADC5
+	GPIONUM, // ADC6
+	GPIONUM, // ADC7
+};
+#else
+static GPIO_INDEX adcToGpio[] = {
+	-1,		// ADC0 - VBAT
+	GPIO4,	// ADC1
+	GPIO5,	// ADC2
+	GPIO23, // ADC3
+	GPIO2,	// ADC4
+	GPIO3,	// ADC5
+	GPIO12, // ADC6
+	GPIO13, // ADC7
+};
+#endif
+
+static uint8_t gpioToPwm(GPIO_INDEX gpio) {
+	for (uint8_t i = 0; i < sizeof(pwmToGpio) / sizeof(GPIO_INDEX); i++) {
+		if (pwmToGpio[i] == gpio)
+			return i;
+	}
+	return 0;
+}
+
+static uint8_t gpioToAdc(GPIO_INDEX gpio) {
+	for (uint8_t i = 0; i < sizeof(adcToGpio) / sizeof(GPIO_INDEX); i++) {
+		if (adcToGpio[i] == gpio)
+			return i;
+	}
+	return 0;
+}
+
+static pwm_param_t pwm;
+static uint16_t adcData[1];
+
+uint16_t analogReadVoltage(pin_size_t pinNumber) {
+	PinInfo *pin = pinInfo(pinNumber);
+	if (!pin)
+		return 0;
+	if (!pinSupported(pin, PIN_ADC))
+		return 0;
+
+	UINT32 status;
+	saradc_desc_t adc;
+	DD_HANDLE handle;
+	saradc_config_param_init(&adc);
+	adc.channel		   = gpioToAdc(pin->gpio);
+	adc.mode		   = ADC_CONFIG_MODE_CONTINUE;
+	adc.pData		   = adcData;
+	adc.data_buff_size = 1;
+	handle			   = ddev_open(SARADC_DEV_NAME, &status, (uint32_t)&adc);
+	if (status)
+		return 0;
+	// wait for data
+	while (!adc.has_data || adc.current_sample_data_cnt < 1) {
+		delay(1);
+	}
+	ddev_control(handle, SARADC_CMD_RUN_OR_STOP_ADC, (void *)false);
+	ddev_close(handle);
+	return adcData[0];
+}
+
+uint16_t analogReadMaxVoltage(pin_size_t pinNumber) {
+	return 3300;
+}
+
+void analogWrite(pin_size_t pinNumber, int value) {
+	PinInfo *pin = pinInfo(pinNumber);
+	if (!pin)
+		return;
+	if (!pinSupported(pin, PIN_PWM))
+		return;
+
+	float percent	   = value * 1.0 / ((1 << _analogWriteResolution) - 1);
+	uint32_t frequency = 26 * _analogWritePeriod - 1;
+	uint32_t dutyCycle = percent * frequency;
+	pwm.channel		   = gpioToPwm(pin->gpio);
+#if CFG_SOC_NAME != SOC_BK7231N
+	pwm.duty_cycle = dutyCycle;
+#else
+	pwm.duty_cycle1 = dutyCycle;
+	pwm.duty_cycle2 = 0;
+	pwm.duty_cycle3 = 0;
+#endif
+
+	if (value) {
+		if (!pinEnabled(pin, PIN_PWM)) {
+			// enable PWM and set its value
+			pwm.cfg.bits.en		= PWM_ENABLE;
+			pwm.cfg.bits.int_en = PWM_INT_DIS;
+			pwm.cfg.bits.mode	= PWM_PWM_MODE;
+			pwm.cfg.bits.clk	= PWM_CLK_26M;
+			pwm.end_value		= frequency;
+			pwm.p_Int_Handler	= NULL;
+			__wrap_bk_printf_disable();
+			sddev_control(PWM_DEV_NAME, CMD_PWM_INIT_PARAM, &pwm);
+			sddev_control(PWM_DEV_NAME, CMD_PWM_INIT_LEVL_SET_HIGH, &pwm.channel);
+			sddev_control(PWM_DEV_NAME, CMD_PWM_UNIT_ENABLE, &pwm.channel);
+			__wrap_bk_printf_enable();
+			pin->enabled &= ~PIN_GPIO;
+			pin->enabled |= PIN_PWM;
+		} else {
+			// update duty cycle
+			sddev_control(PWM_DEV_NAME, CMD_PWM_SET_DUTY_CYCLE, &pwm);
+		}
+	} else {
+		if (pinEnabled(pin, PIN_PWM)) {
+			// disable PWM
+			pwm.cfg.bits.en = PWM_DISABLE;
+			__wrap_bk_printf_disable();
+			sddev_control(PWM_DEV_NAME, CMD_PWM_SET_DUTY_CYCLE, &pwm);
+			sddev_control(PWM_DEV_NAME, CMD_PWM_DEINIT_PARAM, &pwm);
+			__wrap_bk_printf_enable();
+			pin->enabled &= ~PIN_PWM;
+		}
+		// force level as LOW
+		pinMode(pinNumber, OUTPUT);
+		digitalWrite(pinNumber, LOW);
+	}
+}

arduino/beken-72xx/cores/arduino/wiring_digital.c

@@ -0,0 +1,62 @@
+/* Copyright (c) Kuba Szczodrzyński 2022-06-20. */
+
+#include <Arduino.h>
+
+void pinMode(pin_size_t pinNumber, PinMode pinMode) {
+	PinInfo *pin = pinInfo(pinNumber);
+	if (!pin)
+		return;
+	if (!pinSupported(pin, PIN_GPIO))
+		return;
+	if (pinEnabled(pin, PIN_PWM))
+		// disable PWM before using the pin
+		analogWrite(pinNumber, 0);
+	if (pinEnabled(pin, PIN_GPIO) && pin->mode == pinMode)
+		return;
+	switch (pinMode) {
+		case INPUT:
+			gpio_config(pin->gpio, GMODE_INPUT);
+			break;
+		case OUTPUT:
+			gpio_config(pin->gpio, GMODE_OUTPUT);
+			break;
+		case INPUT_PULLUP:
+			gpio_config(pin->gpio, GMODE_INPUT_PULLUP);
+			break;
+		case INPUT_PULLDOWN:
+			gpio_config(pin->gpio, GMODE_INPUT_PULLDOWN);
+			break;
+		case OUTPUT_OPENDRAIN:
+			gpio_config(pin->gpio, GMODE_SET_HIGH_IMPENDANCE);
+			break;
+	}
+	pin->enabled |= PIN_GPIO;
+	pin->mode = pinMode;
+}
+
+void digitalWrite(pin_size_t pinNumber, PinStatus status) {
+	// verify level is 0 or 1
+	if (status > HIGH)
+		return;
+	PinInfo *pin = pinInfo(pinNumber);
+	if (!pin)
+		return;
+	// pin is not GPIO yet or not OUTPUT; enable or disable input pullup
+	if (!pinEnabled(pin, PIN_GPIO) || !pinIsOutput(pin)) {
+		pinMode(pinNumber, status * INPUT_PULLUP);
+		return;
+	}
+	// write the new state
+	gpio_output(pin->gpio, status);
+}
+
+PinStatus digitalRead(pin_size_t pinNumber) {
+	PinInfo *pin = pinInfo(pinNumber);
+	if (!pin)
+		return 0;
+	// pin is not GPIO yet or not INPUT; change the mode
+	if (!pinEnabled(pin, PIN_GPIO) || !pinIsInput(pin))
+		pinMode(pinNumber, INPUT);
+	// read the value
+	return gpio_input(pin->gpio);
+}

arduino/beken-72xx/cores/arduino/wiring_irq.c

@@ -0,0 +1,99 @@
+/* Copyright (c) Kuba Szczodrzyński 2022-07-31. */
+
+#include <Arduino.h>
+
+static void *irqHandlerList[PINS_COUNT] = {NULL};
+static void *irqHandlerArgs[PINS_COUNT] = {NULL};
+static bool irqChangeList[PINS_COUNT];
+
+static void irqHandler(unsigned char gpio) {
+	int pin = -1;
+	for (pin_size_t i = 0; i < PINS_COUNT; i++) {
+		if (pinTable[i].gpio == gpio) {
+			pin = i;
+			break;
+		}
+	}
+	if (pin == -1)
+		return;
+	if (!irqHandlerList[pin])
+		return;
+	if (irqChangeList[pin]) {
+		if (pinTable[pin].mode == INPUT_PULLDOWN) {
+			pinTable[pin].mode = INPUT_PULLUP;
+			gpio_int_enable(pinTable[pin].gpio, GPIO_INT_LEVEL_FALLING, irqHandler);
+		} else if (pinTable[pin].mode == INPUT_PULLUP) {
+			pinTable[pin].mode = INPUT_PULLDOWN;
+			gpio_int_enable(pinTable[pin].gpio, GPIO_INT_LEVEL_RISING, irqHandler);
+		}
+	}
+	if (irqHandlerArgs[pin] == NULL) {
+		((voidFuncPtr)irqHandlerList[pin])();
+	} else {
+		((voidFuncPtrParam)irqHandlerList[pin])(irqHandlerArgs[pin]);
+	}
+}
+
+void attachInterrupt(pin_size_t interruptNumber, voidFuncPtr callback, PinStatus mode) {
+	attachInterruptParam(interruptNumber, (voidFuncPtrParam)callback, mode, NULL);
+}
+
+void attachInterruptParam(pin_size_t interruptNumber, voidFuncPtrParam callback, PinStatus mode, void *param) {
+	PinInfo *pin = pinInfo(interruptNumber);
+	if (!pin)
+		return;
+	if (!pinSupported(pin, PIN_IRQ))
+		return;
+	uint32_t event	= 0;
+	PinMode modeNew = 0;
+	bool change		= 0;
+
+	switch (mode) {
+		case LOW:
+			event	= GPIO_INT_LEVEL_LOW;
+			modeNew = INPUT_PULLUP;
+			change	= false;
+			break;
+		case HIGH:
+			event	= GPIO_INT_LEVEL_HIGH;
+			modeNew = INPUT_PULLDOWN;
+			change	= false;
+			break;
+		case FALLING:
+			event	= GPIO_INT_LEVEL_FALLING;
+			modeNew = INPUT_PULLUP;
+			change	= false;
+			break;
+		case RISING:
+			event	= GPIO_INT_LEVEL_RISING;
+			modeNew = INPUT_PULLDOWN;
+			change	= false;
+			break;
+		case CHANGE:
+			event	= GPIO_INT_LEVEL_FALLING;
+			modeNew = INPUT_PULLUP;
+			change	= true;
+			break;
+		default:
+			return;
+	}
+	irqHandlerList[interruptNumber] = callback;
+	irqHandlerArgs[interruptNumber] = param;
+	irqChangeList[interruptNumber]	= change;
+	gpio_int_enable(pin->gpio, event, irqHandler);
+	pin->enabled |= PIN_IRQ | PIN_GPIO;
+	pin->mode = modeNew;
+}
+
+void detachInterrupt(pin_size_t interruptNumber) {
+	PinInfo *pin = pinInfo(interruptNumber);
+	if (!pin)
+		return;
+	if (!pinSupported(pin, PIN_IRQ))
+		return;
+	irqHandlerList[interruptNumber] = NULL;
+	irqHandlerArgs[interruptNumber] = NULL;
+	irqChangeList[interruptNumber]	= false;
+	gpio_int_disable(pin->gpio);
+	pin->enabled &= ~PIN_IRQ;
+}

arduino/beken-72xx/libraries/MD5/MD5Impl.h

@@ -0,0 +1,5 @@
+/* Copyright (c) Kuba Szczodrzyński 2022-07-11. */
+
+#pragma once
+
+#define LT_MD5_USE_HOSTAPD 1

arduino/beken-72xx/libraries/WiFi/WiFi.cpp

@@ -0,0 +1,81 @@
+/* Copyright (c) Kuba Szczodrzyński 2022-06-26. */
+
+#include "WiFiPriv.h"
+
+WiFiClass::WiFiClass() {
+	memset(&data, 0x00, sizeof(WiFiData));
+	data.scanSem = xSemaphoreCreateBinary();
+}
+
+WiFiClass::~WiFiClass() {
+	vSemaphoreDelete(data.scanSem);
+}
+
+void WiFiClass::dataInitialize() {
+	if (data.statusIp)
+		return;
+	LT_DM(WIFI, "Data init");
+	data.configSta	   = zalloc(sizeof(network_InitTypeDef_st));
+	data.configAp	   = zalloc(sizeof(network_InitTypeDef_ap_st));
+	data.statusIp	   = malloc(sizeof(IPStatusTypedef));
+	data.statusLink	   = malloc(sizeof(LinkStatusTypeDef));
+	STA_CFG->dhcp_mode = DHCP_CLIENT;
+	LT_DM(WIFI, "Data = %p", data.configSta);
+}
+
+void WiFiClass::dataFree() {
+	LT_DM(WIFI, "Data free");
+	free(data.configSta);
+	free(data.configAp);
+	free(data.statusIp);
+	free(data.statusLink);
+	data.configSta	= NULL;
+	data.configAp	= NULL;
+	data.statusIp	= NULL;
+	data.statusLink = NULL;
+}
+
+WiFiStatus eventTypeToStatus(uint8_t type) {
+	// rw_msg_pub.h:9
+	switch (type) {
+		case RW_EVT_STA_IDLE:
+			return WL_IDLE_STATUS;
+		case RW_EVT_STA_NO_AP_FOUND:
+			return WL_NO_SSID_AVAIL;
+		case RW_EVT_STA_CONNECTING:
+		case RW_EVT_STA_CONNECTED:
+			return WL_SCAN_COMPLETED;
+		case RW_EVT_STA_GOT_IP:
+			return WL_CONNECTED;
+		case RW_EVT_STA_PASSWORD_WRONG:
+		case RW_EVT_STA_ASSOC_FULL:
+		case RW_EVT_STA_CONNECT_FAILED:
+			return WL_CONNECT_FAILED;
+		case RW_EVT_STA_BEACON_LOSE:
+			return WL_CONNECTION_LOST;
+		case RW_EVT_STA_DISCONNECTED:
+			return WL_DISCONNECTED;
+	}
+}
+
+WiFiAuthMode securityTypeToAuthMode(uint8_t type) {
+	// wlan_ui_pub.h:62
+	switch (type) {
+		case BK_SECURITY_TYPE_NONE:
+			return WIFI_AUTH_OPEN;
+		case BK_SECURITY_TYPE_WEP:
+			return WIFI_AUTH_WEP;
+		case BK_SECURITY_TYPE_WPA_TKIP:
+		case BK_SECURITY_TYPE_WPA_AES:
+			return WIFI_AUTH_WPA_PSK;
+		case BK_SECURITY_TYPE_WPA2_TKIP:
+		case BK_SECURITY_TYPE_WPA2_AES:
+		case BK_SECURITY_TYPE_WPA2_MIXED:
+			return WIFI_AUTH_WPA2_PSK;
+		case BK_SECURITY_TYPE_WPA3_SAE:
+			return WIFI_AUTH_WPA3_PSK;
+		case BK_SECURITY_TYPE_WPA3_WPA2_MIXED:
+			return WIFI_AUTH_WPA2_WPA3_PSK;
+	}
+	return WIFI_AUTH_INVALID;
+}

arduino/beken-72xx/libraries/WiFi/WiFi.h

@@ -0,0 +1,10 @@
+/* Copyright (c) Kuba Szczodrzyński 2022-06-26. */
+
+#pragma once
+
+#include <Arduino.h>
+#include <api/WiFi/WiFi.h>
+
+#include "WiFiClient.h"
+#include "WiFiClientSecure.h"
+#include "WiFiServer.h"

arduino/beken-72xx/libraries/WiFi/WiFiAP.cpp

@@ -0,0 +1,127 @@
+/* Copyright (c) Kuba Szczodrzyński 2022-07-01. */
+
+#include "WiFiPriv.h"
+
+bool WiFiClass::softAP(const char *ssid, const char *passphrase, int channel, bool ssidHidden, int maxClients) {
+	if (!enableAP(true))
+		return WL_CONNECT_FAILED;
+	if (!validate(ssid, passphrase))
+		return WL_CONNECT_FAILED;
+
+	LT_HEAP_I();
+
+	// Beken SDK bug: bk_wlan_ap_init_adv() doesn't null-terminate the passphrase
+	memset(g_ap_param_ptr->key, '\0', 65);
+
+	strcpy(AP_CFG->wifi_ssid, ssid);
+	if (passphrase) {
+		strcpy(AP_CFG->wifi_key, passphrase);
+		AP_CFG->security = BK_SECURITY_TYPE_WPA2_MIXED;
+	} else {
+		AP_CFG->wifi_key[0] = '\0';
+		AP_CFG->security	= BK_SECURITY_TYPE_NONE;
+	}
+
+	AP_CFG->channel				= channel;
+	AP_CFG->ssid_hidden			= ssidHidden;
+	AP_CFG->max_con				= maxClients;
+	AP_CFG->dhcp_mode			= DHCP_SERVER;
+	AP_CFG->wifi_retry_interval = 100;
+
+	LT_IM(WIFI, "Creating SoftAP %s", ssid);
+
+	if (!AP_CFG->local_ip_addr[0]) {
+		LT_DM(WIFI, "Setting default IP config");
+		softAPConfig((uint32_t)0, (uint32_t)0, (uint32_t)0);
+	}
+
+	LT_DM(WIFI, "Static IP: %s / %s / %s", AP_CFG->local_ip_addr, AP_CFG->net_mask, AP_CFG->gateway_ip_addr);
+
+	__wrap_bk_printf_disable();
+	OSStatus ret = bk_wlan_start_ap_adv(AP_CFG);
+	__wrap_bk_printf_enable();
+
+	if (ret != 0) {
+		LT_EM(WIFI, "SoftAP failed; ret=%d", ret);
+		return false;
+	}
+	LT_DM(WIFI, "AP start OK");
+	return true;
+}
+
+bool WiFiClass::softAPConfig(IPAddress localIP, IPAddress gateway, IPAddress subnet) {
+	dataInitialize();
+	if (!localIP) {
+		localIP = gateway = IPAddress(192, 168, 43, 1);
+		subnet			  = IPAddress(255, 255, 255, 0);
+	}
+	sprintf(AP_CFG->local_ip_addr, IP_FMT, localIP[0], localIP[1], localIP[2], localIP[3]);
+	sprintf(AP_CFG->net_mask, IP_FMT, subnet[0], subnet[1], subnet[2], subnet[3]);
+	sprintf(AP_CFG->gateway_ip_addr, IP_FMT, gateway[0], gateway[1], gateway[2], gateway[3]);
+	// from wlan_ui.c:1370
+	if (uap_ip_is_start()) {
+		uap_ip_down();
+		ip_address_set(
+			BK_STATION,
+			AP_CFG->dhcp_mode,
+			AP_CFG->local_ip_addr,
+			AP_CFG->net_mask,
+			AP_CFG->gateway_ip_addr,
+			AP_CFG->dns_server_ip_addr
+		);
+		uap_ip_start();
+	}
+	return true;
+}
+
+bool WiFiClass::softAPdisconnect(bool wifiOff) {
+	if (!(getMode() & WIFI_MODE_AP))
+		// do not call SDK methods before even initializing WiFi first
+		return true;
+	return bk_wlan_stop(BK_SOFT_AP) == kNoErr;
+}
+
+uint8_t WiFiClass::softAPgetStationNum() {
+	return 0;
+}
+
+IPAddress WiFiClass::softAPIP() {
+	AP_GET_IP_STATUS_RETURN((uint32_t)0);
+	IPAddress ip;
+	ip.fromString(IP_STATUS->ip);
+	return ip;
+}
+
+IPAddress WiFiClass::softAPSubnetMask() {
+	AP_GET_IP_STATUS_RETURN((uint32_t)0);
+	IPAddress ip;
+	ip.fromString(IP_STATUS->mask);
+	return ip;
+}
+
+const char *WiFiClass::softAPgetHostname() {
+	struct netif *ifs = (struct netif *)net_get_uap_handle();
+	return netif_get_hostname(ifs);
+}
+
+bool WiFiClass::softAPsetHostname(const char *hostname) {
+	struct netif *ifs = (struct netif *)net_get_uap_handle();
+	netif_set_hostname(ifs, (char *)hostname);
+	return true;
+}
+
+uint8_t *WiFiClass::softAPmacAddress(uint8_t *mac) {
+	setMacAddress(mac);
+	return mac;
+}
+
+String WiFiClass::softAPmacAddress(void) {
+	uint8_t mac[ETH_ALEN];
+	wifi_get_mac_address((char *)mac, CONFIG_ROLE_AP);
+	return macToString(mac);
+}
+
+const String WiFiClass::softAPSSID(void) {
+	AP_GET_LINK_STATUS_RETURN("");
+	return AP_CFG->wifi_ssid;
+}

arduino/beken-72xx/libraries/WiFi/WiFiClient.h

@@ -0,0 +1,8 @@
+/* Copyright (c) Kuba Szczodrzyński 2022-06-27. */
+
+#pragma once
+
+#include <api/WiFi/WiFi.h>
+#include <lwip/LwIPClient.h>
+
+typedef LwIPClient WiFiClient;

arduino/beken-72xx/libraries/WiFi/WiFiClientSecure.h

@@ -0,0 +1,8 @@
+/* Copyright (c) Kuba Szczodrzyński 2022-05-04. */
+
+#pragma once
+
+#include <api/WiFi/WiFi.h>
+#include <ssl/MbedTLSClient.h>
+
+typedef MbedTLSClient WiFiClientSecure;

arduino/beken-72xx/libraries/WiFi/WiFiData.h

@@ -0,0 +1,25 @@
+/* Copyright (c) Kuba Szczodrzyński 2022-06-26. */
+
+#pragma once
+
+#include <Arduino.h>
+
+extern "C" {
+
+#include <FreeRTOS.h>
+#include <rw_msg_pub.h>
+#include <semphr.h>
+
+} // extern "C"
+
+typedef struct {
+	void *configSta;
+	void *configAp;
+	unsigned long scannedAt;
+	SemaphoreHandle_t scanSem;
+	void *statusIp;
+	void *statusLink;
+	rw_evt_type lastStaEvent;
+	rw_evt_type lastApEvent;
+	bool apEnabled;
+} WiFiData;

arduino/beken-72xx/libraries/WiFi/WiFiEvents.cpp

@@ -0,0 +1,149 @@
+/* Copyright (c) Kuba Szczodrzyński 2022-07-10. */
+
+#include "WiFiPriv.h"
+
+#include <vector>
+
+static xQueueHandle wifiEventQueueHandle = NULL;
+static xTaskHandle wifiEventTaskHandle	 = NULL;
+
+static const rw_evt_type eventConnected = RW_EVT_STA_CONNECTED;
+
+// callback for bk_wlan_status_register_cb()
+static void wifiStatusCallback(rw_evt_type *pEvent) {
+	if (wifiEventQueueHandle && wifiEventTaskHandle) {
+		xQueueSend(wifiEventQueueHandle, pEvent, portMAX_DELAY);
+	} else {
+		wifiEventHandler(*pEvent);
+	}
+}
+
+static void wifiEventTask(void *arg) {
+	rw_evt_type event = RW_EVT_MAX;
+	for (;;) {
+		if (xQueueReceive(wifiEventQueueHandle, &event, portMAX_DELAY) == pdTRUE) {
+			wifiEventHandler(event);
+		}
+	}
+}
+
+void wifiEventSendArduino(EventId event) {
+	event = (EventId)(RW_EVT_ARDUINO | event);
+	wifiStatusCallback((rw_evt_type *)&event);
+}
+
+void startWifiTask() {
+	if (!wifiEventQueueHandle) {
+		LT_HEAP_I();
+		wifiEventQueueHandle = xQueueCreate(32, sizeof(rw_evt_type));
+		LT_HEAP_I();
+	}
+	if (!wifiEventTaskHandle) {
+		LT_HEAP_I();
+		xTaskCreate(wifiEventTask, "wifievent", 512, NULL, 4, &wifiEventTaskHandle);
+		LT_HEAP_I();
+	}
+	bk_wlan_status_register_cb((FUNC_1PARAM_PTR)wifiStatusCallback);
+}
+
+void wifiEventHandler(rw_evt_type event) {
+	if (!pWiFi)
+		return; // failsafe
+
+	LT_DM(WIFI, "BK event %u", event);
+
+	if (event <= RW_EVT_STA_GOT_IP)
+		pWiFi->data.lastStaEvent = event;
+	else
+		pWiFi->data.lastApEvent = event;
+
+	EventId eventId;
+	EventInfo eventInfo;
+	String ssid;
+
+	memset(&eventInfo, 0, sizeof(EventInfo));
+
+	switch (event) {
+		case RW_EVT_STA_IDLE:
+			eventId = ARDUINO_EVENT_WIFI_READY;
+			break;
+
+		case RW_EVT_STA_BEACON_LOSE:
+		case RW_EVT_STA_PASSWORD_WRONG:
+		case RW_EVT_STA_NO_AP_FOUND:
+		case RW_EVT_STA_ASSOC_FULL:
+		case RW_EVT_STA_DISCONNECTED:
+		case RW_EVT_STA_CONNECT_FAILED:
+			eventId									 = ARDUINO_EVENT_WIFI_STA_DISCONNECTED;
+			eventInfo.wifi_sta_disconnected.ssid_len = 0;
+			switch (event) {
+				case RW_EVT_STA_BEACON_LOSE:
+					eventInfo.wifi_sta_disconnected.reason = WIFI_REASON_BEACON_TIMEOUT;
+					break;
+				case RW_EVT_STA_PASSWORD_WRONG:
+					eventInfo.wifi_sta_disconnected.reason = WIFI_REASON_AUTH_FAIL;
+					break;
+				case RW_EVT_STA_NO_AP_FOUND:
+					eventInfo.wifi_sta_disconnected.reason = WIFI_REASON_NO_AP_FOUND;
+					break;
+				case RW_EVT_STA_ASSOC_FULL:
+					eventInfo.wifi_sta_disconnected.reason = WIFI_REASON_ASSOC_TOOMANY;
+					break;
+				case RW_EVT_STA_DISCONNECTED:
+					eventInfo.wifi_sta_disconnected.reason = WIFI_REASON_ASSOC_LEAVE;
+					break;
+				case RW_EVT_STA_CONNECT_FAILED:
+					eventInfo.wifi_sta_disconnected.reason = WIFI_REASON_CONNECTION_FAIL;
+					break;
+				default:
+					eventInfo.wifi_sta_disconnected.reason = WIFI_REASON_UNSPECIFIED;
+					break;
+			}
+			break;
+
+		case RW_EVT_STA_CONNECTED:
+			eventId								  = ARDUINO_EVENT_WIFI_STA_CONNECTED;
+			ssid								  = pWiFi->SSID();
+			eventInfo.wifi_sta_connected.ssid_len = ssid.length();
+			eventInfo.wifi_sta_connected.channel  = pWiFi->channel();
+			eventInfo.wifi_sta_connected.authmode = pWiFi->getEncryption();
+			memcpy(eventInfo.wifi_sta_connected.ssid, ssid.c_str(), eventInfo.wifi_sta_connected.ssid_len + 1);
+			memcpy(eventInfo.wifi_sta_connected.bssid, pWiFi->BSSID(), 6);
+			break;
+
+		case RW_EVT_STA_GOT_IP:
+			eventId								  = ARDUINO_EVENT_WIFI_STA_GOT_IP;
+			eventInfo.got_ip.if_index			  = 0;
+			eventInfo.got_ip.ip_changed			  = true;
+			eventInfo.got_ip.ip_info.ip.addr	  = WiFi.localIP();
+			eventInfo.got_ip.ip_info.netmask.addr = WiFi.subnetMask();
+			eventInfo.got_ip.ip_info.gw.addr	  = WiFi.gatewayIP();
+			break;
+
+		case RW_EVT_AP_CONNECTED:
+			eventId = ARDUINO_EVENT_WIFI_AP_STACONNECTED;
+			// TODO station MAC
+			break;
+
+		case RW_EVT_AP_DISCONNECTED:
+			eventId = ARDUINO_EVENT_WIFI_AP_STADISCONNECTED;
+			// TODO station MAC
+			break;
+
+		case RW_EVT_ARDUINO | ARDUINO_EVENT_WIFI_SCAN_DONE:
+			eventId							= ARDUINO_EVENT_WIFI_SCAN_DONE;
+			eventInfo.wifi_scan_done.status = 0;
+			if (pWiFi->scan)
+				eventInfo.wifi_scan_done.number = pWiFi->scan->count;
+			eventInfo.wifi_scan_done.scan_id = 0;
+			break;
+
+		default:
+			if (event < RW_EVT_ARDUINO)
+				return;
+			eventId = (EventId)(event - RW_EVT_ARDUINO);
+			break;
+	}
+
+	pWiFi->postEvent(eventId, eventInfo);
+}

arduino/beken-72xx/libraries/WiFi/WiFiGeneric.cpp

@@ -0,0 +1,89 @@
+/* Copyright (c) Kuba Szczodrzyński 2022-06-26. */
+
+#include "WiFiPriv.h"
+
+bool WiFiClass::modePriv(WiFiMode mode, WiFiModeAction sta, WiFiModeAction ap) {
+	__wrap_bk_printf_disable();
+	startWifiTask();
+
+	if (!__bk_rf_is_init) {
+		LT_DM(WIFI, "Initializing func&app");
+		func_init_extended();
+		app_pre_start();
+		// wait for the init_thread to finish its job
+		while (xTaskGetHandle("init_thread")) {
+			LT_VM(WIFI, "Waiting for init_thread");
+			delay(10);
+		}
+		LT_DM(WIFI, "Init OK");
+		__bk_rf_is_init = true;
+	}
+
+	LT_HEAP_I();
+
+	if (mode) {
+		LT_DM(WIFI, "Wakeup RF");
+		uint32_t reg = 1; // this is only checked for being true-ish
+		sddev_control(SCTRL_DEV_NAME, CMD_RF_HOLD_BIT_SET, &reg);
+	}
+
+	if (sta == WLMODE_ENABLE) {
+		LT_DM(WIFI, "Enabling STA");
+		bk_wlan_sta_init(NULL);
+#if CFG_WPA_CTRL_IFACE
+		wlan_sta_enable();
+#endif
+		wifiEventSendArduino(ARDUINO_EVENT_WIFI_STA_START);
+	} else if (sta == WLMODE_DISABLE) {
+		LT_DM(WIFI, "Disabling STA");
+		bk_wlan_stop(BK_STATION);
+		wifiEventSendArduino(ARDUINO_EVENT_WIFI_STA_STOP);
+	}
+
+	LT_HEAP_I();
+
+	if (ap == WLMODE_ENABLE) {
+		LT_DM(WIFI, "Enabling AP");
+		// fake it - on BK7231, enabling the AP without starting it breaks all connection attempts
+		data.apEnabled = true;
+		wifiEventSendArduino(ARDUINO_EVENT_WIFI_AP_START);
+	} else if (ap == WLMODE_DISABLE) {
+		LT_DM(WIFI, "Disabling AP");
+		bk_wlan_stop(BK_SOFT_AP);
+		data.apEnabled = false;
+		wifiEventSendArduino(ARDUINO_EVENT_WIFI_AP_STOP);
+	}
+
+	// force checking actual mode again
+	mode = getMode();
+
+	if (!mode)
+		dataFree();
+
+	LT_HEAP_I();
+
+	__wrap_bk_printf_enable();
+	return true;
+}
+
+WiFiMode WiFiClass::getMode() {
+	uint8_t sta = !!bk_wlan_has_role(VIF_STA) * WIFI_MODE_STA;
+	uint8_t ap	= data.apEnabled * WIFI_MODE_AP; // report the faked value
+	return (WiFiMode)(sta | ap);
+}
+
+WiFiStatus WiFiClass::status() {
+	rw_evt_type status = data.lastStaEvent;
+	if (status == RW_EVT_STA_CONNECTED && STA_CFG->dhcp_mode == DHCP_DISABLE)
+		status = RW_EVT_STA_GOT_IP;
+	return eventTypeToStatus(status);
+}
+
+IPAddress WiFiClass::hostByName(const char *hostname) {
+	ip_addr_t ip;
+	int ret = netconn_gethostbyname(hostname, &ip);
+	if (ret == ERR_OK) {
+		return ip.addr;
+	}
+	return IPAddress();
+}

arduino/beken-72xx/libraries/WiFi/WiFiPriv.h

@@ -0,0 +1,90 @@
+/* Copyright (c) Kuba Szczodrzyński 2022-06-26. */
+
+#pragma once
+
+#include <api/WiFi/WiFi.h>
+
+extern "C" {
+
+#include <lwip/api.h>
+#include <lwip/ip_addr.h>
+#include <lwip/netif.h>
+// port/net.h
+#include <net.h>
+
+#include <FreeRTOS.h>
+#include <semphr.h>
+
+#include <common.h>
+#include <config.h>
+#include <main_none.h>
+#include <param_config.h>
+#include <rw_msg_rx.h>
+#include <sa_ap.h>
+#include <sys_ctrl_pub.h>
+#include <vif_mgmt.h>
+#include <wlan_ui_pub.h>
+#include <wpa_supplicant_i.h>
+
+extern void func_init_extended();
+extern void app_pre_start();
+extern void bk_wlan_ap_init(network_InitTypeDef_st *inNetworkInitPara);
+
+// func/hostapd-2.5/wpa_supplicant/main_supplicant.c
+extern struct wpa_ssid_value *wpas_connect_ssid;
+
+// app/param_config.c
+extern general_param_t *g_wlan_general_param;
+extern ap_param_t *g_ap_param_ptr;
+extern sta_param_t *g_sta_param_ptr;
+extern uint8_t system_mac[6];
+
+// WiFi.cpp
+WiFiStatus eventTypeToStatus(uint8_t type);
+WiFiAuthMode securityTypeToAuthMode(uint8_t type);
+
+// WiFiEvents.cpp
+extern void wifiEventSendArduino(EventId event);
+extern void startWifiTask();
+extern void wifiEventHandler(rw_evt_type event);
+
+#define RW_EVT_ARDUINO (1 << 7)
+
+#define IP_FMT "%u.%u.%u.%u"
+
+#define STA_CFG		((network_InitTypeDef_st *)data.configSta)
+#define AP_CFG		((network_InitTypeDef_ap_st *)data.configAp)
+#define IP_STATUS	((IPStatusTypedef *)data.statusIp)
+#define LINK_STATUS ((LinkStatusTypeDef *)data.statusLink)
+
+#define STA_GET_LINK_STATUS_RETURN(ret)                                                                                \
+	{                                                                                                                  \
+		if (!sta_ip_is_start())                                                                                        \
+			return ret;                                                                                                \
+		memset(LINK_STATUS, 0x00, sizeof(LinkStatusTypeDef));                                                          \
+		bk_wlan_get_link_status(LINK_STATUS);                                                                          \
+	}
+
+#define STA_GET_IP_STATUS_RETURN(ret)                                                                                  \
+	{                                                                                                                  \
+		if (!sta_ip_is_start())                                                                                        \
+			return ret;                                                                                                \
+		memset(IP_STATUS, 0x00, sizeof(IPStatusTypedef));                                                              \
+		bk_wlan_get_ip_status(IP_STATUS, BK_STATION);                                                                  \
+	}
+
+#define AP_GET_LINK_STATUS_RETURN(ret)                                                                                 \
+	{                                                                                                                  \
+		if (!uap_ip_is_start())                                                                                        \
+			return ret;                                                                                                \
+	}
+
+#define AP_GET_IP_STATUS_RETURN(ret)                                                                                   \
+	{                                                                                                                  \
+		if (!uap_ip_is_start())                                                                                        \
+			return ret;                                                                                                \
+		memset(IP_STATUS, 0x00, sizeof(IPStatusTypedef));                                                              \
+		bk_wlan_get_ip_status(IP_STATUS, BK_SOFT_AP);                                                                  \
+	}
+
+} // extern "C"

arduino/beken-72xx/libraries/WiFi/WiFiSTA.cpp

@@ -0,0 +1,224 @@
+/* Copyright (c) Kuba Szczodrzyński 2022-06-27. */
+
+#include "WiFiPriv.h"
+
+WiFiStatus
+WiFiClass::begin(const char *ssid, const char *passphrase, int32_t channel, const uint8_t *bssid, bool connect) {
+	if (!enableSTA(true))
+		return WL_CONNECT_FAILED;
+	if (!validate(ssid, passphrase))
+		return WL_CONNECT_FAILED;
+
+	LT_HEAP_I();
+
+	disconnect(false);
+
+	strcpy(STA_CFG->wifi_ssid, ssid);
+	if (passphrase) {
+		strcpy(STA_CFG->wifi_key, passphrase);
+	} else {
+		STA_CFG->wifi_bssid[0] = '\0';
+	}
+
+	if (reconnect(bssid))
+		return WL_CONNECTED;
+
+	return WL_CONNECT_FAILED;
+}
+
+bool WiFiClass::config(IPAddress localIP, IPAddress gateway, IPAddress subnet, IPAddress dns1, IPAddress dns2) {
+	dataInitialize();
+
+	STA_CFG->dhcp_mode = localIP ? DHCP_DISABLE : DHCP_CLIENT;
+	if (localIP) {
+		sprintf(STA_CFG->local_ip_addr, IP_FMT, localIP[0], localIP[1], localIP[2], localIP[3]);
+		sprintf(STA_CFG->net_mask, IP_FMT, subnet[0], subnet[1], subnet[2], subnet[3]);
+		sprintf(STA_CFG->gateway_ip_addr, IP_FMT, gateway[0], gateway[1], gateway[2], gateway[3]);
+		if (dns1) {
+			sprintf(STA_CFG->dns_server_ip_addr, IP_FMT, dns1[0], dns1[1], dns1[2], dns1[3]);
+		} else {
+			STA_CFG->dns_server_ip_addr[0] = '\0';
+		}
+	} else {
+		STA_CFG->local_ip_addr[0]	   = '\0';
+		STA_CFG->net_mask[0]		   = '\0';
+		STA_CFG->gateway_ip_addr[0]	   = '\0';
+		STA_CFG->dns_server_ip_addr[0] = '\0';
+	}
+
+	// from wlan_ui.c:1370
+	if (sta_ip_is_start()) {
+		sta_ip_down();
+		ip_address_set(
+			BK_STATION,
+			STA_CFG->dhcp_mode,
+			STA_CFG->local_ip_addr,
+			STA_CFG->net_mask,
+			STA_CFG->gateway_ip_addr,
+			STA_CFG->dns_server_ip_addr
+		);
+		sta_ip_start();
+	}
+	return true;
+}
+
+bool WiFiClass::reconnect(const uint8_t *bssid) {
+	dataInitialize();
+	if (!bssid && !STA_CFG->wifi_ssid[0]) {
+		LT_EM(WIFI, "(B)SSID not specified");
+		goto error;
+	}
+
+	if (bssid) {
+		LT_IM(WIFI, "Connecting to " MACSTR, MAC2STR(bssid));
+	} else {
+		LT_IM(WIFI, "Connecting to %s", STA_CFG->wifi_ssid);
+	}
+
+	LT_DM(WIFI, "Data = %p", data.configSta);
+
+	STA_CFG->wifi_mode			 = BK_STATION;
+	STA_CFG->wifi_retry_interval = 100;
+	if (bssid)
+		memcpy(STA_CFG->wifi_bssid, bssid, 6);
+	else
+		memset(STA_CFG->wifi_bssid, 0x00, 6);
+
+	if (STA_CFG->dhcp_mode == DHCP_DISABLE) {
+		LT_DM(WIFI, "Static IP: %s / %s / %s", STA_CFG->local_ip_addr, STA_CFG->net_mask, STA_CFG->gateway_ip_addr);
+		LT_DM(WIFI, "Static DNS: %s", STA_CFG->dns_server_ip_addr);
+	} else {
+		LT_DM(WIFI, "Using DHCP");
+	}
+
+	LT_DM(WIFI, "Starting WiFi...");
+
+	__wrap_bk_printf_disable();
+	bk_wlan_start_sta(STA_CFG);
+	__wrap_bk_printf_enable();
+
+	LT_DM(WIFI, "Start OK");
+	return true;
+
+error:
+	return false;
+}
+
+bool WiFiClass::disconnect(bool wifiOff) {
+#if LT_DEBUG_WIFI
+	memset(LINK_STATUS, 0x00, sizeof(LinkStatusTypeDef));
+	bk_wlan_get_link_status(LINK_STATUS);
+	LT_DM(WIFI, "Disconnecting from %s (wifiOff=%d)", LINK_STATUS ? LINK_STATUS->ssid : NULL, wifiOff);
+#endif
+	bk_wlan_connection_loss();
+	if (wifiOff)
+		enableSTA(false);
+	return true;
+}
+
+bool WiFiClass::setAutoReconnect(bool autoReconnect) {
+	return false;
+}
+
+bool WiFiClass::getAutoReconnect() {
+	return false;
+}
+
+IPAddress WiFiClass::localIP() {
+	STA_GET_IP_STATUS_RETURN((uint32_t)0);
+	IPAddress ip;
+	ip.fromString(IP_STATUS->ip);
+	return ip;
+}
+
+IPAddress WiFiClass::subnetMask() {
+	STA_GET_IP_STATUS_RETURN((uint32_t)0);
+	IPAddress ip;
+	ip.fromString(IP_STATUS->mask);
+	return ip;
+}
+
+IPAddress WiFiClass::gatewayIP() {
+	STA_GET_IP_STATUS_RETURN((uint32_t)0);
+	IPAddress ip;
+	ip.fromString(IP_STATUS->gate);
+	return ip;
+}
+
+IPAddress WiFiClass::dnsIP(uint8_t dns_no) {
+	STA_GET_IP_STATUS_RETURN((uint32_t)0);
+	IPAddress ip;
+	ip.fromString(IP_STATUS->dns);
+	return ip;
+}
+
+IPAddress WiFiClass::broadcastIP() {
+	return calculateBroadcast(localIP(), subnetMask());
+}
+
+const char *WiFiClass::getHostname() {
+	struct netif *ifs = (struct netif *)net_get_sta_handle();
+	return netif_get_hostname(ifs);
+}
+
+bool WiFiClass::setHostname(const char *hostname) {
+	struct netif *ifs = (struct netif *)net_get_sta_handle();
+	netif_set_hostname(ifs, (char *)hostname);
+	return true;
+}
+
+uint8_t *WiFiClass::macAddress(uint8_t *mac) {
+	wifi_get_mac_address((char *)mac, CONFIG_ROLE_STA);
+	return mac;
+}
+
+bool WiFiClass::setMacAddress(const uint8_t *mac) {
+	if (mac[0] & 0x01) {
+		LT_EM(WIFI, "Invalid MAC address");
+		return false;
+	}
+	// ensure "mac_inited" is true
+	wifi_get_mac_address((char *)system_mac, BK_STATION);
+	// store the MAC globally
+	memcpy(system_mac, mac, 6);
+	WiFiMode previousMode = getMode();
+	if (previousMode) {
+		mode(WIFI_MODE_NULL);
+		mode(previousMode);
+	}
+	return true;
+}
+
+const String WiFiClass::SSID() {
+	STA_GET_LINK_STATUS_RETURN("");
+	return (char *)LINK_STATUS->ssid;
+}
+
+const String WiFiClass::psk() {
+	if (!isConnected())
+		return "";
+	struct wpa_supplicant *wpas = wpa_suppliant_ctrl_get_wpas();
+	if (!wpas || !wpas->conf || !wpas->conf->ssid)
+		return "";
+	return (char *)wpas->conf->ssid->passphrase;
+}
+
+uint8_t *WiFiClass::BSSID() {
+	STA_GET_LINK_STATUS_RETURN(NULL);
+	return LINK_STATUS->bssid;
+}
+
+int32_t WiFiClass::channel() {
+	STA_GET_LINK_STATUS_RETURN(0);
+	return LINK_STATUS->channel;
+}
+
+int8_t WiFiClass::RSSI() {
+	STA_GET_LINK_STATUS_RETURN(0);
+	return LINK_STATUS->wifi_strength;
+}
+
+WiFiAuthMode WiFiClass::getEncryption() {
+	STA_GET_LINK_STATUS_RETURN(WIFI_AUTH_INVALID);
+	return securityTypeToAuthMode(LINK_STATUS->security);
+}

arduino/beken-72xx/libraries/WiFi/WiFiScan.cpp

@@ -0,0 +1,95 @@
+/* Copyright (c) Kuba Szczodrzyński 2022-06-27. */
+
+#include "WiFiPriv.h"
+
+static void scanHandler(void *ctx, uint8_t param) {
+	LT_HEAP_I();
+	WiFiClass *cls = (WiFiClass *)ctx;
+	if (!cls) {
+		LT_WM(WIFI, "Called without ctx");
+		return;
+	}
+	WiFiScanData *scan = cls->scan;
+	if (!scan) {
+		LT_WM(WIFI, "Called without cls->scan");
+		return;
+	}
+
+	ScanResult_adv result;
+	if (wlan_sta_scan_result(&result)) {
+		LT_EM(WIFI, "Failed to get scan result");
+		goto end;
+	}
+	LT_IM(WIFI, "Found %d APs", result.ApNum);
+
+	cls->scanAlloc(result.ApNum);
+	if (!scan->ap) {
+		LT_WM(WIFI, "scan->ap alloc failed");
+		goto end;
+	}
+
+	for (uint8_t i = 0; i < result.ApNum; i++) {
+		scan->ap[i].ssid	= strdup(result.ApList[i].ssid);
+		scan->ap[i].auth	= securityTypeToAuthMode(result.ApList[i].security);
+		scan->ap[i].rssi	= result.ApList[i].ApPower;
+		scan->ap[i].channel = result.ApList[i].channel;
+		memcpy(scan->ap[i].bssid.addr, result.ApList[i].bssid, 6);
+	}
+
+	cls->data.scannedAt = millis();
+
+	wifiEventSendArduino(ARDUINO_EVENT_WIFI_SCAN_DONE);
+
+end:
+	scan->timeout = 0;
+	if (scan->running) {
+		// running == false means it was discarded (timeout)
+		scan->running = false;
+		xSemaphoreGive(cls->data.scanSem);
+	}
+	LT_HEAP_I();
+	return;
+}
+
+int16_t WiFiClass::scanNetworks(bool async, bool showHidden, bool passive, uint32_t maxMsPerChannel, uint8_t channel) {
+	if (scan && scan->running) {
+		if (scan->timeout && millis() > scan->timeout) {
+			LT_WM(WIFI, "Scan timeout, discarding");
+			scan->running = false;
+		} else {
+			return WIFI_SCAN_RUNNING;
+		}
+	}
+	enableSTA(true);
+	scanDelete();
+	scanInit();
+
+	LT_IM(WIFI, "Starting WiFi scan");
+
+	__wrap_bk_printf_disable();
+	mhdr_scanu_reg_cb(scanHandler, this);
+	bk_wlan_start_scan();
+
+	LT_HEAP_I();
+
+	scan->running = true;
+	scan->timeout = millis() + maxMsPerChannel * 20 + 1000;
+
+	int16_t ret = WIFI_SCAN_RUNNING;
+	if (!async) {
+		LT_IM(WIFI, "Waiting for results");
+		xSemaphoreTake(data.scanSem, 1); // reset the semaphore quickly
+		xSemaphoreTake(data.scanSem, pdMS_TO_TICKS(maxMsPerChannel * 20));
+		if (scan->running) {
+			scanDelete();
+			ret = WIFI_SCAN_FAILED;
+			goto exit;
+		}
+		ret = scan->count;
+		goto exit;
+	}
+
+exit:
+	__wrap_bk_printf_enable();
+	return ret;
+}

arduino/beken-72xx/libraries/WiFi/WiFiServer.h

@@ -0,0 +1,8 @@
+/* Copyright (c) Kuba Szczodrzyński 2022-06-27. */
+
+#pragma once
+
+#include <api/WiFi/WiFi.h>
+#include <lwip/LwIPServer.h>
+
+typedef LwIPServer WiFiServer;

arduino/beken-72xx/libraries/WiFi/WiFiUdp.h

@@ -0,0 +1,8 @@
+/* Copyright (c) Kuba Szczodrzyński 2022-09-10. */
+
+#pragma once
+
+#include <api/WiFi/WiFi.h>
+#include <lwip/LwIPUdp.h>
+
+typedef LwIPUDP WiFiUDP;

arduino/beken-72xx/port/flashdb/fal_flash_bk72xx_port.c

@@ -0,0 +1,65 @@
+/* Copyright (c) Kuba Szczodrzyński 2022-06-19. */
+
+#include <lt_logger.h>
+#include <sdk_extern.h>
+
+#include <fal.h>
+#include <flash_pub.h>
+
+#define FLASH_ERASE_MIN_SIZE (4 * 1024)
+
+extern uint32_t flash_ctrl(uint32_t cmd, void *param);
+extern PROTECT_TYPE get_flash_protect();
+extern void flash_protection_op(uint8_t mode, PROTECT_TYPE type);
+
+static void unprotect() {
+	PROTECT_TYPE type = get_flash_protect();
+	if (type != FLASH_PROTECT_NONE) {
+		flash_protection_op(0, FLASH_PROTECT_NONE);
+#if LT_LOGLEVEL <= LT_LEVEL_DEBUG
+		LT_D("Flash protect: %u -> %u", type, get_flash_protect());
+		uint16_t sr = 0;
+		flash_ctrl(CMD_FLASH_READ_SR, &sr);
+		LT_D("SR = %04x", sr);
+#endif
+	}
+}
+
+static int init() {
+	__wrap_bk_printf_disable();
+	flash_init();
+	flash_ctrl(CMD_FLASH_WRITE_ENABLE, NULL);
+	unprotect();
+	__wrap_bk_printf_enable();
+	return 0;
+}
+
+static int read(long offset, uint8_t *buf, size_t size) {
+	flash_read((char *)buf, size, offset);
+	return size;
+}
+
+static int write(long offset, const uint8_t *buf, size_t size) {
+	unprotect();
+	flash_write((char *)buf, size, offset);
+	return size;
+}
+
+static int erase(long offset, size_t size) {
+	unprotect();
+	size = ((size - 1) / FLASH_ERASE_MIN_SIZE) + 1;
+	for (uint16_t i = 0; i < size; i++) {
+		uint32_t addr = offset + i * FLASH_ERASE_MIN_SIZE;
+		flash_ctrl(CMD_FLASH_ERASE_SECTOR, &addr);
+	}
+	return size * FLASH_ERASE_MIN_SIZE;
+}
+
+const struct fal_flash_dev flash0 = {
+	.name		= FAL_FLASH_DEV_NAME,
+	.addr		= 0x0,
+	.len		= FLASH_LENGTH,
+	.blk_size	= FLASH_ERASE_MIN_SIZE,
+	.ops		= {init, read, write, erase},
+	.write_gran = 1,
+};

arduino/beken-72xx/port/printf/printf.c

@@ -0,0 +1,21 @@
+/* Copyright (c) Kuba Szczodrzyński 2022-06-19. */
+
+#include <printf_config.h>
+
+#include <printf/printf.h>
+#include <stdarg.h>
+#include <stdint.h>
+#include <stdio.h>
+
+extern void bk_send_byte(uint8_t uport, uint8_t data);
+extern int uart_print_port;
+
+void putchar_(char c) {
+	bk_send_byte(uart_print_port, c);
+}
+
+void putchar_p(char c, unsigned long port) {
+	bk_send_byte((port & 0xFF) - 1, c);
+}
+
+WRAP_PRINTF(bk_printf);

arduino/beken-72xx/port/printf/printf_port.h

@@ -0,0 +1,7 @@
+/* Copyright (c) Kuba Szczodrzyński 2022-06-20. */
+
+#pragma once
+
+#include <printf_config.h>
+
+WRAP_DISABLE_DEF(bk_printf);

arduino/descript.ion

@@ -1,2 +0,0 @@
-realtek-ambz Realtek AmebaZ Arduino Core
-libretuya Interfaces for LibreTuya Arduino cores

arduino/libretuya/api/Events.cpp

@@ -0,0 +1,5 @@
+/* Copyright (c) Kuba Szczodrzyński 2022-05-17. */
+
+#include "Events.h"
+
+uint16_t EventHandler_s::lastId = 1;

arduino/libretuya/api/Events.h

@@ -0,0 +1,117 @@
+/*
+ ESP8266WiFiGeneric.h - esp8266 Wifi support.
+ Based on WiFi.h from Ardiono WiFi shield library.
+ Copyright (c) 2011-2014 Arduino.  All right reserved.
+ Modified by Ivan Grokhotkov, December 2014
+ Reworked by Markus Sattler, December 2015
+
+ This library is free software; you can redistribute it and/or
+ modify it under the terms of the GNU Lesser General Public
+ License as published by the Free Software Foundation; either
+ version 2.1 of the License, or (at your option) any later version.
+
+ This library is distributed in the hope that it will be useful,
+ but WITHOUT ANY WARRANTY; without even the implied warranty of
+ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ Lesser General Public License for more details.
+
+ You should have received a copy of the GNU Lesser General Public
+ License along with this library; if not, write to the Free Software
+ Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
+ */
+
+#pragma once
+
+#include <Arduino.h>
+#include <api/WiFi/WiFiEvents.h>
+#include <functional>
+
+typedef enum {
+	ARDUINO_EVENT_WIFI_READY = 0,			/**< ESP32 WiFi ready */
+	ARDUINO_EVENT_WIFI_SCAN_DONE,			/**< ESP32 finish scanning AP */
+	ARDUINO_EVENT_WIFI_STA_START,			/**< ESP32 station start */
+	ARDUINO_EVENT_WIFI_STA_STOP,			/**< ESP32 station stop */
+	ARDUINO_EVENT_WIFI_STA_CONNECTED,		/**< ESP32 station connected to AP */
+	ARDUINO_EVENT_WIFI_STA_DISCONNECTED,	/**< ESP32 station disconnected from AP */
+	ARDUINO_EVENT_WIFI_STA_AUTHMODE_CHANGE, /**< the auth mode of AP connected by ESP32 station changed */
+	ARDUINO_EVENT_WIFI_STA_GOT_IP,
+	ARDUINO_EVENT_WIFI_STA_GOT_IP6,
+	ARDUINO_EVENT_WIFI_STA_LOST_IP,
+	ARDUINO_EVENT_WIFI_AP_START,		   /**< ESP32 soft-AP start */
+	ARDUINO_EVENT_WIFI_AP_STOP,			   /**< ESP32 soft-AP stop */
+	ARDUINO_EVENT_WIFI_AP_STACONNECTED,	   /**< a station connected to ESP32 soft-AP */
+	ARDUINO_EVENT_WIFI_AP_STADISCONNECTED, /**< a station disconnected from ESP32 soft-AP */
+	ARDUINO_EVENT_WIFI_AP_STAIPASSIGNED,
+	ARDUINO_EVENT_WIFI_AP_PROBEREQRECVED, /**< Receive probe request packet in soft-AP interface */
+	ARDUINO_EVENT_WIFI_AP_GOT_IP6,
+	ARDUINO_EVENT_WIFI_FTM_REPORT, /**< Receive report of FTM procedure */
+	ARDUINO_EVENT_ETH_START,
+	ARDUINO_EVENT_ETH_STOP,
+	ARDUINO_EVENT_ETH_CONNECTED,
+	ARDUINO_EVENT_ETH_DISCONNECTED,
+	ARDUINO_EVENT_ETH_GOT_IP,
+	ARDUINO_EVENT_ETH_GOT_IP6,
+	ARDUINO_EVENT_WPS_ER_SUCCESS,	  /**< ESP32 station wps succeeds in enrollee mode */
+	ARDUINO_EVENT_WPS_ER_FAILED,	  /**< ESP32 station wps fails in enrollee mode */
+	ARDUINO_EVENT_WPS_ER_TIMEOUT,	  /**< ESP32 station wps timeout in enrollee mode */
+	ARDUINO_EVENT_WPS_ER_PIN,		  /**< ESP32 station wps pin code in enrollee mode */
+	ARDUINO_EVENT_WPS_ER_PBC_OVERLAP, /**< ESP32 station wps overlap in enrollee mode */
+	ARDUINO_EVENT_SC_SCAN_DONE,
+	ARDUINO_EVENT_SC_FOUND_CHANNEL,
+	ARDUINO_EVENT_SC_GOT_SSID_PSWD,
+	ARDUINO_EVENT_SC_SEND_ACK_DONE,
+	ARDUINO_EVENT_PROV_INIT,
+	ARDUINO_EVENT_PROV_DEINIT,
+	ARDUINO_EVENT_PROV_START,
+	ARDUINO_EVENT_PROV_END,
+	ARDUINO_EVENT_PROV_CRED_RECV,
+	ARDUINO_EVENT_PROV_CRED_FAIL,
+	ARDUINO_EVENT_PROV_CRED_SUCCESS,
+	ARDUINO_EVENT_MAX
+} arduino_event_id_t;
+
+typedef union {
+	wifi_event_sta_scan_done_t wifi_scan_done;
+	wifi_event_sta_authmode_change_t wifi_sta_authmode_change;
+	wifi_event_sta_connected_t wifi_sta_connected;
+	wifi_event_sta_disconnected_t wifi_sta_disconnected;
+	wifi_event_sta_wps_er_pin_t wps_er_pin;
+	wifi_event_sta_wps_fail_reason_t wps_fail_reason;
+	wifi_event_ap_probe_req_rx_t wifi_ap_probereqrecved;
+	wifi_event_ap_staconnected_t wifi_ap_staconnected;
+	wifi_event_ap_stadisconnected_t wifi_ap_stadisconnected;
+	wifi_event_ftm_report_t wifi_ftm_report;
+	ip_event_ap_staipassigned_t wifi_ap_staipassigned;
+	ip_event_got_ip_t got_ip;
+	ip_event_got_ip6_t got_ip6;
+	// smartconfig_event_got_ssid_pswd_t sc_got_ssid_pswd;
+	// esp_eth_handle_t eth_connected;
+	// wifi_sta_config_t prov_cred_recv;
+	// wifi_prov_sta_fail_reason_t prov_fail_reason;
+} arduino_event_info_t;
+
+typedef struct {
+	arduino_event_id_t event_id;
+	arduino_event_info_t event_info;
+} arduino_event_t;
+
+#define EventId		arduino_event_id_t
+#define EventId_t	arduino_event_id_t
+#define EventInfo	arduino_event_info_t
+#define EventInfo_t arduino_event_info_t
+#define Event_t		arduino_event_t
+
+typedef void (*EventCb)(EventId event);
+typedef std::function<void(EventId event, EventInfo info)> EventFuncCb;
+typedef void (*EventSysCb)(Event_t *event);
+
+typedef struct EventHandler_s {
+	static uint16_t lastId;
+	uint16_t id;
+	EventCb cb;
+	EventFuncCb fcb;
+	EventSysCb scb;
+	EventId eventId;
+
+	EventHandler_s() : id(lastId++), cb(NULL), fcb(NULL), scb(NULL) {}
+} EventHandler;

arduino/libretuya/api/FS.cpp

@@ -0,0 +1,228 @@
+/*
+ FS.cpp - file system wrapper
+ Copyright (c) 2015 Ivan Grokhotkov. All rights reserved.
+ This file is part of the esp8266 core for Arduino environment.
+
+ This library is free software; you can redistribute it and/or
+ modify it under the terms of the GNU Lesser General Public
+ License as published by the Free Software Foundation; either
+ version 2.1 of the License, or (at your option) any later version.
+
+ This library is distributed in the hope that it will be useful,
+ but WITHOUT ANY WARRANTY; without even the implied warranty of
+ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ Lesser General Public License for more details.
+
+ You should have received a copy of the GNU Lesser General Public
+ License along with this library; if not, write to the Free Software
+ Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
+ */
+
+#include "FS.h"
+
+using namespace fs;
+
+size_t File::write(uint8_t c) {
+	if (!*this) {
+		return 0;
+	}
+	return _p->write(&c, 1);
+}
+
+time_t File::getLastWrite() {
+	if (!*this) {
+		return 0;
+	}
+	return _p->getLastWrite();
+}
+
+size_t File::write(const uint8_t *buf, size_t size) {
+	if (!*this) {
+		return 0;
+	}
+	return _p->write(buf, size);
+}
+
+int File::available() {
+	if (!*this) {
+		return false;
+	}
+	return _p->size() - _p->position();
+}
+
+int File::read() {
+	if (!*this) {
+		return -1;
+	}
+	uint8_t result;
+	if (_p->read(&result, 1) != 1) {
+		return -1;
+	}
+	return result;
+}
+
+size_t File::read(uint8_t *buf, size_t size) {
+	if (!*this) {
+		return -1;
+	}
+	return _p->read(buf, size);
+}
+
+int File::peek() {
+	if (!*this) {
+		return -1;
+	}
+	size_t curPos = _p->position();
+	int result	  = read();
+	seek(curPos, SeekSet);
+	return result;
+}
+
+void File::flush() {
+	if (!*this) {
+		return;
+	}
+	_p->flush();
+}
+
+bool File::seek(uint32_t pos, SeekMode mode) {
+	if (!*this) {
+		return false;
+	}
+	return _p->seek(pos, mode);
+}
+
+size_t File::position() const {
+	if (!*this) {
+		return 0;
+	}
+	return _p->position();
+}
+
+size_t File::size() const {
+	if (!*this) {
+		return 0;
+	}
+	return _p->size();
+}
+
+bool File::setBufferSize(size_t size) {
+	if (!*this) {
+		return 0;
+	}
+	return _p->setBufferSize(size);
+}
+
+void File::close() {
+	if (_p) {
+		_p->close();
+		_p = nullptr;
+	}
+}
+
+File::operator bool() const {
+	return _p != nullptr && *_p != false;
+}
+
+const char *File::path() const {
+	if (!*this) {
+		return nullptr;
+	}
+	return _p->path();
+}
+
+const char *File::name() const {
+	if (!*this) {
+		return nullptr;
+	}
+	return _p->name();
+}
+
+// to implement
+boolean File::isDirectory(void) {
+	if (!*this) {
+		return false;
+	}
+	return _p->isDirectory();
+}
+
+File File::openNextFile(const char *mode) {
+	if (!*this) {
+		return File();
+	}
+	return _p->openNextFile(mode);
+}
+
+void File::rewindDirectory(void) {
+	if (!*this) {
+		return;
+	}
+	_p->rewindDirectory();
+}
+
+File FS::open(const String &path, const char *mode, const bool create) {
+	return open(path.c_str(), mode, create);
+}
+
+File FS::open(const char *path, const char *mode, const bool create) {
+	if (!_impl) {
+		return File();
+	}
+
+	return File(_impl->open(path, mode, create));
+}
+
+bool FS::exists(const char *path) {
+	if (!_impl) {
+		return false;
+	}
+	return _impl->exists(path);
+}
+
+bool FS::exists(const String &path) {
+	return exists(path.c_str());
+}
+
+bool FS::remove(const char *path) {
+	if (!_impl) {
+		return false;
+	}
+	return _impl->remove(path);
+}
+
+bool FS::remove(const String &path) {
+	return remove(path.c_str());
+}
+
+bool FS::rename(const char *pathFrom, const char *pathTo) {
+	if (!_impl) {
+		return false;
+	}
+	return _impl->rename(pathFrom, pathTo);
+}
+
+bool FS::rename(const String &pathFrom, const String &pathTo) {
+	return rename(pathFrom.c_str(), pathTo.c_str());
+}
+
+bool FS::mkdir(const char *path) {
+	if (!_impl) {
+		return false;
+	}
+	return _impl->mkdir(path);
+}
+
+bool FS::mkdir(const String &path) {
+	return mkdir(path.c_str());
+}
+
+bool FS::rmdir(const char *path) {
+	if (!_impl) {
+		return false;
+	}
+	return _impl->rmdir(path);
+}
+
+bool FS::rmdir(const String &path) {
+	return rmdir(path.c_str());
+}

arduino/libretuya/api/FS.h

@@ -0,0 +1,152 @@
+/*
+ FS.h - file system wrapper
+ Copyright (c) 2015 Ivan Grokhotkov. All rights reserved.
+ This file is part of the esp8266 core for Arduino environment.
+
+ This library is free software; you can redistribute it and/or
+ modify it under the terms of the GNU Lesser General Public
+ License as published by the Free Software Foundation; either
+ version 2.1 of the License, or (at your option) any later version.
+
+ This library is distributed in the hope that it will be useful,
+ but WITHOUT ANY WARRANTY; without even the implied warranty of
+ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ Lesser General Public License for more details.
+
+ You should have received a copy of the GNU Lesser General Public
+ License along with this library; if not, write to the Free Software
+ Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
+ */
+
+#pragma once
+
+#include <Arduino.h>
+#include <memory>
+
+namespace fs {
+
+#define FILE_READ	"r"
+#define FILE_WRITE	"w"
+#define FILE_APPEND "a"
+
+class File;
+
+class FileImpl;
+typedef std::shared_ptr<FileImpl> FileImplPtr;
+class FSImpl;
+typedef std::shared_ptr<FSImpl> FSImplPtr;
+
+enum SeekMode { SeekSet = 0, SeekCur = 1, SeekEnd = 2 };
+
+class File : public Stream {
+  public:
+	File(FileImplPtr p = FileImplPtr()) : _p(p) {
+		_timeout = 0;
+	}
+
+	size_t write(uint8_t) override;
+	size_t write(const uint8_t *buf, size_t size) override;
+	int available() override;
+	int read() override;
+	int peek() override;
+	void flush() override;
+	size_t read(uint8_t *buf, size_t size);
+
+	size_t readBytes(char *buffer, size_t length) {
+		return read((uint8_t *)buffer, length);
+	}
+
+	bool seek(uint32_t pos, SeekMode mode);
+
+	bool seek(uint32_t pos) {
+		return seek(pos, SeekSet);
+	}
+
+	size_t position() const;
+	size_t size() const;
+	bool setBufferSize(size_t size);
+	void close();
+	operator bool() const;
+	time_t getLastWrite();
+	const char *path() const;
+	const char *name() const;
+
+	boolean isDirectory(void);
+	File openNextFile(const char *mode = FILE_READ);
+	void rewindDirectory(void);
+
+  protected:
+	FileImplPtr _p;
+};
+
+class FileImpl {
+  public:
+	virtual ~FileImpl() {}
+
+	virtual size_t write(const uint8_t *buf, size_t size) = 0;
+	virtual size_t read(uint8_t *buf, size_t size)		  = 0;
+	virtual void flush()								  = 0;
+	virtual bool seek(uint32_t pos, SeekMode mode)		  = 0;
+	virtual size_t position() const						  = 0;
+	virtual size_t size() const							  = 0;
+	virtual bool setBufferSize(size_t size)				  = 0;
+	virtual void close()								  = 0;
+	virtual time_t getLastWrite()						  = 0;
+	virtual const char *path() const					  = 0;
+	virtual const char *name() const					  = 0;
+	virtual boolean isDirectory(void)					  = 0;
+	virtual FileImplPtr openNextFile(const char *mode)	  = 0;
+	virtual void rewindDirectory(void)					  = 0;
+	virtual operator bool()								  = 0;
+};
+
+class FS {
+  public:
+	FS(FSImplPtr impl) : _impl(impl) {}
+
+	File open(const char *path, const char *mode = FILE_READ, const bool create = false);
+	File open(const String &path, const char *mode = FILE_READ, const bool create = false);
+
+	bool exists(const char *path);
+	bool exists(const String &path);
+
+	bool remove(const char *path);
+	bool remove(const String &path);
+
+	bool rename(const char *pathFrom, const char *pathTo);
+	bool rename(const String &pathFrom, const String &pathTo);
+
+	bool mkdir(const char *path);
+	bool mkdir(const String &path);
+
+	bool rmdir(const char *path);
+	bool rmdir(const String &path);
+
+  protected:
+	FSImplPtr _impl;
+};
+
+class FSImpl {
+  public:
+	FSImpl() {}
+
+	virtual ~FSImpl() {}
+
+	virtual FileImplPtr open(const char *path, const char *mode, const bool create) = 0;
+	virtual bool exists(const char *path)											= 0;
+	virtual bool rename(const char *pathFrom, const char *pathTo)					= 0;
+	virtual bool remove(const char *path)											= 0;
+	virtual bool mkdir(const char *path)											= 0;
+	virtual bool rmdir(const char *path)											= 0;
+};
+
+} // namespace fs
+
+#ifndef FS_NO_GLOBALS
+using fs::File;
+using fs::FS;
+using fs::SeekCur;
+using fs::SeekEnd;
+using fs::SeekMode;
+using fs::SeekSet;
+#endif // FS_NO_GLOBALS

arduino/libretuya/api/Flash.h

@@ -1,25 +0,0 @@
-#pragma once
-
-#include <stdbool.h>
-#include <stdint.h>
-#include <stdlib.h>
-
-typedef struct {
-	uint8_t manufacturerId;
-	uint8_t chipId;
-	uint8_t chipSizeId;
-} FlashId;
-
-class IFlashClass {
-  public:
-	IFlashClass() {}
-
-	~IFlashClass() {}
-
-	virtual FlashId getChipId() = 0;
-	virtual uint32_t getSize()	= 0;
-
-	virtual bool eraseSector(uint32_t sector)							 = 0;
-	virtual bool readBlock(uint32_t offset, uint8_t *data, size_t size)	 = 0;
-	virtual bool writeBlock(uint32_t offset, uint8_t *data, size_t size) = 0;
-};

arduino/libretuya/api/IPv6Address.cpp

@@ -1,91 +0,0 @@
-/*
- IPv6Address.cpp - Base class that provides IPv6Address
- Copyright (c) 2011 Adrian McEwen.  All right reserved.
-
- This library is free software; you can redistribute it and/or
- modify it under the terms of the GNU Lesser General Public
- License as published by the Free Software Foundation; either
- version 2.1 of the License, or (at your option) any later version.
-
- This library is distributed in the hope that it will be useful,
- but WITHOUT ANY WARRANTY; without even the implied warranty of
- MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
- Lesser General Public License for more details.
-
- You should have received a copy of the GNU Lesser General Public
- License along with this library; if not, write to the Free Software
- Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
- */
-
-#include <Arduino.h>
-#include <api/Print.h>
-
-#include "IPv6Address.h"
-
-IPv6Address::IPv6Address()
-{
-    memset(_address.bytes, 0, sizeof(_address.bytes));
-}
-
-IPv6Address::IPv6Address(const uint8_t *address)
-{
-    memcpy(_address.bytes, address, sizeof(_address.bytes));
-}
-
-IPv6Address::IPv6Address(const uint32_t *address)
-{
-    memcpy(_address.bytes, (const uint8_t *)address, sizeof(_address.bytes));
-}
-
-IPv6Address& IPv6Address::operator=(const uint8_t *address)
-{
-    memcpy(_address.bytes, address, sizeof(_address.bytes));
-    return *this;
-}
-
-bool IPv6Address::operator==(const uint8_t* addr) const
-{
-    return memcmp(addr, _address.bytes, sizeof(_address.bytes)) == 0;
-}
-
-size_t IPv6Address::printTo(Print& p) const
-{
-    /* size_t n = 0;
-    for(int i = 0; i < 16; i+=2) {
-        if(i){
-            n += p.print(':');
-        }
-        n += p.printf("%02x", _address.bytes[i]);
-        n += p.printf("%02x", _address.bytes[i+1]);
-
-    }
-    return n; */
-}
-
-String IPv6Address::toString() const
-{
-    char szRet[40];
-    sprintf(szRet,"%02x%02x:%02x%02x:%02x%02x:%02x%02x:%02x%02x:%02x%02x:%02x%02x:%02x%02x",
-            _address.bytes[0], _address.bytes[1], _address.bytes[2], _address.bytes[3],
-            _address.bytes[4], _address.bytes[5], _address.bytes[6], _address.bytes[7],
-            _address.bytes[8], _address.bytes[9], _address.bytes[10], _address.bytes[11],
-            _address.bytes[12], _address.bytes[13], _address.bytes[14], _address.bytes[15]);
-    return String(szRet);
-}
-
-bool IPv6Address::fromString(const char *address)
-{
-    //format 0011:2233:4455:6677:8899:aabb:ccdd:eeff
-    if(strlen(address) != 39){
-        return false;
-    }
-    char * pos = (char *)address;
-    size_t i = 0;
-    for(i = 0; i < 16; i+=2) {
-        if(!sscanf(pos, "%2hhx", &_address.bytes[i]) || !sscanf(pos+2, "%2hhx", &_address.bytes[i+1])){
-            return false;
-        }
-        pos += 5;
-    }
-    return true;
-}

arduino/libretuya/api/IPv6Address.h

@@ -1,98 +0,0 @@
-/*
- IPv6Address.h - Base class that provides IPv6Address
- Copyright (c) 2011 Adrian McEwen.  All right reserved.
-
- This library is free software; you can redistribute it and/or
- modify it under the terms of the GNU Lesser General Public
- License as published by the Free Software Foundation; either
- version 2.1 of the License, or (at your option) any later version.
-
- This library is distributed in the hope that it will be useful,
- but WITHOUT ANY WARRANTY; without even the implied warranty of
- MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
- Lesser General Public License for more details.
-
- You should have received a copy of the GNU Lesser General Public
- License along with this library; if not, write to the Free Software
- Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
- */
-
-#pragma once
-
-#include <stdint.h>
-#include <api/String.h>
-#include <api/Print.h>
-
-// A class to make it easier to handle and pass around IP addresses
-
-namespace arduino {
-
-class IPv6Address: public Printable
-{
-private:
-    union {
-        uint8_t bytes[16];  // IPv4 address
-        uint32_t dword[4];
-    } _address;
-
-    // Access the raw byte array containing the address.  Because this returns a pointer
-    // to the internal structure rather than a copy of the address this function should only
-    // be used when you know that the usage of the returned uint8_t* will be transient and not
-    // stored.
-    uint8_t* raw_address()
-    {
-        return _address.bytes;
-    }
-
-public:
-    // Constructors
-    IPv6Address();
-    IPv6Address(const uint8_t *address);
-    IPv6Address(const uint32_t *address);
-    virtual ~IPv6Address() {}
-
-    bool fromString(const char *address);
-    bool fromString(const String &address) { return fromString(address.c_str()); }
-
-    operator const uint8_t*() const
-    {
-        return _address.bytes;
-    }
-    operator const uint32_t*() const
-    {
-        return _address.dword;
-    }
-    bool operator==(const IPv6Address& addr) const
-    {
-        return (_address.dword[0] == addr._address.dword[0])
-            && (_address.dword[1] == addr._address.dword[1])
-            && (_address.dword[2] == addr._address.dword[2])
-            && (_address.dword[3] == addr._address.dword[3]);
-    }
-    bool operator==(const uint8_t* addr) const;
-
-    // Overloaded index operator to allow getting and setting individual octets of the address
-    uint8_t operator[](int index) const
-    {
-        return _address.bytes[index];
-    }
-    uint8_t& operator[](int index)
-    {
-        return _address.bytes[index];
-    }
-
-    // Overloaded copy operators to allow initialisation of IPv6Address objects from other types
-    IPv6Address& operator=(const uint8_t *address);
-
-    // TODO implement printTo()
-    virtual size_t printTo(Print& p) const;
-    String toString() const;
-
-    friend class UDP;
-    friend class Client;
-    friend class Server;
-};
-
-}
-
-using arduino::IPv6Address;

arduino/libretuya/api/LibreTuyaAPI.h

@@ -1,36 +0,0 @@
-#pragma once
-
-#ifndef LT_VERSION
-#define LT_VERSION 1.0.0
-#endif
-
-#ifndef LT_BOARD
-#define LT_BOARD unknown
-#endif
-
-#define STRINGIFY(x)	   #x
-#define STRINGIFY_MACRO(x) STRINGIFY(x)
-#define LT_VERSION_STR	   STRINGIFY_MACRO(LT_VERSION)
-#define LT_BOARD_STR	   STRINGIFY_MACRO(LT_BOARD)
-
-#include <Arduino.h>
-
-#include "LibreTuyaConfig.h"
-
-#ifdef __cplusplus
-extern "C" {
-#endif // __cplusplus
-
-#include "lt_logger.h"
-
-#ifdef __cplusplus
-} // extern "C"
-#endif
-
-#define LT_BANNER()                                                                                                    \
-	LT_LOG(                                                                                                            \
-		LT_LEVEL_INFO,                                                                                                 \
-		"main.cpp",                                                                                                    \
-		__LINE__,                                                                                                      \
-		"LibreTuya v" LT_VERSION_STR " on " LT_BOARD_STR ", compiled at " __DATE__ " " __TIME__                        \
-	)

arduino/libretuya/api/LibreTuyaConfig.h

@@ -1,64 +0,0 @@
-#pragma once
-
-// see docs/API Configuration
-
-// Loglevels
-#define LT_LEVEL_VERBOSE LT_LEVEL_TRACE
-#define LT_LEVEL_TRACE	 0
-#define LT_LEVEL_DEBUG	 1
-#define LT_LEVEL_INFO	 2
-#define LT_LEVEL_WARN	 3
-#define LT_LEVEL_ERROR	 4
-#define LT_LEVEL_FATAL	 5
-
-// Logger enabled/disabled
-#ifndef LT_LOGGER
-#define LT_LOGGER 1
-#endif
-
-// Logger format options
-#ifndef LT_LOGGER_TIMESTAMP
-#define LT_LOGGER_TIMESTAMP 1
-#endif
-
-#ifndef LT_LOGGER_FILE
-#define LT_LOGGER_FILE 0
-#endif
-
-#ifndef LT_LOGGER_TASK
-#define LT_LOGGER_TASK 1
-#endif
-
-#ifndef LT_LOGGER_COLOR
-#define LT_LOGGER_COLOR 0
-#endif
-
-#ifndef LT_PRINTF_BROKEN
-#define LT_PRINTF_BROKEN 0
-#endif
-
-// Global loglevel
-#ifndef LT_LOGLEVEL
-#define LT_LOGLEVEL LT_LEVEL_INFO
-#endif
-
-// Per-module debugging
-#ifndef LT_DEBUG_WIFI
-#define LT_DEBUG_WIFI 0
-#endif
-
-#ifndef LT_DEBUG_WIFI_CLIENT
-#define LT_DEBUG_WIFI_CLIENT 0
-#endif
-
-#ifndef LT_DEBUG_WIFI_SERVER
-#define LT_DEBUG_WIFI_SERVER 0
-#endif
-
-#ifndef LT_DEBUG_WIFI_STA
-#define LT_DEBUG_WIFI_STA 0
-#endif
-
-#ifndef LT_DEBUG_WIFI_AP
-#define LT_DEBUG_WIFI_AP 0
-#endif

arduino/libretuya/api/Preferences.h

@@ -17,7 +17,7 @@
 #include <stdint.h>
 #include <stdlib.h>
 
-#include "api/String.h"
+#include <api/String.h>
 
 typedef enum {
 	PT_I8,

arduino/libretuya/api/SoftwareSerial.cpp

@@ -0,0 +1,45 @@
+/* Copyright (c) Kuba Szczodrzyński 2022-07-03. */
+
+#include "SoftwareSerial.h"
+
+#ifdef LT_ARD_HAS_SOFTSERIAL
+
+SoftwareSerial::SoftwareSerial(pin_size_t receivePin, pin_size_t transmitPin, bool inverted) {
+	data.rx.buf = NULL;
+	data.tx.buf = NULL;
+	data.rx.pin = receivePin;
+	data.tx.pin = transmitPin;
+	data.invert = inverted == true;
+}
+
+int SoftwareSerial::available() {
+	return data.rx.buf->available();
+}
+
+int SoftwareSerial::peek() {
+	return data.rx.buf->peek();
+}
+
+int SoftwareSerial::read() {
+	return data.rx.buf->read_char();
+}
+
+void SoftwareSerial::flush() {
+	while (data.rx.buf->available()) {
+		yield();
+	}
+}
+
+size_t SoftwareSerial::write(uint8_t c) {
+	while (data.tx.buf->isFull()) {
+		yield();
+	}
+	data.tx.buf->store_char(c);
+	if (data.tx.state == SS_IDLE) {
+		data.tx.state = SS_START;
+		this->startTx();
+	}
+	return 1;
+}
+
+#endif

arduino/libretuya/api/SoftwareSerial.h

@@ -0,0 +1,76 @@
+/* Copyright (c) Kuba Szczodrzyński 2022-07-03. */
+
+#pragma once
+
+#ifdef LT_ARD_HAS_SOFTSERIAL
+
+#include <Arduino.h>
+#include <api/HardwareSerial.h>
+#include <api/RingBuffer.h>
+
+using namespace arduino;
+
+typedef enum {
+	SS_IDLE = 0,
+	SS_START,
+	SS_DATA0,
+	SS_DATA1,
+	SS_DATA2,
+	SS_DATA3,
+	SS_DATA4,
+	SS_DATA5,
+	SS_DATA6,
+	SS_DATA7,
+	SS_STOP,
+	SS_END,
+} SoftState;
+
+typedef struct {
+	SoftState state;
+	RingBuffer *buf;
+	uint8_t byte;
+	pin_size_t pin;
+	void *param;
+} SoftData;
+
+typedef struct {
+	SoftData rx;
+	SoftData tx;
+	uint8_t invert;
+	void *param;
+} SoftSerial;
+
+class SoftwareSerial : public HardwareSerial {
+  private:
+	SoftSerial data;
+	void *param;
+
+  public:
+	SoftwareSerial(pin_size_t receivePin, pin_size_t transmitPin, bool inverted = false);
+
+	inline void begin(unsigned long baudrate) {
+		begin(baudrate, SERIAL_8N1);
+	}
+
+	int available();
+	int peek();
+	int read();
+	void flush();
+	size_t write(uint8_t c);
+
+	operator bool() {
+		return data.rx.buf || data.tx.buf;
+	}
+
+  public: // Family needs to implement these methods only
+	void begin(unsigned long baudrate, uint16_t config);
+	void end();
+
+  private:
+	void startTx();
+	void endTx();
+
+	using Print::write;
+};
+
+#endif

arduino/libretuya/api/WiFi.h

@@ -1,177 +0,0 @@
-/*
- WiFi.h - esp32 Wifi support.
- Based on WiFi.h from Arduino WiFi shield library.
- Copyright (c) 2011-2014 Arduino.  All right reserved.
- Modified by Ivan Grokhotkov, December 2014
-
- This library is free software; you can redistribute it and/or
- modify it under the terms of the GNU Lesser General Public
- License as published by the Free Software Foundation; either
- version 2.1 of the License, or (at your option) any later version.
-
- This library is distributed in the hope that it will be useful,
- but WITHOUT ANY WARRANTY; without even the implied warranty of
- MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
- Lesser General Public License for more details.
-
- You should have received a copy of the GNU Lesser General Public
- License along with this library; if not, write to the Free Software
- Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
- */
-
-#pragma once
-
-#include <stdint.h>
-
-#include <api/IPAddress.h>
-#include <api/IPv6Address.h>
-#include <api/Print.h>
-
-#include "WiFiType.h"
-
-// TODO wifi events
-// TODO WiFiMulti library
-
-class IWiFiClass {
-  public:
-	virtual void printDiag(Print &dest) = 0;
-};
-
-class IWiFiGenericClass {
-  public:
-	virtual int32_t channel(void)	 = 0;
-	virtual bool mode(WiFiMode mode) = 0;
-	virtual WiFiMode getMode()		 = 0;
-	virtual WiFiStatus status()		 = 0;
-
-	virtual bool enableSTA(bool enable) = 0;
-	virtual bool enableAP(bool enable)	= 0;
-
-	virtual bool setSleep(bool enable) = 0;
-	virtual bool getSleep()			   = 0;
-
-	virtual bool setTxPower(int power) = 0;
-	virtual int getTxPower()		   = 0;
-
-	virtual int hostByName(const char *hostname, IPAddress &aResult) {
-		aResult = hostByName(hostname);
-		return true;
-	}
-
-	virtual IPAddress hostByName(const char *hostname) = 0;
-
-	static IPAddress calculateNetworkID(IPAddress ip, IPAddress subnet);
-	static IPAddress calculateBroadcast(IPAddress ip, IPAddress subnet);
-	static uint8_t calculateSubnetCIDR(IPAddress subnetMask);
-	static String macToString(uint8_t *mac);
-};
-
-class IWiFiSTAClass {
-  public:
-	virtual WiFiStatus begin(
-		const char *ssid,
-		const char *passphrase = NULL,
-		int32_t channel		   = 0,
-		const uint8_t *bssid   = NULL,
-		bool connect		   = true
-	) = 0;
-	virtual WiFiStatus begin(
-		char *ssid, char *passphrase = NULL, int32_t channel = 0, const uint8_t *bssid = NULL, bool connect = true
-	) = 0;
-
-	virtual bool config(
-		IPAddress localIP,
-		IPAddress gateway,
-		IPAddress subnet,
-		IPAddress dns1 = (uint32_t)0x00000000,
-		IPAddress dns2 = (uint32_t)0x00000000
-	) = 0;
-
-	virtual bool reconnect()					  = 0;
-	virtual bool disconnect(bool wifiOff = false) = 0;
-
-	virtual bool isConnected();
-
-	virtual bool setAutoReconnect(bool autoReconnect) = 0;
-	virtual bool getAutoReconnect()					  = 0;
-
-	virtual WiFiStatus waitForConnectResult(unsigned long timeout) = 0;
-
-	virtual IPAddress localIP()					   = 0;
-	virtual uint8_t *macAddress(uint8_t *mac)	   = 0;
-	virtual String macAddress()					   = 0;
-	virtual IPAddress subnetMask()				   = 0;
-	virtual IPAddress gatewayIP()				   = 0;
-	virtual IPAddress dnsIP(uint8_t dns_no = 0)	   = 0;
-	virtual IPAddress broadcastIP()				   = 0;
-	virtual IPAddress networkID()				   = 0;
-	virtual uint8_t subnetCIDR()				   = 0;
-	virtual bool enableIpV6()					   = 0;
-	virtual IPv6Address localIPv6()				   = 0;
-	virtual const char *getHostname()			   = 0;
-	virtual bool setHostname(const char *hostname) = 0;
-	virtual bool setMacAddress(const uint8_t *mac) = 0;
-
-	inline bool hostname(const String &aHostname) {
-		return setHostname(aHostname.c_str());
-	}
-
-	virtual const String SSID()			 = 0;
-	virtual const String psk()			 = 0;
-	virtual uint8_t *BSSID()			 = 0;
-	virtual String BSSIDstr()			 = 0;
-	virtual int8_t RSSI()				 = 0;
-	virtual WiFiAuthMode getEncryption() = 0;
-};
-
-class IWiFiScanClass {
-  public:
-	virtual int16_t scanNetworks(
-		bool async				 = false,
-		bool showHidden			 = false,
-		bool passive			 = false,
-		uint32_t maxMsPerChannel = 300,
-		uint8_t channel			 = 0
-	) = 0;
-	virtual bool getNetworkInfo(
-		uint8_t networkItem,
-		String &ssid,
-		WiFiAuthMode &encryptionType,
-		int32_t &RSSI,
-		uint8_t *&BSSID,
-		int32_t &channel
-	) = 0;
-
-	virtual int16_t scanComplete() = 0;
-	virtual void scanDelete()	   = 0;
-
-	virtual String SSID(uint8_t networkItem)				 = 0;
-	virtual WiFiAuthMode encryptionType(uint8_t networkItem) = 0;
-	virtual int32_t RSSI(uint8_t networkItem)				 = 0;
-	virtual uint8_t *BSSID(uint8_t networkItem)				 = 0;
-	virtual String BSSIDstr(uint8_t networkItem)			 = 0;
-	virtual int32_t channel(uint8_t networkItem)			 = 0;
-};
-
-class IWiFiAPClass {
-  public:
-	virtual bool softAP(
-		const char *ssid, const char *passphrase = NULL, int channel = 1, bool ssidHidden = false, int maxClients = 4
-	)																				  = 0;
-	virtual bool softAPConfig(IPAddress localIP, IPAddress gateway, IPAddress subnet) = 0;
-	virtual bool softAPdisconnect(bool wifiOff = false)								  = 0;
-
-	virtual uint8_t softAPgetStationNum() = 0;
-
-	virtual IPAddress softAPIP()						 = 0;
-	virtual IPAddress softAPBroadcastIP()				 = 0;
-	virtual IPAddress softAPNetworkID()					 = 0;
-	virtual uint8_t softAPSubnetCIDR()					 = 0;
-	virtual bool softAPenableIpV6()						 = 0;
-	virtual IPv6Address softAPIPv6()					 = 0;
-	virtual const char *softAPgetHostname()				 = 0;
-	virtual bool softAPsetHostname(const char *hostname) = 0;
-	virtual uint8_t *softAPmacAddress(uint8_t *mac)		 = 0;
-	virtual String softAPmacAddress(void)				 = 0;
-	virtual const String softAPSSID(void)				 = 0;
-};

arduino/libretuya/api/WiFi/WiFi.cpp

@@ -0,0 +1,77 @@
+/* Copyright (c) Kuba Szczodrzyński 2022-04-25. */
+
+#include "WiFi.h"
+
+void WiFiClass::printDiag(Print &dest) {
+	const char *modes[] = {"NULL", "STA", "AP", "STA+AP"};
+	const char *enc[]	= {"Open", "WEP", "WPA PSK", "WPA2 PSK", "WPA/WPA2", "WPA", "WPA2"};
+
+	dest.print("Mode: ");
+	dest.println(modes[getMode()]);
+
+	if (getMode() & WIFI_MODE_STA) {
+		dest.println("-- Station --");
+		dest.print("SSID: ");
+		if (isConnected()) {
+			dest.println(SSID());
+			dest.print("Channel: ");
+			dest.println(channel());
+			dest.print("BSSID: ");
+			dest.println(BSSIDstr());
+			dest.print("RSSI: ");
+			dest.println(RSSI());
+			dest.print("Encryption: ");
+			dest.println(enc[getEncryption()]);
+			dest.print("IP: ");
+			dest.println(localIP());
+			dest.print("MAC: ");
+			dest.println(macAddress());
+			dest.print("Hostname: ");
+			dest.println(getHostname());
+		} else {
+			dest.println("disconnected");
+		}
+	}
+
+	if (getMode() & WIFI_MODE_AP) {
+		dest.println("-- Access Point --");
+		dest.print("SSID: ");
+		if (softAPSSID().length()) {
+			dest.println(softAPSSID());
+			dest.print("IP: ");
+			dest.println(softAPIP());
+			dest.print("MAC: ");
+			dest.println(softAPmacAddress());
+			dest.print("Hostname: ");
+			dest.println(softAPgetHostname());
+		} else {
+			dest.println("disconnected");
+		}
+	}
+}
+
+bool WiFiClass::validate(const char *ssid, const char *passphrase) {
+	if (!ssid || *ssid == 0x00 || strlen(ssid) > 32) {
+		LT_WM(WIFI, "SSID not specified or too long");
+		return false;
+	}
+	if (passphrase) {
+		uint16_t length = strlen(passphrase);
+		if (length < 8) {
+			LT_WM(WIFI, "Passphrase too short (%u)", length);
+			return false;
+		}
+		if (length > 63) {
+			LT_WM(WIFI, "Passphrase too long (%u)", length);
+			return false;
+		}
+	}
+	return true;
+}
+
+__attribute__((weak)) void WiFiClass::dataInitialize() {}
+
+__attribute__((weak)) void WiFiClass::dataFree() {}
+
+WiFiClass WiFi;
+WiFiClass *pWiFi = NULL;

arduino/libretuya/api/WiFi/WiFi.h

@@ -0,0 +1,197 @@
+/*
+ WiFi.h - esp32 Wifi support.
+ Based on WiFi.h from Arduino WiFi shield library.
+ Copyright (c) 2011-2014 Arduino.  All right reserved.
+ Modified by Ivan Grokhotkov, December 2014
+
+ This library is free software; you can redistribute it and/or
+ modify it under the terms of the GNU Lesser General Public
+ License as published by the Free Software Foundation; either
+ version 2.1 of the License, or (at your option) any later version.
+
+ This library is distributed in the hope that it will be useful,
+ but WITHOUT ANY WARRANTY; without even the implied warranty of
+ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ Lesser General Public License for more details.
+
+ You should have received a copy of the GNU Lesser General Public
+ License along with this library; if not, write to the Free Software
+ Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
+ */
+
+#pragma once
+
+#include <Arduino.h>
+#include <api/Events.h>
+#include <api/IPAddress.h>
+#include <api/IPv6Address.h>
+#include <vector>
+
+#include "WiFiType.h"
+
+#ifdef LT_ARD_HAS_WIFI
+// family's data structure
+#include <WiFiData.h>
+#endif
+
+class WiFiClass {
+  public:
+#ifdef LT_ARD_HAS_WIFI
+	// must be public for WiFiEvents & WiFiScan static handlers
+	WiFiData data;
+#endif
+	WiFiScanData *scan = NULL;
+
+  public: /* WiFi.cpp */
+	WiFiClass();
+	~WiFiClass();
+	void printDiag(Print &dest);
+	bool validate(const char *ssid, const char *passphrase);
+	void dataInitialize();
+	void dataFree();
+
+  public: /* WiFiGeneric.cpp */
+	bool mode(WiFiMode mode);
+	bool modePriv(WiFiMode mode, WiFiModeAction sta, WiFiModeAction ap);
+	WiFiMode getMode();
+	WiFiStatus status();
+
+	bool enableSTA(bool enable);
+	bool enableAP(bool enable);
+
+	bool setSleep(bool enable);
+	bool getSleep();
+
+	bool setTxPower(int power);
+	int getTxPower();
+
+	int hostByName(const char *hostname, IPAddress &aResult);
+	IPAddress hostByName(const char *hostname);
+
+	static IPAddress calculateNetworkID(IPAddress ip, IPAddress subnet);
+	static IPAddress calculateBroadcast(IPAddress ip, IPAddress subnet);
+	static uint8_t calculateSubnetCIDR(IPAddress subnetMask);
+	static String macToString(uint8_t *mac);
+
+  protected: /* WiFiEvents.cpp */
+	static std::vector<EventHandler> handlers;
+
+  public: /* WiFiEvents.cpp */
+	uint16_t onEvent(EventCb callback, EventId eventId = ARDUINO_EVENT_MAX);
+	uint16_t onEvent(EventFuncCb callback, EventId eventId = ARDUINO_EVENT_MAX);
+	uint16_t onEvent(EventSysCb callback, EventId eventId = ARDUINO_EVENT_MAX);
+	void removeEvent(EventCb callback, EventId eventId);
+	void removeEvent(EventSysCb callback, EventId eventId);
+	void removeEvent(uint16_t id);
+	static void postEvent(EventId eventId, EventInfo eventInfo);
+
+  public: /* WiFiSTA.cpp */
+	WiFiStatus begin(
+		const char *ssid,
+		const char *passphrase = NULL,
+		int32_t channel		   = 0,
+		const uint8_t *bssid   = NULL,
+		bool connect		   = true
+	);
+	WiFiStatus
+	begin(char *ssid, char *passphrase = NULL, int32_t channel = 0, const uint8_t *bssid = NULL, bool connect = true);
+
+	bool config(
+		IPAddress localIP,
+		IPAddress gateway,
+		IPAddress subnet,
+		IPAddress dns1 = (uint32_t)0x00000000,
+		IPAddress dns2 = (uint32_t)0x00000000
+	);
+
+	bool reconnect(const uint8_t *bssid = NULL);
+	bool disconnect(bool wifiOff = false);
+
+	bool isConnected();
+
+	bool setAutoReconnect(bool autoReconnect);
+	bool getAutoReconnect();
+
+	WiFiStatus waitForConnectResult(unsigned long timeout);
+
+	IPAddress localIP();
+	uint8_t *macAddress(uint8_t *mac);
+	String macAddress();
+	IPAddress subnetMask();
+	IPAddress gatewayIP();
+	IPAddress dnsIP(uint8_t dns_no = 0);
+	IPAddress broadcastIP();
+	IPAddress networkID();
+	uint8_t subnetCIDR();
+	bool enableIpV6();
+	IPv6Address localIPv6();
+	const char *getHostname();
+	bool setHostname(const char *hostname);
+	bool setMacAddress(const uint8_t *mac);
+
+	inline bool hostname(const String &aHostname) {
+		return setHostname(aHostname.c_str());
+	}
+
+	const String SSID();
+	const String psk();
+	uint8_t *BSSID();
+	String BSSIDstr();
+	int32_t channel();
+	int8_t RSSI();
+	WiFiAuthMode getEncryption();
+
+  public: /* WiFiScan.cpp */
+	int16_t scanNetworks(
+		bool async				 = false,
+		bool showHidden			 = false,
+		bool passive			 = false,
+		uint32_t maxMsPerChannel = 300,
+		uint8_t channel			 = 0
+	);
+	bool getNetworkInfo(
+		uint8_t networkItem,
+		String &ssid,
+		WiFiAuthMode &encryptionType,
+		int32_t &RSSI,
+		uint8_t *&BSSID,
+		int32_t &channel
+	);
+
+	int16_t scanComplete();
+	uint8_t scanAlloc(uint8_t count);
+	void scanInit();
+	void scanDelete();
+
+	String SSID(uint8_t networkItem);
+	WiFiAuthMode encryptionType(uint8_t networkItem);
+	int32_t RSSI(uint8_t networkItem);
+	uint8_t *BSSID(uint8_t networkItem);
+	String BSSIDstr(uint8_t networkItem);
+	int32_t channel(uint8_t networkItem);
+
+  public: /* WiFiAP.cpp */
+	bool softAP(
+		const char *ssid, const char *passphrase = NULL, int channel = 1, bool ssidHidden = false, int maxClients = 4
+	);
+	bool softAPConfig(IPAddress localIP, IPAddress gateway, IPAddress subnet);
+	bool softAPdisconnect(bool wifiOff = false);
+
+	uint8_t softAPgetStationNum();
+
+	IPAddress softAPIP();
+	IPAddress softAPBroadcastIP();
+	IPAddress softAPNetworkID();
+	uint8_t softAPSubnetCIDR();
+	IPAddress softAPSubnetMask();
+	bool softAPenableIpV6();
+	IPv6Address softAPIPv6();
+	const char *softAPgetHostname();
+	bool softAPsetHostname(const char *hostname);
+	uint8_t *softAPmacAddress(uint8_t *mac);
+	String softAPmacAddress(void);
+	const String softAPSSID(void);
+};
+
+extern WiFiClass WiFi;
+extern WiFiClass *pWiFi;

arduino/libretuya/api/WiFi/WiFiAP.cpp

@@ -0,0 +1,23 @@
+/* Copyright (c) Kuba Szczodrzyński 2022-04-25. */
+
+#include "WiFi.h"
+
+IPAddress WiFiClass::softAPBroadcastIP() {
+	return calculateBroadcast(softAPIP(), softAPSubnetMask());
+}
+
+IPAddress WiFiClass::softAPNetworkID() {
+	return calculateNetworkID(softAPIP(), softAPSubnetMask());
+}
+
+uint8_t WiFiClass::softAPSubnetCIDR() {
+	return calculateSubnetCIDR(softAPSubnetMask());
+}
+
+__attribute__((weak)) bool WiFiClass::softAPenableIpV6() {
+	return false;
+}
+
+__attribute__((weak)) IPv6Address WiFiClass::softAPIPv6() {
+	return IPv6Address();
+}

arduino/libretuya/api/WiFi/WiFiEvents.cpp

@@ -0,0 +1,84 @@
+/* Copyright (c) Kuba Szczodrzyński 2022-05-17. */
+
+#include "WiFi.h"
+
+std::vector<EventHandler> WiFiClass::handlers;
+
+uint16_t WiFiClass::onEvent(EventCb callback, EventId eventId) {
+	if (!callback)
+		return 0;
+	EventHandler handler;
+	handler.cb		= callback;
+	handler.eventId = eventId;
+	handlers.push_back(handler);
+	return handler.id;
+}
+
+uint16_t WiFiClass::onEvent(EventFuncCb callback, EventId eventId) {
+	if (!callback)
+		return 0;
+	EventHandler handler;
+	handler.fcb		= callback;
+	handler.eventId = eventId;
+	handlers.push_back(handler);
+	return handler.id;
+}
+
+uint16_t WiFiClass::onEvent(EventSysCb callback, EventId eventId) {
+	if (!callback)
+		return 0;
+	EventHandler handler;
+	handler.scb		= callback;
+	handler.eventId = eventId;
+	handlers.push_back(handler);
+	return handler.id;
+}
+
+void WiFiClass::removeEvent(EventCb callback, EventId eventId) {
+	if (!callback)
+		return;
+	for (uint16_t i = 0; i < handlers.size(); i++) {
+		EventHandler handler = handlers[i];
+		if (handler.cb == callback && handler.eventId == eventId) {
+			handlers.erase(handlers.begin() + i);
+		}
+	}
+}
+
+void WiFiClass::removeEvent(EventSysCb callback, EventId eventId) {
+	if (!callback)
+		return;
+	for (uint16_t i = 0; i < handlers.size(); i++) {
+		EventHandler handler = handlers[i];
+		if (handler.scb == callback && handler.eventId == eventId) {
+			handlers.erase(handlers.begin() + i);
+		}
+	}
+}
+
+void WiFiClass::removeEvent(uint16_t id) {
+	for (uint16_t i = 0; i < handlers.size(); i++) {
+		EventHandler handler = handlers[i];
+		if (handler.id == id) {
+			handlers.erase(handlers.begin() + i);
+		}
+	}
+}
+
+void WiFiClass::postEvent(EventId eventId, EventInfo eventInfo) {
+	for (auto handler : handlers) {
+		if (handler.eventId != ARDUINO_EVENT_MAX && handler.eventId != eventId)
+			continue;
+		if (handler.cb) {
+			handler.cb(eventId);
+		} else if (handler.fcb) {
+			handler.fcb(eventId, eventInfo);
+		} else if (handler.scb) {
+			Event_t event = {
+				.event_id	= eventId,
+				.event_info = eventInfo,
+			};
+			handler.scb(&event);
+		}
+	}
+}

arduino/libretuya/api/WiFi/WiFiEvents.h

@@ -0,0 +1,173 @@
+/*
+ * SPDX-FileCopyrightText: 2015-2021 Espressif Systems (Shanghai) CO LTD
+ *
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+#pragma once
+
+#include "WiFiType.h"
+
+/** Argument structure for WIFI_EVENT_SCAN_DONE event */
+typedef struct {
+	uint32_t status; /**< status of scanning APs: 0 - success, 1 - failure */
+	uint8_t number;	 /**< number of scan results */
+	uint8_t scan_id; /**< scan sequence number, used for block scan */
+} wifi_event_sta_scan_done_t;
+
+/** Argument structure for WIFI_EVENT_STA_CONNECTED event */
+typedef struct {
+	uint8_t ssid[32];		   /**< SSID of connected AP */
+	uint8_t ssid_len;		   /**< SSID length of connected AP */
+	uint8_t bssid[6];		   /**< BSSID of connected AP*/
+	uint8_t channel;		   /**< channel of connected AP*/
+	wifi_auth_mode_t authmode; /**< authentication mode used by AP*/
+} wifi_event_sta_connected_t;
+
+/** Argument structure for WIFI_EVENT_STA_DISCONNECTED event */
+typedef struct {
+	uint8_t ssid[32]; /**< SSID of disconnected AP */
+	uint8_t ssid_len; /**< SSID length of disconnected AP */
+	uint8_t bssid[6]; /**< BSSID of disconnected AP */
+	uint8_t reason;	  /**< reason of disconnection */
+} wifi_event_sta_disconnected_t;
+
+/** Argument structure for WIFI_EVENT_STA_AUTHMODE_CHANGE event */
+typedef struct {
+	wifi_auth_mode_t old_mode; /**< the old auth mode of AP */
+	wifi_auth_mode_t new_mode; /**< the new auth mode of AP */
+} wifi_event_sta_authmode_change_t;
+
+/** Argument structure for WIFI_EVENT_STA_WPS_ER_PIN event */
+typedef struct {
+	uint8_t pin_code[8]; /**< PIN code of station in enrollee mode */
+} wifi_event_sta_wps_er_pin_t;
+
+/** Argument structure for WIFI_EVENT_STA_WPS_ER_FAILED event */
+typedef enum {
+	WPS_FAIL_REASON_NORMAL = 0, /**< ESP32 WPS normal fail reason */
+	WPS_FAIL_REASON_RECV_M2D,	/**< ESP32 WPS receive M2D frame */
+	WPS_FAIL_REASON_MAX
+} wifi_event_sta_wps_fail_reason_t;
+
+#define MAX_SSID_LEN	   32
+#define MAX_PASSPHRASE_LEN 64
+#define MAX_WPS_AP_CRED	   3
+
+/** Argument structure for WIFI_EVENT_STA_WPS_ER_SUCCESS event */
+typedef struct {
+	uint8_t ap_cred_cnt; /**< Number of AP credentials received */
+
+	struct {
+		uint8_t ssid[MAX_SSID_LEN];				/**< SSID of AP */
+		uint8_t passphrase[MAX_PASSPHRASE_LEN]; /**< Passphrase for the AP */
+	} ap_cred[MAX_WPS_AP_CRED];					/**< All AP credentials received from WPS handshake */
+} wifi_event_sta_wps_er_success_t;
+
+/** Argument structure for WIFI_EVENT_AP_STACONNECTED event */
+typedef struct {
+	uint8_t mac[6];		/**< MAC address of the station connected to ESP32 soft-AP */
+	uint8_t aid;		/**< the aid that ESP32 soft-AP gives to the station connected to  */
+	bool is_mesh_child; /**< flag to identify mesh child */
+} wifi_event_ap_staconnected_t;
+
+/** Argument structure for WIFI_EVENT_AP_STADISCONNECTED event */
+typedef struct {
+	uint8_t mac[6];		/**< MAC address of the station disconnects to ESP32 soft-AP */
+	uint8_t aid;		/**< the aid that ESP32 soft-AP gave to the station disconnects to  */
+	bool is_mesh_child; /**< flag to identify mesh child */
+} wifi_event_ap_stadisconnected_t;
+
+/** Argument structure for WIFI_EVENT_AP_PROBEREQRECVED event */
+typedef struct {
+	int rssi;		/**< Received probe request signal strength */
+	uint8_t mac[6]; /**< MAC address of the station which send probe request */
+} wifi_event_ap_probe_req_rx_t;
+
+/**
+ * @brief FTM operation status types
+ *
+ */
+typedef enum {
+	FTM_STATUS_SUCCESS = 0,	  /**< FTM exchange is successful */
+	FTM_STATUS_UNSUPPORTED,	  /**< Peer does not support FTM */
+	FTM_STATUS_CONF_REJECTED, /**< Peer rejected FTM configuration in FTM Request */
+	FTM_STATUS_NO_RESPONSE,	  /**< Peer did not respond to FTM Requests */
+	FTM_STATUS_FAIL,		  /**< Unknown error during FTM exchange */
+} wifi_ftm_status_t;
+
+/** Argument structure for */
+typedef struct {
+	uint8_t dlog_token; /**< Dialog Token of the FTM frame */
+	int8_t rssi;		/**< RSSI of the FTM frame received */
+	uint32_t rtt;		/**< Round Trip Time in pSec with a peer */
+	uint64_t t1;		/**< Time of departure of FTM frame from FTM Responder in pSec */
+	uint64_t t2;		/**< Time of arrival of FTM frame at FTM Initiator in pSec */
+	uint64_t t3;		/**< Time of departure of ACK from FTM Initiator in pSec */
+	uint64_t t4;		/**< Time of arrival of ACK at FTM Responder in pSec */
+} wifi_ftm_report_entry_t;
+
+/** Argument structure for WIFI_EVENT_FTM_REPORT event */
+typedef struct {
+	uint8_t peer_mac[6];	  /**< MAC address of the FTM Peer */
+	wifi_ftm_status_t status; /**< Status of the FTM operation */
+	uint32_t rtt_raw;		  /**< Raw average Round-Trip-Time with peer in Nano-Seconds */
+	uint32_t rtt_est;		  /**< Estimated Round-Trip-Time with peer in Nano-Seconds */
+	uint32_t dist_est;		  /**< Estimated one-way distance in Centi-Meters */
+	wifi_ftm_report_entry_t
+		*ftm_report_data;			/**< Pointer to FTM Report with multiple entries, should be freed after use */
+	uint8_t ftm_report_num_entries; /**< Number of entries in the FTM Report data */
+} wifi_event_ftm_report_t;
+
+#define WIFI_STATIS_BUFFER (1 << 0)
+#define WIFI_STATIS_RXTX   (1 << 1)
+#define WIFI_STATIS_HW	   (1 << 2)
+#define WIFI_STATIS_DIAG   (1 << 3)
+#define WIFI_STATIS_PS	   (1 << 4)
+#define WIFI_STATIS_ALL	   (-1)
+
+/** Argument structure for WIFI_EVENT_ACTION_TX_STATUS event */
+typedef struct {
+	int ifx;		  /**< WiFi interface to send request to */
+	uint32_t context; /**< Context to identify the request */
+	uint8_t da[6];	  /**< Destination MAC address */
+	uint8_t status;	  /**< Status of the operation */
+} wifi_event_action_tx_status_t;
+
+/** Argument structure for WIFI_EVENT_ROC_DONE event */
+typedef struct {
+	uint32_t context; /**< Context to identify the request */
+} wifi_event_roc_done_t;
+
+/** Event structure for IP_EVENT_STA_GOT_IP, IP_EVENT_ETH_GOT_IP events  */
+typedef struct {
+	esp_ip4_addr_t ip;		/**< Interface IPV4 address */
+	esp_ip4_addr_t netmask; /**< Interface IPV4 netmask */
+	esp_ip4_addr_t gw;		/**< Interface IPV4 gateway address */
+} esp_netif_ip_info_t;
+
+/** @brief IPV6 IP address information
+ */
+typedef struct {
+	esp_ip6_addr_t ip; /**< Interface IPV6 address */
+} esp_netif_ip6_info_t;
+
+typedef struct {
+	int if_index;				 /*!< Interface index for which the event is received (left for legacy compilation) */
+	void *esp_netif;			 /*!< Pointer to corresponding esp-netif object */
+	esp_netif_ip_info_t ip_info; /*!< IP address, netmask, gatway IP address */
+	bool ip_changed;			 /*!< Whether the assigned IP has changed or not */
+} ip_event_got_ip_t;
+
+/** Event structure for IP_EVENT_GOT_IP6 event */
+typedef struct {
+	int if_index;				   /*!< Interface index for which the event is received (left for legacy compilation) */
+	void *esp_netif;			   /*!< Pointer to corresponding esp-netif object */
+	esp_netif_ip6_info_t ip6_info; /*!< IPv6 address of the interface */
+	int ip_index;				   /*!< IPv6 address index */
+} ip_event_got_ip6_t;
+
+/** Event structure for IP_EVENT_AP_STAIPASSIGNED event */
+typedef struct {
+	esp_ip4_addr_t ip; /*!< IP address which was assigned to the station */
+} ip_event_ap_staipassigned_t;

arduino/libretuya/api/WiFi/WiFiGeneric.cpp

@@ -0,0 +1,117 @@
+/* Copyright (c) Kuba Szczodrzyński 2022-04-25. */
+
+#include "WiFi.h"
+
+bool WiFiClass::mode(WiFiMode mode) {
+	// store a pointer to WiFi for WiFiEvents.cpp
+	pWiFi = this;
+
+	WiFiMode currentMode = getMode();
+	LT_DM(WIFI, "Mode changing %u -> %u", currentMode, mode);
+	if (mode == currentMode)
+		return true;
+
+	// get mode changes as 0/1
+	WiFiModeAction sta = WiFiModeAction((mode & WIFI_MODE_STA) != (currentMode & WIFI_MODE_STA));
+	WiFiModeAction ap  = WiFiModeAction((mode & WIFI_MODE_AP) != (currentMode & WIFI_MODE_AP));
+	// change 0/1 to 1/2
+	sta = WiFiModeAction(sta + sta * !!(mode & WIFI_MODE_STA));
+	ap	= WiFiModeAction(ap + ap * !!(mode & WIFI_MODE_AP));
+	// initialize data structures if wifi is enabled
+	if (mode)
+		dataInitialize();
+	// actually change the mode
+	LT_HEAP_I();
+	if (!modePriv(mode, sta, ap))
+		return false;
+	if (getMode() != mode) {
+		LT_WM(WIFI, "Mode changed to %d (requested %d)", getMode(), mode);
+	}
+	return true;
+}
+
+bool WiFiClass::enableSTA(bool enable) {
+	WiFiMode currentMode = getMode();
+	if (((currentMode & WIFI_MODE_STA) != 0) != enable) {
+		return mode((WiFiMode)(currentMode ^ WIFI_MODE_STA));
+	}
+	return true;
+}
+
+bool WiFiClass::enableAP(bool enable) {
+	WiFiMode currentMode = getMode();
+	if (((currentMode & WIFI_MODE_AP) != 0) != enable) {
+		return mode((WiFiMode)(currentMode ^ WIFI_MODE_AP));
+	}
+	return true;
+}
+
+__attribute__((weak)) bool WiFiClass::setSleep(bool enable) {
+	return false;
+}
+
+__attribute__((weak)) bool WiFiClass::getSleep() {
+	return false;
+}
+
+__attribute__((weak)) bool WiFiClass::setTxPower(int power) {
+	return false;
+}
+
+__attribute__((weak)) int WiFiClass::getTxPower() {
+	return 0;
+}
+
+int WiFiClass::hostByName(const char *hostname, IPAddress &aResult) {
+	aResult = hostByName(hostname);
+	return true;
+}
+
+IPAddress WiFiClass::calculateNetworkID(IPAddress ip, IPAddress subnet) {
+	IPAddress networkID;
+
+	for (size_t i = 0; i < 4; i++)
+		networkID[i] = subnet[i] & ip[i];
+
+	return networkID;
+}
+
+IPAddress WiFiClass::calculateBroadcast(IPAddress ip, IPAddress subnet) {
+	IPAddress broadcastIp;
+
+	for (int i = 0; i < 4; i++)
+		broadcastIp[i] = ~subnet[i] | ip[i];
+
+	return broadcastIp;
+}
+
+uint8_t WiFiClass::calculateSubnetCIDR(IPAddress subnetMask) {
+	uint8_t CIDR = 0;
+
+	for (uint8_t i = 0; i < 4; i++) {
+		if (subnetMask[i] == 0x80) // 128
+			CIDR += 1;
+		else if (subnetMask[i] == 0xC0) // 192
+			CIDR += 2;
+		else if (subnetMask[i] == 0xE0) // 224
+			CIDR += 3;
+		else if (subnetMask[i] == 0xF0) // 242
+			CIDR += 4;
+		else if (subnetMask[i] == 0xF8) // 248
+			CIDR += 5;
+		else if (subnetMask[i] == 0xFC) // 252
+			CIDR += 6;
+		else if (subnetMask[i] == 0xFE) // 254
+			CIDR += 7;
+		else if (subnetMask[i] == 0xFF) // 255
+			CIDR += 8;
+	}
+
+	return CIDR;
+}
+
+String WiFiClass::macToString(uint8_t *mac) {
+	char macStr[18]; // 6*2 + 5*':' + '\0'
+	sprintf(macStr, "%02X:%02X:%02X:%02X:%02X:%02X", mac[0], mac[1], mac[2], mac[3], mac[4], mac[5]);
+	return macStr;
+}

arduino/libretuya/api/WiFi/WiFiSTA.cpp

@@ -0,0 +1,48 @@
+/* Copyright (c) Kuba Szczodrzyński 2022-04-25. */
+
+#include "WiFi.h"
+
+WiFiStatus WiFiClass::begin(char *ssid, char *passphrase, int32_t channel, const uint8_t *bssid, bool connect) {
+	return begin((const char *)ssid, (const char *)passphrase, channel, bssid, connect);
+}
+
+bool WiFiClass::isConnected() {
+	return status() == WL_CONNECTED;
+}
+
+WiFiStatus WiFiClass::waitForConnectResult(unsigned long timeout) {
+	if ((getMode() & WIFI_MODE_STA) == 0) {
+		return WL_DISCONNECTED;
+	}
+	unsigned long start = millis();
+	while ((!status() || status() >= WL_DISCONNECTED) && (millis() - start) < timeout) {
+		delay(100);
+	}
+	return status();
+}
+
+String WiFiClass::macAddress(void) {
+	uint8_t mac[6];
+	macAddress(mac);
+	return macToString(mac);
+}
+
+IPAddress WiFiClass::networkID() {
+	return calculateNetworkID(gatewayIP(), subnetMask());
+}
+
+uint8_t WiFiClass::subnetCIDR() {
+	return calculateSubnetCIDR(subnetMask());
+}
+
+String WiFiClass::BSSIDstr() {
+	return macToString(BSSID());
+}
+
+__attribute__((weak)) bool WiFiClass::enableIpV6() {
+	return false;
+}
+
+__attribute__((weak)) IPv6Address WiFiClass::localIPv6() {
+	return IPv6Address();
+}

arduino/libretuya/api/WiFi/WiFiScan.cpp

@@ -0,0 +1,83 @@
+/* Copyright (c) Kuba Szczodrzyński 2022-04-25. */
+
+#include "WiFi.h"
+
+bool WiFiClass::getNetworkInfo(
+	uint8_t networkItem, String &ssid, WiFiAuthMode &encType, int32_t &rssi, uint8_t *&bssid, int32_t &channel
+) {
+	ssid	= SSID(networkItem);
+	encType = encryptionType(networkItem);
+	rssi	= RSSI(networkItem);
+	bssid	= BSSID(networkItem);
+	channel = this->channel(networkItem);
+	return true;
+}
+
+int16_t WiFiClass::scanComplete() {
+	if (!scan)
+		return 0;
+	if (scan->running)
+		return WIFI_SCAN_RUNNING;
+	return scan->count;
+}
+
+void WiFiClass::scanInit() {
+	if (scan)
+		return;
+	scan = (WiFiScanData *)zalloc(sizeof(WiFiScanData));
+}
+
+void WiFiClass::scanDelete() {
+	if (!scan)
+		return;
+	for (uint8_t i = 0; i < scan->count; i++) {
+		free(scan->ap[i].ssid);
+	}
+	free(scan->ap);
+	free(scan);
+	scan = NULL;
+}
+
+uint8_t WiFiClass::scanAlloc(uint8_t count) {
+	uint8_t last = scan->count;
+	scan->count	 = count;
+	scan->ap	 = (WiFiScanAP *)realloc(scan->ap, count * sizeof(WiFiScanAP));
+	if (!scan->ap)
+		return 255;
+	memset(scan->ap + last, 0, sizeof(WiFiScanAP));
+	return last;
+}
+
+String WiFiClass::SSID(uint8_t networkItem) {
+	if (!scan || networkItem >= scan->count)
+		return "";
+	return scan->ap[networkItem].ssid;
+}
+
+WiFiAuthMode WiFiClass::encryptionType(uint8_t networkItem) {
+	if (!scan || networkItem >= scan->count)
+		return WIFI_AUTH_INVALID;
+	return scan->ap[networkItem].auth;
+}
+
+int32_t WiFiClass::RSSI(uint8_t networkItem) {
+	if (!scan || networkItem >= scan->count)
+		return 0;
+	return scan->ap[networkItem].rssi;
+}
+
+uint8_t *WiFiClass::BSSID(uint8_t networkItem) {
+	if (!scan || networkItem >= scan->count)
+		return NULL;
+	return scan->ap[networkItem].bssid.addr;
+}
+
+String WiFiClass::BSSIDstr(uint8_t networkItem) {
+	return macToString(BSSID(networkItem));
+}
+
+int32_t WiFiClass::channel(uint8_t networkItem) {
+	if (!scan || networkItem >= scan->count)
+		return 0;
+	return scan->ap[networkItem].channel;
+}

arduino/libretuya/api/WiFi/WiFiType.h

@@ -0,0 +1,150 @@
+/*
+ ESP8266WiFiType.h - esp8266 Wifi support.
+ Copyright (c) 2011-2014 Arduino.  All right reserved.
+ Modified by Ivan Grokhotkov, December 2014
+ Reworked by Markus Sattler, December 2015
+
+ This library is free software; you can redistribute it and/or
+ modify it under the terms of the GNU Lesser General Public
+ License as published by the Free Software Foundation; either
+ version 2.1 of the License, or (at your option) any later version.
+
+ This library is distributed in the hope that it will be useful,
+ but WITHOUT ANY WARRANTY; without even the implied warranty of
+ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ Lesser General Public License for more details.
+
+ You should have received a copy of the GNU Lesser General Public
+ License along with this library; if not, write to the Free Software
+ Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
+ */
+
+#pragma once
+
+#include <Arduino.h>
+
+#define WIFI_SCAN_RUNNING (-1)
+#define WIFI_SCAN_FAILED  (-2)
+
+#define WiFiMode_t	 wifi_mode_t
+#define WiFiMode	 wifi_mode_t
+#define WiFiStatus	 wl_status_t
+#define WiFiAuthMode wifi_auth_mode_t
+
+#define WIFI_OFF	WIFI_MODE_NULL
+#define WIFI_STA	WIFI_MODE_STA
+#define WIFI_AP		WIFI_MODE_AP
+#define WIFI_AP_STA WIFI_MODE_APSTA
+
+#define WiFiEvent_t		arduino_event_id_t
+#define WiFiEventInfo_t arduino_event_info_t
+#define WiFiEventId_t	uint16_t
+
+typedef struct {
+	uint8_t addr[6];
+} WiFiMacAddr;
+
+struct esp_ip6_addr {
+	uint32_t addr[4];
+	uint8_t zone;
+};
+
+struct esp_ip4_addr {
+	uint32_t addr;
+};
+
+typedef struct esp_ip4_addr esp_ip4_addr_t;
+typedef struct esp_ip6_addr esp_ip6_addr_t;
+
+typedef enum {
+	WIFI_MODE_NULL = 0, /**< null mode */
+	WIFI_MODE_STA,		/**< WiFi station mode */
+	WIFI_MODE_AP,		/**< WiFi soft-AP mode */
+	WIFI_MODE_APSTA,	/**< WiFi station + soft-AP mode */
+	WIFI_MODE_MAX
+} wifi_mode_t;
+
+typedef enum {
+	WL_NO_SHIELD	   = 255, // for compatibility with WiFi Shield library
+	WL_IDLE_STATUS	   = 0,
+	WL_NO_SSID_AVAIL   = 1,
+	WL_SCAN_COMPLETED  = 2,
+	WL_CONNECTED	   = 3,
+	WL_CONNECT_FAILED  = 4,
+	WL_CONNECTION_LOST = 5,
+	WL_DISCONNECTED	   = 6,
+} wl_status_t;
+
+typedef enum {
+	WIFI_AUTH_OPEN = 0,		   /**< authenticate mode : open */
+	WIFI_AUTH_WEP,			   /**< authenticate mode : WEP */
+	WIFI_AUTH_WPA_PSK,		   /**< authenticate mode : WPA_PSK */
+	WIFI_AUTH_WPA2_PSK,		   /**< authenticate mode : WPA2_PSK */
+	WIFI_AUTH_WPA_WPA2_PSK,	   /**< authenticate mode : WPA_WPA2_PSK */
+	WIFI_AUTH_WPA2_ENTERPRISE, /**< authenticate mode : WPA2_ENTERPRISE */
+	WIFI_AUTH_WPA3_PSK,		   /**< authenticate mode : WPA3_PSK */
+	WIFI_AUTH_WPA2_WPA3_PSK,   /**< authenticate mode : WPA2_WPA3_PSK */
+	WIFI_AUTH_WAPI_PSK,		   /**< authenticate mode : WAPI_PSK */
+	WIFI_AUTH_WPA,
+	WIFI_AUTH_WPA2,
+	WIFI_AUTH_AUTO	  = 200,
+	WIFI_AUTH_INVALID = 255,
+	WIFI_AUTH_MAX
+} wifi_auth_mode_t;
+
+typedef enum {
+	WIFI_REASON_UNSPECIFIED				 = 1,
+	WIFI_REASON_AUTH_EXPIRE				 = 2,
+	WIFI_REASON_AUTH_LEAVE				 = 3,
+	WIFI_REASON_ASSOC_EXPIRE			 = 4,
+	WIFI_REASON_ASSOC_TOOMANY			 = 5,
+	WIFI_REASON_NOT_AUTHED				 = 6,
+	WIFI_REASON_NOT_ASSOCED				 = 7,
+	WIFI_REASON_ASSOC_LEAVE				 = 8,
+	WIFI_REASON_ASSOC_NOT_AUTHED		 = 9,
+	WIFI_REASON_DISASSOC_PWRCAP_BAD		 = 10,
+	WIFI_REASON_DISASSOC_SUPCHAN_BAD	 = 11,
+	WIFI_REASON_BSS_TRANSITION_DISASSOC	 = 12,
+	WIFI_REASON_IE_INVALID				 = 13,
+	WIFI_REASON_MIC_FAILURE				 = 14,
+	WIFI_REASON_4WAY_HANDSHAKE_TIMEOUT	 = 15,
+	WIFI_REASON_GROUP_KEY_UPDATE_TIMEOUT = 16,
+	WIFI_REASON_IE_IN_4WAY_DIFFERS		 = 17,
+	WIFI_REASON_GROUP_CIPHER_INVALID	 = 18,
+	WIFI_REASON_PAIRWISE_CIPHER_INVALID	 = 19,
+	WIFI_REASON_AKMP_INVALID			 = 20,
+	WIFI_REASON_UNSUPP_RSN_IE_VERSION	 = 21,
+	WIFI_REASON_INVALID_RSN_IE_CAP		 = 22,
+	WIFI_REASON_802_1X_AUTH_FAILED		 = 23,
+	WIFI_REASON_CIPHER_SUITE_REJECTED	 = 24,
+	WIFI_REASON_INVALID_PMKID			 = 53,
+	WIFI_REASON_BEACON_TIMEOUT			 = 200,
+	WIFI_REASON_NO_AP_FOUND				 = 201,
+	WIFI_REASON_AUTH_FAIL				 = 202,
+	WIFI_REASON_ASSOC_FAIL				 = 203,
+	WIFI_REASON_HANDSHAKE_TIMEOUT		 = 204,
+	WIFI_REASON_CONNECTION_FAIL			 = 205,
+	WIFI_REASON_AP_TSF_RESET			 = 206,
+	WIFI_REASON_ROAMING					 = 207,
+} wifi_err_reason_t;
+
+typedef struct {
+	char *ssid;
+	WiFiAuthMode auth;
+	int32_t rssi;
+	WiFiMacAddr bssid;
+	int32_t channel;
+} WiFiScanAP;
+
+typedef struct {
+	bool running		  = false;
+	unsigned long timeout = 0;
+	uint8_t count		  = 0;
+	WiFiScanAP *ap		  = NULL;
+} WiFiScanData;
+
+typedef enum {
+	WLMODE_NONE	   = 0,
+	WLMODE_DISABLE = 1,
+	WLMODE_ENABLE  = 2,
+} WiFiModeAction;

arduino/libretuya/api/WiFiClient.h

@@ -35,12 +35,15 @@ class IWiFiClient : public Client {
 
 	virtual size_t write(Stream &stream) = 0;
 
+	size_t write_P(PGM_P buffer, size_t size) {
+		return write((const uint8_t *)buffer, size);
+	}
+
 	virtual int fd() const					 = 0;
 	virtual int socket()					 = 0;
 	virtual int setTimeout(uint32_t seconds) = 0;
 
-	virtual IWiFiClient &operator=(const IWiFiClient &other) = 0;
-	virtual bool operator==(const IWiFiClient &other) const	 = 0;
+	bool operator==(const IWiFiClient &other) const;
 
 	operator bool() {
 		return connected();

arduino/libretuya/api/WiFiClientSecure.h

@@ -22,42 +22,28 @@
 
 #include <Arduino.h>
 
-#include "WiFi.h"
+#include "WiFiClient.h"
 
-class IWiFiClientSecure : public IWiFiClient {
+class IWiFiClientSecure {
   public:
-	int connect(IPAddress ip, uint16_t port, const char *rootCABuff, const char *cli_cert, const char *cli_key);
-	int connect(const char *host, uint16_t port, const char *rootCABuff, const char *cli_cert, const char *cli_key);
-	int connect(IPAddress ip, uint16_t port, const char *pskIdent, const char *psKey);
-	int connect(const char *host, uint16_t port, const char *pskIdent, const char *psKey);
+	virtual int
+	connect(IPAddress ip, uint16_t port, const char *rootCABuf, const char *clientCert, const char *clientKey) = 0;
+	virtual int
+	connect(const char *host, uint16_t port, const char *rootCABuf, const char *clientCert, const char *clientKey) = 0;
+	virtual int connect(IPAddress ip, uint16_t port, const char *pskIdent, const char *psk)						   = 0;
+	virtual int connect(const char *host, uint16_t port, const char *pskIdent, const char *psk)					   = 0;
 
-	int lastError(char *buf, const size_t size);
-	void setInsecure(); // Don't validate the chain, just accept whatever is given. VERY INSECURE!
-	void setPreSharedKey(const char *pskIdent, const char *psKey); // psKey in Hex
-	void setCACert(const char *rootCA);
-	void setCertificate(const char *client_ca);
-	void setPrivateKey(const char *private_key);
-	bool loadCACert(Stream &stream, size_t size);
-	bool loadCertificate(Stream &stream, size_t size);
-	bool loadPrivateKey(Stream &stream, size_t size);
-	bool verify(const char *fingerprint, const char *domain_name);
-	void setHandshakeTimeout(unsigned long handshake_timeout);
-
-	WiFiClientSecure &operator=(const WiFiClientSecure &other);
-
-	bool operator==(const bool value) {
-		return bool() == value;
-	}
-
-	bool operator!=(const bool value) {
-		return bool() != value;
-	}
-
-	bool operator==(const WiFiClientSecure &);
-
-	bool operator!=(const WiFiClientSecure &rhs) {
-		return !this->operator==(rhs);
-	};
-
-	using Print::write;
+	virtual int lastError(char *buf, const size_t size) = 0;
+	virtual void setInsecure() = 0; // Don't validate the chain, just accept whatever is given. VERY INSECURE!
+	virtual void setPreSharedKey(const char *pskIdent, const char *psk)	 = 0; // psk in hex
+	virtual void setCACert(const char *rootCA)							 = 0;
+	virtual void setCertificate(const char *clientCA)					 = 0;
+	virtual void setPrivateKey(const char *privateKey)					 = 0;
+	virtual bool loadCACert(Stream &stream, size_t size)				 = 0;
+	virtual bool loadCertificate(Stream &stream, size_t size)			 = 0;
+	virtual bool loadPrivateKey(Stream &stream, size_t size)			 = 0;
+	virtual bool verify(const char *fingerprint, const char *domainName) = 0;
+	virtual void setHandshakeTimeout(unsigned long handshakeTimeout)	 = 0;
+	virtual void setAlpnProtocols(const char **alpnProtocols)			 = 0;
+	virtual bool getFingerprintSHA256(uint8_t result[32])				 = 0;
 };

arduino/libretuya/api/WiFiServer.h

@@ -34,6 +34,8 @@ class IWiFiServer : public Print { // arduino::Server is useless anyway
 
 	IWiFiServer(uint16_t port = 80, uint8_t maxClients = 4) {}
 
+	IWiFiServer(const IPAddress &addr, uint16_t port = 80, uint8_t maxClients = 4) {}
+
 	~IWiFiServer() {
 		stop();
 	}

arduino/libretuya/api/WiFiType.h

@@ -1,66 +0,0 @@
-/*
- ESP8266WiFiType.h - esp8266 Wifi support.
- Copyright (c) 2011-2014 Arduino.  All right reserved.
- Modified by Ivan Grokhotkov, December 2014
- Reworked by Markus Sattler, December 2015
-
- This library is free software; you can redistribute it and/or
- modify it under the terms of the GNU Lesser General Public
- License as published by the Free Software Foundation; either
- version 2.1 of the License, or (at your option) any later version.
-
- This library is distributed in the hope that it will be useful,
- but WITHOUT ANY WARRANTY; without even the implied warranty of
- MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
- Lesser General Public License for more details.
-
- You should have received a copy of the GNU Lesser General Public
- License along with this library; if not, write to the Free Software
- Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
- */
-
-#pragma once
-
-#define WIFI_SCAN_RUNNING (-1)
-#define WIFI_SCAN_FAILED  (-2)
-
-#define WiFiMode_t	 wifi_mode_t
-#define WiFiMode	 wifi_mode_t
-#define WiFiStatus	 wl_status_t
-#define WiFiAuthMode wifi_auth_mode_t
-
-#define WIFI_OFF	WIFI_MODE_NULL
-#define WIFI_STA	WIFI_MODE_STA
-#define WIFI_AP		WIFI_MODE_AP
-#define WIFI_AP_STA WIFI_MODE_APSTA
-
-typedef enum {
-	WIFI_MODE_NULL = 0,
-	WIFI_MODE_STA,
-	WIFI_MODE_AP,
-	WIFI_MODE_APSTA,
-	WIFI_MODE_MAX,
-} wifi_mode_t;
-
-typedef enum {
-	WL_NO_SHIELD	   = 255, // for compatibility with WiFi Shield library
-	WL_IDLE_STATUS	   = 0,
-	WL_NO_SSID_AVAIL   = 1,
-	WL_SCAN_COMPLETED  = 2,
-	WL_CONNECTED	   = 3,
-	WL_CONNECT_FAILED  = 4,
-	WL_CONNECTION_LOST = 5,
-	WL_DISCONNECTED	   = 6,
-} wl_status_t;
-
-typedef enum {
-	WIFI_AUTH_INVALID	   = 255,
-	WIFI_AUTH_AUTO		   = 200,
-	WIFI_AUTH_OPEN		   = 0,
-	WIFI_AUTH_WEP		   = 1,
-	WIFI_AUTH_WPA		   = 5,
-	WIFI_AUTH_WPA2		   = 6,
-	WIFI_AUTH_WPA_PSK	   = 2,
-	WIFI_AUTH_WPA2_PSK	   = 3,
-	WIFI_AUTH_WPA_WPA2_PSK = 4,
-} wifi_auth_mode_t;

arduino/libretuya/api/WiFiUdp.h

@@ -5,7 +5,28 @@
 
 class IWiFiUDP : public UDP {
   public:
-	uint8_t beginMulticast(IPAddress ip, uint16_t port);
-	int beginMulticastPacket();
-	int beginPacket();
+	IWiFiUDP() {}
+
+	~IWiFiUDP() {}
+
+	virtual uint8_t begin(IPAddress ip, uint16_t port)			= 0;
+	virtual uint8_t begin(uint16_t port)						= 0;
+	virtual uint8_t beginMulticast(IPAddress ip, uint16_t port) = 0;
+	virtual void stop()											= 0;
+	virtual int beginMulticastPacket()							= 0;
+	virtual int beginPacket()									= 0;
+	virtual int beginPacket(IPAddress ip, uint16_t port)		= 0;
+	virtual int beginPacket(const char *host, uint16_t port)	= 0;
+	virtual int endPacket()										= 0;
+	virtual size_t write(uint8_t)								= 0;
+	virtual size_t write(const uint8_t *buffer, size_t size)	= 0;
+	virtual int parsePacket()									= 0;
+	virtual int available()										= 0;
+	virtual int read()											= 0;
+	virtual int read(unsigned char *buffer, size_t len)			= 0;
+	virtual int read(char *buffer, size_t len)					= 0;
+	virtual int peek()											= 0;
+	virtual void flush()										= 0;
+	virtual IPAddress remoteIP()								= 0;
+	virtual uint16_t remotePort()								= 0;
 };

arduino/libretuya/api/Wire.h

@@ -0,0 +1,66 @@
+/* Copyright (c) Kuba Szczodrzyński 2022-05-09. */
+
+#include <api/Stream.h>
+
+class ITwoWire : public Stream {
+  protected:
+	int8_t _sda	   = -1;
+	int8_t _scl	   = -1;
+	uint32_t _freq = 0;
+
+	void (*onRequestCallback)(void);
+	void (*onReceiveCallback)(int);
+
+  public:
+	bool begin() {
+		return begin(_sda, _scl, _freq);
+	}
+
+	bool begin(uint8_t address) {
+		return begin(address, _sda, _scl, _freq);
+	}
+
+	virtual bool setPins(int8_t sda, int8_t scl) = 0;
+
+	virtual bool begin(int8_t sda, int8_t scl, uint32_t frequency = 0)					= 0;
+	virtual bool begin(uint8_t address, int8_t sda, int8_t scl, uint32_t frequency = 0) = 0;
+	virtual bool end()																	= 0;
+
+	virtual bool setClock(uint32_t freq) = 0;
+
+	virtual void beginTransmission(uint8_t address) = 0;
+	virtual uint8_t endTransmission(bool stopBit)	= 0;
+
+	virtual size_t requestFrom(uint8_t address, size_t len, bool stopBit) = 0;
+
+	virtual size_t write(const uint8_t *data, size_t len) = 0;
+
+	virtual int available() = 0;
+	virtual int read()		= 0;
+	virtual int peek()		= 0;
+	virtual void flush()	= 0;
+
+	uint32_t getClock() {
+		return _freq;
+	}
+
+	uint8_t endTransmission() {
+		return endTransmission(true);
+	}
+
+	size_t requestFrom(uint8_t address, size_t len) {
+		return requestFrom(address, len, true);
+	}
+
+	virtual size_t write(uint8_t data) {
+		return write(&data, 1);
+	}
+
+	void onReceive(void (*cb)(int)) {
+		onReceiveCallback = cb;
+	}
+
+	void onRequest(void (*cb)(void)) {
+		onRequestCallback = cb;
+	}
+};

arduino/libretuya/api/lt_logger.h

@@ -1,89 +0,0 @@
-#pragma once
-
-#include "LibreTuyaConfig.h"
-#include <stdint.h>
-
-#if LT_LOGGER_FILE
-#define LT_LOG(level, file, line, ...) lt_log(level, file, line, __VA_ARGS__)
-void lt_log(const uint8_t level, const char *filename, const unsigned short line, const char *format, ...);
-#else
-#define LT_LOG(level, file, line, ...) lt_log(level, __VA_ARGS__)
-void lt_log(const uint8_t level, const char *format, ...);
-#endif
-
-#if LT_LEVEL_TRACE >= LT_LOGLEVEL
-#define LT_T(...) LT_LOG(LT_LEVEL_TRACE, __FILE__, __LINE__, __VA_ARGS__)
-#define LT_V(...) LT_LOG(LT_LEVEL_TRACE, __FILE__, __LINE__, __VA_ARGS__)
-#else
-#define LT_T(...)
-#define LT_V(...)
-#endif
-
-#if LT_LEVEL_DEBUG >= LT_LOGLEVEL
-#define LT_D(...) LT_LOG(LT_LEVEL_DEBUG, __FILE__, __LINE__, __VA_ARGS__)
-#else
-#define LT_D(...)
-#endif
-
-#if LT_LEVEL_INFO >= LT_LOGLEVEL
-#define LT_I(...) LT_LOG(LT_LEVEL_INFO, __FILE__, __LINE__, __VA_ARGS__)
-#else
-#define LT_I(...)
-#endif
-
-#if LT_LEVEL_WARN >= LT_LOGLEVEL
-#define LT_W(...) LT_LOG(LT_LEVEL_WARN, __FILE__, __LINE__, __VA_ARGS__)
-#else
-#define LT_W(...)
-#endif
-
-#if LT_LEVEL_ERROR >= LT_LOGLEVEL
-#define LT_E(...) LT_LOG(LT_LEVEL_ERROR, __FILE__, __LINE__, __VA_ARGS__)
-#else
-#define LT_E(...)
-#endif
-
-#if LT_LEVEL_FATAL >= LT_LOGLEVEL
-#define LT_F(...) LT_LOG(LT_LEVEL_FATAL, __FILE__, __LINE__, __VA_ARGS__)
-#else
-#define LT_F(...)
-#endif
-
-#define LT_T_MOD(module, ...)                                                                                          \
-	do {                                                                                                               \
-		if (module) {                                                                                                  \
-			LT_T(__VA_ARGS__)                                                                                          \
-		}                                                                                                              \
-	} while (0)
-
-#define LT_D_MOD(module, ...)                                                                                          \
-	do {                                                                                                               \
-		if (module) {                                                                                                  \
-			LT_D(__VA_ARGS__)                                                                                          \
-		}                                                                                                              \
-	} while (0)
-
-// WiFi.cpp
-#define LT_T_WG(...) LT_T_MOD(LT_DEBUG_WIFI, __VA_ARGS__)
-#define LT_V_WG(...) LT_T_MOD(LT_DEBUG_WIFI, __VA_ARGS__)
-#define LT_D_WG(...) LT_D_MOD(LT_DEBUG_WIFI, __VA_ARGS__)
-
-// WiFiClient.cpp
-#define LT_T_WC(...) LT_T_MOD(LT_DEBUG_WIFI_CLIENT, __VA_ARGS__)
-#define LT_V_WC(...) LT_T_MOD(LT_DEBUG_WIFI_CLIENT, __VA_ARGS__)
-#define LT_D_WC(...) LT_D_MOD(LT_DEBUG_WIFI_CLIENT, __VA_ARGS__)
-
-// WiFiServer.cpp
-#define LT_T_WS(...) LT_T_MOD(LT_DEBUG_WIFI_SERVER, __VA_ARGS__)
-#define LT_V_WS(...) LT_T_MOD(LT_DEBUG_WIFI_SERVER, __VA_ARGS__)
-#define LT_D_WS(...) LT_D_MOD(LT_DEBUG_WIFI_SERVER, __VA_ARGS__)
-
-// WiFiSTA.cpp
-#define LT_T_WSTA(...) LT_T_MOD(LT_DEBUG_WIFI_STA, __VA_ARGS__)
-#define LT_V_WSTA(...) LT_T_MOD(LT_DEBUG_WIFI_STA, __VA_ARGS__)
-#define LT_D_WSTA(...) LT_D_MOD(LT_DEBUG_WIFI_STA, __VA_ARGS__)
-
-// WiFiAP.cpp
-#define LT_T_WAP(...) LT_T_MOD(LT_DEBUG_WIFI_AP, __VA_ARGS__)
-#define LT_V_WAP(...) LT_T_MOD(LT_DEBUG_WIFI_AP, __VA_ARGS__)
-#define LT_D_WAP(...) LT_D_MOD(LT_DEBUG_WIFI_AP, __VA_ARGS__)

arduino/libretuya/common/WMath.cpp

@@ -1,5 +1,5 @@
 /*
-  Copyright (c) 2012 Arduino.  All right reserved.
+  Copyright (c) 2014 Arduino.  All right reserved.
 
   This library is free software; you can redistribute it and/or
   modify it under the terms of the GNU Lesser General Public
@@ -16,19 +16,28 @@
   Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
 */
 
-#ifndef RESET_H
-#define RESET_H
+#include <Arduino.h>
 
-#ifdef __cplusplus
-extern "C" {
-#endif
-
-void initiateReset(int ms);
-void tickReset();
-void cancelReset();
-
-#ifdef __cplusplus
+void randomSeed(uint32_t dwSeed) {
+	if (dwSeed != 0) {
+		srand(dwSeed);
+	}
 }
-#endif
 
-#endif
+long random(long howbig) {
+	if (howbig == 0) {
+		return 0;
+	}
+
+	return rand() % howbig;
+}
+
+long random(long howsmall, long howbig) {
+	if (howsmall >= howbig) {
+		return howsmall;
+	}
+
+	long diff = howbig - howsmall;
+
+	return random(diff) + howsmall;
+}

arduino/libretuya/common/abi.cpp

@@ -1,5 +1,5 @@
 /*
-  Copyright (c) 2011 Arduino.  All right reserved.
+  Copyright (c) 2014 Arduino LLC.  All right reserved.
 
   This library is free software; you can redistribute it and/or
   modify it under the terms of the GNU Lesser General Public
@@ -8,7 +8,7 @@
 
   This library is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
-  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. 
+  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
   See the GNU Lesser General Public License for more details.
 
   You should have received a copy of the GNU Lesser General Public
@@ -16,11 +16,21 @@
   Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
 */
 
-extern "C" void __cxa_pure_virtual(void) ;
+#include <stdlib.h>
 
-/* We compile with nodefaultlibs, so we need to provide an error
- * handler for an empty pure virtual function */
-extern "C" void __cxa_pure_virtual(void) {
-    while(1)
-        ;
+extern "C" void __cxa_pure_virtual(void) __attribute__((__noreturn__));
+extern "C" void __cxa_deleted_virtual(void) __attribute__((__noreturn__));
+
+void __cxa_pure_virtual(void) {
+	// We might want to write some diagnostics to uart in this case
+	// std::terminate();
+	while (1)
+		;
+}
+
+void __cxa_deleted_virtual(void) {
+	// We might want to write some diagnostics to uart in this case
+	// std::terminate();
+	while (1)
+		;
 }

arduino/libretuya/common/dtostrf.c

@@ -18,16 +18,11 @@
   Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
 */
 
-#ifdef ARDUINO_AMEBA
 #include <Arduino.h>
-#else
-#include <stdio.h>
-#endif
 
-char *dtostrf (double val, signed char width, unsigned char prec, char *sout) {
-  char fmt[20];
-  sprintf(fmt, "%%%d.%df", width, prec);
-  sprintf(sout, fmt, val);
-  return sout;
+char *dtostrf(double val, signed char width, unsigned char prec, char *sout) {
+	char fmt[20];
+	sprintf(fmt, "%%%d.%df", width, prec);
+	sprintf(sout, fmt, val);
+	return sout;
 }
-

arduino/libretuya/common/hooks.c

@@ -1,5 +1,5 @@
 /*
-  Copyright (c) 2012 Arduino.  All right reserved.
+  Copyright (c) 2015 Arduino LLC.  All right reserved.
 
   This library is free software; you can redistribute it and/or
   modify it under the terms of the GNU Lesser General Public
@@ -29,12 +29,7 @@ static void __empty() {
 	// Empty
 }
 
-#include "cmsis_os.h"
-
-void yield(void) {
-  vTaskDelay(1);
-  taskYIELD();
-}
+void yield(void) __attribute__((weak, alias("__empty")));
 
 /**
  * SysTick hook
@@ -46,7 +41,8 @@ static int __false() {
 	// Return false
 	return 0;
 }
-int sysTickHook(void) __attribute__ ((weak, alias("__false")));
+
+int sysTickHook(void) __attribute__((weak, alias("__false")));
 
 /**
  * SVC hook
@@ -60,5 +56,6 @@ static void __halt() {
 	while (1)
 		;
 }
-void svcHook(void)    __attribute__ ((weak, alias("__halt")));
-void pendSVHook(void) __attribute__ ((weak, alias("__halt")));
+
+void svcHook(void) __attribute__((weak, alias("__halt")));
+void pendSVHook(void) __attribute__((weak, alias("__halt")));

arduino/libretuya/common/itoa.c

@@ -0,0 +1,111 @@
+/*
+  Copyright (c) 2014 Arduino LLC.  All right reserved.
+
+  This library is free software; you can redistribute it and/or
+  modify it under the terms of the GNU Lesser General Public
+  License as published by the Free Software Foundation; either
+  version 2.1 of the License, or (at your option) any later version.
+
+  This library is distributed in the hope that it will be useful,
+  but WITHOUT ANY WARRANTY; without even the implied warranty of
+  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
+  See the GNU Lesser General Public License for more details.
+
+  You should have received a copy of the GNU Lesser General Public
+  License along with this library; if not, write to the Free Software
+  Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
+*/
+
+#include <string.h>
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+char *ltoa(long value, char *string, int radix) {
+	char tmp[33];
+	char *tp = tmp;
+	long i;
+	unsigned long v;
+	int sign;
+	char *sp;
+
+	if (string == NULL) {
+		return 0;
+	}
+
+	if (radix > 36 || radix <= 1) {
+		return 0;
+	}
+
+	sign = (radix == 10 && value < 0);
+	if (sign) {
+		v = -value;
+	} else {
+		v = (unsigned long)value;
+	}
+
+	while (v || tp == tmp) {
+		i = v % radix;
+		v = v / radix;
+		if (i < 10)
+			*tp++ = i + '0';
+		else
+			*tp++ = i + 'a' - 10;
+	}
+
+	sp = string;
+
+	if (sign)
+		*sp++ = '-';
+	while (tp > tmp)
+		*sp++ = *--tp;
+	*sp = 0;
+
+	return string;
+}
+
+char *ultoa(unsigned long value, char *string, int radix) {
+	char tmp[33];
+	char *tp = tmp;
+	long i;
+	unsigned long v = value;
+	char *sp;
+
+	if (string == NULL) {
+		return 0;
+	}
+
+	if (radix > 36 || radix <= 1) {
+		return 0;
+	}
+
+	while (v || tp == tmp) {
+		i = v % radix;
+		v = v / radix;
+		if (i < 10)
+			*tp++ = i + '0';
+		else
+			*tp++ = i + 'a' - 10;
+	}
+
+	sp = string;
+
+	while (tp > tmp)
+		*sp++ = *--tp;
+	*sp = 0;
+
+	return string;
+}
+
+char *itoa(int value, char *string, int radix) {
+	return ltoa(value, string, radix);
+}
+
+char *utoa(unsigned int value, char *string, int radix) {
+	return ultoa(value, string, radix);
+}
+
+#ifdef __cplusplus
+} // extern "C"
+#endif

arduino/libretuya/common/serial_event.cpp

@@ -0,0 +1,11 @@
+/* Copyright (c) Kuba Szczodrzyński 2022-06-19. */
+
+#include <Arduino.h>
+
+void serialEvent() __attribute__((weak));
+bool Serial_available() __attribute__((weak));
+
+void serialEventRun(void) {
+	if (Serial_available && serialEvent && Serial_available())
+		serialEvent();
+}

arduino/libretuya/common/wiring_shift.c

@@ -0,0 +1,54 @@
+/*
+  Copyright (c) 2014 Arduino.  All right reserved.
+
+  This library is free software; you can redistribute it and/or
+  modify it under the terms of the GNU Lesser General Public
+  License as published by the Free Software Foundation; either
+  version 2.1 of the License, or (at your option) any later version.
+
+  This library is distributed in the hope that it will be useful,
+  but WITHOUT ANY WARRANTY; without even the implied warranty of
+  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
+  See the GNU Lesser General Public License for more details.
+
+  You should have received a copy of the GNU Lesser General Public
+  License along with this library; if not, write to the Free Software
+  Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
+*/
+
+#include <Arduino.h>
+#include <stdint.h>
+
+uint8_t shiftIn(pin_size_t ulDataPin, pin_size_t ulClockPin, BitOrder ulBitOrder) {
+	uint8_t value = 0;
+	uint8_t i;
+
+	for (i = 0; i < 8; ++i) {
+		digitalWrite(ulClockPin, HIGH);
+
+		if (ulBitOrder == LSBFIRST) {
+			value |= digitalRead(ulDataPin) << i;
+		} else {
+			value |= digitalRead(ulDataPin) << (7 - i);
+		}
+
+		digitalWrite(ulClockPin, LOW);
+	}
+
+	return value;
+}
+
+void shiftOut(pin_size_t ulDataPin, pin_size_t ulClockPin, BitOrder ulBitOrder, uint8_t ulVal) {
+	uint8_t i;
+
+	for (i = 0; i < 8; i++) {
+		if (ulBitOrder == LSBFIRST) {
+			digitalWrite(ulDataPin, !!(ulVal & (1 << i)));
+		} else {
+			digitalWrite(ulDataPin, !!(ulVal & (1 << (7 - i))));
+		}
+
+		digitalWrite(ulClockPin, HIGH);
+		digitalWrite(ulClockPin, LOW);
+	}
+}

arduino/libretuya/compat/FS.h

@@ -0,0 +1,5 @@
+/* Copyright (c) Kuba Szczodrzyński 2022-04-30. */
+
+#pragma once
+
+#include <api/FS.h>

arduino/libretuya/compat/FSImpl.h

@@ -0,0 +1,3 @@
+/* Copyright (c) Kuba Szczodrzyński 2022-04-30. */
+
+// nop

arduino/libretuya/compat/WiFiAP.h

@@ -1,3 +1,5 @@
+/* Copyright (c) Kuba Szczodrzyński 2022-04-26. */
+
 #pragma once
 
 // ESP32 WiFi examples use WiFiAP.h include

arduino/libretuya/compat/md5.h

@@ -0,0 +1,6 @@
+/* Copyright (c) Kuba Szczodrzyński 2022-06-04. */
+
+#pragma once
+
+// lowercase "md5.h" to allow including actual MD5.h on case-sensitive OSes
+#include <MD5.h>

arduino/libretuya/compat/pgmspace.h

@@ -0,0 +1,5 @@
+/* Copyright (c) Kuba Szczodrzyński 2022-04-30. */
+
+#pragma once
+
+#include <api/deprecated-avr-comp/avr/pgmspace.h>

arduino/libretuya/compat/vfs_api.h

@@ -0,0 +1,3 @@
+/* Copyright (c) Kuba Szczodrzyński 2022-04-30. */
+
+// nop

arduino/libretuya/core/ChipType.h

@@ -0,0 +1,37 @@
+/* Copyright (c) Kuba Szczodrzyński 2022-05-28. */
+
+#pragma once
+
+#define CHIP_TYPE(family, chip_id)		(((family >> 24) << 8) | chip_id)
+#define CHIP_TYPE_ENUM(family, chip_id) (ChipType) CHIP_TYPE(family, chip_id)
+
+enum ChipFamily {
+	// used in UF2 Family ID
+	F_RTL8710A = 0x9FFFD543, // Realtek Ameba1
+	F_RTL8710B = 0x22E0D6FC, // Realtek AmebaZ (realtek-ambz)
+	F_RTL8720C = 0xE08F7564, // Realtek AmebaZ2
+	F_RTL8720D = 0x3379CFE2, // Realtek AmebaD
+	F_BK7231U  = 0x675A40B0, // Beken 7231U/7231T
+	F_BK7231N  = 0x7B3EF230, // Beken 7231N
+	F_BK7251   = 0x6A82CC42, // Beken 7251/7252
+	F_BL602	   = 0xDE1270B7, // Boufallo 602
+	F_XR809	   = 0x51E903A8, // Xradiotech 809
+	F_NATIVE   = 0xDEADBEEF, // Host-native
+};
+
+enum ChipType {
+	// Realtek AmebaZ
+	// IDs copied from rtl8710b_efuse.h
+	RTL8710BL = CHIP_TYPE(F_RTL8710B, 0xE0), // ???
+	RTL8710BN = CHIP_TYPE(F_RTL8710B, 0xFF), // CHIPID_8710BN / QFN32
+	RTL8710BU = CHIP_TYPE(F_RTL8710B, 0xFE), // CHIPID_8710BU / QFN48
+	RTL8710BX = CHIP_TYPE(F_RTL8710B, 0xF6), // found on an actual RTL8710BX
+	RTL8710L0 = CHIP_TYPE(F_RTL8710B, 0xFB), // CHIPID_8710BN_L0 / QFN32
+	RTL8711BN = CHIP_TYPE(F_RTL8710B, 0xFD), // CHIPID_8711BN / QFN48
+	RTL8711BU = CHIP_TYPE(F_RTL8710B, 0xFC), // CHIPID_8711BG / QFN68
+	// Beken 72XX
+	BK7231T = CHIP_TYPE(F_BK7231U, 0x1A), // *SCTRL_CHIP_ID = 0x7231a
+	BK7231N = CHIP_TYPE(F_BK7231N, 0x1C), // *SCTRL_CHIP_ID = 0x7231c
+	BL2028N = CHIP_TYPE(F_BK7231N, 0x1C), // *SCTRL_CHIP_ID = 0x7231c
+	BK7252	= CHIP_TYPE(F_BK7251, 0x00),  // TODO
+};

arduino/libretuya/core/LibreTuyaAPI.cpp

@@ -0,0 +1,65 @@
+/* Copyright (c) Kuba Szczodrzyński 2022-04-29. */
+
+#include "LibreTuyaAPI.h"
+
+String ipToString(const IPAddress &ip) {
+	char szRet[16];
+	sprintf(szRet, "%hhu.%hhu.%hhu.%hhu", ip[0], ip[1], ip[2], ip[3]);
+	return String(szRet);
+}
+
+/**
+ * @brief Generate random bytes using rand().
+ *
+ * @param buf destination pointer
+ * @param len how many bytes to generate
+ */
+extern "C" {
+void lt_rand_bytes(uint8_t *buf, size_t len) {
+	int *data = (int *)buf;
+	size_t i;
+	for (i = 0; len >= sizeof(int); len -= sizeof(int)) {
+		data[i++] = rand();
+	}
+	if (len) {
+		int rem				= rand();
+		unsigned char *pRem = (unsigned char *)&rem;
+		memcpy(buf + i * sizeof(int), pRem, len);
+	}
+}
+
+#undef putchar
+
+/**
+ * @brief Print data pointed to by buf in hexdump-like format (hex+ASCII).
+ *
+ * @param buf source pointer
+ * @param len how many bytes to print
+ * @param offset increment printed offset by this value
+ * @param width how many bytes on a line
+ */
+void hexdump(const uint8_t *buf, size_t len, uint32_t offset, uint8_t width) {
+	uint16_t pos = 0;
+	while (pos < len) {
+		// print hex offset
+		printf("%06x ", offset + pos);
+		// calculate current line width
+		uint8_t lineWidth = min(width, len - pos);
+		// print hexadecimal representation
+		for (uint8_t i = 0; i < lineWidth; i++) {
+			if (i % 8 == 0) {
+				printf(" ");
+			}
+			printf("%02x ", buf[pos + i]);
+		}
+		// print ascii representation
+		printf(" |");
+		for (uint8_t i = 0; i < lineWidth; i++) {
+			char c = buf[pos + i];
+			putchar((c >= 0x20 && c <= 0x7f) ? c : '.');
+		}
+		puts("|\r");
+		pos += lineWidth;
+	}
+}
+}

arduino/libretuya/core/LibreTuyaAPI.h

@@ -0,0 +1,80 @@
+/* Copyright (c) Kuba Szczodrzyński 2022-04-28. */
+
+#pragma once
+
+// C standard libraries
+#include <inttypes.h>
+#include <stdarg.h>
+#include <stdbool.h>
+#include <stddef.h>
+#include <stdint.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+
+// C++ standard libraries
+#ifdef __cplusplus
+#include <algorithm>
+#include <cmath>
+using ::round;
+using std::abs;
+using std::isinf;
+using std::isnan;
+using std::max;
+using std::min;
+#endif
+
+// LibreTuya version macros
+#ifndef LT_VERSION
+#define LT_VERSION 1.0.0
+#endif
+#ifndef LT_BOARD
+#define LT_BOARD unknown
+#endif
+#define STRINGIFY(x)	   #x
+#define STRINGIFY_MACRO(x) STRINGIFY(x)
+#define LT_VERSION_STR	   STRINGIFY_MACRO(LT_VERSION)
+#define LT_BOARD_STR	   STRINGIFY_MACRO(LT_BOARD)
+
+// Includes
+#include "LibreTuyaClass.h"	 // global LT class
+#include "LibreTuyaCompat.h" // compatibility methods
+#include "LibreTuyaConfig.h" // configuration macros
+#include "LibreTuyaCustom.h" // family-defined methods (Wiring custom)
+#include <Arduino.h>
+
+// C includes
+#ifdef __cplusplus
+extern "C" {
+#endif // __cplusplus
+
+#include "lt_logger.h"
+#include "lt_posix_api.h"
+
+#ifdef __cplusplus
+} // extern "C"
+#endif
+
+// Functional macros
+#define LT_BANNER()                                                                                                    \
+	LT_LOG(                                                                                                            \
+		LT_LEVEL_INFO,                                                                                                 \
+		__FUNCTION__,                                                                                                  \
+		__LINE__,                                                                                                      \
+		"LibreTuya v" LT_VERSION_STR " on " LT_BOARD_STR ", compiled at " __DATE__ " " __TIME__                        \
+	)
+
+#ifdef __cplusplus
+String ipToString(const IPAddress &ip);
+
+extern "C" {
+void lt_rand_bytes(uint8_t *buf, size_t len);
+void hexdump(const uint8_t *buf, size_t len, uint32_t offset = 0, uint8_t width = 16);
+}
+
+#else
+
+void lt_rand_bytes(uint8_t *buf, size_t len);
+void hexdump(const uint8_t *buf, size_t len, uint32_t offset, uint8_t width);
+
+#endif

arduino/libretuya/core/LibreTuyaClass.cpp

@@ -0,0 +1,148 @@
+/* Copyright (c) Kuba Szczodrzyński 2022-06-06. */
+
+#include "LibreTuyaClass.h"
+
+/**
+ * @brief Get LibreTuya version string.
+ */
+const char *LibreTuya::getVersion() {
+	return LT_VERSION_STR;
+}
+
+/**
+ * @brief Get board name.
+ */
+const char *LibreTuya::getBoard() {
+	return LT_BOARD_STR;
+}
+
+/**
+ * @brief Get CPU family ID.
+ */
+ChipFamily LibreTuya::getChipFamily() {
+	return FAMILY;
+}
+
+/**
+ * @brief Get CPU family name as string.
+ */
+const char *LibreTuya::getChipFamilyName() {
+	return STRINGIFY_MACRO(FAMILY) + 2;
+}
+
+static char *deviceName = NULL;
+
+/**
+ * @brief Get device friendly name in format "LT-<board>-<chip id>".
+ * Can be used as hostname.
+ */
+const char *LibreTuya::getDeviceName() {
+	if (deviceName)
+		return deviceName;
+	uint32_t chipId = getChipId();
+	uint8_t *id		= (uint8_t *)&chipId;
+
+	const char *board = getBoard();
+	uint8_t boardLen  = strlen(board);
+	deviceName		  = (char *)malloc(3 + boardLen + 1 + 6 + 1);
+
+	sprintf(deviceName, "LT-%s-%02x%02x%02x", board, id[0], id[1], id[2]);
+	return deviceName;
+}
+
+/**
+ * @brief Get a textual representation of a reset reason.
+ *
+ * @param reason value to convert to text, uses getResetReason() by default
+ */
+const char *LibreTuya::getResetReasonName(ResetReason reason) {
+	if (reason >= RESET_REASON_MAX)
+		reason = getResetReason();
+	switch (reason) {
+		case RESET_REASON_POWER:
+			return "Power-On";
+		case RESET_REASON_BROWNOUT:
+			return "Brownout";
+		case RESET_REASON_HARDWARE:
+			return "HW Reboot";
+		case RESET_REASON_SOFTWARE:
+			return "SW Reboot";
+		case RESET_REASON_WATCHDOG:
+			return "WDT Reset";
+		case RESET_REASON_CRASH:
+			return "Crash";
+		case RESET_REASON_SLEEP:
+			return "Sleep Wakeup";
+	}
+	return "Unknown";
+}
+
+/**
+ * @brief Get CPU frequency in MHz.
+ */
+uint32_t LibreTuya::getCpuFreqMHz() {
+	return getCpuFreq() / 1000000;
+}
+
+/**
+ * @brief Get flash chip total size.
+ * The default implementation uses the least significant
+ * byte of the chip ID to determine the size.
+ */
+__attribute__((weak)) uint32_t LibreTuya::getFlashChipSize() {
+	FlashId id = getFlashChipId();
+	if (id.chipSizeId >= 0x14 && id.chipSizeId <= 0x19) {
+		return (1 << id.chipSizeId);
+	}
+#ifdef FLASH_LENGTH
+	return FLASH_LENGTH;
+#else
+	return 0;
+#endif
+}
+
+/**
+ * @brief Get the OTA index for updated firmware.
+ *
+ * Note: returns 1 for chips without dual-OTA.
+ */
+uint8_t LibreTuya::otaGetTarget() {
+	if (!otaSupportsDual())
+		return 1;
+	return otaGetRunning() ^ 0b11;
+}
+
+/**
+ * @brief Perform OTA rollback: switch to the previous image, or abort current
+ * switched OTA update, if not rebooted yet.
+ *
+ * @return false if no second image to run, writing failed or dual-OTA not supported
+ */
+bool LibreTuya::otaRollback() {
+	if (!otaCanRollback())
+		return false;
+	if (otaGetRunning() != otaGetStoredIndex())
+		// force switching back to current image
+		return otaSwitch(true);
+	return true;
+}
+
+/**
+ * @brief Check if OTA rollback is supported and available (there is another image to run).
+ * @return false if no second image to run or dual-OTA not supported
+ */
+bool LibreTuya::otaCanRollback() {
+	if (!otaSupportsDual())
+		return false;
+	if (otaGetRunning() == otaGetStoredIndex())
+		return true;
+	if (otaGetRunning() == 1 && otaHasImage1())
+		return true;
+	if (otaGetRunning() == 2 && otaHasImage2())
+		return true;
+	return false;
+}
+
+__attribute__((weak)) void LibreTuya::gpioRecover() {
+	// nop by default
+}

arduino/libretuya/core/LibreTuyaClass.h

@@ -0,0 +1,193 @@
+/* Copyright (c) Kuba Szczodrzyński 2022-06-06. */
+
+#pragma once
+
+#ifdef __cplusplus
+
+#include "LibreTuyaAPI.h"
+#include <core/ChipType.h>
+
+typedef enum {
+	RESET_REASON_UNKNOWN  = 0,
+	RESET_REASON_POWER	  = 1,
+	RESET_REASON_BROWNOUT = 2,
+	RESET_REASON_HARDWARE = 3,
+	RESET_REASON_SOFTWARE = 4,
+	RESET_REASON_WATCHDOG = 5,
+	RESET_REASON_CRASH	  = 6,
+	RESET_REASON_SLEEP	  = 7,
+	RESET_REASON_MAX	  = 8,
+} ResetReason;
+
+/**
+ * @brief Flash chip ID structure.
+ */
+typedef struct {
+	uint8_t manufacturerId;
+	uint8_t chipId;
+	uint8_t chipSizeId;
+} FlashId;
+
+/**
+ * @brief Main LibreTuya API class.
+ *
+ * This class contains all functions common amongst all families.
+ * Implementations of these methods may vary between families.
+ *
+ * The class is accessible using the `LT` global object (defined by the family).
+ */
+class LibreTuya {
+  public: /* Common methods - note: these are documented in LibreTuyaAPI.cpp */
+	const char *getVersion();
+	const char *getBoard();
+	ChipFamily getChipFamily();
+	const char *getChipFamilyName();
+	const char *getDeviceName();
+	const char *getResetReasonName(ResetReason reason = RESET_REASON_MAX);
+	uint32_t getCpuFreqMHz();
+	uint32_t getFlashChipSize();
+	uint8_t otaGetTarget();
+	bool otaRollback();
+	bool otaCanRollback();
+
+  public: /* Compatibility methods */
+	/**
+	 * @brief Alias of getMaxAllocHeap().
+	 */
+	inline uint32_t getMaxFreeBlockSize() {
+		return getMaxAllocHeap();
+	}
+
+  public: /* Family-defined methods */
+	/**
+	 * @brief Reboot the CPU.
+	 */
+	void restart();
+	/**
+	 * @brief Reboot the CPU and stay in download mode (if possible).
+	 */
+	void restartDownloadMode();
+	/**
+	 * @brief Get the reason of last chip reset.
+	 */
+	ResetReason getResetReason();
+	/**
+	 * @brief Reconfigure GPIO pins used for debugging
+	 * (SWD/JTAG), so that they can be used as normal I/O.
+	 */
+	void gpioRecover();
+
+  public: /* CPU-related */
+	/**
+	 * @brief Get CPU model ID.
+	 */
+	ChipType getChipType();
+	/**
+	 * @brief Get CPU model name as string.
+	 */
+	const char *getChipModel();
+	/**
+	 * @brief Get CPU unique ID. This may be based on MAC, eFuse, etc.
+	 * Note: the number should be 24-bit (with most significant byte being zero).
+	 */
+	uint32_t getChipId();
+	/**
+	 * @brief Get CPU core count.
+	 */
+	uint8_t getChipCores();
+	/**
+	 * @brief Get CPU core type name as string.
+	 */
+	const char *getChipCoreType();
+	/**
+	 * @brief Get CPU frequency in Hz.
+	 */
+	uint32_t getCpuFreq();
+	/**
+	 * @brief Get CPU cycle count.
+	 */
+	uint32_t getCycleCount();
+
+  public: /* Flash memory utilities */
+	/**
+	 * @brief Read flash chip ID and return a FlashId struct.
+	 */
+	FlashId getFlashChipId();
+
+  public: /* Memory management */
+	/**
+	 * @brief Get total RAM size.
+	 */
+	uint32_t getRamSize();
+	/**
+	 * @brief Get total heap size.
+	 */
+	uint32_t getHeapSize();
+	/**
+	 * @brief Get free heap size.
+	 */
+	uint32_t getFreeHeap();
+	/**
+	 * @brief Get lowest level of free heap memory.
+	 */
+	uint32_t getMinFreeHeap();
+	/**
+	 * @brief Get largest block of heap that can be allocated at once.
+	 */
+	uint32_t getMaxAllocHeap();
+
+  public: /* OTA-related */
+	/**
+	 * @brief Get the currently running firmware OTA index.
+	 */
+	uint8_t otaGetRunning();
+	/**
+	 * @brief Read the currently active OTA index, i.e. the one that will boot upon restart.
+	 */
+	uint8_t otaGetStoredIndex();
+	/**
+	 * @brief Check if the chip supports dual-OTA (i.e. OTA is flashed to a different partition).
+	 *
+	 * TODO: make this work for actual dual-OTA chips; remove checking this in otaGetTarget() etc.
+	 */
+	bool otaSupportsDual();
+	/**
+	 * @brief Check if OTA1 image is valid.
+	 */
+	bool otaHasImage1();
+	/**
+	 * @brief Check if OTA2 image is valid.
+	 */
+	bool otaHasImage2();
+	/**
+	 * @brief Try to switch OTA index to the other image.
+	 *
+	 * Note: should return true for chips without dual-OTA. Should return false if one of two images is not valid.
+	 *
+	 * @param force switch even if other image already marked as active
+	 * @return false if writing failed; true otherwise
+	 */
+	bool otaSwitch(bool force = false);
+
+  public: /* Watchdog */
+	/**
+	 * @brief Enable the hardware watchdog.
+	 *
+	 * @param timeout watchdog timeout, milliseconds (defaults to 10s)
+	 * @return whether the chip has a hardware watchdog
+	 */
+	bool wdtEnable(uint32_t timeout = 10000);
+	/**
+	 * @brief Disable the hardware watchdog.
+	 */
+	void wdtDisable();
+	/**
+	 * @brief Feed/reset the hardware watchdog timer.
+	 */
+	void wdtFeed();
+};
+
+extern LibreTuya LT;
+extern LibreTuya ESP;
+
+#endif

arduino/libretuya/core/LibreTuyaCompat.cpp

@@ -0,0 +1,33 @@
+/* Copyright (c) Kuba Szczodrzyński 2022-06-04. */
+
+#include "LibreTuyaCompat.h"
+
+#if LT_HAS_FREERTOS
+BaseType_t xTaskCreateUniversal(
+	TaskFunction_t pxTaskCode,
+	const char *const pcName,
+	const uint32_t usStackDepth,
+	void *const pvParameters,
+	UBaseType_t uxPriority,
+	TaskHandle_t *const pxCreatedTask,
+	const BaseType_t xCoreID
+) {
+	// #ifndef CONFIG_FREERTOS_UNICORE
+	// 	if (xCoreID >= 0 && xCoreID < 2) {
+	// 		return xTaskCreatePinnedToCore(
+	// 			pxTaskCode,
+	// 			pcName,
+	// 			usStackDepth,
+	// 			pvParameters,
+	// 			uxPriority,
+	// 			pxCreatedTask,
+	// 			xCoreID
+	// 		);
+	// 	} else {
+	// #endif
+	return xTaskCreate(pxTaskCode, pcName, usStackDepth, pvParameters, uxPriority, pxCreatedTask);
+	// #ifndef CONFIG_FREERTOS_UNICORE
+	// 	}
+	// #endif
+}
+#endif

arduino/libretuya/core/LibreTuyaCompat.h

@@ -0,0 +1,42 @@
+/* Copyright (c) Kuba Szczodrzyński 2022-06-04. */
+
+#pragma once
+
+#include <Arduino.h>
+
+#if LT_HAS_FREERTOS
+#include <FreeRTOS.h>
+#include <task.h>
+#endif
+
+// Definitions for error constants.
+#define esp_err_t int
+#define ESP_OK	  0	 /*!< esp_err_t value indicating success (no error) */
+#define ESP_FAIL  -1 /*!< Generic esp_err_t code indicating failure */
+
+// ArduinoCore-API doesn't define these anymore
+#define FPSTR(pstr_pointer) (reinterpret_cast<const __FlashStringHelper *>(pstr_pointer))
+#define PGM_VOID_P			const void *
+#define vsnprintf_P			vsnprintf
+#define OUTPUT_OPEN_DRAIN	OUTPUT_OPENDRAIN
+#define attachInterruptArg	attachInterruptParam
+#define voidFuncPtrArg		voidFuncPtrParam
+
+// FreeRTOS utilities
+#if LT_HAS_FREERTOS
+// if xCoreID < 0 or CPU is unicore, it will use xTaskCreate, else xTaskCreatePinnedToCore
+// allows to easily handle all possible situations without repetitive code
+BaseType_t xTaskCreateUniversal(
+	TaskFunction_t pxTaskCode,
+	const char *const pcName,
+	const uint32_t usStackDepth,
+	void *const pvParameters,
+	UBaseType_t uxPriority,
+	TaskHandle_t *const pxCreatedTask,
+	const BaseType_t xCoreID
+);
+#define xTaskCreatePinnedToCore xTaskCreateUniversal
+#endif
+
+// Default values from sdkconfig.h
+#define CONFIG_LWIP_MAX_ACTIVE_TCP 16

arduino/libretuya/core/LibreTuyaConfig.h

@@ -0,0 +1,132 @@
+/* Copyright (c) Kuba Szczodrzyński 2022-04-28. */
+
+#pragma once
+
+// see docs/API Configuration
+
+// Loglevels
+#define LT_LEVEL_VERBOSE LT_LEVEL_TRACE
+#define LT_LEVEL_TRACE	 0
+#define LT_LEVEL_DEBUG	 1
+#define LT_LEVEL_INFO	 2
+#define LT_LEVEL_WARN	 3
+#define LT_LEVEL_ERROR	 4
+#define LT_LEVEL_FATAL	 5
+#define LT_LEVEL_NONE	 6
+
+// Logger enabled/disabled
+#ifndef LT_LOGGER
+#define LT_LOGGER 1
+#endif
+
+// Logger format options
+#ifndef LT_LOGGER_TIMESTAMP
+#define LT_LOGGER_TIMESTAMP 1
+#endif
+
+#ifndef LT_LOGGER_CALLER
+#define LT_LOGGER_CALLER 0
+#endif
+
+#ifndef LT_LOGGER_TASK
+#define LT_LOGGER_TASK 0
+#endif
+
+#ifndef LT_LOGGER_COLOR
+#define LT_LOGGER_COLOR 0
+#endif
+
+#ifndef LT_PRINTF_BROKEN
+#define LT_PRINTF_BROKEN 0
+#endif
+
+// Global loglevel
+#ifndef LT_LOGLEVEL
+#define LT_LOGLEVEL LT_LEVEL_INFO
+#endif
+
+#if !LT_LOGGER
+#undef LT_LOGLEVEL
+#define LT_LOGLEVEL LT_LEVEL_NONE
+#endif
+
+// Free heap size debugging
+#ifndef LT_LOG_HEAP
+#define LT_LOG_HEAP 0
+#endif
+
+// Debug errno values using LT_ERRNO()
+#ifndef LT_LOG_ERRNO
+#define LT_LOG_ERRNO 0
+#endif
+
+// Serial output options
+#ifndef LT_UART_SILENT_ENABLED
+#define LT_UART_SILENT_ENABLED 1
+#endif
+
+#ifndef LT_UART_SILENT_ALL
+#define LT_UART_SILENT_ALL 0
+#endif
+
+#ifndef LT_UART_DEFAULT_LOGGER
+#define LT_UART_DEFAULT_LOGGER LT_UART_DEFAULT_PORT
+#endif
+
+#ifndef LT_UART_DEFAULT_SERIAL
+#define LT_UART_DEFAULT_SERIAL LT_UART_DEFAULT_PORT
+#endif
+
+// Misc options
+#ifndef LT_USE_TIME
+#define LT_USE_TIME 0
+#endif
+
+#ifndef LT_MICROS_HIGH_RES // NOTE: this is also defined in fixups/clock_rtos.c
+#define LT_MICROS_HIGH_RES 1
+#endif
+
+#ifndef LT_AUTO_DOWNLOAD_REBOOT
+#define LT_AUTO_DOWNLOAD_REBOOT 1
+#endif
+
+// Per-module logging output - applies to all loglevels
+#ifndef LT_DEBUG_ALL
+#define LT_DEBUG_ALL 0
+#endif
+
+#ifndef LT_DEBUG_WIFI
+#define LT_DEBUG_WIFI 1
+#endif
+
+#ifndef LT_DEBUG_CLIENT
+#define LT_DEBUG_CLIENT LT_DEBUG_ALL
+#endif
+
+#ifndef LT_DEBUG_SERVER
+#define LT_DEBUG_SERVER LT_DEBUG_ALL
+#endif
+
+#ifndef LT_DEBUG_SSL
+#define LT_DEBUG_SSL LT_DEBUG_ALL
+#endif
+
+#ifndef LT_DEBUG_OTA
+#define LT_DEBUG_OTA 1
+#endif
+
+#ifndef LT_DEBUG_FDB
+#define LT_DEBUG_FDB 0
+#endif
+
+#ifndef LT_DEBUG_MDNS
+#define LT_DEBUG_MDNS LT_DEBUG_ALL
+#endif
+
+#ifndef LT_DEBUG_LWIP
+#define LT_DEBUG_LWIP 0
+#endif
+
+#ifndef LT_DEBUG_LWIP_ASSERT
+#define LT_DEBUG_LWIP_ASSERT 0
+#endif

arduino/libretuya/core/LibreTuyaCustom.c

@@ -0,0 +1,103 @@
+/* Copyright (c) Kuba Szczodrzyński 2022-06-20. */
+
+#include "LibreTuyaCustom.h"
+
+int _analogReadResolution  = 10;	// 0-1023
+int _analogWriteResolution = 8;		// 0-255
+int _analogWritePeriod	   = 20000; // 50 Hz
+
+/**
+ * @brief Check if pin is invalid (too low or too high).
+ */
+bool pinInvalid(pin_size_t pinNumber) {
+#ifdef PINS_COUNT
+	return pinNumber < 0 || pinNumber >= PINS_COUNT;
+#else
+	return false;
+#endif
+}
+
+/**
+ * @brief Get PinInfo struct for the specified number.
+ * Returns NULL if pin number is invalid.
+ */
+PinInfo *pinInfo(pin_size_t pinNumber) {
+	if (pinInvalid(pinNumber))
+		return NULL;
+	return &(pinTable[pinNumber]);
+}
+
+/**
+ * @brief Check if pin supports all features represented by 'mask'.
+ */
+bool pinSupported(PinInfo *pin, uint32_t mask) {
+	return (pin->supported & mask) == mask;
+}
+
+/**
+ * @brief Check if pin has all features represented by 'mask' enabled.
+ */
+bool pinEnabled(PinInfo *pin, uint32_t mask) {
+	return (pin->enabled & mask) == mask;
+}
+
+/**
+ * @brief Check if GPIO pin is configured as output.
+ */
+bool pinIsOutput(PinInfo *pin) {
+	return pin->mode == OUTPUT || pin->mode == OUTPUT_OPENDRAIN;
+}
+
+/**
+ * @brief Check if GPIO pin is configured as output.
+ */
+bool pinIsInput(PinInfo *pin) {
+	return pin->mode == INPUT || pin->mode == INPUT_PULLUP || pin->mode == INPUT_PULLDOWN;
+}
+
+/**
+ * @brief Read voltage from ADC and return a value between 0 and
+ * the current reading resolution.
+ */
+int analogRead(pin_size_t pinNumber) {
+	float voltage	 = analogReadVoltage(pinNumber);
+	float maxVoltage = analogReadMaxVoltage(pinNumber);
+	uint16_t ret	 = round((1 << _analogReadResolution) * voltage / maxVoltage);
+	if (ret >= (1 << _analogReadResolution))
+		ret = (1 << _analogReadResolution) - 1;
+	return ret;
+}
+
+/**
+ * @brief Set resolution of values (in bits) returned by analogRead().
+ * Defaults to 10 bit (0-1023).
+ */
+void analogReadResolution(int res) {
+	_analogReadResolution = res;
+}
+
+/**
+ * @brief Set resolution of values (in bits) expected by analogWrite().
+ * Defaults to 8 bit (0-255).
+ */
+void analogWriteResolution(int res) {
+	_analogWriteResolution = res;
+}
+
+/**
+ * @brief Set PWM output frequency (in Hz).
+ * Defaults to 50 Hz (20,000 uS).
+ */
+void analogWriteFrequency(int hz) {
+	_analogWritePeriod = 1E6 / hz;
+}
+
+/**
+ * @brief Set PWM output frequency (cycle period) in microseconds.
+ * Defaults to 20,000 uS (50 Hz).
+ */
+void analogWritePeriod(int us) {
+	_analogWritePeriod = us;
+}
+
+__attribute__((weak)) void analogReference(uint8_t mode) {}

arduino/libretuya/core/LibreTuyaCustom.h

@@ -0,0 +1,96 @@
+/* Copyright (c) Kuba Szczodrzyński 2022-06-06. */
+
+#pragma once
+
+#include "LibreTuyaAPI.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/**
+ * @brief Run mainTask & start OS kernel (family-defined).
+ * Return false if an error occured; else do not return and
+ * and keep the OS kernel running.
+ */
+extern bool startMainTask();
+
+/**
+ * @brief Main setup() and loop() task.
+ * Not to be called directly.
+ */
+extern void mainTask(const void *arg);
+
+/**
+ * @brief Run periodic tasks, like printing free heap or checking millis() overflow.
+ *
+ * This is called during delaying operations, like yield() or delay().
+ */
+extern void runPeriodicTasks();
+
+#define PIN_NONE (1 << 0)
+#define PIN_GPIO (1 << 1)
+#define PIN_IRQ	 (1 << 2)
+#define PIN_PWM	 (1 << 3)
+#define PIN_ADC	 (1 << 4)
+#define PIN_DAC	 (1 << 5)
+#define PIN_I2C	 (1 << 6)
+#define PIN_I2S	 (1 << 7)
+#define PIN_JTAG (1 << 8)
+#define PIN_SPI	 (1 << 9)
+#define PIN_SWD	 (1 << 10)
+#define PIN_UART (1 << 11)
+
+typedef struct {
+	/**
+	 * @brief GPIO name in the family SDK.
+	 */
+	uint32_t gpio;
+	/**
+	 * @brief Supported pin functions.
+	 */
+	uint32_t supported;
+	/**
+	 * @brief Enabled pin functions. Used values are family-specific.
+	 */
+	uint32_t enabled;
+	/**
+	 * @brief Pin mode (direction, IRQ level, etc.).
+	 */
+	uint32_t mode;
+} PinInfo;
+
+extern PinInfo pinTable[];
+
+// Custom Wiring methods
+
+bool pinInvalid(pin_size_t pinNumber);
+PinInfo *pinInfo(pin_size_t pinNumber);
+bool pinSupported(PinInfo *pin, uint32_t mask);
+bool pinEnabled(PinInfo *pin, uint32_t mask);
+bool pinIsOutput(PinInfo *pin);
+bool pinIsInput(PinInfo *pin);
+
+int analogRead(pin_size_t pinNumber);
+void analogReadResolution(int res);
+void analogWriteResolution(int res);
+void analogWriteFrequency(int hz);
+void analogWritePeriod(int us);
+
+extern int _analogReadResolution;
+extern int _analogWriteResolution;
+extern int _analogWritePeriod;
+
+/**
+ * @brief Read voltage from analog input (in millivolts).
+ */
+uint16_t analogReadVoltage(pin_size_t pinNumber);
+
+/**
+ * @brief Get max reading voltage for the specified pin (millivolts).
+ */
+uint16_t analogReadMaxVoltage(pin_size_t pinNumber);
+
+#ifdef __cplusplus
+} // extern "C"
+#endif

arduino/libretuya/core/SerialExtern.h

@@ -0,0 +1,25 @@
+/* Copyright (c) Kuba Szczodrzyński 2022-07-04. */
+
+#pragma once
+
+#include <Arduino.h>
+
+#ifdef HAS_SERIAL_CLASS // failsafe for circular inclusion
+
+#ifdef PIN_SERIAL0_TX
+extern SerialClass Serial0;
+#endif
+
+#ifdef PIN_SERIAL1_TX
+extern SerialClass Serial1;
+#endif
+
+#ifdef PIN_SERIAL2_TX
+extern SerialClass Serial2;
+#endif
+
+#define SerialN(x) Serial##x
+#define SerialM(x) SerialN(x)
+#define Serial	   SerialM(LT_UART_DEFAULT_SERIAL)
+
+#endif

arduino/libretuya/core/lt_logger.c

@@ -1,8 +1,11 @@
+/* Copyright (c) Kuba Szczodrzyński 2022-04-28. */
+
 #include "lt_logger.h"
 
 #include <Arduino.h>
+#include <printf/printf.h>
 
-#if LT_LOGGER_TASK
+#if LT_LOGGER_TASK && LT_HAS_FREERTOS
 #include <FreeRTOS.h>
 #include <task.h>
 #endif
@@ -25,10 +28,11 @@
 #define COLOR_BRIGHT_CYAN	 0x16
 #define COLOR_BRIGHT_WHITE	 0x17
 
-const char levels[] = {'V', 'D', 'I', 'W', 'E', 'F'};
+static uint32_t uart_port  = LT_UART_DEFAULT_LOGGER;
+static const char levels[] = {'V', 'D', 'I', 'W', 'E', 'F'};
 
 #if LT_LOGGER_COLOR
-const uint8_t colors[] = {
+static const uint8_t colors[] = {
 	COLOR_BRIGHT_CYAN,
 	COLOR_BRIGHT_BLUE,
 	COLOR_BRIGHT_GREEN,
@@ -40,12 +44,15 @@ const uint8_t colors[] = {
 
 unsigned long millis(void);
 
-#if LT_LOGGER_FILE
-void lt_log(const uint8_t level, const char *filename, const unsigned short line, const char *format, ...) {
+#if LT_LOGGER_CALLER
+void lt_log(const uint8_t level, const char *caller, const unsigned short line, const char *format, ...) {
 #else
 void lt_log(const uint8_t level, const char *format, ...) {
 #endif
 
+	if (uart_port == 0xFF)
+		return;
+
 #if LT_LOGGER_TIMESTAMP
 	float seconds = millis() / 1000.0f;
 #if LT_PRINTF_BROKEN
@@ -55,7 +62,7 @@ void lt_log(const uint8_t level, const char *format, ...) {
 #endif
 #endif
 
-#if LT_LOGGER_TASK
+#if LT_LOGGER_TASK && LT_HAS_FREERTOS
 	char task_colon	  = ':';
 	TaskHandle_t task = xTaskGetCurrentTaskHandle();
 	char *task_name	  = pcTaskGetTaskName(task);
@@ -70,7 +77,10 @@ void lt_log(const uint8_t level, const char *format, ...) {
 	char c_value  = '0' + (colors[level] & 0x7);
 #endif
 
-	printf(
+	fctprintf(
+		(void (*)(char, void *))putchar_p,
+		(void *)uart_port,
+	// format:
 #if LT_LOGGER_COLOR
 		"\e[%c;3%cm"
 #endif
@@ -85,19 +95,19 @@ void lt_log(const uint8_t level, const char *format, ...) {
 #if LT_LOGGER_COLOR
 		"\e[0m"
 #endif
-#if LT_LOGGER_FILE
-		"%s:%hu: "
+#if LT_LOGGER_CALLER
+		"%s():%hu: "
 #endif
-#if LT_LOGGER_TASK
+#if LT_LOGGER_TASK && LT_HAS_FREERTOS
 		"%s%c "
 #endif
 		,
-		levels[level]
+	// arguments:
 #if LT_LOGGER_COLOR
-		,
 		c_bright, // whether text is bright
-		c_value	  // text color
+		c_value,  // text color
 #endif
+		levels[level]
 #if LT_LOGGER_TIMESTAMP
 		,
 		seconds // float
@@ -106,12 +116,12 @@ void lt_log(const uint8_t level, const char *format, ...) {
 		zero // append missing zeroes if printf "%11.3f" prints "0."
 #endif
 #endif
-#if LT_LOGGER_FILE
+#if LT_LOGGER_CALLER
 		,
-		filename,
+		caller,
 		line
 #endif
-#if LT_LOGGER_TASK
+#if LT_LOGGER_TASK && LT_HAS_FREERTOS
 		,
 		task_name,
 		task_colon // printing outside of tasks
@@ -120,7 +130,16 @@ void lt_log(const uint8_t level, const char *format, ...) {
 
 	va_list va_args;
 	va_start(va_args, format);
-	vprintf(format, va_args);
+	vfctprintf((void (*)(char, void *))putchar_p, (void *)uart_port, format, va_args);
 	va_end(va_args);
-	printf("\r\n");
+	putchar_p('\r', uart_port);
+	putchar_p('\n', uart_port);
+}
+
+void lt_log_set_port(uint8_t port) {
+	uart_port = port;
+}
+
+void lt_log_disable() {
+	uart_port = 0xFF;
 }

arduino/libretuya/core/lt_logger.h

@@ -0,0 +1,170 @@
+/* Copyright (c) Kuba Szczodrzyński 2022-04-28. */
+
+#pragma once
+
+#include "LibreTuyaConfig.h"
+#include <stdint.h>
+
+#if LT_LOGGER_CALLER
+#define LT_LOG(level, caller, line, ...) lt_log(level, caller, line, __VA_ARGS__)
+#define LT_LOGM(level, module, caller, line, ...)                                                                      \
+	do {                                                                                                               \
+		if (LT_DEBUG_##module) {                                                                                       \
+			lt_log(level, caller, line, #module ": " __VA_ARGS__);                                                     \
+		}                                                                                                              \
+	} while (0)
+void lt_log(const uint8_t level, const char *caller, const unsigned short line, const char *format, ...)
+	__attribute__((format(printf, 4, 5)));
+#else
+#define LT_LOG(level, caller, line, ...) lt_log(level, __VA_ARGS__)
+#define LT_LOGM(level, module, caller, line, ...)                                                                      \
+	do {                                                                                                               \
+		if (LT_DEBUG_##module) {                                                                                       \
+			lt_log(level, #module ": " __VA_ARGS__);                                                                   \
+		}                                                                                                              \
+	} while (0)
+void lt_log(const uint8_t level, const char *format, ...) __attribute__((format(printf, 2, 3)));
+#endif
+
+/**
+ * @brief Change log output port.
+ *
+ * @param port UART port index - can be 0, 1 or 2
+ */
+void lt_log_set_port(uint8_t port);
+
+/**
+ * @brief Disable LT logger. Enable it back using lt_log_set_port(LT_UART_DEFAULT_LOGGER).
+ */
+void lt_log_disable();
+
+#if LT_LEVEL_TRACE >= LT_LOGLEVEL
+#define LT_T(...)		   LT_LOG(LT_LEVEL_TRACE, __FUNCTION__, __LINE__, __VA_ARGS__)
+#define LT_V(...)		   LT_LOG(LT_LEVEL_TRACE, __FUNCTION__, __LINE__, __VA_ARGS__)
+#define LT_TM(module, ...) LT_LOGM(LT_LEVEL_TRACE, module, __FUNCTION__, __LINE__, __VA_ARGS__)
+#define LT_VM(module, ...) LT_LOGM(LT_LEVEL_TRACE, module, __FUNCTION__, __LINE__, __VA_ARGS__)
+#else
+#define LT_T(...)
+#define LT_V(...)
+#define LT_TM(...)
+#define LT_VM(...)
+#endif
+
+#if LT_LEVEL_DEBUG >= LT_LOGLEVEL
+#define LT_D(...)		   LT_LOG(LT_LEVEL_DEBUG, __FUNCTION__, __LINE__, __VA_ARGS__)
+#define LT_DM(module, ...) LT_LOGM(LT_LEVEL_DEBUG, module, __FUNCTION__, __LINE__, __VA_ARGS__)
+#else
+#define LT_D(...)
+#define LT_DM(...)
+#endif
+
+#if LT_LEVEL_INFO >= LT_LOGLEVEL
+#define LT_I(...)		   LT_LOG(LT_LEVEL_INFO, __FUNCTION__, __LINE__, __VA_ARGS__)
+#define LT_IM(module, ...) LT_LOGM(LT_LEVEL_INFO, module, __FUNCTION__, __LINE__, __VA_ARGS__)
+#else
+#define LT_I(...)
+#define LT_IM(...)
+#endif
+
+#if LT_LEVEL_WARN >= LT_LOGLEVEL
+#define LT_W(...)		   LT_LOG(LT_LEVEL_WARN, __FUNCTION__, __LINE__, __VA_ARGS__)
+#define LT_WM(module, ...) LT_LOGM(LT_LEVEL_WARN, module, __FUNCTION__, __LINE__, __VA_ARGS__)
+#else
+#define LT_W(...)
+#define LT_WM(...)
+#endif
+
+#if LT_LEVEL_ERROR >= LT_LOGLEVEL
+#define LT_E(...)		   LT_LOG(LT_LEVEL_ERROR, __FUNCTION__, __LINE__, __VA_ARGS__)
+#define LT_EM(module, ...) LT_LOGM(LT_LEVEL_ERROR, module, __FUNCTION__, __LINE__, __VA_ARGS__)
+#else
+#define LT_E(...)
+#define LT_EM(...)
+#endif
+
+#if LT_LEVEL_FATAL >= LT_LOGLEVEL
+#define LT_F(...)		   LT_LOG(LT_LEVEL_FATAL, __FUNCTION__, __LINE__, __VA_ARGS__)
+#define LT_FM(module, ...) LT_LOGM(LT_LEVEL_FATAL, module, __FUNCTION__, __LINE__, __VA_ARGS__)
+#else
+#define LT_F(...)
+#define LT_FM(...)
+#endif
+
+#if LT_LOG_HEAP
+#define LT_HEAP_I() LT_I("Free heap: %u", LT_HEAP_FUNC());
+#else
+#define LT_HEAP_I()
+#endif
+
+// ESP32 compat
+#define log_printf(...)		LT_I(__VA_ARGS__)
+#define log_v(...)			LT_V(__VA_ARGS__)
+#define log_d(...)			LT_D(__VA_ARGS__)
+#define log_i(...)			LT_I(__VA_ARGS__)
+#define log_w(...)			LT_W(__VA_ARGS__)
+#define log_e(...)			LT_E(__VA_ARGS__)
+#define log_n(...)			LT_E(__VA_ARGS__)
+#define isr_log_v(...)		LT_V(__VA_ARGS__)
+#define isr_log_d(...)		LT_D(__VA_ARGS__)
+#define isr_log_i(...)		LT_I(__VA_ARGS__)
+#define isr_log_w(...)		LT_W(__VA_ARGS__)
+#define isr_log_e(...)		LT_E(__VA_ARGS__)
+#define isr_log_n(...)		LT_E(__VA_ARGS__)
+#define ESP_LOGV(...)		LT_V(__VA_ARGS__)
+#define ESP_LOGD(...)		LT_D(__VA_ARGS__)
+#define ESP_LOGI(...)		LT_I(__VA_ARGS__)
+#define ESP_LOGW(...)		LT_W(__VA_ARGS__)
+#define ESP_LOGE(...)		LT_E(__VA_ARGS__)
+#define ESP_EARLY_LOGV(...) LT_V(__VA_ARGS__)
+#define ESP_EARLY_LOGD(...) LT_D(__VA_ARGS__)
+#define ESP_EARLY_LOGI(...) LT_I(__VA_ARGS__)
+#define ESP_EARLY_LOGW(...) LT_W(__VA_ARGS__)
+#define ESP_EARLY_LOGE(...) LT_E(__VA_ARGS__)
+#define ets_printf(...)		LT_I(__VA_ARGS__)
+#define ETS_PRINTF(...)		LT_I(__VA_ARGS__)
+
+#define LT_RET(ret)                                                                                                    \
+	LT_E("ret=%d", ret);                                                                                               \
+	return ret;
+
+#define LT_RET_NZ(ret)                                                                                                 \
+	if (ret) {                                                                                                         \
+		LT_E("ret=%d", ret);                                                                                           \
+		return ret;                                                                                                    \
+	}
+#define LT_RET_LZ(ret)                                                                                                 \
+	if (ret < 0) {                                                                                                     \
+		LT_E("ret=%d", ret);                                                                                           \
+		return ret;                                                                                                    \
+	}
+#define LT_RET_LEZ(ret)                                                                                                \
+	if (ret <= 0) {                                                                                                    \
+		LT_E("ret=%d", ret);                                                                                           \
+		return ret;                                                                                                    \
+	}
+
+#define LT_ERRNO_NZ(ret)                                                                                               \
+	if (ret) {                                                                                                         \
+		LT_E("errno=%d, ret=%d", errno, ret);                                                                          \
+		return ret;                                                                                                    \
+	}
+#define LT_ERRNO_LZ(ret)                                                                                               \
+	if (ret < 0) {                                                                                                     \
+		LT_E("errno=%d, ret=%d", errno, ret);                                                                          \
+		return ret;                                                                                                    \
+	}
+#define LT_ERRNO_LEZ(ret)                                                                                              \
+	if (ret <= 0) {                                                                                                    \
+		LT_E("errno=%d, ret=%d", errno, ret);                                                                          \
+		return ret;                                                                                                    \
+	}
+
+#if LT_LOG_ERRNO
+#define LT_ERRNO()                                                                                                     \
+	if (errno) {                                                                                                       \
+		LT_E("errno=%d", errno);                                                                                       \
+		errno = 0;                                                                                                     \
+	}
+#else
+#define LT_ERRNO()
+#endif

arduino/libretuya/core/main.cpp

@@ -0,0 +1,74 @@
+/* Copyright (c) Kuba Szczodrzyński 2022-06-19. */
+
+#include <Arduino.h>
+#include <api/HardwareSerial.h>
+
+using namespace arduino;
+
+extern "C" {
+#include <fal.h>
+fal_partition_t fal_root_part = NULL;
+}
+
+// Arduino framework initialization.
+// May be redefined by family files.
+void initArduino() __attribute__((weak));
+
+// Weak empty variant initialization function.
+// May be redefined by variant files.
+void initVariant() __attribute__((weak));
+
+// Initialize C library
+extern "C" void __libc_init_array(void);
+
+void mainTask(const void *arg) {
+	setup();
+
+	for (;;) {
+		loop();
+		if (serialEventRun)
+			serialEventRun();
+		yield();
+	}
+}
+
+static unsigned long periodicTasks[] = {0, 0};
+
+void runPeriodicTasks() {
+#if LT_LOG_HEAP
+	if (millis() - periodicTasks[0] > 1000) {
+		LT_HEAP_I();
+		periodicTasks[0] = millis();
+	}
+#endif
+#if LT_USE_TIME
+	if (millis() - periodicTasks[1] > 10000) {
+		gettimeofday(NULL, NULL);
+		periodicTasks[1] = millis();
+	}
+#endif
+}
+
+int main(void) {
+	// print a startup banner
+	LT_BANNER();
+	// initialize C library
+	__libc_init_array();
+	// inform about the reset reason
+	LT_I("Reset reason: %u", LT.getResetReason());
+	// initialize Arduino framework
+	initArduino();
+	// optionally initialize per-variant code
+	initVariant();
+	// initialize FAL
+	fal_init();
+	// provide root partition
+	fal_root_part = (fal_partition_t)fal_partition_find("root");
+	// start the main task and OS kernel
+	if (!startMainTask()) {
+		LT_F("Couldn't start the main task");
+	}
+
+	while (1) {}
+	return 0;
+}

arduino/libretuya/libraries/Flash/Flash.cpp

@@ -0,0 +1,30 @@
+/* Copyright (c) Kuba Szczodrzyński 2022-04-24. */
+
+#include "Flash.h"
+
+extern "C" {
+#include <fal.h>
+}
+
+// Global Flash object.
+FlashClass Flash;
+
+FlashId FlashClass::getChipId() {
+	return LT.getFlashChipId();
+}
+
+uint32_t FlashClass::getSize() {
+	return LT.getFlashChipSize();
+}
+
+bool FlashClass::eraseSector(uint32_t offset) {
+	return fal_partition_erase(fal_root_part, offset, 1) >= 0;
+}
+
+bool FlashClass::readBlock(uint32_t offset, uint8_t *data, size_t size) {
+	return fal_partition_read(fal_root_part, offset, data, size) >= 0;
+}
+
+bool FlashClass::writeBlock(uint32_t offset, uint8_t *data, size_t size) {
+	return fal_partition_write(fal_root_part, offset, data, size) >= 0;
+}

arduino/libretuya/libraries/Flash/Flash.h

@@ -1,19 +1,11 @@
+/* Copyright (c) Kuba Szczodrzyński 2022-04-24. */
+
 #pragma once
 
-#include "api/Flash.h"
-
-struct flash_s;
-typedef struct flash_s flash_t;
-
-class FlashClass : public IFlashClass {
-  private:
-	flash_t *flash;
-	void initialize();
+#include <Arduino.h>
 
+class FlashClass {
   public:
-	FlashClass();
-	~FlashClass();
-
 	FlashId getChipId();
 	uint32_t getSize();
 

arduino/libretuya/libraries/HTTPClient/HTTPClient.h

@@ -0,0 +1,305 @@
+/**
+ * HTTPClient.h
+ *
+ * Created on: 02.11.2015
+ *
+ * Copyright (c) 2015 Markus Sattler. All rights reserved.
+ * This file is part of the HTTPClient for Arduino.
+ * Port to ESP32 by Evandro Luis Copercini (2017),
+ * changed fingerprints to CA verification.
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 2.1 of the License, or (at your option) any later version.
+ *
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this library; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
+ *
+ */
+
+#ifndef HTTPClient_H_
+#define HTTPClient_H_
+
+#ifndef HTTPCLIENT_1_1_COMPATIBLE
+#define HTTPCLIENT_1_1_COMPATIBLE
+#endif
+
+#include <Arduino.h>
+#include <WiFiClient.h>
+#include <WiFiClientSecure.h>
+#include <memory>
+
+/// Cookie jar support
+#include <vector>
+
+#define HTTPCLIENT_DEFAULT_TCP_TIMEOUT (5000)
+
+/// HTTP client errors
+#define HTTPC_ERROR_CONNECTION_REFUSED	(-1)
+#define HTTPC_ERROR_SEND_HEADER_FAILED	(-2)
+#define HTTPC_ERROR_SEND_PAYLOAD_FAILED (-3)
+#define HTTPC_ERROR_NOT_CONNECTED		(-4)
+#define HTTPC_ERROR_CONNECTION_LOST		(-5)
+#define HTTPC_ERROR_NO_STREAM			(-6)
+#define HTTPC_ERROR_NO_HTTP_SERVER		(-7)
+#define HTTPC_ERROR_TOO_LESS_RAM		(-8)
+#define HTTPC_ERROR_ENCODING			(-9)
+#define HTTPC_ERROR_STREAM_WRITE		(-10)
+#define HTTPC_ERROR_READ_TIMEOUT		(-11)
+
+/// size for the stream handling
+#define HTTP_TCP_BUFFER_SIZE (1460)
+
+/// HTTP codes see RFC7231
+typedef enum {
+	HTTP_CODE_CONTINUE						  = 100,
+	HTTP_CODE_SWITCHING_PROTOCOLS			  = 101,
+	HTTP_CODE_PROCESSING					  = 102,
+	HTTP_CODE_OK							  = 200,
+	HTTP_CODE_CREATED						  = 201,
+	HTTP_CODE_ACCEPTED						  = 202,
+	HTTP_CODE_NON_AUTHORITATIVE_INFORMATION	  = 203,
+	HTTP_CODE_NO_CONTENT					  = 204,
+	HTTP_CODE_RESET_CONTENT					  = 205,
+	HTTP_CODE_PARTIAL_CONTENT				  = 206,
+	HTTP_CODE_MULTI_STATUS					  = 207,
+	HTTP_CODE_ALREADY_REPORTED				  = 208,
+	HTTP_CODE_IM_USED						  = 226,
+	HTTP_CODE_MULTIPLE_CHOICES				  = 300,
+	HTTP_CODE_MOVED_PERMANENTLY				  = 301,
+	HTTP_CODE_FOUND							  = 302,
+	HTTP_CODE_SEE_OTHER						  = 303,
+	HTTP_CODE_NOT_MODIFIED					  = 304,
+	HTTP_CODE_USE_PROXY						  = 305,
+	HTTP_CODE_TEMPORARY_REDIRECT			  = 307,
+	HTTP_CODE_PERMANENT_REDIRECT			  = 308,
+	HTTP_CODE_BAD_REQUEST					  = 400,
+	HTTP_CODE_UNAUTHORIZED					  = 401,
+	HTTP_CODE_PAYMENT_REQUIRED				  = 402,
+	HTTP_CODE_FORBIDDEN						  = 403,
+	HTTP_CODE_NOT_FOUND						  = 404,
+	HTTP_CODE_METHOD_NOT_ALLOWED			  = 405,
+	HTTP_CODE_NOT_ACCEPTABLE				  = 406,
+	HTTP_CODE_PROXY_AUTHENTICATION_REQUIRED	  = 407,
+	HTTP_CODE_REQUEST_TIMEOUT				  = 408,
+	HTTP_CODE_CONFLICT						  = 409,
+	HTTP_CODE_GONE							  = 410,
+	HTTP_CODE_LENGTH_REQUIRED				  = 411,
+	HTTP_CODE_PRECONDITION_FAILED			  = 412,
+	HTTP_CODE_PAYLOAD_TOO_LARGE				  = 413,
+	HTTP_CODE_URI_TOO_LONG					  = 414,
+	HTTP_CODE_UNSUPPORTED_MEDIA_TYPE		  = 415,
+	HTTP_CODE_RANGE_NOT_SATISFIABLE			  = 416,
+	HTTP_CODE_EXPECTATION_FAILED			  = 417,
+	HTTP_CODE_MISDIRECTED_REQUEST			  = 421,
+	HTTP_CODE_UNPROCESSABLE_ENTITY			  = 422,
+	HTTP_CODE_LOCKED						  = 423,
+	HTTP_CODE_FAILED_DEPENDENCY				  = 424,
+	HTTP_CODE_UPGRADE_REQUIRED				  = 426,
+	HTTP_CODE_PRECONDITION_REQUIRED			  = 428,
+	HTTP_CODE_TOO_MANY_REQUESTS				  = 429,
+	HTTP_CODE_REQUEST_HEADER_FIELDS_TOO_LARGE = 431,
+	HTTP_CODE_INTERNAL_SERVER_ERROR			  = 500,
+	HTTP_CODE_NOT_IMPLEMENTED				  = 501,
+	HTTP_CODE_BAD_GATEWAY					  = 502,
+	HTTP_CODE_SERVICE_UNAVAILABLE			  = 503,
+	HTTP_CODE_GATEWAY_TIMEOUT				  = 504,
+	HTTP_CODE_HTTP_VERSION_NOT_SUPPORTED	  = 505,
+	HTTP_CODE_VARIANT_ALSO_NEGOTIATES		  = 506,
+	HTTP_CODE_INSUFFICIENT_STORAGE			  = 507,
+	HTTP_CODE_LOOP_DETECTED					  = 508,
+	HTTP_CODE_NOT_EXTENDED					  = 510,
+	HTTP_CODE_NETWORK_AUTHENTICATION_REQUIRED = 511
+} t_http_codes;
+
+typedef enum { HTTPC_TE_IDENTITY, HTTPC_TE_CHUNKED } transferEncoding_t;
+
+/**
+ * redirection follow mode.
+ * + `HTTPC_DISABLE_FOLLOW_REDIRECTS` - no redirection will be followed.
+ * + `HTTPC_STRICT_FOLLOW_REDIRECTS` - strict RFC2616, only requests using
+ *      GET or HEAD methods will be redirected (using the same method),
+ *      since the RFC requires end-user confirmation in other cases.
+ * + `HTTPC_FORCE_FOLLOW_REDIRECTS` - all redirections will be followed,
+ *      regardless of a used method. New request will use the same method,
+ *      and they will include the same body data and the same headers.
+ *      In the sense of the RFC, it's just like every redirection is confirmed.
+ */
+typedef enum {
+	HTTPC_DISABLE_FOLLOW_REDIRECTS,
+	HTTPC_STRICT_FOLLOW_REDIRECTS,
+	HTTPC_FORCE_FOLLOW_REDIRECTS
+} followRedirects_t;
+
+#ifdef HTTPCLIENT_1_1_COMPATIBLE
+class TransportTraits;
+typedef std::unique_ptr<TransportTraits> TransportTraitsPtr;
+#endif
+
+// cookie jar support
+typedef struct {
+	String host; // host which tries to set the cookie
+	time_t date; // timestamp of the response that set the cookie
+	String name;
+	String value;
+	String domain;
+	String path = "";
+
+	struct {
+		time_t date = 0;
+		bool valid	= false;
+	} expires;
+
+	struct {
+		time_t duration = 0;
+		bool valid		= false;
+	} max_age;
+
+	bool http_only = false;
+	bool secure	   = false;
+} Cookie;
+
+typedef std::vector<Cookie> CookieJar;
+
+class HTTPClient {
+  public:
+	HTTPClient();
+	~HTTPClient();
+
+	/*
+	 * Since both begin() functions take a reference to client as a parameter, you need to
+	 * ensure the client object lives the entire time of the HTTPClient
+	 */
+	bool begin(WiFiClient &client, String url);
+	bool begin(WiFiClient &client, String host, uint16_t port, String uri = "/", bool https = false);
+
+#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
+
+	void end(void);
+
+	bool connected(void);
+
+	void setReuse(bool reuse); /// keep-alive
+	void setUserAgent(const String &userAgent);
+	void setAuthorization(const char *user, const char *password);
+	void setAuthorization(const char *auth);
+	void setAuthorizationType(const char *authType);
+	void setConnectTimeout(int32_t connectTimeout);
+	void setTimeout(uint16_t timeout);
+
+	// Redirections
+	void setFollowRedirects(followRedirects_t follow);
+	void setRedirectLimit(uint16_t limit); // max redirects to follow for a single request
+
+	bool setURL(const String &url);
+	void useHTTP10(bool usehttp10 = true);
+
+	/// request handling
+	int GET();
+	int PATCH(uint8_t *payload, size_t size);
+	int PATCH(String payload);
+	int POST(uint8_t *payload, size_t size);
+	int POST(String payload);
+	int PUT(uint8_t *payload, size_t size);
+	int PUT(String payload);
+	int sendRequest(const char *type, String payload);
+	int sendRequest(const char *type, uint8_t *payload = NULL, size_t size = 0);
+	int sendRequest(const char *type, Stream *stream, size_t size = 0);
+
+	void addHeader(const String &name, const String &value, bool first = false, bool replace = true);
+
+	/// Response handling
+	void collectHeaders(const char *headerKeys[], const size_t headerKeysCount);
+	String header(const char *name);  // get request header value by name
+	String header(size_t i);		  // get request header value by number
+	String headerName(size_t i);	  // get request header name by number
+	int headers();					  // get header count
+	bool hasHeader(const char *name); // check if header exists
+
+	int getSize(void);
+	const String &getLocation(void);
+
+	WiFiClient &getStream(void);
+	WiFiClient *getStreamPtr(void);
+	int writeToStream(Stream *stream);
+	// String getString(void);
+
+	static String errorToString(int error);
+
+	/// Cookie jar support
+	void setCookieJar(CookieJar *cookieJar);
+	void resetCookieJar();
+	void clearAllCookies();
+
+  protected:
+	struct RequestArgument {
+		String key;
+		String value;
+	};
+
+	bool beginInternal(String url, const char *expectedProtocol);
+	void disconnect(bool preserveClient = false);
+	void clear();
+	int returnError(int error);
+	bool connect(void);
+	bool sendHeader(const char *type);
+	int handleHeaderResponse();
+	int writeToStreamDataBlock(Stream *stream, int len);
+
+	/// Cookie jar support
+	void setCookie(String date, String headerValue);
+	bool generateCookieString(String *cookieString);
+
+#ifdef HTTPCLIENT_1_1_COMPATIBLE
+	TransportTraitsPtr _transportTraits;
+	std::unique_ptr<WiFiClient> _tcpDeprecated;
+#endif
+
+	WiFiClient *_client = nullptr;
+
+	/// request handling
+	String _host;
+	uint16_t _port			= 0;
+	int32_t _connectTimeout = -1;
+	bool _reuse				= true;
+	uint16_t _tcpTimeout	= HTTPCLIENT_DEFAULT_TCP_TIMEOUT;
+	bool _useHTTP10			= false;
+	bool _secure			= false;
+
+	String _uri;
+	String _protocol;
+	String _headers;
+	String _userAgent = "ESP32HTTPClient";
+	String _base64Authorization;
+	String _authorizationType = "Basic";
+
+	/// Response handling
+	RequestArgument *_currentHeaders = nullptr;
+	size_t _headerKeysCount			 = 0;
+
+	int _returnCode					   = 0;
+	int _size						   = -1;
+	bool _canReuse					   = false;
+	followRedirects_t _followRedirects = HTTPC_DISABLE_FOLLOW_REDIRECTS;
+	uint16_t _redirectLimit			   = 10;
+	String _location;
+	transferEncoding_t _transferEncoding = HTTPC_TE_IDENTITY;
+
+	/// Cookie jar support
+	CookieJar *_cookieJar = nullptr;
+};
+
+#endif /* HTTPClient_H_ */

arduino/libretuya/libraries/HTTPClient/strptime.h

@@ -0,0 +1,7 @@
+/* Copyright (c) Kuba Szczodrzyński 2022-04-29. */
+
+#pragma once
+
+#include <time.h>
+
+extern char *strptime(const char *buf, const char *fmt, struct tm *tm);