To work in a console and have it separated from Home Assistant, as regular user create and enter into a python virtual environment and do pip install esphome then esphome version or esphome --help.

esphome wizard <project name>.yaml initializes a project and creates the initial <project name>.yaml file

Now the <project name>.yaml file needs to be edited to get some peripheral functions as for the d1_mini_lite board putting a switch from GPIO2 to ground.

switch:
  - platform: gpio
    name: "<switch name>"
    pin: GPIO2

Now plug the device into the computer and when having attached to USB

esphome run <project name>.yaml --device /dev/tty<???>0

or when it was already programmed and has a working WLAN connection

esphome run <project name>.yaml

esphome logs espcam.yaml --device /dev/ttyACM0 will just print out the logs

To have it automatically found in Home Assistant, install the ESPHome Integration and make sure <project name>.yaml holds the api: line. Passwords or keys are optional.

# Enable Home Assistant API
api:
#  password: ""

The ESPHome device builder is a IDE and can be used as http://<ip>:6052

It can be installed via "Add-on" store of the Home Assistant OS.

However the "Add-on" store is not available when Home Assistant got installed as docker application or if there is no Home Assistant.

services:
  homeassistant:
    container_name: homeassistant
    image: "ghcr.io/home-assistant/home-assistant:stable"
    volumes:
      - /opt/smart-home/ha-config:/config
      - /etc/localtime:/etc/localtime:ro
    restart: unless-stopped
    network_mode: host

  go2rtc:
    container_name: go2rtc
    image: alexxit/go2rtc
    volumes:
      - /opt/smart-home/go2rtc-config:/config
    restart: unless-stopped
    network_mode: host

  esphome:
    container_name: esphome
    image: ghcr.io/esphome/esphome:latest
    volumes:
      - /opt/smart-home/esphome-config:/config
      - /etc/localtime:/etc/localtime:ro
    environment:
      - TZ=Europe/Zurich
    restart: unless-stopped
    network_mode: host

Since memory on the ESP is limited not all what Tasmota offers can be put into a firmware. . Therefore it is not very clear what GPIOs configuratons and functions the uploaded firmware supports.

A simple test is to select a module type as Sonoff Basic (brand of smart home devices created by ITEAD) and set GPIO4 to Relay and verify that the number 1 appears right to it this makes it as RELAY1. For multiple relays assign the numbers uniquely. Attach a voltmeter on this pin. Then go to the console and do POWER1 ON to turn it on and POWER1 OFF to turn it off.

To attach a chip check https://tasmota.github.io/docs/Supported-Peripherals/ for its support and driver to be selected. As Example the Humidity Sensor DHT22 uses the AM2301 driver. Then select the GPIO pin (as GPIO4) to use the signal for the 1 wire DHT22 device.

Tasmota supports many different boards. How the boards connect the external peripherals creates lot of versions. To have a flexibility for this, and not required to recreate a additional firmware variant, templates have been introduced. Templates define how the GPIOx pins of the ESP32 are connected to the signals that Tasmota understands.

It is therefore not necessary to create a new firmware just because the hardware has its peripherals connected differently. Templates are json strings that can be entered in the Web UI → Configuration → Configure Other → Template

Templates can be exported also via this Web Ui or via the console command template.

Templates can be modified via Web UI → Configuration → Template

STATUS <n> will tell something about the firmware

Reset <n> can be used to do a factory reset <n> defines what will be wiped off. 4 attempts to keep the WLAN settings 5 not.

PowerOnState will show what will be done after power on. 0 means all outputs off, 3 means restore as after power down.

To have networking support as for Home Assistant add the IP, username and password for the MQTT broker. In Home Assistant add first MQTT and then add Tasmota.

To turn power 1 on using mqtt send mosquitto_pub -h <IP of broker> -t "cmnd/tasmota_<last 6 chars of the MAC address>/Power1" -m "ON" -u <user> -P <pass>

Tasmota devices are discovered in Home Assistant and ready to be used.

Inside the MQTT parameters window the default topics as tasmota_<last 6 chars of the MAC address> can be changed to a more meaningful name as kitchen_light_1

Sometimes Tasmota does not behave as desired, this can be modified using rules.

Rule shows the configured rules as Rule1

Rule1 shows Rule1

Examples:

Rule1 ON Wifi#Connected DO Power1 OFF ENDON

Rule1 ON Mqtt#Connected DO Power1 OFF ENDON

Rule1 ON System#Init DO Power1 OFF ENDON

Commands:

Rule1 ON activates the rule

Rule1 1 executes the rule right now without required event

Rule1 Off or Rule1 0 deactivates the rule

Rule1 "" makes it useless, it seems that there is no command to remove it from the list

The log will show when the rule has been executed:

log: 00:00:00.135 RUL: SYSTEM#INIT performs 'Power1 OFF'

There is a Master and a development branch available for the firmware. If not having a brand new device select Master. Download and unzip the source code https://tasmota.github.io/docs/Compile-your-build/ or https://github.com/arendst/Tasmota/tree/development

To have pio the platform io compiler create and enter to a virtual python environment in the tasmota folder and do pip install -U platformio

pio run -e tasmota32 compiles a simple firmware that can confirm that the environment is working.

The work goes in .pio and pio run --target clean to clean up

The firmware is found in build_output/firmware. There are two files tasmota32.bin used for web installer and OTA

tasmota32.factory.bin used for complete empty devices where the bootloader needs to be added. esptool.py write_flash 0x0 tasmota32.factory.bin would be the command.python3 -m pip install --upgrade esptool to get it.

pio home opens a browser http://127.0.0.1:8008/ where the work can be done.

See https://shelly-api-docs.shelly.cloud/

export SHELLY=192.168.1.20 to not continuously have to type in the IP Address when working with curl

curl http://${SHELLY}/rpc/Shelly.GetStatus to check it on the console

curl http://${SHELLY}/rpc/Shelly.GetStatus curl -X POST -d '{"id":1,"method":"Cloud.GetConfig"}' http://${SHELLY}/rpc to get cloud info

curl -X POST -d '{"id":1,"method":"Cloud.SetConfig","params":{"config":{"enable":true}}}' http://${SHELLY}/rpc to set cloud

See https://shelly-api-docs.shelly.cloud/ and

Go to https://control.shelly.cloud/#/settings/user to get

To see if the cloud is in reached:

curl -I https://shelly-133-eu.shelly.cloud

ping -c3 shelly-133-eu.shelly.cloud

When working with curl export those things to not repeat them continuously

export=MmExMjYxxxxxxxxxxxxxxxxxxxxxxxxxxxxxC30 for the auth_key

export SHELLYURI=https://shelly-133-eu.shelly.cloud for the uri of the cloud server

export SHELLYID=cc8da144c474 for the unique id of the shelly device

The device must have the cloud enabled

curl -X POST "${SHELLYURI}/v2/devices/api/get?auth_key=${SHELLYKEY} -H 'Content-Type: application/json' -d '{"ids":["'"${SHELLYID}"'"]}' to see the device status

curl -X POST "${SHELLYURI}/v2/devices/api/set/switch?auth_key=${SHELLYKEY}" -H 'Content-Type: application/json' -d '{"id":"'"${SHELLYID}"'", "on":true}' to turn on its output

curl -X POST "${SHELLYURI}/v2/devices/api/set/switch?auth_key=${SHELLYKEY}" -H 'Content-Type: application/json' -d '{"id":"'"${SHELLYID}"'", "on":false}' to turn off its output

Usually Shellys are just used as input output devices. But certain devices allow to run scripts. The script language is similar to JavaScript.

See the tutorial https://shelly-api-docs.shelly.cloud/gen2/Scripts/Tutorial/

Features are https://shelly-api-docs.shelly.cloud/gen2/Scripts/ShellyScriptLanguageFeatures/

The script has an id number and can be managed with commands over the network see https://shelly-api-docs.shelly.cloud/gen2/ComponentsAndServices/Script or more human friendly over its web interface.

The tutorials have webcamera examples, some run some not. All are considered as demo or start to develop applications. They require to modify the code having WLAN username and password.

However there are many advanced project around that are ready to go as: https://github.com/rzeldent/esp32cam-rtsp/tree/develop (currently just the development branch holds support for XIAO ESP32-S3 Sense). Setup goes quick and easy see the web page or:

To see what it tells pio device monitor

Access it using WLAN as from a smart-phone and if it does not show a web page open 192.158.4.1. Set the AP password of the Webcam and then type in the local SSID and its password. The monitor will show then the ip address received from the local WLAN.

To access the camera in Homeassistant go to Settings → Devices & Services → Add Integration. Search for "MJPEG IP Camera" and add the links.