Shellys ("Alt und Plus") über MQTT Adapter

[mickym]

@hotspot_2 Ok - nun scheinst Du es verstanden zu haben. - Auch wenn ich Dein Flow trotzdem komplex finde und ich ggf. den Waschküchen BWM komplett eigenständig behandelt hätte, so hast Du nun die Fehler im Flow selbst ausgebessert. Nur wenn Du halt behauptest, es hätte am Anfang alles funktioniert, dann war das sicher nicht richtig.

Aber ich denke, Du hast heute eine Menge gelernt.

[hotspot_2]

@mickym Ja, auf jeden Fall. Die herangehensweise und wie man das simuliert und auch durchtestet. Das war für mich so nicht greifbar.

Dankeschön!

[mickym]

@hotspot_2 Ok - nun scheinst Du es verstanden zu haben. - Auch wenn ich Dein Flow trotzdem komplex finde und ich ggf. den Waschküchen BWM komplett eigenständig behandelt hätte, so hast Du nun die Fehler im Flow selbst ausgebessert. Nur wenn Du halt behauptest, es hätte am Anfang alles funktioniert, dann war das sicher nicht richtig.

Aber ich denke, Du hast heute eine Menge gelernt.

UND function Nodes und JS Programmierung sind für Dich erst mal tabu. - Dann kannst Du ja gleich wieder Javascript im Javascript Adapter programmieren. - Du wirst sehen, dass Du sehr lange ohne function Nodes auskommst - und kopiere nicht Flows aus dem Netz. Die meisten nehmen function Nodes und fangen wieder das herkömmliche Programmieren an.

Wir können Deinen kompletten Flow in einer Function Node unterbringen. Willst Du das etwa????

Dann lernst Du lieber erst mal JSONATA und Du wirst sehen - wie mächtig das sein kann und wieviel Codeschreiberei Du Dir sparen kannst.

[dos1973]

@mickym

mein 2PM Plus als Schalter läuft. Danke Dir.

[mickym]

@dos1973 Das nur ACK=False kannst Du direkt in der iobroker-IN Node einstellen bzw. filtern.

[hotspot_2]

@mickym Hallo mickym,

ich habe mal ne Frage zum Thema msg und flow Payload. Ich würde gerne den msg. Payload der von dem MQTT in kommt an mehreren Stellen im Flow auslesen bzw. verschiedene Items (alarm, mute usw.) prüfen. Am Ende muss aber ein msg Payload an eine Pushover Node gehen damit eine Nachricht verschickt wird.

Ich würde nun gerne die Payload für den Pushover in flow.* aufbauen und den msg.* Payload nicht verändern. Am Ende dann quasi die flow. zur msg. Payload machen kurz vor der Pushover Node. Geht das? Ist das ein guter Ansatz?

Oder besser mit Variablen arbeiten und am Ende die msg.payload zusammenbauen?

Ich hoffe Du kannst nachvollziehen was ich meine.

[mickym]

@hotspot_2 sagte in Shellys ("Alt und Plus") über MQTT Adapter:

Oder besser mit Variablen arbeiten und am Ende die msg.payload zusammenbauen?

Nun im flow Kontext ist das eine Variable - klar geht das. Ob den zusammengefassten Status in einem Datenpunkt sammelst oder im flow-Kontext ist letztlich nur davon abhängig, ob die Informationen einen Neustart von NodeRed überleben sollen oder nicht.

Ansonsten allgemein zur Überwachung - kannst Dir ja mal mein Post von hier anschauen: https://forum.iobroker.net/post/625108

[hotspot_2]

@mickym Habe noch ein anderes Problem entdeckt wo ich nicht wirklich eine Lösung finden kann.

Im MQTT Adapter habe ich folgenden Eintrag gefunden unter mqtt/0:

Die ID die hier sichtbar ist in diesem Objekt ist die 199:

Die schreiben wir in einem Flow in Node RED:

Ich habe, extra um dem auf die Schliche zu kommen woher das kommt, die IDs verändert.

Muss das so sein? Oder habe ich da irgendwo einen Fehler drin?

[mickym]

@hotspot_2 der rpc kanal hotspot2 enthält alle Antworten auf alle Deine Befehle - also die Quittung. Das ist also kein Fehler - Du siehst das Gerät in src und das Ergebnis Deines Befehls. Die Beschreibung der RPC Kanäle findest Du hier:
https://shelly-api-docs.shelly.cloud/gen2/General/RPCChannels

Ich habe auch mal für Dich die entsprechende Stelle rausgesucht:

Du kannst aber seit Version 14 auch direkt ohne den RPC Kanal schalten. Das habe ich gesehen und siehst an den Beispielen von @dos1973. Ich würde, wenn ich DU wäre das nun alles auf command/switch umstellen. Du musst halt nur true und false in on und off wandeln. In der Generation 1 war es ja auch on und off.

Wenn Du viel von unterschiedlichen Quellen schaltest mag zwar das RPC Protokoll ganz praktisch sein da Du siehst woher ein Befehl kam. Musst Du wissen - ich finde das normale Schalten über den command Ast einfacher.

[hotspot_2]

@mickym Ok, schaue ich mir an. Tendenziell sehe ich es auch so das schalten über command einfacher ist ;-).

Macht richtig viel Spaß mit der Methode die JSONs zu analysieren, mit Injects und Debugs zu arbeiten. Man lernt einiges dabei. Baue mir gerade einen Flow für alle Alarme im Haus, Batteriemeldungen und sonstige Benachrichtigungen die über Pushover oder Email versendet werden.

Node Red ist einfach genial ;-).

[mickym]

@hotspot_2 Node Red ist einfach genial ;-). Na da rennst Du bei mir offene Türen ein. Leider beschäftigen sich die meisten erst gar nicht damit. Die, die auf den Geschmack gekommen sind, habe ich noch nie wieder auf Blockly zurück migrieren sehen.;)

Was Du halt noch machen kannst, wenn Du willst, deswegen habe ich Dir den anderen Thread verlinkt, dass Du selbst Objekte baust und mit true und false arbeitest. Aber mach erst mal - zur Optimierung und weiteren Idee ist ja immer noch Zeit.

Und wie Du siehst, wenn man einmal gelernt hat, mit Objekten umzugehen, dann ist das eigentlich ganz easy und lernt die Vorteile von Objekten kennen.

[hotspot_2]

@mickym Ich hätte noch mal eine Frage dazu wie Du sowas angehen würdest.

Ich habe im Garten eine elektrische Klingel die ich über einen Shelly ansteuere. Klingelt jemand an der Haustüre dann mache ich seither über einen Blockly die Klingel zweimal an und wieder aus mit kurzen Pausen dazwischen.

Wenn ich sowas jetzt in Node-Red machen möchte wie würde ich das angehen? Gibt es da sowas wie eine Schleife oder so?

Trigger wäre ein Ansatz gewesen aber der macht halt nur einmal an und wieder aus.

[mickym]

@hotspot_2 Nein die Trigger Node kann auch unendlich oft in bestimmten Abständen triggern. Aber natürlich kannst Du auch Schleifen bauen - du musst ja nun den Ausgang mit dem Eingang verbinden.

Das macht sie solange, bis Du die Trigger Node zurücksetzt.

Wenn die Klingel zwischendrin wieder ausschalten musst, dann kannst auch wie bisher den trigger nehmen und über den 2.Ausgang die Schleife antriggern.

Du kannst dann über eine Flow-variable zählen oder in dem Fall auch über eine function-Node und JS - wenn Dir für einen stupiden Zähler die Variable im FlowKontext zu viel ist. Hier mal 2 Varianten.

Hier mal eine Variante mit Flow-Kontext:

Spoiler

[
   {
       "id": "0af2185be7349ad3",
       "type": "trigger",
       "z": "2e7d4cac81c671e3",
       "name": "",
       "op1": "true",
       "op2": "false",
       "op1type": "bool",
       "op2type": "bool",
       "duration": "2",
       "extend": false,
       "overrideDelay": false,
       "units": "s",
       "reset": "0",
       "bytopic": "all",
       "topic": "topic",
       "outputs": 2,
       "x": 480,
       "y": 4460,
       "wires": [
           [
               "92d78df371e2dde2"
           ],
           [
               "92d78df371e2dde2",
               "3c4db8300739ee09"
           ]
       ]
   },
   {
       "id": "92d78df371e2dde2",
       "type": "debug",
       "z": "2e7d4cac81c671e3",
       "name": "Klingel",
       "active": true,
       "tosidebar": true,
       "console": false,
       "tostatus": false,
       "complete": "payload",
       "targetType": "msg",
       "statusVal": "",
       "statusType": "auto",
       "x": 710,
       "y": 4440,
       "wires": []
   },
   {
       "id": "7a93f96057f10e61",
       "type": "inject",
       "z": "2e7d4cac81c671e3",
       "name": "Es klingelt",
       "props": [
           {
               "p": "payload"
           },
           {
               "p": "topic",
               "vt": "str"
           }
       ],
       "repeat": "",
       "crontab": "",
       "once": false,
       "onceDelay": 0.1,
       "topic": "",
       "payload": "true",
       "payloadType": "bool",
       "x": 280,
       "y": 4460,
       "wires": [
           [
               "0af2185be7349ad3"
           ]
       ]
   },
   {
       "id": "3c4db8300739ee09",
       "type": "change",
       "z": "2e7d4cac81c671e3",
       "name": "",
       "rules": [
           {
               "t": "set",
               "p": "payload",
               "pt": "msg",
               "to": "numKlingel",
               "tot": "flow"
           },
           {
               "t": "set",
               "p": "payload",
               "pt": "msg",
               "to": "payload ? payload : 0",
               "tot": "jsonata"
           },
           {
               "t": "set",
               "p": "payload",
               "pt": "msg",
               "to": "(payload + 1) % 2",
               "tot": "jsonata"
           },
           {
               "t": "set",
               "p": "numKlingel",
               "pt": "flow",
               "to": "payload",
               "tot": "msg"
           }
       ],
       "action": "",
       "property": "",
       "from": "",
       "to": "",
       "reg": false,
       "x": 490,
       "y": 4540,
       "wires": [
           [
               "0af2185be7349ad3"
           ]
       ]
   }
]

Hier das gleiche mit einer function node und node context, falls Du lieber mit Javascript programmieren willst.

Spoiler

![4025c15c-8035-4349-ba7d-81e6b3f4ebd2-image.png](/assets/uploads/files/1681413147135-4025c15c-8035-4349-ba7d-81e6b3f4ebd2-image-resized.png) code_text

Falls nicht zwischen true und false gewechselt werden muss, kannst Du einfach eine function Node nehmen und eine Delay node:

Spoiler

[
    {
        "id": "92d78df371e2dde2",
        "type": "debug",
        "z": "2e7d4cac81c671e3",
        "name": "Klingel",
        "active": true,
        "tosidebar": true,
        "console": false,
        "tostatus": false,
        "complete": "payload",
        "targetType": "msg",
        "statusVal": "",
        "statusType": "auto",
        "x": 1070,
        "y": 4340,
        "wires": []
    },
    {
        "id": "7a93f96057f10e61",
        "type": "inject",
        "z": "2e7d4cac81c671e3",
        "name": "Es klingelt",
        "props": [
            {
                "p": "payload"
            },
            {
                "p": "topic",
                "vt": "str"
            }
        ],
        "repeat": "",
        "crontab": "",
        "once": false,
        "onceDelay": 0.1,
        "topic": "",
        "payload": "true",
        "payloadType": "bool",
        "x": 660,
        "y": 4340,
        "wires": [
            [
                "e0509ab40a79eeb9"
            ]
        ]
    },
    {
        "id": "e0509ab40a79eeb9",
        "type": "function",
        "z": "2e7d4cac81c671e3",
        "name": "zähler bis 3",
        "func": "let counter = context.get(\"zähler\") || 0;\ncounter ++;\ncontext.set(\"zähler\",counter %4);\nif (counter %4 !== 0 ) return msg; ",
        "outputs": 1,
        "noerr": 0,
        "initialize": "",
        "finalize": "",
        "libs": [],
        "x": 850,
        "y": 4340,
        "wires": [
            [
                "92d78df371e2dde2",
                "5ed1e1284f6ff64c"
            ]
        ]
    },
    {
        "id": "5ed1e1284f6ff64c",
        "type": "delay",
        "z": "2e7d4cac81c671e3",
        "name": "",
        "pauseType": "delay",
        "timeout": "5",
        "timeoutUnits": "seconds",
        "rate": "1",
        "nbRateUnits": "1",
        "rateUnits": "second",
        "randomFirst": "1",
        "randomLast": "5",
        "randomUnits": "seconds",
        "drop": false,
        "allowrate": false,
        "outputs": 1,
        "x": 840,
        "y": 4420,
        "wires": [
            [
                "e0509ab40a79eeb9"
            ]
        ]
    }
]

So und hier nochmal das Gleiche ohne Javascript Programmierung und nur mit Change Node und Flow Kontext.

Spoiler

[
   {
       "id": "92d78df371e2dde2",
       "type": "debug",
       "z": "2e7d4cac81c671e3",
       "name": "Klingel",
       "active": true,
       "tosidebar": true,
       "console": false,
       "tostatus": false,
       "complete": "payload",
       "targetType": "msg",
       "statusVal": "",
       "statusType": "auto",
       "x": 1070,
       "y": 4340,
       "wires": []
   },
   {
       "id": "7a93f96057f10e61",
       "type": "inject",
       "z": "2e7d4cac81c671e3",
       "name": "Es klingelt",
       "props": [
           {
               "p": "payload"
           },
           {
               "p": "topic",
               "vt": "str"
           }
       ],
       "repeat": "",
       "crontab": "",
       "once": false,
       "onceDelay": 0.1,
       "topic": "",
       "payload": "true",
       "payloadType": "bool",
       "x": 660,
       "y": 4340,
       "wires": [
           [
               "3c4db8300739ee09"
           ]
       ]
   },
   {
       "id": "5ed1e1284f6ff64c",
       "type": "delay",
       "z": "2e7d4cac81c671e3",
       "name": "",
       "pauseType": "delay",
       "timeout": "5",
       "timeoutUnits": "seconds",
       "rate": "1",
       "nbRateUnits": "1",
       "rateUnits": "second",
       "randomFirst": "1",
       "randomLast": "5",
       "randomUnits": "seconds",
       "drop": false,
       "allowrate": false,
       "outputs": 1,
       "x": 840,
       "y": 4420,
       "wires": [
           [
               "3c4db8300739ee09"
           ]
       ]
   },
   {
       "id": "3c4db8300739ee09",
       "type": "change",
       "z": "2e7d4cac81c671e3",
       "name": "",
       "rules": [
           {
               "t": "set",
               "p": "counter",
               "pt": "msg",
               "to": "numKlingel",
               "tot": "flow"
           },
           {
               "t": "set",
               "p": "counter",
               "pt": "msg",
               "to": "counter? counter : 0",
               "tot": "jsonata"
           },
           {
               "t": "set",
               "p": "counter",
               "pt": "msg",
               "to": "(counter + 1) % 3",
               "tot": "jsonata"
           },
           {
               "t": "set",
               "p": "reset",
               "pt": "msg",
               "to": "counter = 0 ? true : undefined",
               "tot": "jsonata"
           },
           {
               "t": "set",
               "p": "numKlingel",
               "pt": "flow",
               "to": "counter",
               "tot": "msg"
           }
       ],
       "action": "",
       "property": "",
       "from": "",
       "to": "",
       "reg": false,
       "x": 850,
       "y": 4340,
       "wires": [
           [
               "92d78df371e2dde2",
               "5ed1e1284f6ff64c"
           ]
       ]
   },
   {
       "id": "e0509ab40a79eeb9",
       "type": "function",
       "z": "2e7d4cac81c671e3",
       "d": true,
       "name": "zähler bis 3",
       "func": "let counter = context.get(\"zähler\") || 0;\ncounter ++;\ncontext.set(\"zähler\",counter %4);\nif (counter %4 !== 0 ) return msg; ",
       "outputs": 1,
       "noerr": 0,
       "initialize": "",
       "finalize": "",
       "libs": [],
       "x": 850,
       "y": 4480,
       "wires": [
           []
       ]
   }
]

So keine Schleife - aber noch ein ganz anderer Lösungsansatz ist, Du machst Dir zum Beispiel ein Array mit Nachrichten die Du schicken möchtest und splittest die einfach auf . Später wirst Du die split Node mal kennenlernen, die eine Schleife der herkömmlichen Programmierung ersetzt.

Nehmen wir mal Du möchstest verschiedene Nachrichten einfach mit einer delay Node verschicken, dann geht zum Beispiel auch so was.

Du siehst die Möglichkeiten sind vielfältig.

Spoiler

[
   {
       "id": "d74c9ca8835acb75",
       "type": "inject",
       "z": "2e7d4cac81c671e3",
       "name": "",
       "props": [
           {
               "p": "payload"
           }
       ],
       "repeat": "",
       "crontab": "",
       "once": false,
       "onceDelay": 0.1,
       "topic": "",
       "payload": "[true,false, true,false,true,false]",
       "payloadType": "json",
       "x": 970,
       "y": 4440,
       "wires": [
           [
               "23f41eaa57ebf7c3",
               "8b0a0ba6f8f58f1c"
           ]
       ]
   },
   {
       "id": "23f41eaa57ebf7c3",
       "type": "debug",
       "z": "2e7d4cac81c671e3",
       "name": "Array",
       "active": true,
       "tosidebar": true,
       "console": false,
       "tostatus": false,
       "complete": "payload",
       "targetType": "msg",
       "statusVal": "",
       "statusType": "auto",
       "x": 1130,
       "y": 4400,
       "wires": []
   },
   {
       "id": "8b0a0ba6f8f58f1c",
       "type": "split",
       "z": "2e7d4cac81c671e3",
       "name": "",
       "splt": "\\n",
       "spltType": "str",
       "arraySplt": 1,
       "arraySpltType": "len",
       "stream": false,
       "addname": "",
       "x": 1130,
       "y": 4440,
       "wires": [
           [
               "afe4291f50fdaa48",
               "49df363c23a16584"
           ]
       ]
   },
   {
       "id": "afe4291f50fdaa48",
       "type": "debug",
       "z": "2e7d4cac81c671e3",
       "name": "aufgesplittetes Array",
       "active": false,
       "tosidebar": true,
       "console": false,
       "tostatus": false,
       "complete": "payload",
       "targetType": "msg",
       "statusVal": "",
       "statusType": "auto",
       "x": 1320,
       "y": 4500,
       "wires": []
   },
   {
       "id": "49df363c23a16584",
       "type": "delay",
       "z": "2e7d4cac81c671e3",
       "name": "",
       "pauseType": "rate",
       "timeout": "5",
       "timeoutUnits": "seconds",
       "rate": "1",
       "nbRateUnits": "5",
       "rateUnits": "second",
       "randomFirst": "1",
       "randomLast": "5",
       "randomUnits": "seconds",
       "drop": false,
       "allowrate": false,
       "outputs": 1,
       "x": 1320,
       "y": 4440,
       "wires": [
           [
               "e48688c7ddd744a9"
           ]
       ]
   },
   {
       "id": "e48688c7ddd744a9",
       "type": "debug",
       "z": "2e7d4cac81c671e3",
       "name": "in dosierter Form",
       "active": true,
       "tosidebar": true,
       "console": false,
       "tostatus": false,
       "complete": "payload",
       "targetType": "msg",
       "statusVal": "",
       "statusType": "auto",
       "x": 1570,
       "y": 4440,
       "wires": []
   }
]

Und natürlich kannst Du auch alles in JS programmieren mit einer function Node. - falls Du einfach codieren willst.

[dos1973]

@mickym

Node Red ist schon cool - aber ich finde sauschwer, daran liegts vielleicht. blockly bist schnell drin und lässt sich irgendwie leichter lesen.

[mickym]

@dos1973 Na ich finde es ganz und gar nicht schwer und eigentlich viel einfacher zu lesen, weil Du Dich nur an den Kabeln entlang hangeln musst. Blockly ist viel zu starr an die herkömmliche Programmierlogik angelehnt und du kannst keine Funktionsblöcke bilden.

[dos1973]

@mickym
Du … bist ja von flows umschwungen
Bei dir sieht das immer so easy und logisch aus.

[mickym]

@dos1973 sagte in Shellys ("Alt und Plus") über MQTT Adapter:

@mickym
Du … bist ja von flows umschwungen
Bei dir sieht das immer so easy und logisch aus.

Na Du musst Dir doch nur vorstellen, wie ein Nachrichtenobjekt durch die Kabel flutscht und Dir dann jede Node betrachtest, was diese mit dem Nachrichtenobjekt anstellt. - Das schöne ist - Du kannst über Inject Nodes - Zwischenergebnisse in Deinen Flow injizieren, über debug Nodes Dich versichern, dass die Nachrichtenobjekte noch so aussehen, wie Du es erwartest. Mal ein Kabel kappen, um die Hardware nicht unnötig zu belasten und wie gesagt es gibt auch Nodes, die ganze Adapter ersetzen, wenn die mal nicht so wollen, wie man sich das vorstellt.

Du musst nur etwas Vorstellungskraft entwickeln - so ein Nachrichtenobjekt zu sein und durch die Kabel zu fließen.

[hotspot_2]

@mickym

Diese Variante:

Ist mir sehr sympatisch.

Würde ich damit auch so eine Folge hinbekommen:

True - 2 Sekunken Pause - False - 2 Sekunden Pause - True 2 Sekundnen Pause- False

Also quasi 2 mal klingeln mit Pause dazwischen? Im Moment wird ja wieder direkt nach false true geschickt.

[mickym]

@hotspot_2 dann nimm doch lieber die letzte Variante mit dem Array, da kommst auch ohne Variable und Flow Kontext aus. Das Array definierst einfach in einer Change-Node. Damit steuerst Du über ein Array einfach die Nachrichtenfolge und begrenzt die Nachrichtenrate über die delay Node.

Spoiler

[
   {
       "id": "c8b50d3d51d90b9c",
       "type": "inject",
       "z": "2e7d4cac81c671e3",
       "name": "Es klingelt",
       "props": [
           {
               "p": "payload"
           }
       ],
       "repeat": "",
       "crontab": "",
       "once": false,
       "onceDelay": 0.1,
       "topic": "",
       "payload": "true",
       "payloadType": "bool",
       "x": 520,
       "y": 4360,
       "wires": [
           [
               "79bf8d45a373fc13"
           ]
       ]
   },
   {
       "id": "79bf8d45a373fc13",
       "type": "change",
       "z": "2e7d4cac81c671e3",
       "name": "",
       "rules": [
           {
               "t": "set",
               "p": "payload",
               "pt": "msg",
               "to": "[true,false,true,false]",
               "tot": "json"
           }
       ],
       "action": "",
       "property": "",
       "from": "",
       "to": "",
       "reg": false,
       "x": 710,
       "y": 4360,
       "wires": [
           [
               "32dd43edf0eaf0dd"
           ]
       ]
   },
   {
       "id": "32dd43edf0eaf0dd",
       "type": "split",
       "z": "2e7d4cac81c671e3",
       "name": "",
       "splt": "\\n",
       "spltType": "str",
       "arraySplt": 1,
       "arraySpltType": "len",
       "stream": false,
       "addname": "",
       "x": 890,
       "y": 4360,
       "wires": [
           [
               "d7b7548fa616ba39"
           ]
       ]
   },
   {
       "id": "5384ef4e3a1e8116",
       "type": "debug",
       "z": "2e7d4cac81c671e3",
       "name": "Klingel",
       "active": true,
       "tosidebar": true,
       "console": false,
       "tostatus": false,
       "complete": "payload",
       "targetType": "msg",
       "statusVal": "",
       "statusType": "auto",
       "x": 1270,
       "y": 4360,
       "wires": []
   },
   {
       "id": "d7b7548fa616ba39",
       "type": "delay",
       "z": "2e7d4cac81c671e3",
       "name": "",
       "pauseType": "rate",
       "timeout": "5",
       "timeoutUnits": "seconds",
       "rate": "1",
       "nbRateUnits": "2",
       "rateUnits": "second",
       "randomFirst": "1",
       "randomLast": "5",
       "randomUnits": "seconds",
       "drop": false,
       "allowrate": false,
       "outputs": 1,
       "x": 1080,
       "y": 4360,
       "wires": [
           [
               "5384ef4e3a1e8116"
           ]
       ]
   }
]

Du siehst an den Zeitstempeln alle 2 s eine Nachricht. Außerdem siehst du an der Delay Node im Status gleich, wieviele Nachrichten noch kommen.

Bei der Variante unten von dir müsstest Du noch eine delay Node mit 2s in die Schleife einfügen, da finde ich das ohne Flowkontext viel einfacher und intuitiver.

[hotspot_2]

@mickym Funktioniert perfekt!

Hast Du mir noch einen Tipp wie ich den Eingang entprellen kann (Klingeltaster). So dass z.B. alle 2 Sekunden nur eine Meldung durchgeht?