• Expressions / Script language
  • Users and Permissions
  • Backup, restore, reset to factory settings
  • Software release notes
  • Manual configuration

    Implementation in TapHome

    In TapHome, the Packet Parser is a hardware interface (Settings → Hardware → Add new interface → Packet parser) that is used to connect third-party devices to the controller. These devices can communicate with the control unit using either WiFi or LAN via TCP/IP protocol.

    The Packet Parser uses a proprietary scripting language that is specifically designed for the TapHome system. This language is used to control and manage the connected devices and their communication with the controller. Click here for more information on the TapHome scripting language


    TapHome system uses a hierarchical structure for organizing the connected devices. In this structure, a Module acts as a parent device and can communicate with and control its child devices.


    An interface can contain one or more modules, which in most cases cover communication with the entire physical device. From a configuration point of view, the Module defines:

    • IP address or mDNS name of a device
    • Communication port
    • Secure connection: See section Authentication in Service settings of a Module
    • Ignore SSL certificate errors


    Represents a specific control element or sensor in the TapHome system. It must always be part of one parent Module.

    Supported devices:

    • Digital output
    • Analog output
    • Thermostat
    • Multi-Value Switch
    • Temperature sensor
    • Variable
    • Push button
    • Electric meter
    • Reed Contact
    • Shutters, awnings, mix valves
    • RGB Light
    • Tunable white light

    Example: Shelly Plug S
    The module contains information about the IP address, it has scripts for reading the status, settings, and performing service actions. It covers 2 devices: a digital output (relay) and an electricity meter measuring the supplied devices.

    Scripts for reading and writing

    TapHome control unit and the connected devices can communicate using HTTP or HTTPS GET / POST requests. The responses to these requests can be parsed using a set of specialized functions. For example, there may be a function that is specifically designed to parse XML responses, another function for parsing JSON responses, and yet another function for parsing byte array responses. These functions make it easier to interpret and use the information received in the responses, allowing for more efficient and effective communication with the control unit and connected devices.

    TapHome defines multiple attributes that can contain script language:

    • Initialize script: is run when the device starts (e.g. after the control unit is restarted)
    • Read script: setting values of global variables or reading error states
    • Read Value script: script for reading a specific value (quantity) from a connected device (e.g. set temperature on the thermostat or measured temperature on the thermostat)
    • Write Value script: write the value to the connected device

    Definition of error states from scripts

    Service attributes and actions

    Scripts and auxiliary variables on the module

    Scripts and helper variables on the device

    See more info on Modbus documentation page

    Supported protocols

    • HTTP

    • TCP

    • UDP

    • FTP

    • MQTT



    Sends HTTP request with specified parameters, waits for response and returns response as JSON string with values as Content, Headers, HTTP result code. Function is supported only in Packet parser scripts with HTTP protocol.

    SENDHTTPREQUEST( path, method, body, header1, header2… )
    SENDHTTPREQUEST( HttpRequest )


    SENDHTTPREQUEST("/getValue")		Result is:
      "Headers": [
          "Key": "Content-Type", “Value": [“application/json"]
          "Key": "Content-Length", “Value": ["1007"]
      "Content": "{\"value\":31}”,
      "ReasonPhrase": "OK",
      "StatusCode": 200,
      "IsSuccess": true
    SENDHTTPREQUEST("/doSomething", “POST”, “someData”, “header1:value1”, “header2:value2”, “header3:value3”)
    VAR request := HTTPREQUEST(“/path”, “PUT”, “someData”);
    request.Headers := { “name1: value1”, “name2: value2” … };
    request.Method := “POST”;
    VAR response := SENDHTTPREQUEST(request);
    IF response.IsSuccess
    	VAR content := response.Content;

    TCP, UDP


    Sends specified data (string or Collection UInt8) using TCP or UDP protocol. If data is a string object, it’s implicitly converted to bytes using iso-8859-1 encoding. Function is supported only in Packet parser scripts with TCP or UDP protocol. Received bytes can be processed in Listener script.

    SENDDATA( string/Collection<UInt8> )




    Function is used in Listener scripts in Packet parser with TCP/UDP protocol, to notify completion of Service attribute value request. Eg. you create a request in Service attribute script using the SENDDATA function and after receiving the data in listener script, you complete the service attribute read.

    COMPLETESERVICEATTRIBUTE( attributeName, value, error )


    COMPLETESERVICEATTRIBUTE(“Uptime”, “2d:21h:43m”)
    COMPLETESERVICEATTRIBUTE(“Status”, “”, “Device is offline”)


    Function is used in Listener scripts in Packet parser with TCP/UDP protocol, to notify completion of Service action request.
    Eg. you create a request in Service action script using the SENDDATA function and after receiving the data in Listener script, you complete the Service action.

    COMPLETESERVICEACTION( actionName, result )


    COMPLETESERVICEACTION(“Reboot”, “Rebooted successfully”)
    COMPLETESERVICEACTION(“Enable cloud”, “Device is offline”)



    Returns the file data (as Collection UInt8) from the FTP server. The function is only supported in Packet parser scripts with FTP protocol.

    FTPDOWNLOAD( pathToFile )


    FTPDOWNLOAD(“/path/to/file”) 		(Result is Collection<UInt8>)


    Uploads data (Collection UInt8 or string) to a file to FTP server.

    FTPUPLOAD( pathToFile, data, mode )


    FTPUPLOAD(“/path/to/file”, “some data”, “write”)
    FTPUPLOAD(“/path/to/file”, BYTECOLLECTION(“a7 ff e2”), “append”)


    In addition to the communication options mentioned above, the TapHome system also allows for communication with third-party devices using the MQTT protocol. MQTT, or Message Queuing Telemetry Transport, is a lightweight publish/subscribe messaging protocol that is designed for efficient and reliable communication between devices in machine-to-machine (M2M) and Internet of Things (IoT) contexts.

    To enable communication with third-party devices using MQTT, it is necessary to create a separate module in Settings → Hardware → Add new interface → MQTT Broker. This module acts as an intermediary between the third-party devices and the control unit, allowing them to communicate using the MQTT protocol. The MQTT Broker can be run autonomously on the control unit, allowing for independent and efficient communication between the third-party devices and the TapHome system.


    The function is used on PacketParser devices with the MQTT protocol to publish a message to the MQTT broker.

    MQTTPUBLISH( topic, message )


    MQTTPUBLISH(“shellies/deviceid/relay/0/command”, “off”)