HTTP Binding UI Tuturial

[N1d45]

Ich habe einen RGB LED Strip an einem ESP8266 Webserver der auf verschiedene URL aufrufe reagiert.

Beispiel:

Code: Alles auswählen

192.168.178.150/control?Power=On       (Schaltet den Strip an)
192.168.178.150/control?Power=Toggler  (Schaltet den Strip um)
192.168.178.150/control?Power=Off      (Schaltet den Strip aus)
192.168.178.150/control?Red=50         (Stellt die Helligkeit der Roten LEDs ein von 0-100%, hier z.B. 50%)
192.168.178.150/control?Green=50       (Stellt die Helligkeit der Roten LEDs ein von 0-100%, hier z.B. 50%)
192.168.178.150/control?Blue=50        (Stellt die Helligkeit der Roten LEDs ein von 0-100%, hier z.B. 50%)

Nun dachte ich mir ich kann das HTTP-Binding dafür nutzen. Ich habe das AddOn installiert.
Dann bin ich die UI http://192.168.178.32:8080/ -> Einstellungen -> Things auf das + und dort wähle ich HTTP Binding und darauf HTTP URL Thing.
Darauf folgend soll ich Basis-URL angeben. Das wäre in dem Fall 192.168.178.150 ?
Wenn ich auf Show-Advance klicke erscheinen noch jede Menge Einstellungsmöglichkeiten. Gibt es ein Tutorial dafür? Irgendwie finde ich Anleitungen die Code zeigen, nicht aber was die einzelnen Eingabemöglichkeiten angeht. (Foren Suche scheitert, da die Begriffe HTTP-Binding zu oft gefunden werden. Ein Link zu einem passenden Forum Beitrag wäre schön)
Was für eine Befehlsmethode habe ich? Ich kann wählen Get, Posten und Put. Ich vermute Posten. Liege ich da richtig?
Muss ich bei Inhaltstyp etwas angeben? Wenn ja was?
Bei Header eine Angabe? Was sind eigentlich in dem Fall Header?
Was muss dann in den Channel rein. Wieder viele Eingabemöglichkeiten, vor allem beim Klick auf Show-Advance.
Bei Command URL Erweiterung hatte ich control?Power eingeben. Wäre das hier richtig?
Ein erstelltes Switch Item macht nicht das was es soll. Der Strip bleibt aus.

Der Code, das beim klicken im Thing kreiert wird ist folgender.

Code: Alles auswählen

UID: http:url:NiciSchrank
label: HTTP URL Thing
thingTypeUID: http:url
configuration:
  authMode: BASIC
  ignoreSSLErrors: false
  baseURL: 192.168.178.150
  delay: 0
  stateMethod: GET
  refresh: 30
  commandMethod: POST
  timeout: 3000
  bufferSize: 2048
channels:
  - id: NiciSchrankPower
    channelTypeUID: http:switch
    label: Switch
    description: ""
    configuration:
      onValue: On
      offValue: Off
      commandExtension: /control?Power

Ich dacht mir schon das dies nicht beim ersten Blauäugigen Versuch funktioniert. Ich weis nur nicht so richtig wo ich nachlesen kann. Was/Warum/Wieso in welches Feld eingetragen werden muss.

(Ich könnte den Code auf dem ESP auch ändern, falls ich da etwas ungünstig erstellt habe. War aber froh das ich gestern Abend ihn über URL, und damit über einen Shelly mit langen Tastendruck einfach schalten konnte.)

Ein Link zu einem Thread hier im Forum, wo es um gleiches/ähnliches geht, wäre auch super nett, da die Suche mir da nichts ausspuckt, bzw. ich wahrscheinlich eher zu blöd bin die Suche richtig zu bedienen. Wenn es einen einfachen Weg gibt dieses Thema zu suchen, wäre eine kleine Anleitung wie man richtig sucht nett.

Herzlich Dank schonmal an alle, die sich diesem Thema annehmen.

[udo1toni]

Darauf folgend soll ich Basis-URL angeben. Das wäre in dem Fall 192.168.178.150 ?

Nein. Die baseURL beinhaltet auf jeden Fall auch das verwendete Protokoll, hier also vermutlich http://. Allerdings ist die baseURL nicht auf Protokoll+FQDN beschränkt. Man könnte auch Teile des restlichen Pfades mit angeben.

Innerhalb des http Things ist das aber auch schon alles, was Du zwingend einstellen musst, alles, was unter den advanced Options zu finden ist, bezieht sich auf weniger häufig gebrauchte Parameter, um z.B. ein BasicAuth zu ermöglichen.

Damit Du Dein Gerät steuern kannst, brauchst Du anschließend noch Channel, das wäre erst mal ein switch Channel. Da das Gerät die Befehle als On und Off erwartet, kommst Du nicht um eine erweiterte Konfiguration herum.
Zum einen musst Du die Werte setzen, zum anderen musst Du die commandExtension setzen, allerdings auch exakt so, wie Du sie brauchst. Die Extension muss auch noch einen Platzhalter beinhalten, der dann durch den transformierten Befehl substituiert wird. Als Code sieht das so aus:

Code: Alles auswählen

UID: http:url:device
label: Mein Device
thingTypeUID: http:url
configuration:
  authMode: BASIC
  ignoreSSLErrors: false
  baseURL: http://192.168.178.150/
  delay: 0
  stateMethod: GET
  refresh: 30
  commandMethod: GET
  timeout: 3000
  bufferSize: 2048
channels:
  - id: ch1
    channelTypeUID: http:switch
    label: Switch
    description: ""
    configuration:
      onValue: On
      mode: WRITEONLY
      offValue: Off
      commandExtension: control?Power=%2$s

openHAB ergänzt meines Wissens automatisch den Slash am Ende der baseURL, aber ordentlicher ist es mit
Wie Du sehen kannst, muss jedes Zeichen der URL auch da stehen, hier das = Zeichen, welches Du unterschlagen hast und eben %2$s als Platzhalter für On bzw. Off. %1$ enthält aktuelles Datum und Zeit, so dass man mit %1$tY z.B. das Jahr mit in der URL übergeben könnte.

All das und noch viel mehr ist aber in der Doku ganz gut beschrieben, die Du (für jedes offizielle Binding) auch direkt aus openHAB heraus aufrufen kannst.

Was den Code auf dem ESP betrifft: kennst Du Tasmota oder ESPeasy? Beide bieten eine extrem ausgereifte Möglichkeit, speziell mit dem ESP8266 zu kommunizieren, mit integrierter Weboberfläche, aber (vor allem...) auch mit MQTT, welches das Leben so viel einfacher machen kann. Mit Tasmota:
1. Du flashst den ESP auf Tasmota.
2. Nachdem der ESP gestartet ist, verbindest Du Dich mit dem Adhoc Netzwerk und rufst im Browser http://192.168.4.1/ auf.
3. Du suchst über die Web UI Dein Netzwerk und trägst nur noch das passende Passwort ein. Anschließend startet der ESP neu und loggt sich in Dein WLAN ein (vor dem Reboot wird automatisch getestet, ob der Zugriff funktionieren wird...)
4. Du verbindest Dich mit der neu vergebenen IP (also z.B. http://192.168.178.150/)
a. Du wählst ein passendes Profil für Deine Hardware aus (welche Funktion, welche Pins) Neustart, zurück zu Punkt 4
b. Du trägst die Zugangsdaten für mqtt ein. Neustart...

In openHAB legst Du eine mqtt Bridge an (das ist der Broker, über den mqtt läuft, meist mosquitto, kannst Du direkt aus openhabian-config heraus installieren lassen) und erzeugst für jedes Gerät ein Thing, ähnlich wie bei http.
Passende Channel sehen dann so aus:

Code: Alles auswählen

UID: mqtt:topic:broker:test
label: test
thingTypeUID: mqtt:topic
configuration: {}
bridgeUID: mqtt:broker:broker
channels:
  - id: switch
    channelTypeUID: mqtt:switch
    label: Switch
    description: ""
    configuration:
      commandTopic: cmnd/meinGeraet/POWER
      stateTopic: stat/meinGeraet/POWER
  - id: color
    channelTypeUID: mqtt:color
    label: Colour
    description: ""
    configuration:
      commandTopic: stat/meinGeraet/color
      stateTopic: stat/meinGeraet/color
      colorMode: RGB

Dieses Thing hat nun zwei Channel, weil schon einer für die Farbsteuerung mit dabei ist. Und das Beste: Das Gerät meldet seinen Zustand an openHAB zurück, wenn Du also das Gerät über die eigene UI steuerst, bekommt openHAB das mit.

Natürlich kannst Du mqtt und besser passende Steuerungsoptionen auch in Deine eigene Firmware implementieren, nur oftmals ist es vergleichsweise aufwändig, ein Rad zu konstruieren, obwohl schon hunderte verschiedene Modelle davon durch die Gegend fahren...
Wenn Du dennoch lieber in der eigenen Firmware bleiben willst, schau Dir das Datenmodell von openHAB an.
Switch Channels erwarten ON und OFF als Befehle. Toggle gibt es in openHAB nicht (es sei denn, man nutzt einen String, aber denke daran, dass ein Toggle niemals eindeutig ist. openHAB will immer klare Anweisungen erteilen).
Color Channels verwenden intern das HSB Farbmodell, man kann natürlich auch mit RGB oder gar xyY steuern, aber gerade für eine intuitiv zu bedienende Oberfläche ist HSB die einfachste Variante, Es werden über ein Farbrad Farbe und Sättigung, sowie über einen Pegelsteller die Helligkeit gewählt, fertig. Die Farbe wird als Tupel übergeben, also z.B. 320,100,50 (erster Wert 0-359, zweiter und dritter Wert 0-100). Dieses Format wird von sehr vielen Geräten am Markt direkt unterstützt, und meist will man nicht drei Befehle senden, um ein Licht zu steuern, sondern am liebsten nur einen...

[N1d45]

Hach. Wie immer bist du eine Super Hilfe. Herzlichen Dank das es dich gibt und du dir immer wieder Zeit nimmst uns zu helfen.

Und es Funktioniert!

Tasmota und ESPeasy, ja kenne ich. Der Reiz liegt eher am c++ Code schreiben und verstehen. Und am Ende das funktionieren.

Toggle ist leider wichtig für den direkten Weg über den Shelly. Mit dem Shelly, kann ich zum Beispiel, über kurzen Tastendruck, das Deckenlicht anschalten, normale Funktion sozusagen. Ich kann aber auch über ein langen Tastendruck, z.B. eine URL aufrufen. Damit ich jetzt über den langen Tastendruck den Strip an und aus schalten kann, geht das am einfachsten über Toggle.

Das Toggle brauche ich in openHAB natürlich nicht, war nur mit erwähnt.

Als nächstes schaue ich, wie ich den Status an openHAB bekomme. Am besten, wenn sich ein Wert am ESP ändert, etwas an openHAB senden.

MQTT ist auch implementiert. Da will ich schauen das ich das über JSON hinbekomme. Etwas vom ESP als JSON zu senden und mit openHAB darauf zu reagieren, bekommen ich schon hin. Nur ein JSON in openHAB zusammenbasteln, und diesen zum ESP zu senden, da probiere ich noch.

Eigentlich brauche ich das HTTP nur für den Shelly.

HSB finde ich nicht so schön für mich am ESP umzusetzen. Am ESP brauche ich die klaren RGB Werte zum schreiben der Pins. Also spätestens dort muss ich es in RGB wandeln. Klar gibt es dafür sogar Libs. Aber da muss ich mich auch noch probieren. RGB ist für mein Verständniss einfacher.

Und aus Erfahrung, spielt man eh nur am Anfang mit der Farbe rum. Nach einer gewissen Zeit bleibt es bei einer für schön empfundenen Farbe. Man macht es dann nur noch an oder aus.

Tausend Dank!

[udo1toni]

MQTT ist auch implementiert. Da will ich schauen das ich das über JSON hinbekomme. Etwas vom ESP als JSON zu senden und mit openHAB darauf zu reagieren, bekommen ich schon hin. Nur ein JSON in openHAB zusammenbasteln, und diesen zum ESP zu senden, da probiere ich noch.

Ja, JSON schicken läuft halt "zu Fuß". Das heißt, Du erzeugst einen String, in dem das JSON drin steht, entweder tatsächlich über einen String Channel und eine Rule, oder halt über formatBeforePublish, dort setzt Du dann das JSON Objekt ein und ersetzt den dynamischen Teil mit dem Platzhalter, analog zur urlExtension beim http Binding.

RGB ist für mein Verständniss einfacher.

Aus Programmierersicht ja, für die Bedienung aber ein klares Nein.

[N1d45]

Um jetzt nicht unbedingt ein neues Thema auf zu machen.
Steuern per HTTP funktioniert.
Steuern per MQTT mit MQTT.fx funktioniert.
Es gibt ein State Topic, was auch auf alle Änderungen, auch per HTTP, ein Publish vom ESP auslöst.

State Topic: Test/Schrank/State
Command Topic: Test/Schrank/Command

Ein Beispiel für ein Publish:

Code: Alles auswählen

{"Power":"On","Red":125,"Green":255,"Blue":0}

Ein Switch für Power ließ sich relativ einfach umsetzen. Er wird auch aktualisiert, wenn ich über HTTP eine Änderung auf dem ESP ausführe.
Nur mit RGB klappt nicht. Ich vermute, ich bekomme die 3 Werte nicht ordentlich aus dem JSON extrahiert. Einzelne Atribute aus einem JSON fischen geht ja relativ einfach, hier als Beispiel für Rot, über 'JSONPATH:$.Red'. Aber wie übergebe ich 3 Werte? Mit den Platzhaltern für das Senden habe ich, zumindest so denke ich, richtig verstanden?

Hier mal der Code vom Thing

Code: Alles auswählen

UID: mqtt:topic:843421fdf2:Nici_Schrank_RGB
label: Nici Schrank RGB
thingTypeUID: mqtt:topic
configuration: {}
bridgeUID: mqtt:broker:843421fdf2
channels:
  - id: Nici_Schrank_RGB_Switch
    channelTypeUID: mqtt:switch
    label: Nici Schrank Switch
    description: ""
    configuration:
      qos: 0
      formatBeforePublish: '{"Power":"%s"}'
      commandTopic: Test/Schrank/Command
      stateTopic: Test/Schrank/State
      transformationPattern: JSONPATH:$.Power
      off: Off
      on: On
  - id: Nici_Schrank_RGB_Farbe
    channelTypeUID: mqtt:colorRGB
    label: Nici Schrank RGB Farbe
    description: ""
    configuration:
      commandTopic: Test/Schrank/Command
      colorMode: RGB
      qos: 0
      formatBeforePublish: '{"Power":"On","Red":%1$d,"Green":%2$d,"Blue":%3$d}'
      stateTopic: Test/Schrank/State
      transformationPattern: JSONPATH:$.Red∩JSONPATH:$.Green∩JSONPATH:$.Blue

Edit: Das ∩ ist vermutlich der falsche Weg im transformationspattern. Kann man da auch irgendwie mit Platzhaltern arbeiten?

[udo1toni]

Direkt mit jsonpath hast Du da keine Chance, glücklicherweise gibt es aber auch noch die Möglichkeit des Scriptings.
Die Variante mit einem DSL Script sollte etwa so aussehen:

Code: Alles auswählen

      transformationPattern: DSL:|transform("JSONPATH","$.Red",input)+", "transform("JSONPATH","$.Green",input)+", "transform("JSONPATH","$.Blue",input)

Die saubere Variante wäre eher, eine Script Datei zu erstellen (in openHAB4 Main UI->Administration->Einstellungen->Configuration->Transformations->Klick auf das weiße Plus im blauen Kreis rechts unten->UID und Label setzen (z.B. json2rgb), Language auf Deutsch setzen, DSL wählen und Code eingeben:

Code: Alles auswählen

var red   = transform("JSONPATH","$.Red",  input)
var green = transform("JSONPATH","$.Green",input)
var blue  = transform("JSONPATH","$.Blue", input)
var returnValue = red + ", "+ green + ", " + blue
returnValue

Save (rechts oben)
Nun kannst Du im Channel

Code: Alles auswählen

]      transformationPattern: DSL:config:dsl:json2rgb:de

schreiben und das DSL Script wird aufgerufen.
Du kannst auch beliebige andere Scriptsprachen auf die gleiche Art verwenden (immer vorausgesetzt, die Sprache ist auch in openHAB als Addon installiert).

Im Script werden hier drei voneinander getrennte JSONpath Transformations ausgeführt und deren Ergebnis anschließend zu einem passenden String zusammengesetzt, welcher über einen color Channel im rgb-Mode verwendet werden kann.

Abgehend (also um mit openHAB die Farbe zu setzen) geht es noch einfacher, Du musst lediglich den Parameter formatBeforePublish setzen:

Code: Alles auswählen

formatBeforePublish: {"Power":"On","Red":%1$d,"Green":%2$d,"Blue":%3$d}

%1$d repräsentiert also rot, %2$d grün und %3$d blau (immer unter der Annahme, dass der color Mode auf rgb steht).

Intern arbeitet openHAB immer mit HSB, nach außen kann es aber auch rgb oder xyY verwenden