Tasmota

https://tasmota.github.io/docs
Admin
Tasmota is an open-source alternative firmware for Espressif ESP8266 and ESP32 based smart home...
Tokens:1,503,482
Snippets:8,895
Trust Score:8.3
Update:1 day ago
Show doc for...
Tokens:
Raw
### Initial register setup example

Source: https://tasmota.github.io/docs/Universal-Display-Driver/

Example of the :I directive for initial register setup of a display controller. All values are in hex; on SPI the first value is the command, then the number of arguments, then the arguments.

```text
:I
EF,3,03,80,02
CF,3,00,C1,30
ED,4,64,03,12,81
E8,3,85,00,78
CB,5,39,2C,00,34,02
F7,1,20
EA,2,00,00
C0,1,23
C1,1,10
C5,2,3e,28
C7,1,86
36,1,48
37,1,00
3A,1,55
B1,2,00,18
B6,3,08,82,27
F2,1,00
26,1,01
E0,0F,0F,31,2B,0C,0E,08,4E,F1,37,07,10,03,0E,09,00
E1,0F,00,0E,14,03,11,07,31,C1,48,08,0F,0C,31,36,0F
11,80
29,80
#
```

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

### Splash setup example

Source: https://tasmota.github.io/docs/Universal-Display-Driver/

Example of the :S directive for splash screen setup, defining font, size, colors, and text position.

```text
:S,2,1,1,0,40,20
```

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

### display.bat example

Source: https://tasmota.github.io/docs/UFS/

Example content for display.bat, which stores display commands executed at boot. Lines starting with semicolon are comments. Commands are executed sequentially.

```plaintext
; clr screen
[z]
; draw full screen picture - corona.rgb file must exist in UFS storage
[x0y0P/corona.rgb]
; define index color
[dc19:31000]
; draw transparent text with new index color
[x60y30f2Ci19D2]Tasmota
```

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

### ESP32 Webcam Scripting Example

Source: https://tasmota.github.io/docs/Scripting-Language/

Complete Tasmota script for webcam initialization, motion detection, and streaming. Uses wc() commands to init with QVGA, get dimensions, start motion detector, and stream when WiFi is up. Displays motion diff and brightness in WEBUI.

```tasmota
    >D
    res=0
    w=0
    h=0
    mot=0
    bri=0

    >B
    ; init cam with QVGA
    res=wc(0 4)
    ; get pixel size
    w=wc(3)
    h=wc(4)
    ; start motion detector, picture every 1000 ms
    mot=wc(6 1000)

    >S
    if wific>0
    then
    ; when wifi up, start stream
    res=wc(5 1)
    endif

    ; get motion detect diff value
    mot=wc(6 -1)
    ; get picture brightnes
    bri=wc(6 -2)

    >W
    <center>motion diff = %mot%<br>
    <center>brightness = %bri%<br>
    ; show stream on WEBUI
    &<br>
    &<img src="http://%lip%:81/stream" style="width:%w%px;height:%h%px">
    &<br><center>webcam stream
```

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

### Examples

Source: https://tasmota.github.io/docs/Zigbee/

Practical examples for sending commands to a plug and a bulb, including reading status.

```APIDOC
## Examples

### Plug

Send Power commands:
```json
ZbSend { "device":"0x4773", "send":{"Power":"On"} }
ZbSend { "device":"0x4773", "send":{"Power":1} }
ZbSend { "device":"0x4773", "send":{"Power":false} }
ZbSend { "device":"0x4773", "send":{"Power":"Toggle"} }
```

Read On/Off status (all three are synonyms):
```json
ZbSend { "device":"0x4773", "endpoint":"0x03", "cluster":"0x0006", "read":"0x0000" }
ZbSend { "device":"0x4773", "endpoint":"0x03", "cluster":"0x0006", "read":["0x0000"] }
ZbSend { "device":"0x4773", "endpoint":3, "cluster":6, "read":0 }
```

Response example (MQTT telemetry):
```json
MQT: tele/tasmota/SENSOR = {"ZbReceived":{"0x4773":{"Power":true,"LinkQuality":52}}}
```

### Bulb

```json
ZbSend { "device":"0x3D82", "send":{"Power":"Off"} }
ZbSend { "device":"0x3D82", "send":{"Dimmer":128} }
ZbSend { "device":"0x3D82", "send":{"Dimmer":254} }
ZbSend { "device":"0x3D82", "endpoint":"0x0B", "send":{"Dimmer":0} }
```
```

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

### webclient download binary to file example

Source: https://tasmota.github.io/docs/Berry/

Interactive Berry console session using webclient to perform an HTTPS GET request and write the response to a file with cl.write_file. Demonstrates downloading binary content to the file-system.

```berry
> cl = webclient()
> cl.begin("https://raw.githubusercontent.com/tasmota/autoconf/main/esp32/M5Stack_Fire_autoconf.zip")
<instance: webclient()>

> r = cl.GET()
> print(r)
200

> cl.write_file("M5Stack_Fire_autoconf.zip")
950
```

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

### WcInit

Source: https://tasmota.github.io/docs/Commands/

Initialize camera.

```APIDOC
## WcInit

### Description
Initialize camera.

### Command
WcInit

### Parameters
None

```

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

### Simple video player using cam module

Source: https://tasmota.github.io/docs/Berry/

Example for boards with a camera and a display. It sets up the camera with cam.setup(5) for 240x240 resolution, captures images into an img instance, and creates an LVGL image descriptor to display the buffer. The video() function updates the image buffer and invalidates the view at a target of 50 Hz.

```berry
# Simple "video player" for boards with a camera and a display

scr = lv.scr_act()
scr.set_style_bg_color(lv.color(lv.COLOR_BLUE), lv.PART_MAIN | lv.STATE_DEFAULT)

# create a lv_img object as image view
cam_view = lv.img(scr)
cam_view.center()

i = img()

import cam
cam.setup(5) # 240 x 240
cam.get_image(i,i.RGB565LE)

def lv_img_dsc(image)
    var i = image.info()
    var dsc = bytes(24)
    dsc..0x19 # magic
    dsc..0x12 # cf RGB565
    dsc.add(0,2) # flags
    dsc.add(i["width"],2) # width
    dsc.add(i["height"],2) # height
    dsc.add(i["width"] * 2,2) # stride
    dsc.add(0,2) # reserved
    dsc.add(i["size"],4) # size
    dsc.add(i["buf_addr"],4) # data
    dsc.add(0,4) # reserved
    print(dsc)
    return dsc
end

descriptor = lv_img_dsc(i)
cam_view.set_src(descriptor) # bind cam_view to buffer of img

def video()
    cam.get_image(i,i.RGB565LE) # this will just update the buffer, no reallocation
    cam_view.invalidate()
    tasmota.set_timer(20,/->video()) # aim for 50 Hz
end

video()
```

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

### Linux: Install and start Wi-Fi sniffing tools (aircrack-ng, wireshark)

Source: https://tasmota.github.io/docs/FAQ/

Commands to install and start Wi-Fi sniffing tools on Linux to discover the misconfigured SSID. Run these commands in a terminal, replacing the interface name (e.g., wlp58s0 or wlan0) as needed.

```bash
apt install aircrack-ng wireshark
airmon-ng check kill
airmon-ng start (e.g. wlp58s0 or wlan0)
wireshark
```

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

### Batch file example

Source: https://tasmota.github.io/docs/Displays/

Example display.bat file content. Executed when present in the file system. Comment lines start with a semicolon.

```plaintext
; clr screen
[z]
; draw full screen picture
[x0y0P/corona.rgb:]
; define index color
[dc19:31000]
; draw transparent text with new index color over picture
[x60y30f2Ci19D2]Tasmota
```

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

### Create and use a Greeter object

Source: https://tasmota.github.io/docs/Berry-Introduction/

Shows how to instantiate a Greeter with a name and call its methods. The output demonstrates the expected responses.

```berry
> greeter = Greeter("Pat")
> greeter.say_hi()
Hi Pat
> greeter.say_bye()
Bye Pat, come back soon.
```

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

### display.start

Source: https://tasmota.github.io/docs/Berry/

Initializes the Universal Display Driver with a string similar to the content of display.ini.

```APIDOC
## display.start

### Description
Initializes the Universal Display Driver with the provided string, similar to the content of `display.ini`. Typically read from a file in the file-system.

### Method
Function call

### Endpoint
`display.start(displayini:string) -> nil`

### Parameters
- **displayini** (string) - Required - The display configuration string.

### Returns
`nil`
```

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

### Raw IR code example from Tasmota

Source: https://tasmota.github.io/docs/IRSend-RAW-Encoding/

Example of raw IR codes captured using Tasmota, showing the typical long Mark-Space-Mark-Space start sequence followed by the bitstream.

```text
[3094,3062,3092,4442,576,1652,578,528,576,1650,580,528,576,528,576,1650,...]
```

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

### Update pip

Source: https://tasmota.github.io/docs/Create-your-own-Firmware-Build-without-IDE/

Upgrades pip to the latest version (18.1 in this example) before proceeding with the build setup.

```bash
(platformio-core) [tasmota_builder@jtest platformio-core]$ pip install --upgrade pip
Collecting pip
  Downloading https://files.pythonhosted.org/packages/c2/d7/90f34cb0d83a6c5631cf71dfe64cc1054598c843a92b400e55675cc2ac37/pip-18.1-py2.py3-none-any.whl (1.3MB)
    100% |████████████████████████████████| 1.3MB 793kB/s 
Installing collected packages: pip
  Found existing installation: pip 9.0.1
    Uninstalling pip-9.0.1:
      Successfully uninstalled pip-9.0.1
Successfully installed pip-18.1
```

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

### Directory structure example

Source: https://tasmota.github.io/docs/Tasmota-Extension/

Shows the required folder layout under raw/ with manifest.json, autoexec.be, and your_extension.be.

```text
raw/
└── Your_Extension_Name/
    ├── manifest.json
    ├── autoexec.be
    └── your_extension.be
```

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

### tcpclient full example: connect, write, read, close

Source: https://tasmota.github.io/docs/Berry/

Complete example of using the tcpclient class to connect to a server, send an HTTP GET request, poll for available data, read the response, and close the connection. The example uses a hardcoded IP address and port 80.

```berry
tcp = tcpclient()
tcp.connect("192.168.2.204", 80)
print("connected:", tcp.connected())
s= "GET / HTTP/1.0\r\n\r\n"
tcp.write(s)
print("available1:", tcp.available())
tasmota.delay(100)
print("available1:", tcp.available())
r = tcp.read()
tcp.close()
print(r)
```

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

### cam.setup

Source: https://tasmota.github.io/docs/Berry/

Initializes the camera hardware with a specified resolution mode, corresponding to the `wcresolution` command value.

```APIDOC
## cam.setup

### Description
Initializes the camera hardware with the given resolution mode. The mode value corresponds to the `wcresolution` command.

### Method
Function call

### Endpoint
`cam.setup(mode:int) -> bool`

### Parameters
- **mode** (int) - Required - Resolution mode, same as `wcresolution` command.

### Returns
- **bool** - `true` on success, `false` on failure.

```

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

### Krinner Lumix IR Remote - HttpGetRequest Example

Source: https://tasmota.github.io/docs/Codes-for-IR-Remotes/

Example of sending a raw IR command via HTTP GET request to a Tasmota device. The URL encodes the irsend command with raw timing data.

```plaintext
sendHttpGetRequest("http://192.168.1.234/cm?cmnd=irsend5%200,2000,1000,%20400,1000,%20400,%20400,1000,1000,%20400,1000,%20400,%20400,1000,%20400,1000,%20400,1000,%20400,2000,5600")
```

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

### webclient GET text response example

Source: https://tasmota.github.io/docs/Berry/

Interactive Berry console session using webclient to perform an HTTP GET request to a URL and print the response status and body. Demonstrates cl.begin, cl.GET, and cl.get_string.

```berry
> cl = webclient()
> cl.begin("http://ota.tasmota.com/tasmota32/release/")
<instance: webclient()>

> r = cl.GET()
> print(r)
200

> s = cl.get_string()
> print(s)
<pre>
<b></b>Alternative firmware for ESP32 based devices with web UI,
[.../...]
```

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

### ZbInfo command example

Source: https://tasmota.github.io/docs/Zigbee/

Shows the ZbInfo command and its MQTT result with detailed device information for two devices.

```text
18:38:51.523 CMD: ZbInfo
18:38:51.532 MQT: tele/xxx/SENSOR = {"ZbInfo":{"0xECD0":{"Device":"0xECD0","Name":"IKEA_Bulb","IEEEAddr":"0x90FD9FFFFE03B051","ModelId":"TRADFRI bulb E27 WS opal 980lm","Manufacturer":"IKEA of Sweden","Endpoints":[1],"Config":["O01","L01.2"],"Power":1,"Dimmer":160,"X":30138,"Y":26909,"CT":350,"ColorMode":2,"RGB":"FFC773","RGBb":"A17E49","Reachable":true,"LastSeen":353,"LastSeenEpoch":1658349178,"LinkQuality":79}}}
18:38:51.570 MQT: tele/xxxx/SENSOR = {"ZbInfo":{"0x8959":{"Device":"0x8959","Name":"Plug","IEEEAddr":"0x7CB03EAA0A0292DD","ModelId":"Plug 01","Manufacturer":"OSRAM","Endpoints":[3],"Config":["L03.0","O03"],"Dimmer":254,"Power":0,"Reachable":false,"LastSeen":16607299,"LastSeenEpoch":1641742232,"LinkQuality":147}}}
```

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

### ZDO_STARTUP_FROM_APP

Source: https://tasmota.github.io/docs/_media/zigbee/Z-Stack_API_1_2.pdf

Starts the device in the network. SREQ command with StartDelay attribute. Returns a status indicating the network state after startup.

```APIDOC
## ZDO_STARTUP_FROM_APP

### Description
This command starts the device in the network.

### Method
SREQ (Command)

### Endpoint
Cmd0 = 0x25, Cmd1 = 0x40

### Parameters
#### Request Body (SREQ)
- **StartDelay** (2 bytes) - Required - Specifies the time delay before the device starts.

### Request Example
Length = 0x01, Cmd0 = 0x25, Cmd1 = 0x40, StartDelay

### Response
#### Success Response (SRSP)
- **Status** (1 byte) - 0x00 – Restored network state, 0x01 – New network state, 0x02 – Leave and not Started.

#### Response Example
Length = 0x01, Cmd0 = 0x65, Cmd1 = 0x40, Status
```

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

### Single-line comment example

Source: https://tasmota.github.io/docs/Berry-Introduction/

Shows a single-line comment starting with #, which tells the Berry compiler to ignore the rest of the line.

```berry
  self.names = []          # empty list
```

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

### Simple LED blink example using ULP

Source: https://tasmota.github.io/docs/Berry/

Loads a precompiled ULP program from a bytes buffer and runs it. The example configures wake periods for off and on times, then loads and executes the program.

```berry
# simple LED blink example
import ULP
ULP.wake_period(0,500000) # off time
ULP.wake_period(1,200000) # on time 
c = bytes("756c70000c006c00000000001000008000000000000000000000000010008072010000d0e5af2c72340040802705cc190005681d10008072e1af8c720100006821008072040000d0120080720800207004000068010005825c0000800405681d00000092680000800505681d0100009268000080000000b0")
ULP.load(c)
ULP.run()
```

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

### Initial startup log for Sonoff Zigbee Bridge Pro (ZNP)

Source: https://tasmota.github.io/docs/Zigbee/

Example log output when first starting Z2T on a Sonoff Zigbee Bridge Pro (ESP32 + CC2652P with ZNP). Shows the sequence of status messages from reboot to started state.

```log
19:02:20.659 ZIG: rebooting ZNP device
19:02:22.960 ZbInput discarding byte 00
19:02:22.962 RSL: RESULT = {"ZbState":{"Status":1,"Message":"CCxxxx ZNP booted","RestartReason":"Power-up","MajorRel":2,"MinorRel":7}}
19:02:23.160 RSL: RESULT = {"ZbState":{"Status":50,"MajorRel":2,"MinorRel":7,"MaintRel":1,"Revision":20220219}}
19:02:23.311 RSL: RESULT = {"ZbState":{"Status":2,"Message":"Resetting configuration"}}
19:02:25.359 ZbInput discarding byte 00
19:02:25.911 RSL: RESULT = {"ZbState":{"Status":3,"Message":"Configured, starting coordinator"}}
19:02:30.062 RSL: RESULT = {"ZbState":{"Status":40,"NewState":9,"Message":"Started as coordinator"}}
19:02:30.162 RSL: RESULT = {"ZbState":{"Status":51,"IEEEAddr":"0x00124B0026B684E4","ShortAddr":"0x0000","DeviceType":7,"DeviceState":9,"NumAssocDevices":0}}
19:02:30.713 RSL: RESULT = {"ZbState":{"Status":0,"Message":"Started"}}
19:02:30.715 ZIG: Zigbee started
19:02:30.720 ZIG: No Zigbee device information
19:02:30.732 ZIG: Zigbee device data in File System (31 bytes)
```

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

### Get current running time with tasmota.millis()

Source: https://tasmota.github.io/docs/Berry/

Returns the current running time in milliseconds since the last boot. The example shows the output 9977038.

```berry
> tasmota.millis()
9977038
```

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

### ZDO_STARTUP_FROM_APP_EX

Source: https://tasmota.github.io/docs/_media/zigbee/Z-Stack_API_1_2.pdf

Starts the ZDO from the application with extended parameters.

```APIDOC
## ZDO_STARTUP_FROM_APP_EX

### Description
Starts the ZDO from the application with extended parameters.

### Method
ZDO Command

### Endpoint
ZDO_STARTUP_FROM_APP_EX

### Parameters
- **StartDelay** (word) - Required - The start delay in milliseconds.
- **ExtendedParams** (object) - Required - Extended startup parameters.

### Response
Returns the status of the startup.
```

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

### EnergyTotal<x>

Source: https://tasmota.github.io/docs/Commands/

Get or set Energy Total values. The new value represents start of day, and output for total includes the today value.

```APIDOC
## EnergyTotal<x>

### Description
Get or set Energy Total values. The new value represents start of day, and output for total includes the today value.

### Parameters
- `<x>` (integer) - Optional - Meter number (default `1`)
- `<value>` (integer) - Required - New value in Wh, `0` for reset
- `<time>` (integer) - Optional - Epoch time for StartTotalTime: `0..4294967295`

### Usage
`EnergyTotal<x> <value>{,<time>}`
```

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

### tcpserver full example

Source: https://tasmota.github.io/docs/Berry/

Shows creating a tcpserver on port 8888, checking for a client, accepting the connection, reading text and binary data, and closing the connection. The example includes the expected output from the Berry REPL.

```berry
> s = tcpserver(8888)    # listen on port 8888
> s.hasclient()
false

# in parallel connect on this port with `nc <ip_address> 8888`

> s.hasclient()
true               # we have an incoming connection
> c = s.accept()
> c
<instance: tcpclient()>

# send 'foobar' from the client
> c.read()
foobar

# send 'foobar2' again from the client
> c.readbytes()
bytes('666F6F626172320A')

> c.close()
# this closes the connection
```

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

### Boot Script for Serial Monitoring

Source: https://tasmota.github.io/docs/Smart-Meter-Interface/

Example boot section script to start serial monitoring at boot-time. It enables the sensor53 r command and sets the LED GPIO to 13.

```plaintext
>B
=>sensor53 r
=>sensor53 l13
```

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

### Start LVGL with lv.start()

Source: https://tasmota.github.io/docs/LVGL/

Starts the LVGL engine. Must be called before creating LVGL objects.

```berry
lv.start()
```

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

### ZbDeviceTopic example with SetOption89

Source: https://tasmota.github.io/docs/Commands/

Example of the MQTT topic format when SetOption89 is enabled, showing a unique device topic based on the Zigbee device ShortAddr.

```plaintext
tele/Zigbee/5ADF/SENSOR = {"ZbReceived":{"0x5ADF":{"Dimmer":254,"Endpoint":1,"LinkQuality":70}}}
```

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

### introspect module usage example

Source: https://tasmota.github.io/docs/Berry/

Interactive Berry console session demonstrating introspect.members, introspect.get, and introspect.set on an instance of a class A. Shows how to list members, get and set member values.

```berry
> class A var a,b def f() return 1 end end
> ins=A()
> ins.a = "foo"
> import introspect

> introspect.members(ins)
['b', 'a', 'f']

> introspect.get(ins, "a")
foo

> introspect.set(ins, "a", "bar")
bar

> ins.a
bar
```

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

### AutoSetup commands for Shelly Plus 2PM

Source: https://tasmota.github.io/docs/Blinds-and-Shutters/

Commands to calibrate and set up the shutter on Shelly Plus 2PM. Repeat 'backlog shuttersetopen;shutterclose' until closed, then set interlock, relay, and start setup.

```tasmota
backlog shuttersetopen;shutterclose
```

```tasmota
interlock 1,2
```

```tasmota
interlock on
```

```tasmota
shutterrelay1 1
```

```tasmota
shuttersetup
```

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

### autoexec.be example for Leds Panel

Source: https://tasmota.github.io/docs/Tasmota-Extension/

Example autoexec.be for a Leds Panel extension, loading the 'wifi_memory_sticker' module and registering it as an extension.

```berry
do                          # embed in `do` so we don't add anything to global namespace
  import introspect
  var wifi_memory_sticker = introspect.module('wifi_memory_sticker', true)     # load module 'wifi_memory_sticker.be' but don't cache
  tasmota.add_extension(wifi_memory_sticker)
end
```

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

### Initialize LVGL and create UI with buttons

Source: https://tasmota.github.io/docs/LVGL/

Berry script to start LVGL, set up a gradient background, a status line with icons, and three buttons with a shared style. Includes an event callback that prints button press coordinates. Paste into Berry console or save as autoexec.be.

```berry
#- start LVGL and init environment -#
lv.start()

hres = lv.get_hor_res()       # should be 320
vres = lv.get_ver_res()       # should be 240

scr = lv.scr_act()            # default screen object
f20 = lv.montserrat_font(20)  # load embedded Montserrat 20

#- Background with a gradient from black #000000 (bottom) to dark blue #0000A0 (top) -#
scr.set_style_bg_color(lv.color(0x000077), lv.PART_MAIN | lv.STATE_DEFAULT)

#- Upper state line -#
stat_line = lv.label(scr)
if f20 != nil stat_line.set_style_text_font(f20, lv.PART_MAIN | lv.STATE_DEFAULT) end
stat_line.set_long_mode(lv.LABEL_LONG_SCROLL)                                        # auto scrolling if text does not fit
stat_line.set_width(hres)
stat_line.set_align(lv.TEXT_ALIGN_LEFT)                                              # align text left
stat_line.set_style_bg_color(lv.color(0xD00000), lv.PART_MAIN | lv.STATE_DEFAULT)    # background #000088
stat_line.set_style_bg_opa(lv.OPA_COVER, lv.PART_MAIN | lv.STATE_DEFAULT)            # 100% background opacity
stat_line.set_style_text_color(lv.color(0xFFFFFF), lv.PART_MAIN | lv.STATE_DEFAULT)  # text color #FFFFFF
stat_line.set_text("Tasmota")
stat_line.refr_size()                                                                # new in LVGL8
stat_line.refr_pos()                                                                 # new in LVGL8

#- display wifi strength indicator icon (for professionals ;) -#
wifi_icon = lv_wifi_arcs_icon(stat_line)    # the widget takes care of positioning and driver stuff
clock_icon = lv_clock_icon(stat_line)

#- create a style for the buttons -#
btn_style = lv.style()
btn_style.set_radius(10)                        # radius of rounded corners
btn_style.set_bg_opa(lv.OPA_COVER)              # 100% background opacity
if f20 != nil btn_style.set_text_font(f20) end  # set font to Montserrat 20
btn_style.set_bg_color(lv.color(0x1fa3ec))      # background color #1FA3EC (Tasmota Blue)
btn_style.set_border_color(lv.color(0x0000FF))  # border color #0000FF
btn_style.set_text_color(lv.color(0xFFFFFF))    # text color white #FFFFFF

#- create buttons -#
prev_btn = lv.btn(scr)                            # create button with main screen as parent
prev_btn.set_pos(20,vres-40)                      # position of button
prev_btn.set_size(80, 35)                         # size of button
prev_btn.add_style(btn_style, lv.PART_MAIN | lv.STATE_DEFAULT)   # style of button
prev_label = lv.label(prev_btn)                   # create a label as sub-object
prev_label.set_text("<")                          # set label text
prev_label.center()

next_btn = lv.btn(scr)                            # right button
next_btn.set_pos(220,vres-40)
next_btn.set_size(80, 35)
next_btn.add_style(btn_style, lv.PART_MAIN | lv.STATE_DEFAULT)
next_label = lv.label(next_btn)
next_label.set_text(">")
next_label.center()

home_btn = lv.btn(scr)                            # center button
home_btn.set_pos(120,vres-40)
home_btn.set_size(80, 35)
home_btn.add_style(btn_style, lv.PART_MAIN | lv.STATE_DEFAULT)
home_label = lv.label(home_btn)
home_label.set_text(lv.SYMBOL_OK)                 # set text as Home icon
home_label.center()

#- callback function when a button is pressed, react to EVENT_CLICKED event -#

def btn_clicked_cb(obj, event)
    var btn = "Unknown"
    if   obj == prev_btn  btn = "Prev"
    elif obj == next_btn  btn = "Next"
    elif obj == home_btn  btn = "Home"
    end
    # get the coordinates
    var indev = event.get_indev()
    var point = lv.point()
    indev.get_point(point)
    # get local coordinates
    var area = lv.area()
    obj.get_coords(area)

    print(f"{btn} button pressed at ({point.x},{point.y}) local ({point.x - area.x1},{point.y - area.y1})")
end


prev_btn.add_event_cb(btn_clicked_cb, lv.EVENT_CLICKED, 0)
next_btn.add_event_cb(btn_clicked_cb, lv.EVENT_CLICKED, 0)
home_btn.add_event_cb(btn_clicked_cb, lv.EVENT_CLICKED, 0)
```

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

### ArtNetConfig JSON example for addressable LEDs

Source: https://tasmota.github.io/docs/ArtNet/

Configures ArtNet for addressable LED mode with 5 rows, 5 columns, offset 0, alternate false, and starting universe 0. All parameters can be specified in this mode.

```json
ArtNetConfig {"Rows":5, "Cols":5, "Offset":0, "Alternate":false, "Universe":0}
```

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

### List directory with path.listdir

Source: https://tasmota.github.io/docs/Berry/

Example showing how to import the path module and list the root directory of the SD card. The output is a list of filenames.

```berry
import path
print(path.listdir("/sd/"))
# outputs a list of filenames at the root dir of the SD card
```

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

### Calculate differences and wake up logic

Source: https://tasmota.github.io/docs/ULP/

Replaces lines 135 and 136 of the original example. Calculates differences between voltage measurements and wakes up if the positive difference exceeds the threshold. Comments note that subtraction order may need to be swapped for your setup.

```assembly
/* calculate differences */
    move r3, Sens_Vn1
    ld r3, r3, 0
    move r2, Sens_Vn0
    ld r2, r2, 0
    sub r3, r2, r3         # eventually change to sub r3, r3, r2 for your setup
    move r2, Sens_Diff_n1
    st r3,r2,0
    move r3, Sens_Vp1
    ld r3, r3, 0
    move r2, Sens_Vp0
    ld r2, r2, 0
    sub r3, r3, r2          # eventually change to sub r3, r2, r3 for your setup
    move r2, Sens_Diff_p1
    st r3,r2,0

/* wake up */
    ld r0,r2,0 # Sens_Diff_p1
    JUMPR wake_up, threshold_pos, GE
```

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

### ZDO_STARTUP_FROM_APP

Source: https://tasmota.github.io/docs/_media/zigbee/Z-Stack_API_1_2.pdf

Starts the ZDO from the application.

```APIDOC
## ZDO_STARTUP_FROM_APP

### Description
Starts the ZDO from the application.

### Method
ZDO Command

### Endpoint
ZDO_STARTUP_FROM_APP

### Parameters
- **StartDelay** (word) - Required - The start delay in milliseconds.

### Response
Returns the status of the startup.
```

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

### Full Example

Source: https://tasmota.github.io/docs/Berry/

Complete example demonstrating asynchronous connection attempts using tcpclientasync.

```APIDOC
## Full Example

### Description
Demonstrates creating a tcpclientasync instance, connecting to a remote host, and checking connection state over time.

### Code
```berry
def try_connect(addr, port)
  import string
  var tcp = tcpclientasync()
  var now = tasmota.millis()
  var r = tcp.connect(addr, port)
  print(string.format("Time=%5i state=%s", tasmota.millis()-now, str(tcp.connected())))
  print(tcp.info())
  tasmota.delay(50)
  print(string.format("Time=%5i state=%s", tasmota.millis()-now, str(tcp.connected())))
  print(tcp.info())
  tasmota.delay(150)
  print(string.format("Time=%5i state=%s", tasmota.millis()-now, str(tcp.connected())))
  print(tcp.info())
  tasmota.delay(500)
  print(string.format("Time=%5i state=%s", tasmota.millis()-now, str(tcp.connected())))
  print(tcp.info())
  return tcp
end
tcp = try_connect("192.168.1.19", 80)
```

```
Tokens:
Raw