openHASP compatibility

[smcgann99]

I post this here in case it is of interest to anyone ....

I have a node red flow which completely manages openHASP devices. As soon as a device is connected to MQTT it is setup and controlled automatically.

I wondered if it would be possible to make haspmota work with this flow (without changing the flow)
So I have been experimenting by using some berry code to replicate some of the missing openHASP functionality.

Basically its a question of listening to openHASP topics, and reacting as native firmware would.
By interpreting commands, adding OR updating objects, publishing touch events and status updates etc.

I had no design in mind, so I just set it up to talk to my NR flow and added bits of code to overcome each problem in the process of downloading my layouts.

As my flow requires information from openHASP, I cobbled this together to send statusupdate messages.

def status()
    #hasp/1/state/statusupdate
    var wifi=tasmota.wifi()
    var mem=tasmota.memory()
    var status2=tasmota.cmd("status 2") 
    var state = tasmota.cmd('state',true) 
        
    var status = {
      "node": tasmota.cmd('Topic',true)['Topic'],
      "idle": "off",
      "version": status2["StatusFWR"]["Version"],
      "uptime": state["UptimeSec"],
      "ssid": state["Wifi"]["SSId"],
      "rssi": state["Wifi"]["RSSI"],
      "bssid": state["Wifi"]["BSSId"],
      "ip": wifi["ip"],
      "mac": wifi["mac"],
      "heapFree": mem["heap_free"],
      "heapFrag": mem["frag"],
      "core": status2["StatusFWR"]["Core"],
      "hardware": status2["StatusFWR"]["Hardware"],
      "canUpdate": "false",
      "page": 1,
      "numPages": 12,
      "tftDriver": "Other",
      "tftWidth":  lv.get_hor_res(),
      "tftHeight": lv.get_ver_res()
    }
    
    mqtt.publish ("hasp/" + device_topic + "/state/statusupdate", json.dump(status))

  end

Publishing touch events is easy enough -

def publish_touch(value, trigger, msg)
    import json
    var object_name = msg['hasp'].keys()()
    var topic = "hasp/" + device_topic + "/state/" + object_name
    var payload = json.dump((msg['hasp'].find(object_name)))
    mqtt.publish (topic, payload)
   
  end
  
  tasmota.add_rule("hasp#?#event",publish_touch)

With this and the main bit of code below, my screen does actually talk to my flow and downloads the layouts etc.

However there are a number of "issues" which are beyond me at the moment.
My NR flows make use of the following widgets and features which are not implemented in haspmota.

msgbox and cpicker (I could live without msgbox but colour picker is essential for home automation)

tag attribute on objects (used to include extra data in touch events)

text_font=xx Because my flows scale screen content to the size of the screen I use arbitrary font sizes. openHASP creates new font sizes on the fly for the default fonts, whereas haspmota only seems to do this for added ttf fonts.

Please don't laugh at my coding "skills" I only just started looking at berry ;-).
I got further than I thought I would (thanks to help from @sfromis)

# Function to handle openHASP MQTT messages

def openHASP(topic, idx, payload_s, payload_b)

    import json
    import string
    import global
    import lv
    import mqtt
                     
    var topic_parts = string.split(topic,"/")
    var topic_end = topic_parts[size(topic_parts)-1] 
    var device_topic = tasmota.cmd('Topic',true)['Topic'] # Retrieve the device-specific MQTT topic
  
    var p
    var cmd
    var page
    var id 
    var object_name
    var value  
    var cmnd_list = ["antiburn", "backlight","page", "clearpage", "restart", "reboot" ,"config", "screenshot" ,"statusupdate"]
    var get_cmnd 
    var get_params
    var jsonList
    var cur_page 
    
    #print(topic, "class",classof(payload_s),"type",type(payload_s),payload_s)
  
    def onoff(value)
      value = string.tolower(value)
      print(value,classof(value),type(value))
      if ["yes","1","true","on"].find(value)
        value="on" 
      elif ["no","0","false","off"].find(value)
        value="off"
      else
        value = nil
      end
      return(value)
    end
  
    #scale a number from 0-255 to 0-100
    def scale100(num) 
      if num < 0 || num > 255
        return
      else
        return (num * 100) / 255
      end
    end
  
  
    def jsonl()
      
      if p == nil return end
      if object_name == nil
        page = p.find("page")!=nil ?  p.find("page"): cur_page 
        id = p.find("id") 
        object_name = "p" + str(page) + "b" + str(id) 
      end
    
      if !global.contains(object_name) && p.find("obj") != nil
        print("HSP:","Added",object_name,json.dump(p))
        haspmota.parse(json.dump(p)) 
  
      elif global.contains(object_name)
        print("HSP:","Updated",object_name,json.dump(p))
        for key: p.keys()
          if key != "obj" && key !="id" && key !="page"
            value = p.find(key)
            global.(object_name).setmember(key,value)
          end
        end
      else
        print("HSP:","Error obj doesn't exist")
      end
    
    end
  
    def get_values(text)
      # figure out if its an object name pxbx. to pxxxbxxx.
      
      if string.startswith(text,"p") && string.count(text,"b",2,4)==1 && string.count(text,".",4,8)==1
        object_name=string.split(text,".")[0] 
        cmd=string.split(text,".")[1] 
        if string.count(cmd,"=")==1
          value=string.split(cmd,"=")[1]
          cmd=string.split(cmd,"=")[0]
        end
        page = string.tr(string.split(object_name,"b")[0], "p","")  
        id = string.split(object_name,"b")[1]
        return "object"
      else 
        return "command"
      end
    
    end
  
    ########################################### Parse messages ###################################

    # temp fix reply to gui request (should return screen rotation as a number)
    if topic_end =="gui"
      var payload = {"gui":{"rotate":2}}
      payload=json.dump(payload)
      mqtt.publish ("hasp/" + device_topic + "/state/config", payload)
      return
    end

    
    # hasp/1/command/jsonl ( multiple obj with multiple properties in payload with page & ids)
    
    if topic_end =="jsonl"
      payload_s = string.split(payload_s,"\n")
      print("class",classof(payload_s),"type",type(payload_s),payload_s)
     for txt: payload_s.iter()
      print("class",classof(txt),"type",type(txt),txt)
        object_name=nil
        p=json.load(txt)
        cur_page = p.find("page")!=nil ?  p.find("page"): cur_page 
        jsonl()
      end
      return
    end
     
     # hasp/1/command/p1b1.jsonl (multiple properties in payload without page & ids)
    if string.startswith(topic_end,"p")
      get_values(topic_end)
  
      if cmd =="jsonl" # add page & id
        p = json.load(payload_s)
        p.insert("id", id)
        p.insert("page", page)
        jsonl()
        return
      end
  
       # hasp/1/command/p1b1.text_color  id and property in topic - single value in payload - (add key and value)
       p = {"page":page , "id":id , cmd:payload_s}
       jsonl()
       return
      
    end
  
    # hasp/1/command/json   ["p0b46.hidden=true",backlight {"state":"ON","brightness":255}]
    # hasp/1/command        ["p0b46.hidden=true",backlight {"state":"ON","brightness":255},{'id': 255, 'page': 0, 'obj': 'msgbox', 'text': 'Receiving design from Node RED...', 'auto_close': 1500}]
    
    if topic_end == "command" || topic_end == "json" 
     jsonList=json.load(payload_s)
     for txt: jsonList.iter()  
        if get_values(txt) == "object" # update a single attribute
          p = {"page":page , "id":id , cmd:value} 
          jsonl()
        elif classof(txt)==map # treat as jsonl - update multiple attributes
          p = txt
          jsonl()
        else
          if string.count(txt," ")>0
            get_cmnd = string.split(txt," ",1)[0]
            get_params = string.split(txt," ",1)[1]
            if string.count(get_params,"{")>0 && string.count(get_params,"}")>0
              get_params=json.load(get_params)
            end
          else
            get_cmnd = txt
            get_params = nil
          end
  
          print(get_cmnd,classof(get_cmnd),type(get_cmnd),get_params,classof(get_params),type(get_params))
        
          if get_cmnd == "backlight"
            var brightness = nil
            var state = nil
            if classof(get_params)==map
              state = onoff(get_params.find("state"))
              brightness = scale100(get_params.find("brightness"))
            else
              state=onoff(get_params)
            end   
            if int(get_params) >0 # need to look at this ###################################################################################
              brightness = scale100(get_params)
            end
  
            print("state",state,classof(state),type(state),"brightness",brightness,classof(brightness),type(brightness))
  
            if state != nil 
              tasmota.cmd ("power" + str(size(tasmota.get_power())) + " " + state) # highest power index =LCD
            end
            if brightness != nil
              tasmota.cmd ("DisplayDimmer " + str(brightness))
            end
          end
          #more commands here ....
        end
      end
    end  
         
  end
    
    
  
  # Build the dynamic MQTT subscription topic
  import mqtt
  var device_topic = tasmota.cmd('Topic',true)['Topic'] # Retrieve the device-specific MQTT topic
  mqtt.unsubscribe("hasp/" + device_topic + "/command/#")
  mqtt.subscribe("hasp/" + device_topic + "/command/#",openHASP)

[s-hadinger]

Hi, there are many questions here, let's address some of them first:

msgbox and cpicker (I could live without msgbox but colour picker is essential for home automation)

msgbox is included in precomipled LVGL firmware, but missing in HASPmota. I will see to add it.

cpicker was removed in LVGL 8 and LVGL 9. OpenHASP is still using LVGL 7. I have no solution for you unless someone codes a new cpicker on top of LVGL 9.

text_font=xx Because my flows scale screen content to the size of the screen I use arbitrary font sizes. openHASP creates new font sizes on the fly for the default fonts, whereas haspmota only seems to do this for added ttf fonts.

I don't see any mention in OpenHASP documentation about arbitrary font size, and there is no such thing in LVGL either, unless you use TTF fonts. Can you be more specific?

tag attribute on objects (used to include extra data in touch events)

Can you be more specific about what's missing?

[s-hadinger]

See discussion about LVGL color picker: lvgl/lvgl#4429

[smcgann99]

Firstly thanks for your reply, I have no expectations that you will make changes just to suit me, unless it benefits the wider project ;-)

I learn better by doing rather than reading, so this experiment was to understand what Berry was all about by doing something "real"

I read the post on cpicker, seems odd to remove it without any replacement but so be it ;-)

I don't think the font size is specifically documented, but it works just like a ttf.
So perhaps it's just a case of having the default font robotocondensed.ttf built in, and generating the requested size with text_font : XX without specifying the actual font ?

Tag is an attribute that can be added to an object containing JSON e.g. tag:"device_name" or tag:{"wibble" : 1,"something" : "a thing"}

The content is added to the event payload, along with event type, text and val , one use for this is to pre-set the tag with info that then allows 1 button to have multiple changing functions. In my case I have a hidden colour picker that is shown on a long press of a light button, before showing the picker I set the tag to the light that called it, so the output of the picker is directed to the correct light.
see https://www.openhasp.com/0.7.0/design/objects/#common-properties

[s-hadinger]

Hi, just to let you know that I'm working on the following:

• I ported the colorwheel from LVGL8 to LVGL9, so I will add OpenHASP cpicker
• I'm adding msgbox too, but it needs more adjustments right now

[s-hadinger]

It's now added, see: #22244

[smcgann99]

Awesome ;-)
What are your thoughts on variable default font and tag attribute ?

I will see if I can squeeze Robotocondensed.ttf into file system and try and fix up incoming json in my script.

[smcgann99]

This works for me -

# Add font name to size
      var font = p.find("text_font") ? p.find("text_font") : nil
      if int(font) > 0
      p.setitem("text_font", "robotocondensed.ttf-" + str(font))   
      end

[smcgann99]

State of the script so far -

Per openHASP docs handles most of the IN and OUT openHASP topics from the ESP.
IN
hasp/node/command keyword=parameter(s)
hasp/node/command/keyword parameter(s)
hasp/node/command/json list of parameter(s)
hasp/node/command/jsonl one or more json formatted lines
hasp/node/config/submodule gui, hasp, debug get or set the configuration
OUT
hasp/node/state/object_name touch events
hasp/node/state/statusupdate status update - at interval defined with hasp/node/config/debug
hasp/node/state/idle current idle state
hasp/node/state/page current page

Also most of the useful commands - antiburn, backlight, page, clearpage, restart, reboot, config, screenshot , statusupdate , idle.

var node = tasmota.cmd('Topic',true)['Topic'] # Retrieve the device-specific MQTT topic
var status2=tasmota.cmd("status 2",true) 
var hasp_settings = {"idle_state":"start","node":node,"page":999,"gui":{"idle1":30,"idle2":60,"rotate":-1},"debug":{"tele":120},"hasp":{"startdim":255,"startpage":1},"backlight":{"state":"on","brightness":40}} # store to persitant file ? 
hasp_settings["backlight"]["brightness"] = hasp_settings["hasp"]["startdim"] 
#hasp_settings["gui"]["rotate"] = tasmota.cmd("displayrotate",true)['DisplayRotate'] -1 flags NR flow that h/w are already correct based on rotation

# Function to handle openHASP MQTT messages
def openhasp(topic, idx, payload_s, payload_b)

  def trim(text)
    var chars_to_remove = [" ", "\n", "/", "\r", "\f", "\t"]
    var start_index = 0
    var end_index = size(text) - 1
    while start_index <= end_index && (chars_to_remove.find(text[start_index]) != nil || chars_to_remove.find(text[end_index]) != nil)
      if chars_to_remove.find(text[start_index]) != nil start_index += 1 end
      if chars_to_remove.find(text[end_index]) != nil end_index -= 1 end
    end
    return text [start_index..end_index]
  end
   
    # sanitize incoming messages
    topic=trim(topic) # strip any extraneous "/" from topic
    payload_s=trim(payload_s) # strip extraneous "LF" from payload_s
    payload_s = string.tolower(payload_s) # to lowercase
    
    var topic_parts = string.split(topic,"/")
    var topic_end = topic_parts[size(topic_parts)-1] 
    var p,cmd,pg,id,object_name,value,jsonList,cur_pg
    var cmnd_list = ["antiburn", "backlight","page", "clearpage", "restart", "reboot","config", "screenshot" ,"statusupdate","idle"]

    print("received",topic, "class",classof(payload_s),"type",type(payload_s),payload_s)
    
    def onoff(value)
      if ["yes","1","true","on"].find(value) !=nil value="on" 
      elif ["no","0","false","off"].find(value) !=nil value="off"
      else value = nil
      end
      return(value)
    end
  
    #scale a number from 0-255 to 0-100
    def scale100(num)
      return ((num < 0 ? 0 : (num > 255 ? 255 : num)) * 100) / 255
    end
    
    def jsonl()
      
      if p == nil return end   ###### check this can object_name be created elswhere  / is it really needed anymore ?
      if object_name == nil
        pg = p.find("page",cur_pg)
        id = p.find("id") 
        object_name = f"p{pg}b{id}"
      end
  
      # Add font name to size
      var font = p.find("text_font",0) 
      if int(font) > 0
        p["text_font"]=f"robotocondensed.ttf-{font}"  
      end
      #print("HSP:","Added",object_name,json.dump(p))
      haspmota.parse(json.dump(p)) 
    end
    
    def get_values(text)
        # Initialize variables
        object_name = nil
        cmd = nil
        value = nil
      
        # Check if the text is an object name in the format 'pxbx.xxx'
        if string.startswith(text, "p") && string.count(text, "b", 2, 4) == 1 && string.count(text, ".", 4, 8) == 1
          var parts = string.split(text, ".")
          object_name = parts[0]  # 'pxbx'
          cmd = trim(parts[1])    # 'xxx' (attribute part)
      
          # Check if cmd contains an attribute and value ('attr=value')
          if string.count(cmd, "=") == 1
            var cmd_parts = string.split(cmd, "=")
            cmd = trim(cmd_parts[0])
            value = trim(cmd_parts[1])
          end
      
          # Extract page and id from object_name ('p' + page + 'b' + id)
          var object_parts = string.split(object_name, "b")
          pg = int(string.tr(object_parts[0], "p", ""))  # Remove 'p' and get page number
          id = int(object_parts[1])  # Get id part after 'b'
          return "object"
      
        # Check if the text is a command in the format 'cmd=value'
        elif string.count(text, "=") == 1
          var cmd_parts = string.split(text, "=")
          cmd = trim(cmd_parts[0])
          value = trim(cmd_parts[1])
      
        # Check if the text is a command in the format 'cmd value'
        elif string.count(text, " ") == 1
          var cmd_parts = string.split(text, " ", 1)
          cmd = trim(cmd_parts[0])
          value = trim(cmd_parts[1])
      
        # If there's no space or '=', it's just a command with no value
        else
          cmd = text
          value = ""
        end
        return "command"
    end
  
    def backlight() 
      var brightness = nil
      var state = nil
      if classof(value)==map
        state = onoff(value.find("state",nil))
        brightness = value.find("brightness",nil)
      else
        state = int(value)==1 ? nil : onoff(value) # if not a map then 1 = brightness 1
        brightness = int(value)>0 ? int(value) : nil 
      end   
      if brightness != nil
        tasmota.cmd (f"DisplayDimmer {scale100(brightness)}")
        hasp_settings["backlight"]["brightness"] = brightness
      end
      if state != nil 
       tasmota.cmd (f"power{size(tasmota.get_power())} {state}") # highest power index=LCD
       hasp_settings["backlight"]["state"] = state
      end 
      mqtt.publish (f"hasp/{node}/state/backlight", json.dump(hasp_settings["backlight"]))
    end
  
    def page()
     # haspmota.page_show ('p3') ('next') ('prev') ('back')
      if value != nil
        if int(value) > 0 
          value=f'p{value}'
        end
        haspmota.page_show(value)
      else
        mqtt.publish (f"hasp/{node}/state/page", str(haspmota.get_page_cur().id()))
      end
    end

    def antiburn()
      #tasmota.cmd("") # run screen saver
    end

    def idle()
      print ("value",value,"cmd",cmd)
      
    end

    def clearpage()
      var pages=haspmota.get_pages()
      var to_delete=[]
      if value == "all" to_delete = pages
      elif value == ""  to_delete = [haspmota.get_page_cur().id()]
      elif pages.find(int(value)) !=nil to_delete = [int(value)]
      end
      for item: to_delete.iter()
        compile(f"return p{item}.delete")()
      end
    end

    def command()
        print("command", cmd, value, classof(value), type(value)) 
      
        if cmnd_list.find(cmd) != nil
          if cmd == "backlight" backlight()
          elif cmd == "page" page()
          elif cmd == "screenshot" lv.screenshot()
          elif cmd == "reboot" || cmd == "restart" tasmota.cmd("restart 1")
          elif cmd == "antiburn" lv.antiburn()
          elif cmd == "idle" idle()
          elif cmd == "clearpage" clearpage()
          end
        else print("HSP: unsupported command", cmd) end
      end
  
    ########################################### Parse messages ###################################

    # query and set config options
    if string.count(topic,"config") > 0
      if payload_s == ""
        #hasp_settings["gui"]["rotate"] = tasmota.cmd("displayrotate",true)['DisplayRotate'] - not needed for haspmota
        var payload = {topic_end:hasp_settings[topic_end]}
        mqtt.publish (f"hasp/{node}/state/config", json.dump(payload))
      else   # update some values from payload     
        payload_s=string.tr(payload_s , "'",'"')
        value=json.load(payload_s)
        if type(value) =="instance" && hasp_settings.contains(topic_end)
          for key: value.keys()
             hasp_settings[topic_end][key]=value.find(key)
          end
        end
      end
      print (hasp_settings[topic_end])
      return
    end

    # hasp/1/command/jsonl ( multiple obj with multiple properties in payload with ids & optional page)
    
    if topic_end =="jsonl"
      payload_s = string.split(payload_s,"\n")
      print("jsonl","class",classof(payload_s),"type",type(payload_s),payload_s)
      for txt: payload_s.iter()
        if txt !="" # check item is not nil
          p=json.load(txt)
          cur_pg = p.find("page")!=nil ?  p.find("page"): cur_pg # track pg number if present
          jsonl()
        end
      end
      return
    end
     
    # hasp/<nodename>/command       string - <keyword>=<parameter(s)> eg p0b42.text="wibble"
    # hasp/<nodename>/command/json  list - ["page 1","backlight {'state':'yes','brightness':155}","idle off"]
    
    if topic_end == "json" || topic_end == "command"
      if topic_end == "command" ; payload_s = f'["{payload_s}"]' ; end #make it a list so we can iterate it
      jsonList=json.load(payload_s) # - check for correct format ??
    
      for txt: jsonList.iter()
        if txt !="" # check item is not nil
          if get_values(txt) == "object" # update a single attribute
            if cmd == "delete" 
              compile(f"return {object_name}.delete")() 
              return
            else
              p = {"page":pg , "id":id , cmd:value}
              print ("single",p,classof(p)) 
              jsonl()
            end
          elif classof(txt)==map # treat as jsonl - update multiple attributes
            p = txt
            print ("multiple",p,classof(p)) 
            jsonl()
          else # assume its an actual command        
            if string.count(value,"{")>0 && string.count(value,"}")>0 # Is value a json object ?
              value=string.tr(value , "'",'"')
              value=json.load(value)
            end
            command()  
          end
        end
      end
      return
    end
  
      # hasp/1/command/p1b1.jsonl (multiple properties in payload without pg & ids)
      if string.startswith(topic_end,"p")  
        if get_values(topic_end) =="object"
          print("starts with p")
          if cmd =="jsonl" # add pg & id
            p = json.load(payload_s)
            p.insert("id", id)
            p.insert("page", pg)
            jsonl()
          # if no payload publish the existing attribute value
          elif payload_s == "" && global.contains(object_name)
            mqtt.publish (f"hasp/{node}/state/{object_name}", global.(object_name).member(cmd))
            return
          else
            # hasp/1/command/p1b1.text_color  id and 1 property in topic - single value in payload - (add key and value)
            p = {"page":pg , "id":id , cmd:payload_s}
            jsonl()
          end
        end
        return
      end

end
    

mqtt.unsubscribe(f"hasp/{node}/command/#")
mqtt.subscribe(f"hasp/{node}/command/#",openhasp)

########################################################################


def hasp_mon()

  var cur_page = haspmota.get_page_cur().id() 
  var cur_state =  hasp_settings["idle_state"]
  var cur_time = lv.disp().get_inactive_time()/1000
  
   # Determine idle state based on cur_time
   if cur_time < hasp_settings["gui"]["idle1"]  cur_state = "off"
  elif cur_time > hasp_settings["gui"]["idle2"] cur_state = "long"
  elif cur_time > hasp_settings["gui"]["idle1"] cur_state = "short"
  end

  # publish new idle state
  if hasp_settings["idle_state"] != cur_state 
  mqtt.publish (f"hasp/{node}/state/idle", cur_state)
  hasp_settings["idle_state"] = cur_state
  end

  # publish new page num
  if hasp_settings["page"] != cur_page
    mqtt.publish (f"hasp/{node}/state/page", str(cur_page))
    hasp_settings["page"] = cur_page
  end

  # Set a timer to call this function again
  tasmota.set_timer(2000,hasp_mon,"hasp_mon_timer")

end
tasmota.remove_timer("hasp_mon_timer")
hasp_mon() # send at startup

def status()
  #hasp/1/state/statusupdate
  var wifi=tasmota.wifi()
  var mem=tasmota.memory()
  var state = tasmota.cmd('state',true)
        
  var status_payload = {
    "node": node,
    "idle":  hasp_settings["idle_state"],
    "version": status2["StatusFWR"]["Version"],
    "uptime": state["UptimeSec"],
    "ssid": state["Wifi"]["SSId"],
    "rssi": state["Wifi"]["RSSI"],
    "bssid": state["Wifi"]["BSSId"],
    "ip": wifi["ip"],
    "mac": wifi["mac"],
    "heapFree": mem["heap_free"]*1000,
    "heapFrag": mem["frag"],
    "core": status2["StatusFWR"]["Core"],
    "hardware": status2["StatusFWR"]["Hardware"],
    "canUpdate": "false",
    "page": haspmota.get_page_cur().id(),
    "numPages": 12,
    "tftDriver": "Other",
    "tftWidth":  lv.get_hor_res(),
    "tftHeight": lv.get_ver_res()
  }
  mqtt.publish (f"hasp/{node}/state/statusupdate", json.dump(status_payload))
  tasmota.set_timer( hasp_settings["debug"]["tele"]*1000,status,"status_timer")
end
tasmota.remove_timer("status_timer")
status() # send at startup


def publish_touch(value, trigger, msg)
  print (msg)
  var object_name = msg['hasp'].keys()()
  mqtt.publish (f"hasp/{node}/state/{object_name}", json.dump((msg['hasp'].find(object_name))))
  # reset idle state on touch event
  if  hasp_settings["idle_state"]!="off"
    mqtt.publish (f"hasp/{node}/state/idle", "off")
    hasp_settings["idle_state"]="off"
  end 
end

tasmota.add_rule("hasp#?#event",publish_touch)


#backlight (hasp_settings["backlight"])

#mqtt.publish (f"hasp/{node}/LWT", "online") # trigger download

#######################################

# change event shows no values !!!!!!!


# tasmota.add_rule("hasp#p1b1#text", / text-> print("p1b1 text value=", text))```

[sfromis]

Looks good. Ready to publish it in a Github repository?

Lots of other tools with Berry are available that way.
http://sfromis.strangled.net/tasmota/berry/github-repositories

[smcgann99]

More of a discussion point / learning exercise, and far from "production" ready yet ;-)

[smcgann99]

@s-hadinger As promised summary of findings from my experimenting, basically key feature gaps.

1. openHASP supports variable default font sizes - so text_font : 99 creates robotocondensed at size 99 on demand

2. tag attribute - can be added to an object containing JSON e.g. tag:"device_name" or tag:{"wibble" : 1,"something" : "a thing"} this is passed along with the touch events for the object.

3. value attribute - Adds a second text label to the object, it's ideal for icons on buttons etc https://www.openhasp.com/0.6.3/design/styling/?h=value
   

4. tabview and tab object types

5. color picker - Not had a chance to test this yet but but in openHASP The object will automatically adjust based on the w and h properties: when the object is longer than it is high a rectangular color picker is created.

6. messagebox - auto_close Close the pop-up message automatically after this number of milliseconds have passed

7. It seems that val and text are not reported on touch events anymore

8. Antiburn, doesn't cover the "standard" header with clock & wifi. But this part of the screen is most like to suffer burn effects.
   Pull request Update antiburn.be #22386 to fix this.