diff --git a/bundles/org.openhab.binding.linktap/NOTICE b/bundles/org.openhab.binding.linktap/NOTICE
new file mode 100644
index 0000000000000..38d625e349232
--- /dev/null
+++ b/bundles/org.openhab.binding.linktap/NOTICE
@@ -0,0 +1,13 @@
+This content is produced and maintained by the openHAB project.
+
+* Project home: https://www.openhab.org
+
+== Declared Project Licenses
+
+This program and the accompanying materials are made available under the terms
+of the Eclipse Public License 2.0 which is available at
+https://www.eclipse.org/legal/epl-2.0/.
+
+== Source Code
+
+https://github.com/openhab/openhab-addons
diff --git a/bundles/org.openhab.binding.linktap/README.md b/bundles/org.openhab.binding.linktap/README.md
new file mode 100644
index 0000000000000..64c1062402273
--- /dev/null
+++ b/bundles/org.openhab.binding.linktap/README.md
@@ -0,0 +1,201 @@
+# LinkTap Binding
+
+This binding is for [LinkTap](https://www.link-tap.com/) devices.
+
+**This is for communication over a local area network, that prevents direct access to your gateway / openHAB instance from the internet. E.g. behind a router**
+
+The method of interaction this binding supports is:
+
+**Program and execution of the watering plan within the application**
+
+The currently supported capabilities include where supported by the gateway / device:
+
+- Time syncrhonisation to openHAB
+- Child lock controls
+- Monitoring and dismissal for device alarms (Water Cut, etc.)
+- Monitoring of sensor states (Battery, Zigbee Signal, Flow Meters Statistics, etc.)
+- Enable watering based on time duration / volume limits
+- Shutdown of active watering
+
+## Requirements
+
+A LinkTap gateway device, in order for openHAB to connect to the system, as a bridge.
+
+## Connection options
+
+LinkTap supports MQTT and a direct interaction via HTTP. 
+This binding directly interact's with LinkTap's bridges using the Local HTTP API (HTTP).
+The binding connects to the bridge's directly, and the Gateway is configured automatically to push updates to openHAB if
+it has a HTTP configured server. (Note HTTPS is not supported).
+
+Should the Gateway device's not be able to connect to the binding it automatically falls-back to a polling
+implementation (15 second cycle). The gateway supports 1 Local HTTP API, for an ideal behaviour the Gateway should be able to
+connect to OpenHab on an HTTP port from its IP, and only a single OpenHab instance should be connected to a Gateway.
+
+It is recommended that you use **static IP's** for this binding, **for both openHAB and the Gateway device(s)**.
+
+## Supported Things
+
+This binding supports the follow thing types:
+
+| Thing          | Thing Type | Thing Type UID | Discovery          | Description                              |
+|----------------|------------|----------------|--------------------|------------------------------------------|
+| Bridge         | Bridge     | linkTapBridge  | Manual / Automatic | A connection to a LinkTap Gateway device |
+| LinkTap Device | Thing      | linkTapDevice  | Automatic          | A end device such as the Q1              |
+
+**NOTE** This binding was developed and tested using a GW-02 gateway with a Q1 device. 
+
+## Discovery
+
+### Gateways
+
+If mDNS has been enabled on the Gateway device via it's webpage, then the gateway(s) will be discovered, and appear in the inbox
+when a manual scan is run when adding a LinkTap Gateway. It is however recommended to use **static IP addresses** and add the
+gateways directly using the IP address.
+
+### Devices
+
+Once connected to a LinkTap gateway, the binding will listen for updates of new devices and add them, to the inbox.
+If the gateway cannot publish to openHAB, then the gateway is checked every 2 minutes for new devices, and they are added to the inbox when discovered.
+
+## Binding Configuration
+
+### Bridge configuration parameters
+
+| Name       | Type   | Description                                                                       | Recommended Values | Required | Advanced |
+|------------|--------|-----------------------------------------------------------------------------------|--------------------|----------|----------|
+| host       | String | The hostname / IP address of the gateway device                                   |                    | Yes      | No       |
+| username   | String | The username if set for the gateway device                                        |                    | No       | No       |
+| password   | String | The password if set for the gateway device                                        |                    | No       | No       |
+| enableMDNS | Switch | On connection whether the mDNS responder should be enabled on the gateway device  | ON                 | No       | Yes      |
+
+**NOTE** When enableMDNS is enabled, upon connection to the gateway option "Enable mDNS responder" is switched on 
+
+### LinkTap Device configuration parameters
+
+It is recommended to use the Device Id, for locating devices. This can be found in the LinkTap mobile application under 
+Settings->TapLinker / ValveLinker, e.g.
+
+- ValueLinker_1 (D71BC52F004B1200_1-xxxx)
+  - has Device Id "ValveLinker_1"
+  - has Device Name D71BC52F004B1200_1
+
+| Name         | Type   | Description                                                           | Recommended Values | Required | Advanced |
+|--------------|--------|-----------------------------------------------------------------------|--------------------|----------|----------|
+| deviceId     | String | The Device Id for the device under the gateway                        |                    | Yes      | No       |
+| deviceName   | String | The name allocated to the device by the app. (Must be unique if used) |                    | Yes      | No       |
+| enableAlerts | Switch | On connection whether the device should be configured to send alerts  | ON                 | No       | Yes      |
+
+**NOTE**
+
+- a **deviceId** or a **deviceName must be provided** to communicate with the device
+- **enableAlerts** allows the binding to **receive updates of Water Cut, and other alerts** conditions are detected for a LinkTap device.
+
+## Thing Configuration
+
+_Describe what is needed to manually configure a thing, either through the UI or via a thing-file._
+_This should be mainly about its mandatory and optional configuration parameters._
+
+_Note that it is planned to generate some part of this based on the XML files within ```src/main/resources/OH-INF/thing``` of your binding._
+
+### `sample` Thing Configuration
+
+| Name            | Type    | Description                           | Default | Required | Advanced |
+|-----------------|---------|---------------------------------------|---------|----------|----------|
+| host            | text    | Hostname or IP address of the device  | N/A     | yes      | no       |
+| password        | text    | Password to access the device         | N/A     | yes      | no       |
+| refreshInterval | integer | Interval the device is polled in sec. | 600     | no       | yes      |
+
+## Channels
+
+There are 3 different Area of channels:
+
+- RO Data (Read Only Data)
+  - These represent data published by the device
+- Alerts
+  - These are switches that are set to ON by the device when an alert condition is detected, such as a Water Cut.
+  - The alert can be dismissed by setting the switch to OFF
+- WR Data (Read Write Data)
+  - Provides the ability to read data
+  - Provides the ability to set a relevant state to the data
+- W Data
+  - Provides parameter values for the named action, is stored within openHAB is not read from the device
+    - E.g. Start Immediate Watering
+      - Can be limited by a time duration - ohDurLimit
+      - If a flow meter is attached can be limited by a volume limit - ohVolLimit
+
+
+| Name             | Type                      | Description                                                               | Representation | Read/Write | Write Action                                                                                                                 |
+|------------------|---------------------------|---------------------------------------------------------------------------|----------------|------------|------------------------------------------------------------------------------------------------------------------------------|
+| water-cut        | Switch                    | Water cut-off alert                                                       | Alert          | Write      | Dismiss alert                                                                                                                |
+| shutdown-failure | Switch                    | The device has failed to close the valve                                  | Alert          | Write      | Dismiss alert                                                                                                                |
+| high-flow        | Switch                    | Unusually high flow rate detected alert                                   | Alert          | Write      | Dismiss alert                                                                                                                |
+| low-flow         | Switch                    | Unusually low flow rate detected alert                                    | Alert          | Write      | Dismiss alert                                                                                                                |
+| fall-status      | Switch                    | The device has fallen                                                     | Alert          | Write      | Dismiss alert                                                                                                                |
+| flm-linked       | Switch                    | The device has a included flow meter                                      | RO Data        | Read       |                                                                                                                              |
+| rf-linked        | Switch                    | Is the device RF linked                                                   | RO Data        | Read       |                                                                                                                              |
+| signal           | Number:Dimensionless      | Reception Signal Strength                                                 | RO Data        | Read       |                                                                                                                              |
+| battery          | Number:Dimensionless      | Battery Remaining Level                                                   | RO Data        | Read       |                                                                                                                              |
+| flow-rate        | Number:VolumetricFlowRate | Current water flow rate                                                   | RO Data        | Read       |                                                                                                                              |
+| volume           | Number:Volume             | Accumulated volume of current watering cycle                              | RO Data        | Read       |                                                                                                                              | 
+| eco-final        | Switch                    | In ECO mode this is true when the final ON watering on segment is running | RO Data        | Read       |                                                                                                                              |
+| remaining        | Number:Time               | Remaining duration of the current watering cycle                          | RO Data        | Read       |                                                                                                                              |
+| duration         | Number:Time               | Total duration of current watering cycle                                  | RO Data        | Read       |                                                                                                                              |
+| active-watering  | Switch                    | Active watering status                                                    | RW Data        | Write      | True - Start immediate watering, False - Stops the current watering process, the next planned watering will run as scheduled |
+| manual-watering  | Switch                    | Manual watering mode status                                               | RW Data        | Write      | False - Stops the current watering process, the next planned watering will run as scheduled                                  |
+| child-lock       | Text                      | The child lock mode                                                       | RW Data        | Write      | Unlocked - Button enabled, Partially locked -> 3 second push required, Completely locked -> Button disabled                  |
+| oh-dur-limit     | Number:Time               | Max duration allowed for the immediate watering                           | W Data         | Write      | Max Time duration for "Start immediate watering"                                                                             |
+| oh-vol-limit     | Number:Volume             | Max Volume limit for immediate watering                                   | W Data         | Write      | Max Volume for "Start immediate watering"                                                                                    |
+| water-skip-ts    | DateTime                  | Time when watering was skipped                                            | RO Data        | Read       |                                                                                                                              |
+| water-skip-prev  | Number:Length             | Previous rainfall calculated when watering was skipped                    | RO Data        | Read       |                                                                                                                              |
+| water-skip-next  | Number:Length             | Future rainfall calculated when watering was skipped                      | RO Data        | Read       |                                                                                                                              |
+
+## Full Example
+
+_Provide a full usage example based on textual configuration files._
+_*.things, *.items examples are mandatory as textual configuration is well used by many users._
+_*.sitemap examples are optional._
+
+### Thing Configuration
+
+- **Gateway Model**: GW_02
+- **Device Model**: Q1
+
+```java
+Bridge linktap:bridge:home "LinkTap GW02" [ host="192.168.0.21", enableMDNS=true ] {
+  Thing device TapValve1 "Outdoor Tap 1"  [ id="D71BC52E985B1200_1", name="ValveLinker_1", enableAlerts=true ]
+  Thing device TapValve2 "Outdoor Tap 2"  [ id="D71BC52E985B1200_2", name="ValveLinker_2", enableAlerts=true ]
+  Thing device TapValve3 "Outdoor Tap 3"  [ id="D71BC52E985B1200_3", name="ValveLinker_3", enableAlerts=true ]
+  Thing device TapValve4 "Outdoor Tap 4"  [ id="D71BC52E985B1200_4", name="ValveLinker_4", enableAlerts=true ]
+}
+```
+
+### Item Configuration
+
+```java
+Number:Dimensionless   	   Tap1BatteryLevel       "Tap 1 - Battery Level"                 <batterylevel>     ["Point"] { channel="linktap:device:home:tapValve1:battery",unit="%%" }
+Number:Dimensionless   	   Tap1SignalLevel        "Tap 1 - Signal Level"                  <qualityofservice> ["Point"] { channel="linktap:device:home:tapValve1:signal",unit="%%" }
+Switch                     Tap1RfLinked           "Tap 1 - RF Linked"                     <switch>           ["Point"] { channel="linktap:device:home:tapValve1:rf-linked"}
+Switch                     Tap1FlmLinked          "Tap 1 - FLM Linked"                    <switch>           ["Point"] { channel="linktap:device:home:tapValve1:flm-linked"}
+Switch                     Tap1WaterCutAlert      "Tap 1 - Water Cut Alert"               <alarm>            ["Point"] { channel="linktap:device:home:tapValve1:water-cut" }
+Switch                     Tap1WaterFallAlert     "Tap 1 - Fallen Alert"                  <alarm>            ["Point"] { channel="linktap:device:home:tapValve1:fall-status" }
+Switch                     Tap1WaterValveAlert    "Tap 1 - Shutdown Failure Alert"        <alarm>            ["Point"] { channel="linktap:device:home:tapValve1:shutdown-failure" }
+Switch                     Tap1WaterLowFlowAlert  "Tap 1 - Low Flow Alert"                <alarm>            ["Point"] { channel="linktap:device:home:tapValve1:low-flow" }
+Switch                     Tap1WaterHighFlowAlert "Tap 1 - High Flow Alert"               <alarm>            ["Point"] { channel="linktap:device:home:tapValve1:high-flow" }
+String                     Tap1ChildLockMode      "Tap 1 - Child Lock Mode"               <lock>             ["Point"] { channel="linktap:device:home:tapValve1:child-lock" }
+Number:VolumetricFlowRate  Tap1FlowRate           "Tap 1 - Flow Rate"                     <flow>             ["Point"] { channel="linktap:device:home:tapValve1:flow-rate",unit="l/min" }
+Number:Volume              Tap1WateringVolume     "Tap 1 - Watering Volume"               <water>            ["Point"] { channel="linktap:device:home:tapValve1:volume",unit="l" }
+Switch                     Tap1FinalEcoSegment    "Tap 1 - Final ECO Segment"             <switch>           ["Point"] { channel="linktap:device:home:tapValve1:eco-final" }
+Switch                     Tap1Watering           "Tap 1 - Watering"                      <water>            ["Point"] { channel="linktap:device:home:tapValve1:active-watering" }
+Switch                     Tap1ManualWatering     "Tap 1 - Manual Watering"               <water>            ["Point"] { channel="linktap:device:home:tapValve1:manual-watering" }
+String                     Tap1WateringkMode      "Tap 1 - Watering Mode"                 <time>             ["Point"] { channel="linktap:device:home:tapValve1:mode" }
+Number:Time                Tap1WateringCycleDur   "Tap 1 - Current Cycle Duration Limit"  <time>             ["Point"] { channel="linktap:device:home:tapValve1:duration",unit="s" }
+Number:Volume              Tap1WateringCycleVol   "Tap 1 - Current Cycle Volume Limit"    <water>            ["Point"] { channel="linktap:device:home:tapValve1:vol-limit",unit="l" }
+```
+
+### Sitemap Configuration
+
+```perl
+Optional Sitemap configuration goes here.
+Remove this section, if not needed.
+```
diff --git a/bundles/org.openhab.binding.linktap/Saved/LinkTapHandler.java b/bundles/org.openhab.binding.linktap/Saved/LinkTapHandler.java
new file mode 100644
index 0000000000000..428f825b55a70
--- /dev/null
+++ b/bundles/org.openhab.binding.linktap/Saved/LinkTapHandler.java
@@ -0,0 +1,559 @@
+/**
+ * Copyright (c) 2010-2024 Contributors to the openHAB project
+ *
+ * See the NOTICE file(s) distributed with this work for additional
+ * information.
+ *
+ * This program and the accompanying materials are made available under the
+ * terms of the Eclipse Public License 2.0 which is available at
+ * http://www.eclipse.org/legal/epl-2.0
+ *
+ * SPDX-License-Identifier: EPL-2.0
+ */
+package org.openhab.binding.linktap.internal;
+
+import static org.openhab.binding.linktap.internal.LinkTapBindingConstants.BRIDGE_PROP_VOL_UNIT;
+import static org.openhab.binding.linktap.internal.LinkTapBindingConstants.CHILD_LOCK_MODE;
+import static org.openhab.binding.linktap.internal.LinkTapBindingConstants.DEVICE_CHANNEL_ACTIVE_WATERING;
+import static org.openhab.binding.linktap.internal.LinkTapBindingConstants.DEVICE_CHANNEL_BATTERY;
+import static org.openhab.binding.linktap.internal.LinkTapBindingConstants.DEVICE_CHANNEL_CHILD_LOCK;
+import static org.openhab.binding.linktap.internal.LinkTapBindingConstants.DEVICE_CHANNEL_CURRENT_VOLUME;
+import static org.openhab.binding.linktap.internal.LinkTapBindingConstants.DEVICE_CHANNEL_FAILSAFE_DURATION;
+import static org.openhab.binding.linktap.internal.LinkTapBindingConstants.DEVICE_CHANNEL_FAILSAFE_VOLUME;
+import static org.openhab.binding.linktap.internal.LinkTapBindingConstants.DEVICE_CHANNEL_FALL_STATUS;
+import static org.openhab.binding.linktap.internal.LinkTapBindingConstants.DEVICE_CHANNEL_FINAL_SEGMENT;
+import static org.openhab.binding.linktap.internal.LinkTapBindingConstants.DEVICE_CHANNEL_FLM_LINKED;
+import static org.openhab.binding.linktap.internal.LinkTapBindingConstants.DEVICE_CHANNEL_FLOW_RATE;
+import static org.openhab.binding.linktap.internal.LinkTapBindingConstants.DEVICE_CHANNEL_HIGH_FLOW;
+import static org.openhab.binding.linktap.internal.LinkTapBindingConstants.DEVICE_CHANNEL_IS_MANUAL_MODE;
+import static org.openhab.binding.linktap.internal.LinkTapBindingConstants.DEVICE_CHANNEL_LOW_FLOW;
+import static org.openhab.binding.linktap.internal.LinkTapBindingConstants.DEVICE_CHANNEL_OH_DURATION_LIMIT;
+import static org.openhab.binding.linktap.internal.LinkTapBindingConstants.DEVICE_CHANNEL_OH_VOLUME_LIMIT;
+import static org.openhab.binding.linktap.internal.LinkTapBindingConstants.DEVICE_CHANNEL_REMAIN_DURATION;
+import static org.openhab.binding.linktap.internal.LinkTapBindingConstants.DEVICE_CHANNEL_RF_LINKED;
+import static org.openhab.binding.linktap.internal.LinkTapBindingConstants.DEVICE_CHANNEL_SHUTDOWN_FAILURE;
+import static org.openhab.binding.linktap.internal.LinkTapBindingConstants.DEVICE_CHANNEL_SIGNAL;
+import static org.openhab.binding.linktap.internal.LinkTapBindingConstants.DEVICE_CHANNEL_TOTAL_DURATION;
+import static org.openhab.binding.linktap.internal.LinkTapBindingConstants.DEVICE_CHANNEL_WATERING_MODE;
+import static org.openhab.binding.linktap.internal.LinkTapBindingConstants.DEVICE_CHANNEL_WATER_CUT;
+import static org.openhab.binding.linktap.internal.LinkTapBindingConstants.DEVICE_CHANNEL_WSKIP_DATE_TIME;
+import static org.openhab.binding.linktap.internal.LinkTapBindingConstants.DEVICE_CHANNEL_WSKIP_NEXT_RAIN;
+import static org.openhab.binding.linktap.internal.LinkTapBindingConstants.DEVICE_CHANNEL_WSKIP_PREV_RAIN;
+import static org.openhab.binding.linktap.internal.LinkTapBindingConstants.GSON;
+import static org.openhab.binding.linktap.internal.LinkTapBindingConstants.WATERING_MODE;
+import static org.openhab.binding.linktap.protocol.frames.DismissAlertReq.ALERT_DEVICE_FALL;
+import static org.openhab.binding.linktap.protocol.frames.DismissAlertReq.ALERT_UNEXPECTED_HIGH_FLOW;
+import static org.openhab.binding.linktap.protocol.frames.DismissAlertReq.ALERT_UNEXPECTED_LOW_FLOW;
+import static org.openhab.binding.linktap.protocol.frames.DismissAlertReq.ALERT_VALVE_SHUTDOWN_FAIL;
+import static org.openhab.binding.linktap.protocol.frames.DismissAlertReq.ALERT_WATER_CUTOFF;
+import static org.openhab.binding.linktap.protocol.frames.SetDeviceConfigReq.CONFIG_DURATION_LIMIT;
+import static org.openhab.binding.linktap.protocol.frames.SetDeviceConfigReq.CONFIG_VOLUME_LIMIT;
+import static org.openhab.binding.linktap.protocol.frames.TLGatewayFrame.CMD_DATETIME_SYNC;
+import static org.openhab.binding.linktap.protocol.frames.TLGatewayFrame.CMD_IMMEDIATE_WATER_STOP;
+import static org.openhab.binding.linktap.protocol.frames.TLGatewayFrame.CMD_NOTIFICATION_WATERING_SKIPPED;
+import static org.openhab.binding.linktap.protocol.frames.TLGatewayFrame.CMD_RAINFALL_DATA;
+import static org.openhab.binding.linktap.protocol.frames.TLGatewayFrame.CMD_UPDATE_WATER_TIMER_STATUS;
+
+import java.time.Duration;
+import java.util.concurrent.ScheduledFuture;
+import java.util.concurrent.TimeUnit;
+
+import javax.validation.constraints.NotNull;
+
+import org.eclipse.jdt.annotation.NonNullByDefault;
+import org.eclipse.jdt.annotation.Nullable;
+import org.openhab.binding.linktap.protocol.frames.AlertStateReq;
+import org.openhab.binding.linktap.protocol.frames.DeviceCmdReq;
+import org.openhab.binding.linktap.protocol.frames.DismissAlertReq;
+import org.openhab.binding.linktap.protocol.frames.LockReq;
+import org.openhab.binding.linktap.protocol.frames.SetDeviceConfigReq;
+import org.openhab.binding.linktap.protocol.frames.StartWateringReq;
+import org.openhab.binding.linktap.protocol.frames.TLGatewayFrame;
+import org.openhab.binding.linktap.protocol.frames.WaterMeterStatus;
+import org.openhab.binding.linktap.protocol.frames.WateringSkippedNotification;
+import org.openhab.core.cache.ExpiringCache;
+import org.openhab.core.library.types.DateTimeType;
+import org.openhab.core.library.types.OnOffType;
+import org.openhab.core.library.types.QuantityType;
+import org.openhab.core.library.types.StringType;
+import org.openhab.core.library.unit.Units;
+import org.openhab.core.storage.Storage;
+import org.openhab.core.thing.Bridge;
+import org.openhab.core.thing.Channel;
+import org.openhab.core.thing.ChannelUID;
+import org.openhab.core.thing.Thing;
+import org.openhab.core.thing.ThingStatus;
+import org.openhab.core.thing.ThingStatusDetail;
+import org.openhab.core.thing.binding.BaseThingHandler;
+import org.openhab.core.thing.binding.BridgeHandler;
+import org.openhab.core.types.Command;
+import org.openhab.core.types.RefreshType;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
+/**
+ * The {@link LinkTapHandler} is responsible for handling commands, which are
+ * sent to one of the channels.
+ *
+ * @author David Goodyear - Initial contribution
+ */
+@NonNullByDefault
+public class LinkTapHandler extends BaseThingHandler {
+
+    private final Logger logger = LoggerFactory.getLogger(LinkTapHandler.class);
+
+    private static final String MARKER_INVALID_DEVICE_KEY = "---INVALID---";
+    private String registeredDeviceId = "";
+
+    private static final String DEFAULT_INST_WATERING_VOL_LIMIT = "0";
+    private static final String DEFAULT_INST_WATERING_TIME_LIMIT = "15";
+
+    private final Object pollLock = new Object();
+    private final Storage<String> strStore;
+
+    protected ExpiringCache<String> lastPollResultCache = new ExpiringCache<>(Duration.ofSeconds(5),
+            LinkTapHandler::expireCacheContents);
+
+    private final Object schedulerLock = new Object();
+    private @Nullable ScheduledFuture<?> backgroundGwPollingScheduler;
+
+    private volatile long lastStatusCommandRecvTs = 0L;
+
+    public LinkTapHandler(Thing thing, Storage<String> strStore) {
+        super(thing);
+        this.strStore = strStore;
+    }
+
+    private void startStatusPolling() {
+        synchronized (schedulerLock) {
+            cancelStatusPolling();
+            backgroundGwPollingScheduler = scheduler.scheduleWithFixedDelay(() -> {
+                if (lastStatusCommandRecvTs + 135000 > System.currentTimeMillis()) {
+                    return;
+                }
+                pollForUpdate();
+            }, 1, 10, TimeUnit.SECONDS);
+        }
+    }
+
+    private void cancelStatusPolling() {
+        synchronized (schedulerLock) {
+            final ScheduledFuture<?> ref = backgroundGwPollingScheduler;
+            if (ref != null) {
+                ref.cancel(true);
+                backgroundGwPollingScheduler = null;
+            }
+        }
+    }
+
+    private static @Nullable String expireCacheContents() {
+        return null;
+    }
+
+    @Override
+    public void handleCommand(ChannelUID channelUID, Command command) {
+        scheduler.submit(() -> {
+            if (command instanceof RefreshType rt) {
+                switch (channelUID.getId()) {
+                    case DEVICE_CHANNEL_OH_DURATION_LIMIT: {
+                        final String savedVal = strStore.get(DEVICE_CHANNEL_OH_DURATION_LIMIT);
+                        if (savedVal != null) {
+                            updateState(DEVICE_CHANNEL_OH_DURATION_LIMIT,
+                                    new QuantityType<>(Integer.valueOf(savedVal), Units.SECOND));
+                        } else {
+                            updateState(DEVICE_CHANNEL_OH_DURATION_LIMIT, new QuantityType<>(15, Units.SECOND));
+                        }
+                    }
+                        break;
+                    case DEVICE_CHANNEL_OH_VOLUME_LIMIT: {
+                        final String savedVal = strStore.get(DEVICE_CHANNEL_OH_VOLUME_LIMIT);
+                        if (savedVal != null) {
+                            updateState(DEVICE_CHANNEL_OH_VOLUME_LIMIT,
+                                    new QuantityType<>(Integer.valueOf(savedVal), Units.LITRE));
+                        } else {
+                            updateState(DEVICE_CHANNEL_OH_VOLUME_LIMIT, new QuantityType<>(10, Units.LITRE));
+                        }
+                    }
+                        break;
+                }
+            } else if (command instanceof QuantityType quantityCommand) {
+                int targetValue = quantityCommand.intValue();
+                switch (channelUID.getId()) {
+                    case DEVICE_CHANNEL_OH_DURATION_LIMIT:
+                        strStore.put(DEVICE_CHANNEL_OH_DURATION_LIMIT, String.valueOf(targetValue));
+                        break;
+                    case DEVICE_CHANNEL_OH_VOLUME_LIMIT:
+                        strStore.put(DEVICE_CHANNEL_OH_VOLUME_LIMIT, String.valueOf(targetValue));
+                        break;
+                    case DEVICE_CHANNEL_FAILSAFE_VOLUME: {
+                        SendRequest(new SetDeviceConfigReq(CONFIG_VOLUME_LIMIT, targetValue));
+                    }
+                        break;
+                    case DEVICE_CHANNEL_TOTAL_DURATION: {
+                        SendRequest(new SetDeviceConfigReq(CONFIG_DURATION_LIMIT, targetValue));
+                    }
+                        break;
+                }
+            } else if (command instanceof StringType stringCmd) {
+                switch (channelUID.getId()) {
+                    case DEVICE_CHANNEL_CHILD_LOCK: {
+                        SendRequest(new LockReq(Integer.valueOf(command.toString())));
+                    }
+                        break;
+                }
+            } else if (command instanceof OnOffType) {
+                // Alert dismiss events below
+                switch (channelUID.getId()) {
+                    case DEVICE_CHANNEL_IS_MANUAL_MODE:
+                        // We can pull from channels I suspect as they feed stateful representations of data
+                        // therefore the data we need below - we need to cache from writes and reads from the relevant
+                        // polls / writes, for the items / data points.
+                        if (command.equals(OnOffType.OFF)) {
+                            SendRequest(new DeviceCmdReq(CMD_IMMEDIATE_WATER_STOP));
+                        }
+                    case DEVICE_CHANNEL_ACTIVE_WATERING:
+                        if (command.equals(OnOffType.ON)) {
+                            String volLimit = strStore.get(DEVICE_CHANNEL_OH_VOLUME_LIMIT);
+                            if (volLimit == null) {
+                                volLimit = DEFAULT_INST_WATERING_VOL_LIMIT;
+                            }
+                            String durLimit = strStore.get(DEVICE_CHANNEL_OH_DURATION_LIMIT);
+                            if (durLimit == null) {
+                                durLimit = DEFAULT_INST_WATERING_TIME_LIMIT;
+                            }
+                            SendRequest(new StartWateringReq(Integer.parseInt(durLimit), Integer.parseInt(volLimit)));
+                        } else if (command.equals(OnOffType.OFF)) {
+                            SendRequest(new DeviceCmdReq(CMD_IMMEDIATE_WATER_STOP));
+                        }
+                    case DEVICE_CHANNEL_FALL_STATUS: // 1
+                        if (command.equals(OnOffType.OFF)) {
+                            SendRequest(new DismissAlertReq(ALERT_DEVICE_FALL));
+                        }
+                        break;
+                    case DEVICE_CHANNEL_SHUTDOWN_FAILURE: // 2
+                        if (command.equals(OnOffType.OFF)) {
+                            SendRequest(new DismissAlertReq(ALERT_VALVE_SHUTDOWN_FAIL));
+                        }
+                        break;
+                    case DEVICE_CHANNEL_WATER_CUT: // 3
+                        if (command.equals(OnOffType.OFF)) {
+                            SendRequest(new DismissAlertReq(ALERT_WATER_CUTOFF));
+                        }
+                        break;
+                    case DEVICE_CHANNEL_HIGH_FLOW: // 4
+                        if (command.equals(OnOffType.OFF)) {
+                            SendRequest(new DismissAlertReq(ALERT_UNEXPECTED_HIGH_FLOW));
+                        }
+                        break;
+                    case DEVICE_CHANNEL_LOW_FLOW: // 5
+                        if (command.equals(OnOffType.OFF)) {
+                            SendRequest(new DismissAlertReq(ALERT_UNEXPECTED_LOW_FLOW));
+                        }
+                        break;
+                }
+            }
+        });
+
+        /*
+         * if (CHANNEL_1.equals(channelUID.getId())) {
+         * if (command instanceof RefreshType) {
+         * // TODO: handle data refresh
+         * }
+         * 
+         * // TODO: handle command`
+         * 
+         * // Note: if communication with thing fails for some reason,
+         * // indicate that by setting the status with detail information:
+         * // updateStatus(ThingStatus.OFFLINE, ThingStatusDetail.COMMUNICATION_ERROR,
+         * // "Could not control device at IP address x.x.x.x");
+         * }
+         */
+    }
+
+    @Override
+    public void initialize() {
+        updateStatus(ThingStatus.UNKNOWN);
+
+        final LinkTapBridgeHandler bridge = (LinkTapBridgeHandler) getBridgeHandler();
+        if (bridge == null) {
+            updateStatus(ThingStatus.OFFLINE, ThingStatusDetail.CONFIGURATION_ERROR, "Bridge is not selected / set");
+            return;
+        }
+
+        scheduler.execute(() -> {
+            switch (bridge.getThing().getStatus()) {
+                case UNKNOWN:
+                case INITIALIZING:
+                case UNINITIALIZED:
+                    scheduler.schedule(this::initialize, 1, TimeUnit.SECONDS);
+                    break;
+                default:
+                    initAfterBridge(bridge);
+            }
+        });
+    }
+
+    private void initAfterBridge(final LinkTapBridgeHandler bridge) {
+        String deviceId = getValidatedIdString();
+        if (deviceId.equals(MARKER_INVALID_DEVICE_KEY)) {
+            updateStatus(ThingStatus.OFFLINE, ThingStatusDetail.CONFIGURATION_ERROR,
+                    "Device not found in bridges known devices");
+            if (!registeredDeviceId.isBlank()) {
+                LinkTapBridgeHandler.devIdLookup.deregisterItem(registeredDeviceId, this, () -> {
+                });
+            }
+            registeredDeviceId = "";
+            return;
+        } else {
+            registeredDeviceId = deviceId;
+        }
+
+        boolean knownToBridge = bridge.GetDiscoveredDevices().anyMatch(x -> deviceId.equals(x.deviceId));
+        if (knownToBridge) {
+            updateStatus(ThingStatus.ONLINE);
+            LinkTapBridgeHandler.devIdLookup.registerItem(registeredDeviceId, this, () -> {
+            });
+            scheduleInitialPoll();
+            scheduler.execute(() -> {
+                SendRequest(new AlertStateReq(0, true));
+            });
+            startStatusPolling();
+        } else {
+            updateStatus(ThingStatus.OFFLINE, ThingStatusDetail.CONFIGURATION_ERROR,
+                    "Bridge does not recognise device id");
+        }
+    }
+
+    @Override
+    public void dispose() {
+        cancelInitialPoll(true);
+        LinkTapBridgeHandler.devIdLookup.deregisterItem(registeredDeviceId, this, () -> {
+        });
+        cancelStatusPolling();
+    }
+
+    public String SendRequest(TLGatewayFrame frame) {
+        if (frame instanceof DeviceCmdReq) {
+            final String deviceAddr = getValidatedIdString();
+            if (deviceAddr.equals(MARKER_INVALID_DEVICE_KEY)) {
+                logger.warn("Device is unknown - will not send");
+                return "";
+            }
+            ((DeviceCmdReq) frame).deviceId = deviceAddr;
+        }
+
+        // Validate the payload is within the expected limits for the device its being sent to
+        // if (!frame.isValid()) {
+        // throw new RuntimeException("Payload validation failed - will not send");
+        // }
+        Bridge parentBridge = getBridge();
+        if (parentBridge == null) {
+            logger.warn("Cannot send device does not have a valid bridge");
+            return "";
+        }
+        LinkTapBridgeHandler parentBridgeHandler = (LinkTapBridgeHandler) parentBridge.getHandler();
+        if (parentBridgeHandler == null) {
+            logger.warn("Cannot send device does not have a valid bridge handler");
+            return "";
+        }
+        return parentBridgeHandler.SendRequest(frame);
+    }
+
+    private @Nullable BridgeHandler getBridgeHandler() {
+        Bridge bridgeRef = getBridge();
+        if (bridgeRef == null) {
+            return null;
+        } else {
+            return bridgeRef.getHandler();
+        }
+    }
+
+    @NotNull
+    public String getValidatedIdString() {
+        final LinkTapDeviceConfiguration config = getConfigAs(LinkTapDeviceConfiguration.class);
+
+        BridgeHandler bridgeHandler = getBridgeHandler();
+        if (bridgeHandler instanceof LinkTapBridgeHandler vesyncBridgeHandler) {
+            final String devId = config.deviceId;
+
+            // Try to use the device address id directly
+            if (devId != null) {
+                logger.trace("Searching for device address id : {}", devId);
+                @Nullable
+                final LinkTapDeviceMetadata metadata = vesyncBridgeHandler.getDeviceLookup().get(devId.toLowerCase());
+
+                if (metadata != null) {
+                    return metadata.deviceId;
+                }
+            }
+
+            final String deviceName = config.deviceName;
+
+            // Check if the device name can be matched to a single device
+            if (deviceName != null) {
+                final String[] matchedAddressIds = vesyncBridgeHandler.GetDiscoveredDevices()
+                        .filter(x -> deviceName.equals(x.deviceName)).map(x -> x.deviceId).toArray(String[]::new);
+
+                for (String val : matchedAddressIds) {
+                    logger.trace("Found Address ID match on name with : {}", val);
+                }
+
+                if (matchedAddressIds.length != 1) {
+                    return MARKER_INVALID_DEVICE_KEY;
+                }
+
+                return matchedAddressIds[0];
+            }
+        }
+
+        return MARKER_INVALID_DEVICE_KEY;
+    }
+
+    public void processDeviceCommand(final int commandId, final String frame) {
+        lastStatusCommandRecvTs = System.currentTimeMillis();
+        logger.debug("{} processing device request with command {}", this.getThing().getLabel(), commandId);
+
+        switch (commandId) {
+            case CMD_UPDATE_WATER_TIMER_STATUS:
+                // Store the latest value in the cache - to prevent unnecessary polls
+                lastPollResultCache.putValue(frame);
+                processCommand3(frame);
+                break;
+            case CMD_NOTIFICATION_WATERING_SKIPPED:
+                processCommand9(frame);
+                break;
+            case CMD_RAINFALL_DATA:
+            case CMD_DATETIME_SYNC:
+                logger.trace("No implementation for command {} for processing the Device request", commandId);
+        }
+    }
+
+    private void processCommand3(final String request) {
+        // There are three different formats that can arrive in this method:
+        // -> Unsolicited with is a WaterMeterStatus.DeviceStatus payload
+        // -> Solicited with a WaterMeterStatus payload (*)
+        // -> Solicited with a WaterMeterStatus payload within an array
+        // (*) A GSON plugin normalises the non array wrapped version to the array based version
+        // This is handled below before the normalised processing takes place.
+        WaterMeterStatus.DeviceStatus devStatus;
+        {
+            WaterMeterStatus mStatus = GSON.fromJson(request, WaterMeterStatus.class);
+            if (mStatus == null) {
+                return;
+            }
+
+            if (!mStatus.deviceStatuses.isEmpty()) {
+                devStatus = mStatus.deviceStatuses.get(0);
+            } else {
+                devStatus = GSON.fromJson(request, WaterMeterStatus.DeviceStatus.class);
+            }
+            if (devStatus == null) {
+                return;
+            }
+        }
+
+        // Normalized processing below which uses devStatus
+
+        final LinkTapBridgeHandler bridgeHandler = (LinkTapBridgeHandler) getBridgeHandler();
+        String volumeUnit = "L";
+        if (bridgeHandler != null) {
+            String volumeUnitProp = bridgeHandler.getThing().getProperties().get(BRIDGE_PROP_VOL_UNIT);
+            if (volumeUnitProp != null) {
+                volumeUnit = volumeUnitProp;
+            }
+        }
+
+        updateState(DEVICE_CHANNEL_WATERING_MODE, new StringType(WATERING_MODE.values()[devStatus.planMode].getDesc()));
+        updateState(DEVICE_CHANNEL_IS_MANUAL_MODE, OnOffType.from(devStatus.isManualMode));
+        updateState(DEVICE_CHANNEL_ACTIVE_WATERING, OnOffType.from(devStatus.isWatering));
+        updateState(DEVICE_CHANNEL_RF_LINKED, OnOffType.from(devStatus.isRfLinked));
+        updateState(DEVICE_CHANNEL_FLM_LINKED, OnOffType.from(devStatus.isFlmPlugin));
+        updateState(DEVICE_CHANNEL_FALL_STATUS, OnOffType.from(devStatus.isFall));
+        updateState(DEVICE_CHANNEL_SHUTDOWN_FAILURE, OnOffType.from(devStatus.isBroken));
+        updateState(DEVICE_CHANNEL_HIGH_FLOW, OnOffType.from(devStatus.isLeak));
+        updateState(DEVICE_CHANNEL_LOW_FLOW, OnOffType.from(devStatus.isClog));
+        updateState(DEVICE_CHANNEL_FINAL_SEGMENT, OnOffType.from(devStatus.isFinal));
+        updateState(DEVICE_CHANNEL_SIGNAL, new QuantityType<>(devStatus.signal, Units.PERCENT));
+        updateState(DEVICE_CHANNEL_BATTERY, new QuantityType<>(devStatus.battery, Units.PERCENT));
+        updateState(DEVICE_CHANNEL_WATER_CUT, OnOffType.from(devStatus.isCutoff));
+        updateState(DEVICE_CHANNEL_CHILD_LOCK, new StringType(CHILD_LOCK_MODE.values()[devStatus.childLock].getDesc()));
+        updateState(DEVICE_CHANNEL_TOTAL_DURATION, new QuantityType<>(devStatus.totalDuration, Units.SECOND));
+        updateState(DEVICE_CHANNEL_REMAIN_DURATION, new QuantityType<>(devStatus.remainDuration, Units.SECOND));
+        updateState(DEVICE_CHANNEL_FAILSAFE_DURATION, new QuantityType<>(devStatus.failsafeDuration, Units.SECOND));
+        updateState(DEVICE_CHANNEL_FLOW_RATE, new QuantityType<>(
+                "L".equals(volumeUnit) ? devStatus.speed : (devStatus.speed * 3.785), Units.LITRE_PER_MINUTE));
+        updateState(DEVICE_CHANNEL_CURRENT_VOLUME, new QuantityType<>(
+                "L".equals(volumeUnit) ? devStatus.volume : (devStatus.volume * 3.785), Units.LITRE));
+        updateState(DEVICE_CHANNEL_FAILSAFE_VOLUME, new QuantityType<>(
+                "L".equals(volumeUnit) ? devStatus.volumeLimit : (devStatus.volumeLimit * 3.785), Units.LITRE));
+    }
+
+    private void processCommand9(final String request) {
+        final WateringSkippedNotification skippedNotice = GSON.fromJson(request, WateringSkippedNotification.class);
+        if (skippedNotice == null) {
+            return;
+        }
+        logger.trace("Received rainfall skipped notice - past hour {}, next hour {}", skippedNotice.getPastRainfall(),
+                skippedNotice.getFutureRainfall());
+        updateState(DEVICE_CHANNEL_WSKIP_PREV_RAIN,
+                new QuantityType<>(skippedNotice.getPastRainfall(), Units.MILLIMETRE_PER_HOUR));
+        updateState(DEVICE_CHANNEL_WSKIP_NEXT_RAIN,
+                new QuantityType<>(skippedNotice.getFutureRainfall(), Units.MILLIMETRE_PER_HOUR));
+        updateState(DEVICE_CHANNEL_WSKIP_DATE_TIME, new DateTimeType());
+    }
+
+    @Override
+    public void channelLinked(ChannelUID channelUID) {
+        super.channelLinked(channelUID);
+
+        if (getThing().getStatusInfo().getStatus() == ThingStatus.ONLINE) {
+            scheduler.execute(this::pollForUpdate);
+        }
+    }
+
+    private void scheduleInitialPoll() {
+        cancelInitialPoll(false);
+        initialPollingTask = scheduler.schedule(() -> {
+            // 15 second's is to ensure even slow systems have time to pull the gateway data
+            // ready.
+            sendChannelRefresh(DEVICE_CHANNEL_OH_DURATION_LIMIT);
+            sendChannelRefresh(DEVICE_CHANNEL_OH_VOLUME_LIMIT);
+
+            pollForUpdate();
+        }, 15, TimeUnit.SECONDS);
+    }
+
+    private void sendChannelRefresh(final String channelName) {
+        final Channel ch = getThing().getChannel(DEVICE_CHANNEL_OH_VOLUME_LIMIT);
+        if (ch != null) {
+            handleCommand(ch.getUID(), RefreshType.REFRESH);
+        }
+    }
+
+    private void cancelInitialPoll(final boolean interruptAllowed) {
+        final ScheduledFuture<?> pollJob = initialPollingTask;
+        if (pollJob != null && !pollJob.isCancelled()) {
+            pollJob.cancel(interruptAllowed);
+            initialPollingTask = null;
+        }
+    }
+
+    @Nullable
+    // This is used to coalesce poll's for CMD 3 - WATER METER STATUS
+    // otherwise bulk new channel links force many poll's, and an unsolicited update
+    // may recently have already provided the data needed.
+    ScheduledFuture<?> initialPollingTask = null;
+
+    public void pollForUpdate() {
+        String response = "";
+        synchronized (pollLock) {
+            response = lastPollResultCache.getValue();
+            if (response == null) {
+                response = SendRequest(new DeviceCmdReq(CMD_UPDATE_WATER_TIMER_STATUS));
+                // Todo: Check response status
+                lastPollResultCache.putValue(response);
+            }
+        }
+        processCommand3(response);
+    }
+}
diff --git a/bundles/org.openhab.binding.linktap/pom.xml b/bundles/org.openhab.binding.linktap/pom.xml
new file mode 100644
index 0000000000000..eadee4cb0d185
--- /dev/null
+++ b/bundles/org.openhab.binding.linktap/pom.xml
@@ -0,0 +1,36 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<project xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns="http://maven.apache.org/POM/4.0.0"
+  xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 https://maven.apache.org/xsd/maven-4.0.0.xsd">
+
+  <modelVersion>4.0.0</modelVersion>
+
+  <parent>
+    <groupId>org.openhab.addons.bundles</groupId>
+    <artifactId>org.openhab.addons.reactor.bundles</artifactId>
+    <version>4.2.0-SNAPSHOT</version>
+  </parent>
+
+  <artifactId>org.openhab.binding.linktap</artifactId>
+
+  <name>openHAB Add-ons :: Bundles :: LinkTap Binding</name>
+
+  <properties>
+    <jsoup.version>1.15.3</jsoup.version>
+  </properties>
+
+  <dependencies>
+    <dependency>
+      <groupId>org.jsoup</groupId>
+      <artifactId>jsoup</artifactId>
+      <version>${jsoup.version}</version>
+      <scope>provided</scope>
+    </dependency>
+    <dependency>
+      <groupId>junit</groupId>
+      <artifactId>junit</artifactId>
+      <version>4.13.2</version>
+      <scope>test</scope>
+    </dependency>
+  </dependencies>
+
+</project>
diff --git a/bundles/org.openhab.binding.linktap/src/main/feature/feature.xml b/bundles/org.openhab.binding.linktap/src/main/feature/feature.xml
new file mode 100644
index 0000000000000..68a82bc9b005f
--- /dev/null
+++ b/bundles/org.openhab.binding.linktap/src/main/feature/feature.xml
@@ -0,0 +1,10 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<features name="org.openhab.binding.linktap-${project.version}" xmlns="http://karaf.apache.org/xmlns/features/v1.4.0">
+	<repository>mvn:org.openhab.core.features.karaf/org.openhab.core.features.karaf.openhab-core/${ohc.version}/xml/features</repository>
+
+	<feature name="openhab-binding-linktap" description="LinkTap Binding" version="${project.version}">
+		<feature>openhab-runtime-base</feature>
+		<bundle dependency="true">mvn:org.jsoup/jsoup/1.15.3</bundle>
+		<bundle start-level="80">mvn:org.openhab.addons.bundles/org.openhab.binding.linktap/${project.version}</bundle>
+	</feature>
+</features>
diff --git a/bundles/org.openhab.binding.linktap/src/main/java/org/openhab/binding/linktap/configuration/LinkTapBridgeConfiguration.java b/bundles/org.openhab.binding.linktap/src/main/java/org/openhab/binding/linktap/configuration/LinkTapBridgeConfiguration.java
new file mode 100644
index 0000000000000..e4980ddf0f802
--- /dev/null
+++ b/bundles/org.openhab.binding.linktap/src/main/java/org/openhab/binding/linktap/configuration/LinkTapBridgeConfiguration.java
@@ -0,0 +1,28 @@
+/**
+ * Copyright (c) 2010-2024 Contributors to the openHAB project
+ *
+ * See the NOTICE file(s) distributed with this work for additional
+ * information.
+ *
+ * This program and the accompanying materials are made available under the
+ * terms of the Eclipse Public License 2.0 which is available at
+ * http://www.eclipse.org/legal/epl-2.0
+ *
+ * SPDX-License-Identifier: EPL-2.0
+ */
+package org.openhab.binding.linktap.configuration;
+
+import org.eclipse.jdt.annotation.NonNullByDefault;
+
+/**
+ * The {@link LinkTapBridgeConfiguration} class contains fields mapping bridge configuration parameters.
+ *
+ * @author David Goodyear - Initial contribution
+ */
+@NonNullByDefault
+public class LinkTapBridgeConfiguration {
+
+    public String host = "";
+    public String username = "";
+    public String password = "";
+}
diff --git a/bundles/org.openhab.binding.linktap/src/main/java/org/openhab/binding/linktap/configuration/LinkTapDeviceConfiguration.java b/bundles/org.openhab.binding.linktap/src/main/java/org/openhab/binding/linktap/configuration/LinkTapDeviceConfiguration.java
new file mode 100644
index 0000000000000..2c5938908ac0c
--- /dev/null
+++ b/bundles/org.openhab.binding.linktap/src/main/java/org/openhab/binding/linktap/configuration/LinkTapDeviceConfiguration.java
@@ -0,0 +1,27 @@
+/**
+ * Copyright (c) 2010-2024 Contributors to the openHAB project
+ *
+ * See the NOTICE file(s) distributed with this work for additional
+ * information.
+ *
+ * This program and the accompanying materials are made available under the
+ * terms of the Eclipse Public License 2.0 which is available at
+ * http://www.eclipse.org/legal/epl-2.0
+ *
+ * SPDX-License-Identifier: EPL-2.0
+ */
+package org.openhab.binding.linktap.configuration;
+
+import org.eclipse.jdt.annotation.NonNullByDefault;
+
+/**
+ * The {@link LinkTapDeviceConfiguration} class contains fields mapping thing configuration parameters.
+ *
+ * @author David Goodyear - Initial contribution
+ */
+@NonNullByDefault
+public class LinkTapDeviceConfiguration {
+
+    public String id = "";
+    public String name = "";
+}
diff --git a/bundles/org.openhab.binding.linktap/src/main/java/org/openhab/binding/linktap/internal/BridgeManager.java b/bundles/org.openhab.binding.linktap/src/main/java/org/openhab/binding/linktap/internal/BridgeManager.java
new file mode 100644
index 0000000000000..5f2cbe83838f5
--- /dev/null
+++ b/bundles/org.openhab.binding.linktap/src/main/java/org/openhab/binding/linktap/internal/BridgeManager.java
@@ -0,0 +1,81 @@
+/**
+ * Copyright (c) 2010-2024 Contributors to the openHAB project
+ *
+ * See the NOTICE file(s) distributed with this work for additional
+ * information.
+ *
+ * This program and the accompanying materials are made available under the
+ * terms of the Eclipse Public License 2.0 which is available at
+ * http://www.eclipse.org/legal/epl-2.0
+ *
+ * SPDX-License-Identifier: EPL-2.0
+ */
+package org.openhab.binding.linktap.internal;
+
+import java.util.Map;
+import java.util.concurrent.ConcurrentHashMap;
+
+import org.eclipse.jdt.annotation.NonNullByDefault;
+import org.openhab.binding.linktap.protocol.servers.BindingServlet;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
+/**
+ * The {@link BridgeManager} is a singleton responsible for routing based on the key (IP address) back to
+ * the relevant LinkTapBridgeHandler instance.
+ *
+ * @author David Goodyear - Initial contribution
+ */
+@NonNullByDefault
+public final class BridgeManager {
+
+    private final Logger logger = LoggerFactory.getLogger(BridgeManager.class);
+
+    private static final BridgeManager INSTANCE = new BridgeManager();
+
+    final Map<String, LinkTapBridgeHandler> ipAddrLookup = new ConcurrentHashMap<String, LinkTapBridgeHandler>();
+    final Map<String, LinkTapBridgeHandler> idLookup = new ConcurrentHashMap<String, LinkTapBridgeHandler>();
+
+    private BridgeManager() {
+    }
+
+    public static BridgeManager getInstance() {
+        return INSTANCE;
+    }
+
+    public boolean isEmpty() {
+        return ipAddrLookup.isEmpty();
+    }
+
+    public boolean registerBridge(final String ipAddress, final LinkTapBridgeHandler bridge) {
+        logger.warn("Adding {} -> {}", ipAddress, bridge);
+        if (ipAddrLookup.containsKey(ipAddress)) {
+            if (!bridge.equals(ipAddrLookup.get(ipAddress))) {
+                return false;
+            }
+        }
+        ipAddrLookup.put(ipAddress, bridge);
+        logger.warn("Total mappings is now : {}", ipAddrLookup.size());
+        BindingServlet.getInstance().registerServlet();
+        return true;
+    }
+
+    public void deregisterBridge(final String ipAddress, final LinkTapBridgeHandler bridge,
+            final LinkTapBridgeHandler handler) {
+        logger.warn("Removing {} -> {}", ipAddress, bridge);
+        ipAddrLookup.remove(ipAddress, handler);
+        logger.warn("Total mappings is now : {}", ipAddrLookup.size());
+        if (ipAddrLookup.isEmpty()) {
+            BindingServlet.getInstance().unregisterServlet();
+        }
+    }
+
+    /*
+     * public LinkTapBridgeHandler getBridge(final String ipAddress) {
+     * logger.warn("Locating {}", ipAddress);
+     * LinkTapBridgeHandler result = ipAddrLookup.get(ipAddress);
+     * logger.warn("Locating result {} -> {}", ipAddress, result);
+     * return result;
+     * }
+     */
+}
diff --git a/bundles/org.openhab.binding.linktap/src/main/java/org/openhab/binding/linktap/internal/DeviceMetaDataUpdatedHandler.java b/bundles/org.openhab.binding.linktap/src/main/java/org/openhab/binding/linktap/internal/DeviceMetaDataUpdatedHandler.java
new file mode 100644
index 0000000000000..1adca3c245bf4
--- /dev/null
+++ b/bundles/org.openhab.binding.linktap/src/main/java/org/openhab/binding/linktap/internal/DeviceMetaDataUpdatedHandler.java
@@ -0,0 +1,25 @@
+/**
+ * Copyright (c) 2010-2024 Contributors to the openHAB project
+ *
+ * See the NOTICE file(s) distributed with this work for additional
+ * information.
+ *
+ * This program and the accompanying materials are made available under the
+ * terms of the Eclipse Public License 2.0 which is available at
+ * http://www.eclipse.org/legal/epl-2.0
+ *
+ * SPDX-License-Identifier: EPL-2.0
+ */
+package org.openhab.binding.linktap.internal;
+
+import org.eclipse.jdt.annotation.NonNullByDefault;
+
+/**
+ * The {@link DeviceMetaDataUpdatedHandler} enables call-backs for when the device meta-data is updated from a bridge.
+ *
+ * @author David Goodyear - Initial contribution
+ */
+@NonNullByDefault
+public interface DeviceMetaDataUpdatedHandler {
+    void handleMetadataRetrieved(LinkTapBridgeHandler handler);
+}
diff --git a/bundles/org.openhab.binding.linktap/src/main/java/org/openhab/binding/linktap/internal/IBridgeData.java b/bundles/org.openhab.binding.linktap/src/main/java/org/openhab/binding/linktap/internal/IBridgeData.java
new file mode 100644
index 0000000000000..bb0a75ccc34f3
--- /dev/null
+++ b/bundles/org.openhab.binding.linktap/src/main/java/org/openhab/binding/linktap/internal/IBridgeData.java
@@ -0,0 +1,23 @@
+/**
+ * Copyright (c) 2010-2024 Contributors to the openHAB project
+ *
+ * See the NOTICE file(s) distributed with this work for additional
+ * information.
+ *
+ * This program and the accompanying materials are made available under the
+ * terms of the Eclipse Public License 2.0 which is available at
+ * http://www.eclipse.org/legal/epl-2.0
+ *
+ * SPDX-License-Identifier: EPL-2.0
+ */
+package org.openhab.binding.linktap.internal;
+
+import org.eclipse.jdt.annotation.NonNullByDefault;
+
+/**
+ * @author David Goodyear - Initial contribution
+ */
+@NonNullByDefault
+public interface IBridgeData {
+    void handleBridgeDataUpdated();
+}
diff --git a/bundles/org.openhab.binding.linktap/src/main/java/org/openhab/binding/linktap/internal/LinkTapBindingConstants.java b/bundles/org.openhab.binding.linktap/src/main/java/org/openhab/binding/linktap/internal/LinkTapBindingConstants.java
new file mode 100644
index 0000000000000..5acebc29a7992
--- /dev/null
+++ b/bundles/org.openhab.binding.linktap/src/main/java/org/openhab/binding/linktap/internal/LinkTapBindingConstants.java
@@ -0,0 +1,199 @@
+/**
+ * Copyright (c) 2010-2024 Contributors to the openHAB project
+ *
+ * See the NOTICE file(s) distributed with this work for additional
+ * information.
+ *
+ * This program and the accompanying materials are made available under the
+ * terms of the Eclipse Public License 2.0 which is available at
+ * http://www.eclipse.org/legal/epl-2.0
+ *
+ * SPDX-License-Identifier: EPL-2.0
+ */
+package org.openhab.binding.linktap.internal;
+
+import java.lang.reflect.Type;
+import java.util.List;
+
+import org.eclipse.jdt.annotation.NonNullByDefault;
+import org.openhab.binding.linktap.protocol.frames.WaterMeterStatus;
+import org.openhab.core.thing.ThingTypeUID;
+
+import com.google.gson.FieldNamingPolicy;
+import com.google.gson.Gson;
+import com.google.gson.GsonBuilder;
+import com.google.gson.reflect.TypeToken;
+
+/**
+ * The {@link LinkTapBindingConstants} class defines common constants, which are
+ * used across the whole binding.
+ *
+ * @author David Goodyear - Initial contribution
+ */
+@NonNullByDefault
+public class LinkTapBindingConstants {
+
+    private static final Type DEVICE_STATUS_CLASS_LIST_TYPE = new TypeToken<List<WaterMeterStatus.DeviceStatus>>() {
+    }.getType();
+
+    public static final Gson GSON = new GsonBuilder()
+            .registerTypeAdapter(DEVICE_STATUS_CLASS_LIST_TYPE, new WaterMeterStatus.DeviceStatusClassTypeAdapter())
+            .excludeFieldsWithoutExposeAnnotation().setFieldNamingPolicy(FieldNamingPolicy.LOWER_CASE_WITH_UNDERSCORES)
+            .disableHtmlEscaping().create();
+
+    private static final String BINDING_ID = "linktap";
+
+    // List of all Thing Type UIDs
+    public static final ThingTypeUID THING_TYPE_DEVICE = new ThingTypeUID(BINDING_ID, "device");
+    public static final ThingTypeUID THING_TYPE_BRIDGE = new ThingTypeUID(BINDING_ID, "bridge");
+
+    // List of all Channel ids
+    public static final String CHANNEL_1 = "channel1";
+
+    public static final String BRIDGE_PROP_GW_ID = "Gateway Id";
+    public static final String BRIDGE_PROP_HW_MODEL = "Hardware Model";
+    public static final String BRIDGE_PROP_GW_VER = "Version";
+    public static final String BRIDGE_PROP_MAC_ADDR = "MAC Address";
+    public static final String BRIDGE_HTTP_API_ENABLED = "HTTP API Enabled";
+    public static final String BRIDGE_HTTP_API_EP = "HTTP API Callback URI";
+    public static final String BRIDGE_PROP_VOL_UNIT = "Volume Unit";
+    public static final String BRIDGE_CONFIG_HOSTNAME = "host";
+    public static final String BRIDGE_CONFIG_MDNS_ENABLE = "enableMDNS";
+
+    public static final String DEVICE_PROP_DEV_ID = "Device Id";
+    public static final String DEVICE_PROP_DEV_NAME = "Device Name";
+    public static final String DEVICE_CONFIG_DEV_ID = "id";
+    public static final String DEVICE_CONFIG_DEV_NAME = "name";
+    public static final String DEVICE_CONFIG_AUTO_ALERTS_ENABLE = "autoEnableAlerts";
+
+    public static final String DEVICE_CHANNEL_WATERING_MODE = "mode";
+    public static final String DEVICE_CHANNEL_IS_MANUAL_MODE = "manual-watering";
+    public static final String DEVICE_CHANNEL_ACTIVE_WATERING = "active-watering";
+    public static final String DEVICE_CHANNEL_RF_LINKED = "rf-linked";
+    public static final String DEVICE_CHANNEL_FLM_LINKED = "flm-linked";
+    public static final String DEVICE_CHANNEL_FALL_STATUS = "fall-status";
+    public static final String DEVICE_CHANNEL_SHUTDOWN_FAILURE = "shutdown-failure";
+    public static final String DEVICE_CHANNEL_HIGH_FLOW = "high-flow";
+    public static final String DEVICE_CHANNEL_LOW_FLOW = "low-flow";
+    public static final String DEVICE_CHANNEL_FINAL_SEGMENT = "eco-final";
+    public static final String DEVICE_CHANNEL_SIGNAL = "signal";
+    public static final String DEVICE_CHANNEL_BATTERY = "battery";
+    public static final String DEVICE_CHANNEL_WATER_CUT = "water-cut";
+    public static final String DEVICE_CHANNEL_CHILD_LOCK = "child-lock";
+    public static final String DEVICE_CHANNEL_FLOW_RATE = "flow-rate";
+    public static final String DEVICE_CHANNEL_CURRENT_VOLUME = "volume";
+    public static final String DEVICE_CHANNEL_TOTAL_DURATION = "duration";
+    public static final String DEVICE_CHANNEL_REMAIN_DURATION = "remaining";
+    public static final String DEVICE_CHANNEL_FAILSAFE_DURATION = "dur-limit";
+    public static final String DEVICE_CHANNEL_FAILSAFE_VOLUME = "vol-limit";
+    public static final String DEVICE_CHANNEL_OH_VOLUME_LIMIT = "oh-vol-limit";
+    public static final String DEVICE_CHANNEL_OH_DURATION_LIMIT = "oh-dur-limit";
+    public static final String DEVICE_CHANNEL_WSKIP_PREV_RAIN = "water-skip-prev";
+    public static final String DEVICE_CHANNEL_WSKIP_NEXT_RAIN = "water-skip-next";
+    public static final String DEVICE_CHANNEL_WSKIP_DATE_TIME = "water-skip-ts";
+
+    public enum WateringMode {
+
+        /**
+         * OFF (Ordinal 0).
+         */
+        OFF(0, "Off"),
+
+        /**
+         * INSTANT (Ordinal 1).
+         */
+        INSTANT(1, "Instant"),
+
+        /**
+         * CALENDAR (Ordinal 2).
+         */
+        CALENDAR(2, "Calendar"),
+
+        /**
+         * DAY (Ordinal 3).
+         */
+        DAY(3, "Day"),
+
+        /**
+         * ODD_EVEN (Ordinal 4).
+         */
+        ODD_EVEN(4, "Odd-even"),
+
+        /**
+         * INTERVAL (Ordinal 5).
+         */
+        INTERVAL(5, "Interval"),
+
+        /**
+         * MONTH (Ordinal 6).
+         */
+        MONTH(6, "Month");
+
+        private final int value;
+        private final String description;
+
+        private WateringMode(final int value, final String description) {
+            this.value = value;
+            this.description = description;
+        }
+
+        public int getValue() {
+            return value;
+        }
+
+        public String getDesc() {
+            return description;
+        }
+
+        @Override
+        public String toString() {
+            return String.format("%d - %s", value, description);
+        }
+    }
+
+    public enum ChildLockMode {
+
+        /**
+         * UNLOCKED (Ordinal 0).
+         */
+        UNLOCKED(0, "Unlocked"),
+
+        /**
+         * PART_LOCKED (Ordinal 1).
+         */
+        PART_LOCKED(1, "Partially locked"),
+
+        /**
+         * FULLY_LOCKED (Ordinal 2).
+         */
+        FULLY_LOCKED(2, "Completely locked");
+
+        private final int value;
+        private final String description;
+
+        private ChildLockMode(final int value, final String description) {
+            this.value = value;
+            this.description = description;
+        }
+
+        public int getValue() {
+            return value;
+        }
+
+        public String getDesc() {
+            return description;
+        }
+
+        @Override
+        public String toString() {
+            return String.format("%d - %s", value, description);
+        }
+    }
+
+    // Property name constants
+    public static final String DEVICE_PROP_DEVICE_NAME = "Device Name";
+    public static final String DEVICE_PROP_DEVICE_TYPE = "Device Type";
+    public static final String DEVICE_PROP_DEVICE_MAC_ID = "MAC Id";
+    public static final String DEVICE_PROP_DEVICE_FAMILY = "Device Family";
+    public static final String DEVICE_PROP_DEVICE_UUID = "UUID";
+}
diff --git a/bundles/org.openhab.binding.linktap/src/main/java/org/openhab/binding/linktap/internal/LinkTapBridgeDiscoveryService.java b/bundles/org.openhab.binding.linktap/src/main/java/org/openhab/binding/linktap/internal/LinkTapBridgeDiscoveryService.java
new file mode 100644
index 0000000000000..4e40b1ad6a96e
--- /dev/null
+++ b/bundles/org.openhab.binding.linktap/src/main/java/org/openhab/binding/linktap/internal/LinkTapBridgeDiscoveryService.java
@@ -0,0 +1,248 @@
+/**
+ * Copyright (c) 2010-2024 Contributors to the openHAB project
+ *
+ * See the NOTICE file(s) distributed with this work for additional
+ * information.
+ *
+ * This program and the accompanying materials are made available under the
+ * terms of the Eclipse Public License 2.0 which is available at
+ * http://www.eclipse.org/legal/epl-2.0
+ *
+ * SPDX-License-Identifier: EPL-2.0
+ */
+package org.openhab.binding.linktap.internal;
+
+import static org.openhab.binding.linktap.internal.LinkTapBindingConstants.*;
+import static org.openhab.binding.linktap.internal.LinkTapBridgeHandler.MDNS_LOOKUP;
+import static org.openhab.binding.linktap.internal.Utils.cleanPrintableChars;
+
+import java.net.Inet4Address;
+import java.util.Arrays;
+import java.util.HashMap;
+import java.util.Map;
+import java.util.Optional;
+import java.util.Properties;
+import java.util.Set;
+import java.util.UUID;
+
+import javax.jmdns.ServiceInfo;
+
+import org.eclipse.jdt.annotation.NonNullByDefault;
+import org.eclipse.jdt.annotation.Nullable;
+import org.openhab.binding.linktap.protocol.frames.TLGatewayFrame;
+import org.openhab.core.config.discovery.DiscoveryResult;
+import org.openhab.core.config.discovery.DiscoveryResultBuilder;
+import org.openhab.core.config.discovery.mdns.MDNSDiscoveryParticipant;
+import org.openhab.core.thing.ThingTypeUID;
+import org.openhab.core.thing.ThingUID;
+import org.osgi.service.component.annotations.Component;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+import org.slf4j.event.Level;
+
+/**
+ * The {@link LinkTapBridgeDiscoveryService} is an implementation of a discovery service for VeSync devices. The
+ * meta-data is
+ * read by the bridge, and the discovery data updated via a callback implemented by the DeviceMetaDataUpdatedHandler.
+ *
+ * @author David Godyear - Initial contribution
+ */
+@NonNullByDefault
+@Component(service = MDNSDiscoveryParticipant.class)
+public class LinkTapBridgeDiscoveryService implements MDNSDiscoveryParticipant {
+
+    private final Logger logger = LoggerFactory.getLogger(LinkTapBridgeDiscoveryService.class);
+
+    private static final String SERVICE_TYPE = "_http._tcp.local.";
+
+    private static final Set<ThingTypeUID> SUPPORTED_THING_TYPES = Set.of(THING_TYPE_BRIDGE);
+
+    private static final String RAW_MODEL = "model";
+    private static final String RAW_ID = "ID";
+    private static final String RAW_MAC = "MAC";
+    private static final String RAW_IP = "IP";
+    private static final String RAW_ADMIN_URL = "admin_url";
+    private static final String RAW_VENDOR = "vendor";
+    private static final String RAW_VERSION = "version";
+    private static final String[] KEYS = new String[] { RAW_MODEL, RAW_ID, RAW_MAC, RAW_IP, RAW_ADMIN_URL, RAW_VENDOR,
+            RAW_VERSION };
+
+    @Override
+    public Set<ThingTypeUID> getSupportedThingTypeUIDs() {
+        return SUPPORTED_THING_TYPES;
+    }
+
+    @Override
+    public String getServiceType() {
+        return SERVICE_TYPE;
+    }
+
+    @Override
+    public @Nullable DiscoveryResult createResult(ServiceInfo service) {
+        final UUID itemId = UUID.randomUUID();
+        String qualifiedName = service.getQualifiedName();
+        String name = service.getName();
+
+        if (logger.isEnabledForLevel(Level.TRACE)) {
+            logger.trace("[{}] Device found: {}", itemId, cleanPrintableChars(qualifiedName));
+            logger.trace("[{}] Port {}", itemId, service.getPort());
+            logger.trace("[{}] Persistent {}", itemId, service.isPersistent());
+            logger.trace("[{}] Domain {}", itemId, cleanPrintableChars(service.getDomain()));
+            logger.trace("[{}] Application {}", itemId, cleanPrintableChars(service.getApplication()));
+            logger.trace("[{}] Protocol {}", itemId, cleanPrintableChars(service.getProtocol()));
+            logger.trace("[{}] Name {}", itemId, cleanPrintableChars(service.getName()));
+            logger.trace("[{}] Type {}", itemId, cleanPrintableChars(service.getType()));
+        }
+
+        if (!name.startsWith("LinkTapGw_")) {
+            logger.trace("[{}] Not a LinkTap Gateway - wrong name", itemId);
+            return null;
+        }
+        if (service.getPort() != 80) {
+            logger.trace("[{}] Not a LinkTap Gateway - incorrect port", itemId);
+            return null;
+        }
+
+        if (!service.getProtocol().equals("tcp")) {
+            logger.trace("[{}] Not a LinkTap Gateway - incorrect protocol", itemId);
+            return null;
+        }
+
+        if (!service.getApplication().equals("http")) {
+            logger.trace("[{}] Not a LinkTap Gateway - incorrect application", itemId);
+            return null;
+        }
+        if (logger.isEnabledForLevel(Level.TRACE)) {
+            {
+                final String[] nameSplit = name.split("_");
+                if (nameSplit.length > 2) {
+                    logger.trace("[{}] GW ID: {}", itemId, cleanPrintableChars(nameSplit[1]));
+                }
+            }
+            logger.trace("[{}] GW Text {}", itemId, cleanPrintableChars(new String(service.getTextBytes())));
+
+            for (int i = 0; i < service.getInet4Addresses().length; ++i) {
+                logger.trace("[{}] GW IPv4 Address: {}", itemId,
+                        cleanPrintableChars(service.getInet4Addresses()[i].toString()));
+            }
+            for (int i = 0; i < service.getInet6Addresses().length; ++i) {
+                logger.trace("[{}] GW IPv6 Address: {}", itemId,
+                        cleanPrintableChars(service.getInet6Addresses()[i].toString()));
+            }
+            for (int i = 0; i < service.getHostAddresses().length; ++i) {
+                logger.trace("[{}] GW Host Address: {}", itemId, cleanPrintableChars(service.getHostAddresses()[i]));
+            }
+        }
+
+        ThingUID uid = getThingUID(service);
+        if (uid == null) {
+            return null;
+        }
+
+        Properties rawDataProps = extractProps(service);
+        if (rawDataProps.isEmpty()) {
+            return null;
+        }
+
+        final Map<String, Object> x = new HashMap<>(4);
+        final String gatewayId = getGwId(service.getName());
+        x.put(BRIDGE_PROP_GW_ID, gatewayId);
+        final String macId = (String) rawDataProps.get(RAW_MAC);
+        if (macId != null) {
+            x.put(BRIDGE_PROP_MAC_ADDR, macId);
+        }
+        final String version = (String) rawDataProps.get(RAW_VERSION);
+        if (version != null) {
+            x.put(BRIDGE_PROP_GW_VER, version);
+        }
+        final String hostname = getHostName(service);
+        if (hostname.isEmpty()) {
+            return null;
+        }
+        x.put(BRIDGE_CONFIG_HOSTNAME, hostname);
+
+        if (gatewayId.isEmpty()) {
+            return null;
+        }
+        logger.debug("[{}] Discovered Gateway Id {}", itemId, gatewayId);
+
+        String ipV4Addr;
+        if (service.getInet4Addresses().length > 0) {
+            ipV4Addr = service.getInet4Addresses()[0].getHostAddress();
+        } else {
+            ipV4Addr = null;
+        }
+        MDNS_LOOKUP.registerItem(hostname, ipV4Addr, () -> {
+            logger.debug("[{}] Registered discovered hostname to IPv4 {} -> {}", itemId, hostname, ipV4Addr);
+        });
+        return DiscoveryResultBuilder.create((new ThingUID(THING_TYPE_BRIDGE, gatewayId))).withProperties(x)
+                .withLabel("LinkTap Gateway (" + gatewayId + ")").withRepresentationProperty(BRIDGE_PROP_GW_ID).build();
+    }
+
+    @Override
+    public @Nullable ThingUID getThingUID(ServiceInfo service) {
+        final Map<String, Object> x = new HashMap<>(4);
+        final String gatewayId = getGwId(service.getName());
+        x.put(BRIDGE_PROP_GW_ID, gatewayId);
+        if (x.get(BRIDGE_PROP_GW_ID) == null) {
+            return null;
+        }
+        return (new ThingUID(THING_TYPE_BRIDGE, gatewayId));
+    }
+
+    public Properties extractProps(ServiceInfo serviceInfo) {
+        final Properties result = new Properties();
+        final String data = new String(serviceInfo.getTextBytes());
+        final int[] keyIndexes = new int[7];
+
+        for (int i = 0; i < KEYS.length; ++i) {
+            keyIndexes[i] = data.indexOf(KEYS[i] + "=");
+        }
+        Arrays.sort(keyIndexes);
+        if (keyIndexes[0] == -1) {
+            return result;
+        }
+
+        String wCopy = data;
+        for (int si = keyIndexes.length - 1; si > -1; --si) {
+            final String foundField = wCopy.substring(keyIndexes[si]).trim();
+            wCopy = wCopy.substring(0, keyIndexes[si]);
+            final Optional<String> potentialKey = Arrays.stream(KEYS).filter(foundField::startsWith).findFirst();
+            if (potentialKey.isPresent()) {
+                final String key = potentialKey.get();
+                result.put(key, foundField.substring(key.length() + 1));
+            }
+        }
+        return result;
+    }
+
+    @Override
+    public long getRemovalGracePeriodSeconds(ServiceInfo serviceInfo) {
+        return MDNSDiscoveryParticipant.super.getRemovalGracePeriodSeconds(serviceInfo);
+    }
+
+    private String getGwId(final String serviceName) {
+        String[] segments = serviceName.split("_");
+        if (segments.length > 1) {
+            return segments[1];
+        }
+        return TLGatewayFrame.EMPTY_STRING;
+    }
+
+    private String getHostName(final ServiceInfo serviceInfo) {
+        final Inet4Address[] addrs = serviceInfo.getInet4Addresses();
+        if (addrs.length == 0) {
+            logger.trace("No IPv4 given in mdns data");
+            return TLGatewayFrame.EMPTY_STRING;
+        }
+        String candidateDnsName = addrs[0].getHostName();
+        if (candidateDnsName.isEmpty()) {
+            logger.trace("No DNS given by IPv4 address from mdns data");
+            candidateDnsName = addrs[0].toString();
+        }
+        if (candidateDnsName.startsWith("/")) {
+            candidateDnsName = candidateDnsName.substring(1);
+        }
+        return candidateDnsName;
+    }
+}
diff --git a/bundles/org.openhab.binding.linktap/src/main/java/org/openhab/binding/linktap/internal/LinkTapBridgeHandler.java b/bundles/org.openhab.binding.linktap/src/main/java/org/openhab/binding/linktap/internal/LinkTapBridgeHandler.java
new file mode 100644
index 0000000000000..55ba820dbbec0
--- /dev/null
+++ b/bundles/org.openhab.binding.linktap/src/main/java/org/openhab/binding/linktap/internal/LinkTapBridgeHandler.java
@@ -0,0 +1,496 @@
+/**
+ * Copyright (c) 2010-2024 Contributors to the openHAB project
+ *
+ * See the NOTICE file(s) distributed with this work for additional
+ * information.
+ *
+ * This program and the accompanying materials are made available under the
+ * terms of the Eclipse Public License 2.0 which is available at
+ * http://www.eclipse.org/legal/epl-2.0
+ *
+ * SPDX-License-Identifier: EPL-2.0
+ */
+package org.openhab.binding.linktap.internal;
+
+import static org.openhab.binding.linktap.internal.LinkTapBindingConstants.BRIDGE_PROP_GW_ID;
+import static org.openhab.binding.linktap.internal.LinkTapBindingConstants.BRIDGE_PROP_GW_VER;
+import static org.openhab.binding.linktap.internal.LinkTapBindingConstants.BRIDGE_PROP_VOL_UNIT;
+import static org.openhab.binding.linktap.protocol.frames.TLGatewayFrame.CMD_DATETIME_SYNC;
+import static org.openhab.binding.linktap.protocol.frames.TLGatewayFrame.CMD_GET_CONFIGURATION;
+import static org.openhab.binding.linktap.protocol.frames.TLGatewayFrame.CMD_HANDSHAKE;
+import static org.openhab.binding.linktap.protocol.frames.TLGatewayFrame.CMD_NOTIFICATION_WATERING_SKIPPED;
+import static org.openhab.binding.linktap.protocol.frames.TLGatewayFrame.CMD_RAINFALL_DATA;
+import static org.openhab.binding.linktap.protocol.frames.TLGatewayFrame.EMPTY_STRING_ARRAY;
+
+import java.io.IOException;
+import java.net.InetAddress;
+import java.net.InetSocketAddress;
+import java.net.MalformedURLException;
+import java.net.Socket;
+import java.net.URL;
+import java.net.UnknownHostException;
+import java.time.Duration;
+import java.util.Arrays;
+import java.util.Collection;
+import java.util.HashMap;
+import java.util.Map;
+import java.util.Optional;
+import java.util.Set;
+import java.util.UUID;
+import java.util.concurrent.ConcurrentHashMap;
+import java.util.concurrent.ConcurrentMap;
+import java.util.concurrent.CopyOnWriteArrayList;
+import java.util.concurrent.ScheduledFuture;
+import java.util.concurrent.TimeUnit;
+import java.util.stream.Stream;
+
+import javax.validation.constraints.NotNull;
+
+import org.eclipse.jdt.annotation.NonNullByDefault;
+import org.eclipse.jdt.annotation.Nullable;
+import org.openhab.binding.linktap.configuration.LinkTapBridgeConfiguration;
+import org.openhab.binding.linktap.protocol.frames.GatewayConfigResp;
+import org.openhab.binding.linktap.protocol.frames.HandshakeReq;
+import org.openhab.binding.linktap.protocol.frames.TLGatewayFrame;
+import org.openhab.binding.linktap.protocol.http.CommandNotSupportedException;
+import org.openhab.binding.linktap.protocol.http.DeviceIdException;
+import org.openhab.binding.linktap.protocol.http.GatewayIdException;
+import org.openhab.binding.linktap.protocol.http.InvalidParameterException;
+import org.openhab.binding.linktap.protocol.http.NotTapLinkGatewayException;
+import org.openhab.binding.linktap.protocol.http.TransientCommunicationIssueException;
+import org.openhab.binding.linktap.protocol.http.WebServerApi;
+import org.openhab.binding.linktap.protocol.servers.BindingServlet;
+import org.openhab.binding.linktap.protocol.servers.IHttpClientProvider;
+import org.openhab.core.cache.ExpiringCache;
+import org.openhab.core.thing.Bridge;
+import org.openhab.core.thing.ChannelUID;
+import org.openhab.core.thing.Thing;
+import org.openhab.core.thing.ThingStatus;
+import org.openhab.core.thing.ThingStatusDetail;
+import org.openhab.core.thing.ThingUID;
+import org.openhab.core.thing.binding.BaseBridgeHandler;
+import org.openhab.core.thing.binding.ThingHandler;
+import org.openhab.core.thing.binding.ThingHandlerService;
+import org.openhab.core.types.Command;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
+/**
+ * The {@link LinkTapBridgeHandler} class defines the handler for a LinkTapHandler
+ *
+ * @author David Goodyear - Initial contribution
+ */
+@NonNullByDefault
+public class LinkTapBridgeHandler extends BaseBridgeHandler {
+
+    private final Logger logger = LoggerFactory.getLogger(LinkTapBridgeHandler.class);
+    private String bridgeKey = "";
+    private String gwId = "";
+    private IHttpClientProvider httpClientProvider;
+    public static final LookupWrapper<@Nullable LinkTapBridgeHandler> ADDR_LOOKUP = new LookupWrapper<>();
+    public static final LookupWrapper<@Nullable LinkTapBridgeHandler> GW_ID_LOOKUP = new LookupWrapper<>();
+    public static final LookupWrapper<@Nullable LinkTapHandler> DEV_ID_LOOKUP = new LookupWrapper<>();
+    public static final LookupWrapper<@Nullable String> MDNS_LOOKUP = new LookupWrapper<>();
+    private final Object schedulerLock = new Object();
+    private @Nullable ScheduledFuture<?> backgroundGwPollingScheduler;
+
+    private volatile long lastGwCommandRecvTs = 0L;
+
+    private final Object getConfigLock = new Object();
+
+    protected ExpiringCache<String> lastGetConfigCache = new ExpiringCache<>(Duration.ofSeconds(10),
+            LinkTapBridgeHandler::expireCacheContents);
+
+    private static @Nullable String expireCacheContents() {
+        return null;
+    }
+
+    public LinkTapBridgeHandler(final Bridge bridge, @NotNull IHttpClientProvider httpClientProvider) {
+        super(bridge);
+        this.httpClientProvider = httpClientProvider;
+    }
+
+    private void startGwPolling() {
+        synchronized (schedulerLock) {
+            cancelGwPolling();
+            backgroundGwPollingScheduler = scheduler.scheduleWithFixedDelay(() -> {
+                if (lastGwCommandRecvTs + 120000 < System.currentTimeMillis()) {
+                    getGatewayConfiguration();
+                }
+            }, 5000, 120000, TimeUnit.MILLISECONDS);
+        }
+    }
+
+    private void cancelGwPolling() {
+        synchronized (schedulerLock) {
+            ScheduledFuture<?> ref = backgroundGwPollingScheduler;
+            if (ref != null) {
+                ref.cancel(true);
+                backgroundGwPollingScheduler = null;
+            }
+        }
+    }
+
+    @Override
+    public void initialize() {
+        updateStatus(ThingStatus.UNKNOWN);
+        scheduler.execute(this::connect);
+    }
+
+    @Override
+    public void dispose() {
+        cancelGwPolling();
+        deregisterBridge(this);
+        GW_ID_LOOKUP.deregisterItem(gwId, this, () -> {
+        });
+    }
+
+    @Override
+    public Collection<Class<? extends ThingHandlerService>> getServices() {
+        return Set.of(LinkTapDeviceDiscoveryService.class);
+    }
+
+    public @Nullable String getGatewayId() {
+        return editProperties().get(BRIDGE_PROP_GW_ID);
+    }
+
+    private void deregisterBridge(final LinkTapBridgeHandler ref) {
+        if (!bridgeKey.isEmpty()) {
+            ADDR_LOOKUP.deregisterItem(bridgeKey, ref, () -> {
+                BindingServlet.getInstance().unregisterServlet();
+            });
+            bridgeKey = "";
+        }
+    }
+
+    public String getHost() {
+        final LinkTapBridgeConfiguration config = getConfigAs(LinkTapBridgeConfiguration.class);
+        return config.host;
+    }
+
+    private boolean registerBridge(final LinkTapBridgeHandler ref) {
+        final WebServerApi api = WebServerApi.getInstance();
+        api.setHttpClient(httpClientProvider.getHttpClient());
+        final LinkTapBridgeConfiguration config = getConfigAs(LinkTapBridgeConfiguration.class);
+        try {
+            final InetAddress ip = InetAddress.getByName(new URL("http://" + config.host).getHost());
+            final String newHost = ip.getHostAddress();
+            if (!bridgeKey.equals(newHost)) {
+                deregisterBridge(this);
+                bridgeKey = newHost;
+            }
+
+            if (!ADDR_LOOKUP.registerItem(bridgeKey, this, () -> {
+                BindingServlet.getInstance().registerServlet();
+            })) {
+                return false;
+            }
+        } catch (MalformedURLException | UnknownHostException e) {
+            deregisterBridge(this);
+            return false;
+        }
+        return true;
+    }
+
+    public void getGatewayConfiguration() {
+        String resp = "";
+        synchronized (getConfigLock) {
+            resp = lastGetConfigCache.getValue();
+            if (lastGetConfigCache.isExpired() || resp == null || resp.isBlank()) {
+                resp = sendApiRequest(new TLGatewayFrame(CMD_GET_CONFIGURATION));
+                lastGetConfigCache.putValue(resp);
+            }
+        }
+
+        final GatewayConfigResp gwConfig = LinkTapBindingConstants.GSON.fromJson(resp, GatewayConfigResp.class);
+        if (gwConfig == null) {
+            return;
+        }
+        final String version = gwConfig.version;
+        final String volUnit = gwConfig.volumeUnit;
+        final String[] devIds = gwConfig.endDevices;
+        final String[] devNames = gwConfig.deviceNames;
+        if (!version.equals(editProperties().get(BRIDGE_PROP_GW_VER))) {
+            final Map<String, String> props = editProperties();
+            props.put(BRIDGE_PROP_GW_VER, version);
+            updateProperties(props);
+            return;
+        }
+        if (!volUnit.equals(editProperties().get(BRIDGE_PROP_VOL_UNIT))) {
+            final Map<String, String> props = editProperties();
+            props.put(BRIDGE_PROP_VOL_UNIT, volUnit);
+            updateProperties(props);
+        }
+
+        boolean updatedDeviceInfo = devIds.length != discoveredDevices.size();
+
+        for (int i = 0; i < devIds.length; ++i) {
+            LinkTapDeviceMetadata deviceInfo = new LinkTapDeviceMetadata(devIds[i], devNames[i]);
+            LinkTapDeviceMetadata replaced = discoveredDevices.put(deviceInfo.deviceId, deviceInfo);
+            if (replaced != null
+                    && (!replaced.deviceId.equals(devIds[i]) || !replaced.deviceName.equals(devNames[i]))) {
+                updatedDeviceInfo = true;
+            }
+        }
+
+        handlers.forEach(x -> x.handleMetadataRetrieved(this));
+
+        if (updatedDeviceInfo) {
+            this.scheduler.execute(() -> {
+                for (Thing el : getThing().getThings()) {
+                    final ThingHandler th = el.getHandler();
+                    if (th instanceof IBridgeData) {
+                        ((IBridgeData) th).handleBridgeDataUpdated();
+                    }
+                }
+            });
+        }
+    }
+
+    public String sendApiRequest(final TLGatewayFrame req) {
+        final UUID uid = UUID.randomUUID();
+
+        final WebServerApi api = WebServerApi.getInstance();
+        final String host = getHost();
+        final String gwId = getGatewayId();
+        if (host.isEmpty() || gwId == null) {
+            return "";
+        }
+        req.gatewayId = gwId;
+        try {
+            final String reqData = LinkTapBindingConstants.GSON.toJson(req);
+            logger.debug("{} = APP BRIDGE -> GW -> Request {}", uid, reqData);
+            final String respData = api.sendRequest(host, reqData);
+            logger.debug("{} = APP BRIDGE -> GW -> Response {}", uid, respData);
+            final TLGatewayFrame gwResponseFrame = LinkTapBindingConstants.GSON.fromJson(respData,
+                    TLGatewayFrame.class);
+            if (gwResponseFrame != null && !gwResponseFrame.gatewayId.equals(req.gatewayId)) {
+                logger.warn("{} = Response from incorrect Gateway \"{}\" != \"{}\"", uid, req.gatewayId,
+                        gwResponseFrame.gatewayId);
+                return "";
+            }
+            if (gwResponseFrame != null && req.command != gwResponseFrame.command) {
+                logger.warn("{} = Received incorrect CMD response {} != {}", uid, req.command, gwResponseFrame.command);
+                return "";
+            }
+            return respData;
+        } catch (NotTapLinkGatewayException e) {
+            logger.warn("{} = {} is not a Link Tap Gateway!", uid, host);
+        } catch (TransientCommunicationIssueException e) {
+            logger.warn("{} = Possible communications issue (auto retry): {}", uid, e.getMessage());
+        }
+        return "";
+    }
+
+    private void connect() {
+        final LinkTapBridgeConfiguration config = getConfigAs(LinkTapBridgeConfiguration.class);
+        // Check if we can resolve the remote host, if so then it can be mapped back to a bridge handler.
+        // If not further communications would fail - so its offline.
+        if (!registerBridge(this)) {
+            updateStatus(ThingStatus.OFFLINE, ThingStatusDetail.COMMUNICATION_ERROR, "Hostname / IP cannot be found");
+            return;
+        }
+        final WebServerApi api = WebServerApi.getInstance();
+        api.setHttpClient(httpClientProvider.getHttpClient());
+        try {
+            final Map<String, String> bridgeProps = api.getBridgeProperities(bridgeKey);
+            if (!bridgeProps.isEmpty()) {
+                final Map<String, String> currentProps = editProperties();
+                currentProps.putAll(bridgeProps);
+                updateProperties(currentProps);
+            } else {
+                if (!api.unlockWebInterface(bridgeKey, config.username, config.password)) {
+                    updateStatus(ThingStatus.OFFLINE, ThingStatusDetail.COMMUNICATION_ERROR,
+                            "Check credentials provided");
+                    return;
+                }
+            }
+            // Update the GW ID -> this bridge lookup
+            String newId = getGatewayId();
+            if (newId != null) {
+                gwId = newId;
+                GW_ID_LOOKUP.registerItem(gwId, this, () -> {
+                });
+            }
+            getGatewayConfiguration();
+
+            String localServerAddr = "";
+            try (Socket socket = new Socket()) {
+                try {
+                    socket.connect(new InetSocketAddress(config.host, 80));
+                } catch (IOException e) {
+                    logger.warn("Failed to connect to remote device due to exception", e);
+                    return;
+                }
+                localServerAddr = socket.getLocalAddress().getHostAddress();
+                logger.trace("Local address for connectivity is {}", socket.getLocalAddress().getHostAddress());
+            } catch (IOException e) {
+                logger.warn("Failed to connect to remote device due to exception", e);
+            }
+
+            final String servletEp = BindingServlet.getServletAddress(localServerAddr);
+            final Optional<String> servletEpOpt = (!servletEp.isEmpty()) ? Optional.of(servletEp) : Optional.empty();
+
+            @NotNull
+            final String hostname = getHostname(config);
+
+            api.configureBridge(hostname, Optional.of(Boolean.TRUE), servletEpOpt);
+            updateStatus(ThingStatus.ONLINE);
+            startGwPolling();
+        } catch (NotTapLinkGatewayException e) {
+            deregisterBridge(this);
+            updateStatus(ThingStatus.OFFLINE, ThingStatusDetail.COMMUNICATION_ERROR,
+                    "Target Host is not a LinkTap Gateway");
+        } catch (TransientCommunicationIssueException e) {
+            updateStatus(ThingStatus.OFFLINE, ThingStatusDetail.COMMUNICATION_ERROR,
+                    "Cannot connect to LinkTap Gateway");
+        }
+    }
+
+    @Override
+    public void handleCommand(final ChannelUID channelUID, final Command command) {
+    }
+
+    protected @NotNull String getHostname() {
+        final LinkTapBridgeConfiguration config = getConfigAs(LinkTapBridgeConfiguration.class);
+        return getHostname(config);
+    }
+
+    private @NotNull String getHostname(final LinkTapBridgeConfiguration config) {
+        @NotNull
+        String hostname = config.host;
+        final String mdnsLookup = MDNS_LOOKUP.getItem(config.host);
+        if (mdnsLookup != null) {
+            hostname = mdnsLookup;
+        }
+        return hostname;
+    }
+
+    public Map<String, String> getMetadataProperities(final @Nullable HandshakeReq handshake) {
+        if (handshake == null) {
+            return Map.of();
+        }
+        final Map<String, String> newProps = new HashMap<>(3);
+        newProps.put(BRIDGE_PROP_GW_ID, handshake.gatewayId);
+        newProps.put(BRIDGE_PROP_GW_VER, handshake.version);
+        newProps.put(BRIDGE_PROP_VOL_UNIT, "?");
+        return newProps;
+    }
+
+    private final Object singleCommLock = new Object();
+
+    public String sendRequest(final TLGatewayFrame frame) throws DeviceIdException, InvalidParameterException {
+        // Validate the payload is within the expected limits for the device its being sent to
+        // if (!frame.isValid()) {
+        // logger.warn("Payload validation failed - will not send");
+        // return "";
+        // }
+        final TransactionProcessor tp = TransactionProcessor.getInstance();
+        final String gatewayId = getGatewayId();
+        if (gatewayId == null) {
+            logger.warn("Error with gateway ID");
+            return "";
+        }
+        frame.gatewayId = gatewayId;
+        // The gateway is a single device that may have to do RF, limit the comm's to ensure
+        // it can maintain a good QoS. Responses for most commands are very fast on a reasonable network.
+        try {
+            synchronized (singleCommLock) {
+                try {
+                    return tp.sendRequest(this, frame);
+                } catch (final CommandNotSupportedException cnse) {
+                    logger.warn("Device {} did not accept command {}", getThing().getLabel(), cnse.getMessage());
+                }
+            }
+        } catch (final GatewayIdException gide) {
+            updateStatus(ThingStatus.OFFLINE, ThingStatusDetail.COMMUNICATION_ERROR, gide.getMessage());
+        }
+        return "";
+    }
+
+    public ThingUID getUID() {
+        return thing.getUID();
+    }
+
+    /**
+     * Discovery handling of Gateway owned Devices
+     */
+
+    public void registerMetaDataUpdatedHandler(DeviceMetaDataUpdatedHandler dmduh) {
+        handlers.add(dmduh);
+    }
+
+    public void unregisterMetaDataUpdatedHandler(DeviceMetaDataUpdatedHandler dmduh) {
+        handlers.remove(dmduh);
+    }
+
+    private final CopyOnWriteArrayList<DeviceMetaDataUpdatedHandler> handlers = new CopyOnWriteArrayList<>();
+
+    private ConcurrentMap<String, LinkTapDeviceMetadata> discoveredDevices = new ConcurrentHashMap<>();
+
+    public final Stream<LinkTapDeviceMetadata> getDiscoveredDevices() {
+        return discoveredDevices.values().stream();
+    }
+
+    public final Map<String, LinkTapDeviceMetadata> getDeviceLookup() {
+        return discoveredDevices;
+    }
+
+    public void processGatewayCommand(final int commandId, final String frame) {
+        logger.debug("{} processing gateway request with command {}", this.getThing().getLabel(), commandId);
+        // Store this so that the only when necessary can poll's be done - aka
+        // no direct from Gateway communications.
+        lastGwCommandRecvTs = System.currentTimeMillis();
+        switch (commandId) {
+            case CMD_HANDSHAKE:
+                lastGetConfigCache.invalidateValue();
+                processCommand0(frame);
+                break;
+            case CMD_RAINFALL_DATA:
+            case CMD_NOTIFICATION_WATERING_SKIPPED:
+            case CMD_DATETIME_SYNC:
+                logger.debug("No implementation for command {} for processing the GW request", commandId);
+        }
+    }
+
+    private void processCommand0(final String request) {
+        final GatewayConfigResp decoded = LinkTapBindingConstants.GSON.fromJson(request, GatewayConfigResp.class);
+
+        // Check the current version property matches and if not update it
+        final String currentVerKnown = editProperties().get(BRIDGE_PROP_GW_VER);
+        if (decoded != null && currentVerKnown != null && !decoded.version.isEmpty()) {
+            if (!currentVerKnown.equals(decoded.version)) {
+                final Map<String, String> currentProps = editProperties();
+                currentProps.put(BRIDGE_PROP_GW_VER, decoded.version);
+                updateProperties(currentProps);
+            }
+        }
+        final String currentVolUnit = editProperties().get(BRIDGE_PROP_VOL_UNIT);
+        if (decoded != null && currentVolUnit != null && !decoded.volumeUnit.isEmpty()) {
+            if (!currentVolUnit.equals(decoded.volumeUnit)) {
+                final Map<String, String> currentProps = editProperties();
+                currentProps.put(BRIDGE_PROP_VOL_UNIT, decoded.volumeUnit);
+                updateProperties(currentProps);
+            }
+        }
+        final String[] devices = decoded != null ? decoded.endDevices : EMPTY_STRING_ARRAY;
+        // Go through all the device ID's returned check we know about them.
+        // If not a background scan should be done
+        boolean fullScanRequired = false;
+        if (discoveredDevices.size() != devices.length) {
+            fullScanRequired = true;
+        }
+        if (!discoveredDevices.keySet().containsAll(Arrays.stream(devices).toList())) {
+            fullScanRequired = true;
+        }
+        if (fullScanRequired) {
+            logger.trace("The configured devices have changed a full scan should be run");
+            scheduler.execute(this::getGatewayConfiguration);
+        }
+    }
+
+    @Override
+    public void childHandlerDisposed(ThingHandler childHandler, Thing childThing) {
+        scheduler.execute(this::getGatewayConfiguration);
+    }
+}
diff --git a/bundles/org.openhab.binding.linktap/src/main/java/org/openhab/binding/linktap/internal/LinkTapDeviceConfiguration.java b/bundles/org.openhab.binding.linktap/src/main/java/org/openhab/binding/linktap/internal/LinkTapDeviceConfiguration.java
new file mode 100644
index 0000000000000..f5edbb156c00f
--- /dev/null
+++ b/bundles/org.openhab.binding.linktap/src/main/java/org/openhab/binding/linktap/internal/LinkTapDeviceConfiguration.java
@@ -0,0 +1,43 @@
+/**
+ * Copyright (c) 2010-2024 Contributors to the openHAB project
+ *
+ * See the NOTICE file(s) distributed with this work for additional
+ * information.
+ *
+ * This program and the accompanying materials are made available under the
+ * terms of the Eclipse Public License 2.0 which is available at
+ * http://www.eclipse.org/legal/epl-2.0
+ *
+ * SPDX-License-Identifier: EPL-2.0
+ */
+package org.openhab.binding.linktap.internal;
+
+import org.eclipse.jdt.annotation.NonNullByDefault;
+import org.eclipse.jdt.annotation.Nullable;
+
+/**
+ * The {@link LinkTapDeviceConfiguration} class contains fields mapping the configuration parameters for a LinkTap
+ * device's configuration.
+ *
+ * @author David Goodyear - Initial contribution
+ */
+@NonNullByDefault
+public class LinkTapDeviceConfiguration {
+
+    /**
+     * The clear text device name as reported by the API.
+     */
+    @Nullable
+    public String name;
+
+    /**
+     * The device id as stored by the gateway to address the device.
+     */
+    @Nullable
+    public String id;
+
+    /**
+     * If enabled the device, will enable all alerts during device initialization.
+     */
+    public boolean enableAlerts;
+}
diff --git a/bundles/org.openhab.binding.linktap/src/main/java/org/openhab/binding/linktap/internal/LinkTapDeviceDiscoveryService.java b/bundles/org.openhab.binding.linktap/src/main/java/org/openhab/binding/linktap/internal/LinkTapDeviceDiscoveryService.java
new file mode 100644
index 0000000000000..2205b03d0a805
--- /dev/null
+++ b/bundles/org.openhab.binding.linktap/src/main/java/org/openhab/binding/linktap/internal/LinkTapDeviceDiscoveryService.java
@@ -0,0 +1,103 @@
+/**
+ * Copyright (c) 2010-2024 Contributors to the openHAB project
+ *
+ * See the NOTICE file(s) distributed with this work for additional
+ * information.
+ *
+ * This program and the accompanying materials are made available under the
+ * terms of the Eclipse Public License 2.0 which is available at
+ * http://www.eclipse.org/legal/epl-2.0
+ *
+ * SPDX-License-Identifier: EPL-2.0
+ */
+package org.openhab.binding.linktap.internal;
+
+import static org.openhab.binding.linktap.internal.LinkTapBindingConstants.*;
+
+import java.util.HashMap;
+import java.util.Map;
+import java.util.Set;
+
+import org.eclipse.jdt.annotation.NonNullByDefault;
+import org.openhab.core.config.discovery.AbstractThingHandlerDiscoveryService;
+import org.openhab.core.config.discovery.DiscoveryResultBuilder;
+import org.openhab.core.config.discovery.DiscoveryService;
+import org.openhab.core.thing.ThingTypeUID;
+import org.openhab.core.thing.ThingUID;
+import org.osgi.service.component.annotations.Component;
+import org.osgi.service.component.annotations.ServiceScope;
+
+/**
+ * The {@link LinkTapDeviceDiscoveryService} is an implementation of a discovery service for VeSync devices. The
+ * meta-data is
+ * read by the bridge, and the discovery data updated via a callback implemented by the DeviceMetaDataUpdatedHandler.
+ *
+ * @author David Godyear - Initial contribution
+ */
+@NonNullByDefault
+@Component(scope = ServiceScope.PROTOTYPE, service = LinkTapDeviceDiscoveryService.class, configurationPid = "discovery.linkTap.devices")
+public class LinkTapDeviceDiscoveryService extends AbstractThingHandlerDiscoveryService<LinkTapBridgeHandler>
+        implements DeviceMetaDataUpdatedHandler {
+
+    private static final Set<ThingTypeUID> SUPPORTED_THING_TYPES = Set.of(THING_TYPE_BRIDGE);
+
+    private static final int DISCOVER_TIMEOUT_SECONDS = 5;
+
+    private @NonNullByDefault({}) ThingUID bridgeUID;
+
+    /**
+     * Creates a VeSyncDiscoveryService with enabled autostart.
+     */
+    public LinkTapDeviceDiscoveryService() {
+        super(LinkTapBridgeHandler.class, SUPPORTED_THING_TYPES, DISCOVER_TIMEOUT_SECONDS);
+    }
+
+    @Override
+    public Set<ThingTypeUID> getSupportedThingTypes() {
+        return SUPPORTED_THING_TYPES;
+    }
+
+    @Override
+    public void activate() {
+        final Map<String, Object> properties = new HashMap<>();
+        properties.put(DiscoveryService.CONFIG_PROPERTY_BACKGROUND_DISCOVERY, Boolean.TRUE);
+        super.activate(properties);
+    }
+
+    @Override
+    public void initialize() {
+        bridgeUID = thingHandler.getUID();
+        super.initialize();
+    }
+
+    @Override
+    protected void startBackgroundDiscovery() {
+        thingHandler.registerMetaDataUpdatedHandler(this);
+    }
+
+    @Override
+    protected void stopBackgroundDiscovery() {
+        thingHandler.unregisterMetaDataUpdatedHandler(this);
+    }
+
+    @Override
+    protected void startScan() {
+        // If the bridge is not online no other thing devices can be found, so no reason to scan at this moment.
+        removeOlderResults(getTimestampOfLastScan());
+    }
+
+    @Override
+    public void handleMetadataRetrieved(final LinkTapBridgeHandler handler) {
+        thingHandler.getDiscoveredDevices().map(x -> {
+            final Map<String, Object> properties = new HashMap<>(4);
+            properties.put(DEVICE_PROP_DEV_ID, x.deviceId);
+            properties.put(DEVICE_PROP_DEV_NAME, x.deviceName);
+            properties.put(DEVICE_CONFIG_DEV_ID, x.deviceId);
+            properties.put(DEVICE_CONFIG_DEV_NAME, x.deviceName);
+            properties.put(DEVICE_CONFIG_AUTO_ALERTS_ENABLE, true);
+            return DiscoveryResultBuilder.create(new ThingUID(THING_TYPE_DEVICE, bridgeUID, x.deviceId))
+                    .withBridge(bridgeUID).withProperties(properties).withLabel(x.deviceName)
+                    .withRepresentationProperty(DEVICE_PROP_DEV_ID).build();
+        }).forEach(this::thingDiscovered);
+    }
+}
diff --git a/bundles/org.openhab.binding.linktap/src/main/java/org/openhab/binding/linktap/internal/LinkTapDeviceMetadata.java b/bundles/org.openhab.binding.linktap/src/main/java/org/openhab/binding/linktap/internal/LinkTapDeviceMetadata.java
new file mode 100644
index 0000000000000..9b283f98693b6
--- /dev/null
+++ b/bundles/org.openhab.binding.linktap/src/main/java/org/openhab/binding/linktap/internal/LinkTapDeviceMetadata.java
@@ -0,0 +1,40 @@
+/**
+ * Copyright (c) 2010-2024 Contributors to the openHAB project
+ *
+ * See the NOTICE file(s) distributed with this work for additional
+ * information.
+ *
+ * This program and the accompanying materials are made available under the
+ * terms of the Eclipse Public License 2.0 which is available at
+ * http://www.eclipse.org/legal/epl-2.0
+ *
+ * SPDX-License-Identifier: EPL-2.0
+ */
+package org.openhab.binding.linktap.internal;
+
+import org.eclipse.jdt.annotation.NonNullByDefault;
+
+/**
+ * The {@link LinkTapDeviceMetadata} class contains the definition of a devices metadata as given by a Gateway device.
+ *
+ * @author David Goodyear - Initial contribution
+ */
+@NonNullByDefault
+public class LinkTapDeviceMetadata {
+
+    public LinkTapDeviceMetadata(final String deviceId, final String deviceName) {
+        this.deviceId = deviceId;
+        this.deviceName = deviceName;
+    }
+
+    /**
+     * The ID of the device as stored in the relevant Gateway Device.
+     *
+     */
+    public final String deviceId;
+
+    /**
+     * The human-readable name of the device as stored in the relevant Gateway Device.
+     */
+    public final String deviceName;
+}
diff --git a/bundles/org.openhab.binding.linktap/src/main/java/org/openhab/binding/linktap/internal/LinkTapHandler.java b/bundles/org.openhab.binding.linktap/src/main/java/org/openhab/binding/linktap/internal/LinkTapHandler.java
new file mode 100644
index 0000000000000..65adbe9b91dc6
--- /dev/null
+++ b/bundles/org.openhab.binding.linktap/src/main/java/org/openhab/binding/linktap/internal/LinkTapHandler.java
@@ -0,0 +1,429 @@
+/**
+ * Copyright (c) 2010-2024 Contributors to the openHAB project
+ *
+ * See the NOTICE file(s) distributed with this work for additional
+ * information.
+ *
+ * This program and the accompanying materials are made available under the
+ * terms of the Eclipse Public License 2.0 which is available at
+ * http://www.eclipse.org/legal/epl-2.0
+ *
+ * SPDX-License-Identifier: EPL-2.0
+ */
+package org.openhab.binding.linktap.internal;
+
+import static org.openhab.binding.linktap.internal.LinkTapBindingConstants.BRIDGE_PROP_VOL_UNIT;
+import static org.openhab.binding.linktap.internal.LinkTapBindingConstants.ChildLockMode;
+import static org.openhab.binding.linktap.internal.LinkTapBindingConstants.DEVICE_CHANNEL_ACTIVE_WATERING;
+import static org.openhab.binding.linktap.internal.LinkTapBindingConstants.DEVICE_CHANNEL_BATTERY;
+import static org.openhab.binding.linktap.internal.LinkTapBindingConstants.DEVICE_CHANNEL_CHILD_LOCK;
+import static org.openhab.binding.linktap.internal.LinkTapBindingConstants.DEVICE_CHANNEL_CURRENT_VOLUME;
+import static org.openhab.binding.linktap.internal.LinkTapBindingConstants.DEVICE_CHANNEL_FAILSAFE_DURATION;
+import static org.openhab.binding.linktap.internal.LinkTapBindingConstants.DEVICE_CHANNEL_FAILSAFE_VOLUME;
+import static org.openhab.binding.linktap.internal.LinkTapBindingConstants.DEVICE_CHANNEL_FALL_STATUS;
+import static org.openhab.binding.linktap.internal.LinkTapBindingConstants.DEVICE_CHANNEL_FINAL_SEGMENT;
+import static org.openhab.binding.linktap.internal.LinkTapBindingConstants.DEVICE_CHANNEL_FLM_LINKED;
+import static org.openhab.binding.linktap.internal.LinkTapBindingConstants.DEVICE_CHANNEL_FLOW_RATE;
+import static org.openhab.binding.linktap.internal.LinkTapBindingConstants.DEVICE_CHANNEL_HIGH_FLOW;
+import static org.openhab.binding.linktap.internal.LinkTapBindingConstants.DEVICE_CHANNEL_IS_MANUAL_MODE;
+import static org.openhab.binding.linktap.internal.LinkTapBindingConstants.DEVICE_CHANNEL_LOW_FLOW;
+import static org.openhab.binding.linktap.internal.LinkTapBindingConstants.DEVICE_CHANNEL_OH_DURATION_LIMIT;
+import static org.openhab.binding.linktap.internal.LinkTapBindingConstants.DEVICE_CHANNEL_OH_VOLUME_LIMIT;
+import static org.openhab.binding.linktap.internal.LinkTapBindingConstants.DEVICE_CHANNEL_REMAIN_DURATION;
+import static org.openhab.binding.linktap.internal.LinkTapBindingConstants.DEVICE_CHANNEL_RF_LINKED;
+import static org.openhab.binding.linktap.internal.LinkTapBindingConstants.DEVICE_CHANNEL_SHUTDOWN_FAILURE;
+import static org.openhab.binding.linktap.internal.LinkTapBindingConstants.DEVICE_CHANNEL_SIGNAL;
+import static org.openhab.binding.linktap.internal.LinkTapBindingConstants.DEVICE_CHANNEL_TOTAL_DURATION;
+import static org.openhab.binding.linktap.internal.LinkTapBindingConstants.DEVICE_CHANNEL_WATERING_MODE;
+import static org.openhab.binding.linktap.internal.LinkTapBindingConstants.DEVICE_CHANNEL_WATER_CUT;
+import static org.openhab.binding.linktap.internal.LinkTapBindingConstants.DEVICE_CHANNEL_WSKIP_DATE_TIME;
+import static org.openhab.binding.linktap.internal.LinkTapBindingConstants.DEVICE_CHANNEL_WSKIP_NEXT_RAIN;
+import static org.openhab.binding.linktap.internal.LinkTapBindingConstants.DEVICE_CHANNEL_WSKIP_PREV_RAIN;
+import static org.openhab.binding.linktap.internal.LinkTapBindingConstants.GSON;
+import static org.openhab.binding.linktap.internal.LinkTapBindingConstants.WateringMode;
+import static org.openhab.binding.linktap.protocol.frames.DismissAlertReq.ALERT_DEVICE_FALL;
+import static org.openhab.binding.linktap.protocol.frames.DismissAlertReq.ALERT_UNEXPECTED_HIGH_FLOW;
+import static org.openhab.binding.linktap.protocol.frames.DismissAlertReq.ALERT_UNEXPECTED_LOW_FLOW;
+import static org.openhab.binding.linktap.protocol.frames.DismissAlertReq.ALERT_VALVE_SHUTDOWN_FAIL;
+import static org.openhab.binding.linktap.protocol.frames.DismissAlertReq.ALERT_WATER_CUTOFF;
+import static org.openhab.binding.linktap.protocol.frames.SetDeviceConfigReq.CONFIG_DURATION_LIMIT;
+import static org.openhab.binding.linktap.protocol.frames.SetDeviceConfigReq.CONFIG_VOLUME_LIMIT;
+import static org.openhab.binding.linktap.protocol.frames.TLGatewayFrame.CMD_DATETIME_SYNC;
+import static org.openhab.binding.linktap.protocol.frames.TLGatewayFrame.CMD_IMMEDIATE_WATER_STOP;
+import static org.openhab.binding.linktap.protocol.frames.TLGatewayFrame.CMD_NOTIFICATION_WATERING_SKIPPED;
+import static org.openhab.binding.linktap.protocol.frames.TLGatewayFrame.CMD_RAINFALL_DATA;
+import static org.openhab.binding.linktap.protocol.frames.TLGatewayFrame.CMD_UPDATE_WATER_TIMER_STATUS;
+
+import java.util.List;
+
+import org.eclipse.jdt.annotation.NonNullByDefault;
+import org.eclipse.jdt.annotation.Nullable;
+import org.openhab.binding.linktap.protocol.frames.AlertStateReq;
+import org.openhab.binding.linktap.protocol.frames.DeviceCmdReq;
+import org.openhab.binding.linktap.protocol.frames.DismissAlertReq;
+import org.openhab.binding.linktap.protocol.frames.LockReq;
+import org.openhab.binding.linktap.protocol.frames.SetDeviceConfigReq;
+import org.openhab.binding.linktap.protocol.frames.StartWateringReq;
+import org.openhab.binding.linktap.protocol.frames.WaterMeterStatus;
+import org.openhab.binding.linktap.protocol.frames.WateringSkippedNotification;
+import org.openhab.binding.linktap.protocol.http.InvalidParameterException;
+import org.openhab.core.library.types.DateTimeType;
+import org.openhab.core.library.types.OnOffType;
+import org.openhab.core.library.types.QuantityType;
+import org.openhab.core.library.types.StringType;
+import org.openhab.core.library.unit.Units;
+import org.openhab.core.storage.Storage;
+import org.openhab.core.thing.ChannelUID;
+import org.openhab.core.thing.Thing;
+import org.openhab.core.types.Command;
+import org.openhab.core.types.RefreshType;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
+/**
+ * The {@link LinkTapHandler} is responsible for handling commands, which are
+ * sent to one of the channels.
+ *
+ * @author David Goodyear - Initial contribution
+ */
+@NonNullByDefault
+public class LinkTapHandler extends PollingDeviceHandler {
+
+    private final Logger logger = LoggerFactory.getLogger(LinkTapHandler.class);
+
+    private static final String DEFAULT_INST_WATERING_VOL_LIMIT = "0";
+    private static final String DEFAULT_INST_WATERING_TIME_LIMIT = "15";
+
+    private final Storage<String> strStore;
+
+    private static final List<String> READBACK_DISABLED_CHANNELS = List.of(DEVICE_CHANNEL_OH_VOLUME_LIMIT,
+            DEVICE_CHANNEL_OH_DURATION_LIMIT);
+
+    public LinkTapHandler(Thing thing, Storage<String> strStore) {
+        super(thing);
+        this.strStore = strStore;
+    }
+
+    /**
+     * Abstract method implementations from PollingDeviceHandler
+     * required for the lifecycle of LinkTap devices.
+     */
+
+    @Override
+    protected void runStartInit() {
+        try {
+            final LinkTapDeviceConfiguration config = getConfigAs(LinkTapDeviceConfiguration.class);
+            if (config.enableAlerts) {
+                sendRequest(new AlertStateReq(0, true));
+            }
+        } catch (final InvalidParameterException ipe) {
+            logger.warn("Failed to enable all alerts");
+        }
+    }
+
+    @Override
+    protected void registerDevice() {
+        LinkTapBridgeHandler.DEV_ID_LOOKUP.registerItem(registeredDeviceId, this, () -> {
+        });
+    }
+
+    @Override
+    protected void deregisterDevice() {
+        LinkTapBridgeHandler.DEV_ID_LOOKUP.deregisterItem(registeredDeviceId, this, () -> {
+        });
+    }
+
+    @Override
+    protected String getPollResponseData() {
+        try {
+            return sendRequest(new DeviceCmdReq(CMD_UPDATE_WATER_TIMER_STATUS));
+        } catch (final InvalidParameterException ipe) {
+            logger.warn("Poll failure - invalid parameter");
+            return "";
+        }
+    }
+
+    @Override
+    protected void processPollResponseData(String data) {
+        processCommand3(data);
+    }
+
+    /**
+     * OpenHab handlers
+     */
+
+    @Override
+    public void handleCommand(final ChannelUID channelUID, final Command command) {
+        scheduler.submit(() -> {
+            try {
+                if (command instanceof RefreshType rt) {
+                    switch (channelUID.getId()) {
+                        case DEVICE_CHANNEL_OH_DURATION_LIMIT: {
+                            final String savedVal = strStore.get(DEVICE_CHANNEL_OH_DURATION_LIMIT);
+                            if (savedVal != null) {
+                                updateState(DEVICE_CHANNEL_OH_DURATION_LIMIT,
+                                        new QuantityType<>(Integer.valueOf(savedVal), Units.SECOND));
+                            } else {
+                                updateState(DEVICE_CHANNEL_OH_DURATION_LIMIT, new QuantityType<>(15, Units.SECOND));
+                            }
+                        }
+                            break;
+                        case DEVICE_CHANNEL_OH_VOLUME_LIMIT: {
+                            final String savedVal = strStore.get(DEVICE_CHANNEL_OH_VOLUME_LIMIT);
+                            if (savedVal != null) {
+                                updateState(DEVICE_CHANNEL_OH_VOLUME_LIMIT,
+                                        new QuantityType<>(Integer.valueOf(savedVal), Units.LITRE));
+                            } else {
+                                updateState(DEVICE_CHANNEL_OH_VOLUME_LIMIT, new QuantityType<>(10, Units.LITRE));
+                            }
+                        }
+                            break;
+                        default:
+                            pollForUpdate(false);
+                    }
+                } else if (command instanceof QuantityType quantityCommand) {
+                    int targetValue = quantityCommand.intValue();
+                    switch (channelUID.getId()) {
+                        case DEVICE_CHANNEL_OH_DURATION_LIMIT:
+                            strStore.put(DEVICE_CHANNEL_OH_DURATION_LIMIT, String.valueOf(targetValue));
+                            break;
+                        case DEVICE_CHANNEL_OH_VOLUME_LIMIT:
+                            strStore.put(DEVICE_CHANNEL_OH_VOLUME_LIMIT, String.valueOf(targetValue));
+                            break;
+                        case DEVICE_CHANNEL_FAILSAFE_VOLUME: {
+                            sendRequest(new SetDeviceConfigReq(CONFIG_VOLUME_LIMIT, targetValue));
+                        }
+                            break;
+                        case DEVICE_CHANNEL_TOTAL_DURATION: {
+                            sendRequest(new SetDeviceConfigReq(CONFIG_DURATION_LIMIT, targetValue));
+                        }
+                            break;
+                    }
+                } else if (command instanceof StringType stringCmd) {
+                    switch (channelUID.getId()) {
+                        case DEVICE_CHANNEL_CHILD_LOCK: {
+                            sendRequest(new LockReq(Integer.valueOf(command.toString())));
+                        }
+                            break;
+                    }
+                } else if (command instanceof OnOffType) {
+                    // Alert dismiss events below
+                    switch (channelUID.getId()) {
+                        case DEVICE_CHANNEL_IS_MANUAL_MODE:
+                            // We can pull from channels I suspect as they feed stateful representations of data
+                            // therefore the data we need below - we need to cache from writes and reads from the
+                            // relevant
+                            // polls / writes, for the items / data points.
+                            if (command.equals(OnOffType.OFF)) {
+                                sendRequest(new DeviceCmdReq(CMD_IMMEDIATE_WATER_STOP));
+                            }
+                        case DEVICE_CHANNEL_ACTIVE_WATERING:
+                            if (command.equals(OnOffType.ON)) {
+                                String volLimit = strStore.get(DEVICE_CHANNEL_OH_VOLUME_LIMIT);
+                                if (volLimit == null) {
+                                    volLimit = DEFAULT_INST_WATERING_VOL_LIMIT;
+                                }
+                                String durLimit = strStore.get(DEVICE_CHANNEL_OH_DURATION_LIMIT);
+                                if (durLimit == null) {
+                                    durLimit = DEFAULT_INST_WATERING_TIME_LIMIT;
+                                }
+                                sendRequest(
+                                        new StartWateringReq(Integer.parseInt(durLimit), Integer.parseInt(volLimit)));
+                            } else if (command.equals(OnOffType.OFF)) {
+                                sendRequest(new DeviceCmdReq(CMD_IMMEDIATE_WATER_STOP));
+                            }
+                        case DEVICE_CHANNEL_FALL_STATUS: // 1
+                            if (command.equals(OnOffType.OFF)) {
+                                sendRequest(new DismissAlertReq(ALERT_DEVICE_FALL));
+                            }
+                            break;
+                        case DEVICE_CHANNEL_SHUTDOWN_FAILURE: // 2
+                            if (command.equals(OnOffType.OFF)) {
+                                sendRequest(new DismissAlertReq(ALERT_VALVE_SHUTDOWN_FAIL));
+                            }
+                            break;
+                        case DEVICE_CHANNEL_WATER_CUT: // 3
+                            if (command.equals(OnOffType.OFF)) {
+                                sendRequest(new DismissAlertReq(ALERT_WATER_CUTOFF));
+                            }
+                            break;
+                        case DEVICE_CHANNEL_HIGH_FLOW: // 4
+                            if (command.equals(OnOffType.OFF)) {
+                                sendRequest(new DismissAlertReq(ALERT_UNEXPECTED_HIGH_FLOW));
+                            }
+                            break;
+                        case DEVICE_CHANNEL_LOW_FLOW: // 5
+                            if (command.equals(OnOffType.OFF)) {
+                                sendRequest(new DismissAlertReq(ALERT_UNEXPECTED_LOW_FLOW));
+                            }
+                            break;
+                    }
+                }
+                if (!READBACK_DISABLED_CHANNELS.contains(channelUID.getId())) {
+                    requestReadbackPoll();
+                }
+            } catch (final InvalidParameterException ipe) {
+                logger.warn("Parameter not accepted by device {} for command {}", getThing().getLabel(),
+                        channelUID.getId());
+            }
+        });
+    }
+
+    /**
+     * LinkTap communication protocol handlers
+     */
+
+    public void processDeviceCommand(final int commandId, final String frame) {
+        receivedDataPush();
+        logger.debug("{} processing device request with command {}", this.getThing().getLabel(), commandId);
+
+        switch (commandId) {
+            case CMD_UPDATE_WATER_TIMER_STATUS:
+                // Store the latest value in the cache - to prevent unnecessary polls
+                lastPollResultCache.putValue(frame);
+                processCommand3(frame);
+                break;
+            case CMD_NOTIFICATION_WATERING_SKIPPED:
+                processCommand9(frame);
+                break;
+            case CMD_RAINFALL_DATA:
+            case CMD_DATETIME_SYNC:
+                logger.trace("No implementation for command {} for processing the Device request", commandId);
+        }
+    }
+
+    private void processCommand3(final String request) {
+        // There are three different formats that can arrive in this method:
+        // -> Unsolicited with is a WaterMeterStatus.DeviceStatus payload
+        // -> Solicited with a WaterMeterStatus payload (*)
+        // -> Solicited with a WaterMeterStatus payload within an array
+        // (*) A GSON plugin normalises the non array wrapped version to the array based version
+        // This is handled below before the normalised processing takes place.
+        WaterMeterStatus.DeviceStatus devStatus;
+        {
+            WaterMeterStatus mStatus = GSON.fromJson(request, WaterMeterStatus.class);
+            if (mStatus == null) {
+                return;
+            }
+
+            if (!mStatus.deviceStatuses.isEmpty()) {
+                devStatus = mStatus.deviceStatuses.get(0);
+            } else {
+                devStatus = GSON.fromJson(request, WaterMeterStatus.DeviceStatus.class);
+            }
+            if (devStatus == null) {
+                return;
+            }
+        }
+
+        // Normalized processing below which uses devStatus
+
+        final LinkTapBridgeHandler bridgeHandler = (LinkTapBridgeHandler) getBridgeHandler();
+        String volumeUnit = "L";
+        if (bridgeHandler != null) {
+            String volumeUnitProp = bridgeHandler.getThing().getProperties().get(BRIDGE_PROP_VOL_UNIT);
+            if (volumeUnitProp != null) {
+                volumeUnit = volumeUnitProp;
+            }
+        }
+        final Integer planModeRaw = devStatus.planMode;
+        if (planModeRaw != null) {
+            updateState(DEVICE_CHANNEL_WATERING_MODE, new StringType(WateringMode.values()[planModeRaw].getDesc()));
+        }
+
+        final Integer childLockRaw = devStatus.childLock;
+        if (childLockRaw != null) {
+            updateState(DEVICE_CHANNEL_CHILD_LOCK, new StringType(ChildLockMode.values()[childLockRaw].getDesc()));
+        }
+
+        updateOnOffValue(DEVICE_CHANNEL_IS_MANUAL_MODE, devStatus.isManualMode);
+        updateOnOffValue(DEVICE_CHANNEL_ACTIVE_WATERING, devStatus.isWatering);
+        updateOnOffValue(DEVICE_CHANNEL_RF_LINKED, devStatus.isRfLinked);
+        updateOnOffValue(DEVICE_CHANNEL_FLM_LINKED, devStatus.isFlmPlugin);
+        updateOnOffValue(DEVICE_CHANNEL_FALL_STATUS, devStatus.isFall);
+        updateOnOffValue(DEVICE_CHANNEL_SHUTDOWN_FAILURE, devStatus.isBroken);
+        updateOnOffValue(DEVICE_CHANNEL_HIGH_FLOW, devStatus.isLeak);
+        updateOnOffValue(DEVICE_CHANNEL_LOW_FLOW, devStatus.isClog);
+        updateOnOffValue(DEVICE_CHANNEL_FINAL_SEGMENT, devStatus.isFinal);
+        updateOnOffValue(DEVICE_CHANNEL_WATER_CUT, devStatus.isCutoff);
+
+        final Integer signal = devStatus.signal;
+        if (signal != null) {
+            updateState(DEVICE_CHANNEL_SIGNAL, new QuantityType<>(signal, Units.PERCENT));
+        }
+
+        final Integer battery = devStatus.battery;
+        if (battery != null) {
+            updateState(DEVICE_CHANNEL_BATTERY, new QuantityType<>(battery, Units.PERCENT));
+        }
+
+        final Integer totalDuration = devStatus.totalDuration;
+        if (totalDuration != null) {
+            updateState(DEVICE_CHANNEL_TOTAL_DURATION, new QuantityType<>(totalDuration, Units.SECOND));
+        }
+
+        final Integer remainDuration = devStatus.remainDuration;
+        if (remainDuration != null) {
+            updateState(DEVICE_CHANNEL_REMAIN_DURATION, new QuantityType<>(remainDuration, Units.SECOND));
+        }
+
+        final Integer failsafeDuration = devStatus.failsafeDuration;
+        if (failsafeDuration != null) {
+            updateState(DEVICE_CHANNEL_FAILSAFE_DURATION, new QuantityType<>(failsafeDuration, Units.SECOND));
+        }
+
+        final Double speed = devStatus.speed;
+        if (speed != null) {
+            updateState(DEVICE_CHANNEL_FLOW_RATE,
+                    new QuantityType<>("L".equals(volumeUnit) ? speed : (speed * 3.785), Units.LITRE_PER_MINUTE));
+        }
+
+        final Double volume = devStatus.volume;
+        if (volume != null) {
+            updateState(DEVICE_CHANNEL_CURRENT_VOLUME,
+                    new QuantityType<>("L".equals(volumeUnit) ? volume : (volume * 3.785), Units.LITRE));
+        }
+
+        final Double volumeLimit = devStatus.volumeLimit;
+        if (volumeLimit != null) {
+            updateState(DEVICE_CHANNEL_FAILSAFE_VOLUME,
+                    new QuantityType<>("L".equals(volumeUnit) ? volumeLimit : (volumeLimit * 3.785), Units.LITRE));
+        }
+    }
+
+    private void updateOnOffValue(final String channelName, final @Nullable Boolean value) {
+        if (value != null) {
+            updateState(channelName, OnOffType.from(value));
+        }
+    }
+
+    private void processCommand9(final String request) {
+        final WateringSkippedNotification skippedNotice = GSON.fromJson(request, WateringSkippedNotification.class);
+        if (skippedNotice == null) {
+            return;
+        }
+        logger.trace("Received rainfall skipped notice - past hour {}, next hour {}", skippedNotice.getPastRainfall(),
+                skippedNotice.getFutureRainfall());
+        updateState(DEVICE_CHANNEL_WSKIP_PREV_RAIN,
+                new QuantityType<>(skippedNotice.getPastRainfall(), Units.MILLIMETRE_PER_HOUR));
+        updateState(DEVICE_CHANNEL_WSKIP_NEXT_RAIN,
+                new QuantityType<>(skippedNotice.getFutureRainfall(), Units.MILLIMETRE_PER_HOUR));
+        updateState(DEVICE_CHANNEL_WSKIP_DATE_TIME, new DateTimeType());
+    }
+
+    @Override
+    public void handleBridgeDataUpdated() {
+        switch (getThing().getStatus()) {
+            case OFFLINE:
+            case UNKNOWN:
+                logger.trace("Handling new bridge data for {}", getThing().getLabel());
+                final LinkTapBridgeHandler bridge = (LinkTapBridgeHandler) getBridgeHandler();
+                if (bridge != null) {
+                    initAfterBridge(bridge);
+                }
+                break;
+            default:
+                logger.trace("Handling new bridge data for {} not required", getThing().getLabel());
+        }
+    }
+}
diff --git a/bundles/org.openhab.binding.linktap/src/main/java/org/openhab/binding/linktap/internal/LinkTapHandlerFactory.java b/bundles/org.openhab.binding.linktap/src/main/java/org/openhab/binding/linktap/internal/LinkTapHandlerFactory.java
new file mode 100644
index 0000000000000..0b03af29f7a8d
--- /dev/null
+++ b/bundles/org.openhab.binding.linktap/src/main/java/org/openhab/binding/linktap/internal/LinkTapHandlerFactory.java
@@ -0,0 +1,89 @@
+/**
+ * Copyright (c) 2010-2024 Contributors to the openHAB project
+ *
+ * See the NOTICE file(s) distributed with this work for additional
+ * information.
+ *
+ * This program and the accompanying materials are made available under the
+ * terms of the Eclipse Public License 2.0 which is available at
+ * http://www.eclipse.org/legal/epl-2.0
+ *
+ * SPDX-License-Identifier: EPL-2.0
+ */
+package org.openhab.binding.linktap.internal;
+
+import static org.openhab.binding.linktap.internal.LinkTapBindingConstants.*;
+
+import java.util.Set;
+
+import org.eclipse.jdt.annotation.NonNullByDefault;
+import org.eclipse.jdt.annotation.Nullable;
+import org.eclipse.jetty.client.HttpClient;
+import org.openhab.binding.linktap.protocol.servers.BindingServlet;
+import org.openhab.binding.linktap.protocol.servers.IHttpClientProvider;
+import org.openhab.core.io.net.http.HttpClientFactory;
+import org.openhab.core.storage.Storage;
+import org.openhab.core.storage.StorageService;
+import org.openhab.core.thing.Bridge;
+import org.openhab.core.thing.Thing;
+import org.openhab.core.thing.ThingTypeUID;
+import org.openhab.core.thing.binding.BaseThingHandlerFactory;
+import org.openhab.core.thing.binding.ThingHandler;
+import org.openhab.core.thing.binding.ThingHandlerFactory;
+import org.osgi.service.component.annotations.Activate;
+import org.osgi.service.component.annotations.Component;
+import org.osgi.service.component.annotations.Reference;
+import org.osgi.service.http.HttpService;
+
+/**
+ * The {@link LinkTapHandlerFactory} is responsible for creating things and thing
+ * handlers.
+ *
+ * @author David Goodyear - Initial contribution
+ */
+@NonNullByDefault
+@Component(configurationPid = "binding.linktap", service = ThingHandlerFactory.class)
+public class LinkTapHandlerFactory extends BaseThingHandlerFactory implements IHttpClientProvider {
+
+    private static final Set<ThingTypeUID> SUPPORTED_THING_TYPES_UIDS = Set.of(THING_TYPE_DEVICE, THING_TYPE_BRIDGE);
+
+    private final StorageService storageService;
+
+    @Activate
+    public LinkTapHandlerFactory(@Reference HttpService httpService, @Reference StorageService storageService) {
+        this.storageService = storageService;
+        BindingServlet.getInstance().setHttpService(httpService);
+    }
+
+    @Override
+    public boolean supportsThingType(ThingTypeUID thingTypeUID) {
+        return SUPPORTED_THING_TYPES_UIDS.contains(thingTypeUID);
+    }
+
+    @Override
+    protected @Nullable ThingHandler createHandler(Thing thing) {
+        ThingTypeUID thingTypeUID = thing.getThingTypeUID();
+
+        if (THING_TYPE_DEVICE.equals(thingTypeUID)) {
+            final Storage<String> storage = storageService.getStorage(thing.getUID().toString(),
+                    String.class.getClassLoader());
+            return new LinkTapHandler(thing, storage);
+        } else if (THING_TYPE_BRIDGE.equals(thingTypeUID)) {
+            return new LinkTapBridgeHandler((Bridge) thing, this);
+        }
+
+        return null;
+    }
+
+    private @Nullable HttpClient httpClientRef = null;
+
+    @Override
+    public @Nullable HttpClient getHttpClient() {
+        return httpClientRef;
+    }
+
+    @Reference
+    protected void setHttpClientFactory(HttpClientFactory httpClientFactory) {
+        httpClientRef = httpClientFactory.getCommonHttpClient();
+    }
+}
diff --git a/bundles/org.openhab.binding.linktap/src/main/java/org/openhab/binding/linktap/internal/LookupWrapper.java b/bundles/org.openhab.binding.linktap/src/main/java/org/openhab/binding/linktap/internal/LookupWrapper.java
new file mode 100644
index 0000000000000..c82f813a75c41
--- /dev/null
+++ b/bundles/org.openhab.binding.linktap/src/main/java/org/openhab/binding/linktap/internal/LookupWrapper.java
@@ -0,0 +1,90 @@
+/**
+ * Copyright (c) 2010-2024 Contributors to the openHAB project
+ *
+ * See the NOTICE file(s) distributed with this work for additional
+ * information.
+ *
+ * This program and the accompanying materials are made available under the
+ * terms of the Eclipse Public License 2.0 which is available at
+ * http://www.eclipse.org/legal/epl-2.0
+ *
+ * SPDX-License-Identifier: EPL-2.0
+ */
+package org.openhab.binding.linktap.internal;
+
+import java.util.Map;
+import java.util.concurrent.ConcurrentHashMap;
+
+import javax.validation.constraints.NotNull;
+
+import org.eclipse.jdt.annotation.NonNullByDefault;
+import org.eclipse.jdt.annotation.Nullable;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
+/**
+ * The {@link LookupWrapper} is a container providing common functionality for providing
+ * key -> T mappings. The backend store is ConcurrentHashMap.
+ *
+ * @author David Goodyear - Initial contribution
+ */
+@NonNullByDefault
+public class LookupWrapper<@Nullable itemT> {
+    private final Logger logger = LoggerFactory.getLogger(LookupWrapper.class);
+
+    final Map<@NotNull String, @Nullable itemT> storeLookup = new ConcurrentHashMap<>();
+
+    /**
+     * Register using key the given T instance, and after addition call the specified Runnable
+     * 
+     * @param key - The key for the item
+     * @param item - The instance to store a reference to
+     * @param afterAddition - The runnable to run after the addition has been completed
+     * @return - false if another item is already assigned to the key preventing the addition, or true
+     *         when added successfully.
+     */
+    public boolean registerItem(final @NotNull String key, final @NotNull itemT item,
+            @NotNull final Runnable afterAddition) {
+        logger.trace("Adding {} -> {}", key, item);
+        if (storeLookup.containsKey(key)) {
+            final itemT found = storeLookup.get(key);
+            if (found != null && !found.equals(item)) {
+                return false;
+            }
+        }
+        storeLookup.put(key, item);
+        logger.trace("Total mappings after addition now : {}", storeLookup.size());
+        afterAddition.run();
+        return true;
+    }
+
+    /**
+     * Remove the given key and item combination
+     * 
+     * @param key - The expected key of the item
+     * @param item - The item referenced by the key
+     * @param whenEmpty - Runnable executed when no more key -> item mappings exist
+     */
+    public void deregisterItem(final @NotNull String key, final @NotNull itemT item,
+            @NotNull final Runnable whenEmpty) {
+        logger.trace("Removing {} -> {}", key, item);
+        storeLookup.remove(key, item);
+        logger.trace("Total mappings after remove now : {}", storeLookup.size());
+        if (storeLookup.isEmpty()) {
+            whenEmpty.run();
+        }
+    }
+
+    /**
+     * Returns the item associated to the given key
+     * 
+     * @param key - the key to find the item for
+     * @return - null if no item is found otherwise the found item
+     */
+    public @Nullable itemT getItem(final @NotNull String key) {
+        logger.trace("Locating {}", key);
+        itemT result = storeLookup.get(key);
+        logger.trace("Located result {} -> {}", key, result);
+        return result;
+    }
+}
diff --git a/bundles/org.openhab.binding.linktap/src/main/java/org/openhab/binding/linktap/internal/PollingDeviceHandler.java b/bundles/org.openhab.binding.linktap/src/main/java/org/openhab/binding/linktap/internal/PollingDeviceHandler.java
new file mode 100644
index 0000000000000..b98203a984a93
--- /dev/null
+++ b/bundles/org.openhab.binding.linktap/src/main/java/org/openhab/binding/linktap/internal/PollingDeviceHandler.java
@@ -0,0 +1,334 @@
+/**
+ * Copyright (c) 2010-2024 Contributors to the openHAB project
+ *
+ * See the NOTICE file(s) distributed with this work for additional
+ * information.
+ *
+ * This program and the accompanying materials are made available under the
+ * terms of the Eclipse Public License 2.0 which is available at
+ * http://www.eclipse.org/legal/epl-2.0
+ *
+ * SPDX-License-Identifier: EPL-2.0
+ */
+package org.openhab.binding.linktap.internal;
+
+import static org.openhab.binding.linktap.internal.LinkTapBindingConstants.DEVICE_CHANNEL_OH_DURATION_LIMIT;
+import static org.openhab.binding.linktap.internal.LinkTapBindingConstants.DEVICE_CHANNEL_OH_VOLUME_LIMIT;
+import static org.openhab.binding.linktap.protocol.frames.TLGatewayFrame.EMPTY_STRING;
+
+import java.time.Duration;
+import java.util.concurrent.ScheduledFuture;
+import java.util.concurrent.TimeUnit;
+
+import javax.validation.constraints.NotNull;
+
+import org.eclipse.jdt.annotation.NonNullByDefault;
+import org.eclipse.jdt.annotation.Nullable;
+import org.openhab.binding.linktap.protocol.frames.DeviceCmdReq;
+import org.openhab.binding.linktap.protocol.frames.TLGatewayFrame;
+import org.openhab.binding.linktap.protocol.http.DeviceIdException;
+import org.openhab.binding.linktap.protocol.http.InvalidParameterException;
+import org.openhab.core.cache.ExpiringCache;
+import org.openhab.core.thing.Bridge;
+import org.openhab.core.thing.Channel;
+import org.openhab.core.thing.ChannelUID;
+import org.openhab.core.thing.Thing;
+import org.openhab.core.thing.ThingStatus;
+import org.openhab.core.thing.ThingStatusDetail;
+import org.openhab.core.thing.binding.BaseThingHandler;
+import org.openhab.core.thing.binding.BridgeHandler;
+import org.openhab.core.types.RefreshType;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
+/**
+ * The {@link PollingDeviceHandler} is responsible for handling commands, which are
+ * sent to one of the channels.
+ *
+ * @author David Goodyear - Initial contribution
+ */
+@NonNullByDefault
+public abstract class PollingDeviceHandler extends BaseThingHandler implements IBridgeData {
+
+    private final Logger logger = LoggerFactory.getLogger(PollingDeviceHandler.class);
+
+    protected Logger getLogger() {
+        return logger;
+    }
+
+    protected static final String MARKER_INVALID_DEVICE_KEY = "---INVALID---";
+    protected String registeredDeviceId = EMPTY_STRING;
+
+    private final Object pollLock = new Object();
+
+    protected ExpiringCache<String> lastPollResultCache = new ExpiringCache<>(Duration.ofSeconds(5),
+            PollingDeviceHandler::expireCacheContents);
+
+    private final Object schedulerLock = new Object();
+    private @Nullable ScheduledFuture<?> backgroundGwPollingScheduler;
+
+    private final Object readBackPollLock = new Object();
+    private @Nullable ScheduledFuture<?> readBackPollSf = null;
+
+    protected void requestReadbackPoll() {
+        synchronized (readBackPollLock) {
+            cancelReadbackPoll();
+            scheduler.schedule(() -> {
+                pollForUpdate(true);
+            }, 750, TimeUnit.MILLISECONDS);
+        }
+    }
+
+    protected void cancelReadbackPoll() {
+        synchronized (readBackPollLock) {
+            ScheduledFuture<?> readBackPollSfRef = readBackPollSf;
+            if (readBackPollSfRef != null) {
+                readBackPollSfRef.cancel(false);
+                readBackPollSf = null;
+            }
+        }
+    }
+
+    private volatile long lastStatusCommandRecvTs = 0L;
+
+    public PollingDeviceHandler(final Thing thing) {
+        super(thing);
+    }
+
+    private void startStatusPolling() {
+        synchronized (schedulerLock) {
+            cancelStatusPolling();
+            backgroundGwPollingScheduler = scheduler.scheduleWithFixedDelay(() -> {
+                if (lastStatusCommandRecvTs + 135000 > System.currentTimeMillis()) {
+                    return;
+                }
+                pollForUpdate(false);
+            }, 1, 10, TimeUnit.SECONDS);
+        }
+    }
+
+    private void cancelStatusPolling() {
+        synchronized (schedulerLock) {
+            final ScheduledFuture<?> ref = backgroundGwPollingScheduler;
+            if (ref != null) {
+                ref.cancel(true);
+                backgroundGwPollingScheduler = null;
+            }
+        }
+    }
+
+    private static @Nullable String expireCacheContents() {
+        return null;
+    }
+
+    @Override
+    public void initialize() {
+        updateStatus(ThingStatus.UNKNOWN);
+
+        final LinkTapBridgeHandler bridge = (LinkTapBridgeHandler) getBridgeHandler();
+        if (bridge == null) {
+            updateStatus(ThingStatus.OFFLINE, ThingStatusDetail.CONFIGURATION_ERROR, "Bridge is not selected / set");
+            return;
+        }
+
+        scheduler.execute(() -> {
+            if (bridge.getThing().getStatus() == ThingStatus.ONLINE) {
+                initAfterBridge(bridge);
+            }
+        });
+    }
+
+    protected void initAfterBridge(final LinkTapBridgeHandler bridge) {
+        String deviceId = getValidatedIdString();
+        if (deviceId.equals(MARKER_INVALID_DEVICE_KEY)) {
+            updateStatus(ThingStatus.OFFLINE, ThingStatusDetail.CONFIGURATION_ERROR,
+                    "Device not found in bridges known devices");
+            if (!registeredDeviceId.isBlank()) {
+                deregisterDevice();
+            }
+            registeredDeviceId = EMPTY_STRING;
+            return;
+        } else {
+            registeredDeviceId = deviceId;
+        }
+
+        boolean knownToBridge = bridge.getDiscoveredDevices().anyMatch(x -> deviceId.equals(x.deviceId));
+        if (knownToBridge) {
+            updateStatus(ThingStatus.ONLINE);
+            registerDevice();
+            scheduleInitialPoll();
+            scheduler.execute(this::runStartInit);
+            startStatusPolling();
+        } else {
+            updateStatus(ThingStatus.OFFLINE, ThingStatusDetail.CONFIGURATION_ERROR,
+                    "Bridge does not recognise device id");
+        }
+    }
+
+    protected abstract void runStartInit();
+
+    protected abstract void registerDevice();
+
+    @Override
+    public void dispose() {
+        cancelInitialPoll(true);
+        deregisterDevice();
+        cancelStatusPolling();
+    }
+
+    protected abstract void deregisterDevice();
+
+    @Nullable
+    BridgeHandler getBridgeHandler() {
+        Bridge bridgeRef = getBridge();
+        if (bridgeRef == null) {
+            return null;
+        } else {
+            return bridgeRef.getHandler();
+        }
+    }
+
+    public String sendRequest(TLGatewayFrame frame) throws InvalidParameterException {
+        if (frame instanceof DeviceCmdReq) {
+            final String deviceAddr = getValidatedIdString();
+            if (deviceAddr.equals(MARKER_INVALID_DEVICE_KEY)) {
+                logger.warn("Device is unknown - will not send");
+                updateStatus(ThingStatus.OFFLINE, ThingStatusDetail.COMMUNICATION_ERROR,
+                        "Check device setup - device is unknown");
+                return EMPTY_STRING;
+            }
+            ((DeviceCmdReq) frame).deviceId = deviceAddr;
+        }
+
+        // Validate the payload is within the expected limits for the device its being sent to
+        final String validationResult = frame.isValid();
+        if (!validationResult.isEmpty()) {
+            logger.warn("Not sending request due to validation error -> {}", validationResult);
+            return EMPTY_STRING;
+        }
+        final Bridge parentBridge = getBridge();
+        if (parentBridge == null) {
+            logger.warn("Cannot send device does not have a valid bridge");
+            updateStatus(ThingStatus.OFFLINE, ThingStatusDetail.COMMUNICATION_ERROR, "Bridge not selected");
+            return EMPTY_STRING;
+        }
+        final LinkTapBridgeHandler parentBridgeHandler = (LinkTapBridgeHandler) parentBridge.getHandler();
+        if (parentBridgeHandler == null) {
+            logger.warn("Cannot send device does not have a valid bridge handler");
+            updateStatus(ThingStatus.OFFLINE, ThingStatusDetail.COMMUNICATION_ERROR, "Bridge not selected");
+            return EMPTY_STRING;
+        }
+        try {
+            return parentBridgeHandler.sendRequest(frame);
+        } catch (final DeviceIdException die) {
+            updateStatus(ThingStatus.OFFLINE, ThingStatusDetail.COMMUNICATION_ERROR, die.getMessage());
+        }
+        return EMPTY_STRING;
+    }
+
+    @NotNull
+    public String getValidatedIdString() {
+        final LinkTapDeviceConfiguration config = getConfigAs(LinkTapDeviceConfiguration.class);
+
+        BridgeHandler bridgeHandler = getBridgeHandler();
+        if (bridgeHandler instanceof LinkTapBridgeHandler vesyncBridgeHandler) {
+            final String devId = config.id;
+
+            // Try to use the device address id directly
+            if (devId != null) {
+                logger.trace("Searching for device address id : {}", devId);
+                @Nullable
+                final LinkTapDeviceMetadata metadata = vesyncBridgeHandler.getDeviceLookup().get(devId);
+
+                if (metadata != null) {
+                    return metadata.deviceId;
+                }
+            }
+
+            final String deviceName = config.name;
+
+            // Check if the device name can be matched to a single device
+            if (deviceName != null) {
+                final String[] matchedAddressIds = vesyncBridgeHandler.getDiscoveredDevices()
+                        .filter(x -> deviceName.equals(x.deviceName)).map(x -> x.deviceId).toArray(String[]::new);
+
+                for (String val : matchedAddressIds) {
+                    logger.trace("Found Address ID match on name with : {}", val);
+                }
+
+                if (matchedAddressIds.length != 1) {
+                    return MARKER_INVALID_DEVICE_KEY;
+                }
+
+                return matchedAddressIds[0];
+            }
+        }
+
+        return MARKER_INVALID_DEVICE_KEY;
+    }
+
+    @Override
+    public void channelLinked(ChannelUID channelUID) {
+        super.channelLinked(channelUID);
+
+        if (getThing().getStatusInfo().getStatus() == ThingStatus.ONLINE) {
+            scheduler.execute(() -> {
+                pollForUpdate(false);
+            });
+        }
+    }
+
+    private void scheduleInitialPoll() {
+        cancelInitialPoll(false);
+        initialPollingTask = scheduler.schedule(() -> {
+            // 15 second's is to ensure even slow systems have time to pull the gateway data
+            // ready.
+            sendChannelRefresh(DEVICE_CHANNEL_OH_DURATION_LIMIT);
+            sendChannelRefresh(DEVICE_CHANNEL_OH_VOLUME_LIMIT);
+
+            pollForUpdate(false);
+        }, 15, TimeUnit.SECONDS);
+    }
+
+    private void sendChannelRefresh(final String channelName) {
+        final Channel ch = getThing().getChannel(DEVICE_CHANNEL_OH_VOLUME_LIMIT);
+        if (ch != null) {
+            handleCommand(ch.getUID(), RefreshType.REFRESH);
+        }
+    }
+
+    private void cancelInitialPoll(final boolean interruptAllowed) {
+        final ScheduledFuture<?> pollJob = initialPollingTask;
+        if (pollJob != null && !pollJob.isCancelled()) {
+            pollJob.cancel(interruptAllowed);
+            initialPollingTask = null;
+        }
+    }
+
+    @Nullable
+    // This is used to coalesce poll's for CMD 3 - WATER METER STATUS
+    // otherwise bulk new channel links force many poll's, and an unsolicited update
+    // may recently have already provided the data needed.
+    ScheduledFuture<?> initialPollingTask = null;
+
+    public void pollForUpdate(boolean skipCache) {
+        String response = EMPTY_STRING;
+        synchronized (pollLock) {
+            response = lastPollResultCache.getValue();
+            if (response == null || skipCache) {
+                response = getPollResponseData();
+                // Todo: Check response status
+                lastPollResultCache.putValue(response);
+            }
+        }
+        processPollResponseData(response);
+    }
+
+    protected abstract String getPollResponseData();
+
+    protected abstract void processPollResponseData(final String data);
+
+    protected void receivedDataPush() {
+        lastStatusCommandRecvTs = System.currentTimeMillis();
+    }
+}
diff --git a/bundles/org.openhab.binding.linktap/src/main/java/org/openhab/binding/linktap/internal/TransactionProcessor.java b/bundles/org.openhab.binding.linktap/src/main/java/org/openhab/binding/linktap/internal/TransactionProcessor.java
new file mode 100644
index 0000000000000..9e72dadf0e4b8
--- /dev/null
+++ b/bundles/org.openhab.binding.linktap/src/main/java/org/openhab/binding/linktap/internal/TransactionProcessor.java
@@ -0,0 +1,315 @@
+/**
+ * Copyright (c) 2010-2024 Contributors to the openHAB project
+ *
+ * See the NOTICE file(s) distributed with this work for additional
+ * information.
+ *
+ * This program and the accompanying materials are made available under the
+ * terms of the Eclipse Public License 2.0 which is available at
+ * http://www.eclipse.org/legal/epl-2.0
+ *
+ * SPDX-License-Identifier: EPL-2.0
+ */
+package org.openhab.binding.linktap.internal;
+
+import static org.openhab.binding.linktap.internal.LinkTapBindingConstants.GSON;
+import static org.openhab.binding.linktap.protocol.frames.GatewayDeviceResponse.*;
+
+import java.time.LocalDateTime;
+import java.time.format.DateTimeFormatter;
+import java.util.UUID;
+
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+import org.eclipse.jdt.annotation.NonNullByDefault;
+import org.eclipse.jdt.annotation.Nullable;
+import org.openhab.binding.linktap.protocol.frames.DeviceCmdReq;
+import org.openhab.binding.linktap.protocol.frames.GatewayDeviceResponse;
+import org.openhab.binding.linktap.protocol.frames.HandshakeResp;
+import org.openhab.binding.linktap.protocol.frames.TLGatewayFrame;
+import org.openhab.binding.linktap.protocol.frames.WaterMeterStatus;
+import org.openhab.binding.linktap.protocol.http.CommandNotSupportedException;
+import org.openhab.binding.linktap.protocol.http.DeviceIdException;
+import org.openhab.binding.linktap.protocol.http.GatewayIdException;
+import org.openhab.binding.linktap.protocol.http.InvalidParameterException;
+import org.openhab.binding.linktap.protocol.http.NotTapLinkGatewayException;
+import org.openhab.binding.linktap.protocol.http.TransientCommunicationIssueException;
+import org.openhab.binding.linktap.protocol.http.WebServerApi;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
+/**
+ * The {@link TransactionProcessor} is a transaction processor, that each Gateway has an instance of.
+ * It is responsible for handling received frames from the Gateway.
+ *
+ * @author David Goodyear - Initial contribution
+ */
+@NonNullByDefault
+public final class TransactionProcessor {
+
+    // The Gateway pushes messages to us, the majority expect a response and are documented as
+    // GW->Broker->App. These are sent via a HTTP request to the WebSerlet listening for the payloads.
+    // Then we can also send data to the Gateway, these all also typically get a response, and are documented as
+    // App->Broker->GW. These are sent via a POST request, to the relevant Gateway.
+    // As the Gateway is an embedded device,
+
+    private static final TransactionProcessor INSTANCE = new TransactionProcessor();
+    // private static final Object InstanceLock = new Object();
+
+    private static final WebServerApi API = WebServerApi.getInstance();
+
+    private TransactionProcessor() {
+    }
+
+    public static TransactionProcessor getInstance() {
+        return INSTANCE;
+    }
+
+    private final Logger logger = LoggerFactory.getLogger(TransactionProcessor.class);
+
+    // private final BridgeManager bridgeIpAddrManager = BridgeManager.getInstance();
+    // private final BridgeManager bridgeIdManager = BridgeManager.getInstance();
+
+    private final LookupWrapper<@Nullable LinkTapBridgeHandler> ipAddrManager = new LookupWrapper<>();
+    // private final LookupWrapper<LinkTapBridgeHandler> idAddrManager = new LookupWrapper<>();
+
+    public void processServletRequest(@Nullable HttpServletRequest req, @Nullable HttpServletResponse resp) {
+        if (req != null) {
+            // Check if we have a bridge for managing the requested device
+            LinkTapBridgeHandler bridge = ipAddrManager.getItem(req.getRemoteHost());
+            // if (bridge == null) {
+            // throw new RuntimeException("Did not find bridge for remote host: " + req.getRemoteHost());
+            // }
+            if (bridge != null) {
+                logger.warn("Found bridge to handle request with name {}", bridge.getThing().getLabel());
+            }
+        }
+    }
+
+    public String processGwRequest(final String sourceHost, int command, final String payload) {
+        final UUID uid = UUID.randomUUID();
+        logger.debug("{} = GW -> APP Request {} -> Payload {}", uid, sourceHost, payload);
+        String response = "";
+        try {
+            processGw(sourceHost, command, payload);
+        } catch (CommandNotSupportedException cnse) {
+            logger.warn("Command {} not supported by gateway - bug should be reported", command);
+        }
+        logger.debug("{} = GW -> APP Response {} -> Payload {}", uid, payload, response);
+        return response;
+    }
+
+    public String processGw(final String sourceHost, int command, final String payload)
+            throws CommandNotSupportedException {
+        final GatewayDeviceResponse frame = GSON.fromJson(payload, GatewayDeviceResponse.class);
+        if (frame == null) {
+            return "";
+        }
+
+        final String fromGatewayId = frame.gatewayId;
+        final LinkTapBridgeHandler bridge = LinkTapBridgeHandler.GW_ID_LOOKUP.getItem(fromGatewayId);
+        if (bridge != null) {
+            logger.trace("Found bridge with ID: {} -> {}", fromGatewayId, bridge.getThing().getLabel());
+        } else {
+            logger.trace("Bridge not found with ID: {}", fromGatewayId);
+        }
+
+        // Only the water timer status payload arrives without a command, if there is a command id
+        // then we use the one from the frame instead.
+        command = CMD_UPDATE_WATER_TIMER_STATUS;
+        if (frame.command != DEFAULT_INT) {
+            command = frame.command;
+        }
+
+        final ResultStatus resultStatus = frame.getRes();
+        if (resultStatus != ResultStatus.RET_CMD_NOT_SUPPORTED) {
+            if (resultStatus == ResultStatus.RET_CMD_NOT_SUPPORTED) {
+                throw new CommandNotSupportedException(resultStatus.getDesc());
+            }
+        }
+
+        String response = "";
+        switch (command) {
+            case CMD_UPDATE_WATER_TIMER_STATUS:
+                WaterMeterStatus meterStatus = GSON.fromJson(payload, WaterMeterStatus.class);
+
+                if (meterStatus != null) {
+                    final LinkTapHandler device = LinkTapBridgeHandler.DEV_ID_LOOKUP
+                            .getItem(meterStatus.deviceStatuses.get(0).deviceId);
+
+                    if (device != null) {
+                        logger.trace("Found device {}", device);
+                        device.processDeviceCommand(command, payload);
+                    } else {
+                        logger.debug("No device with id {} found to process command {}",
+                                meterStatus.deviceStatuses.get(0).deviceId, command);
+                    }
+                }
+                break;
+            case CMD_HANDSHAKE:
+            case CMD_DATETIME_SYNC:
+                response = generateTimeDateResponse(frame.gatewayId, command);
+                if (bridge != null) {
+                    bridge.processGatewayCommand(CMD_HANDSHAKE, payload);
+                }
+                break;
+            case CMD_NOTIFICATION_WATERING_SKIPPED: {
+                // This does not work - device id is within devStat!
+                final DeviceCmdReq devFrame = GSON.fromJson(payload, DeviceCmdReq.class);
+                if (devFrame != null) {
+                    final LinkTapHandler device = LinkTapBridgeHandler.DEV_ID_LOOKUP.getItem(devFrame.deviceId);
+
+                    if (device != null) {
+                        logger.trace("Found device {}", device);
+                        device.processDeviceCommand(command, payload);
+                    } else {
+                        logger.debug("No device with id {} found to process command {}", devFrame.deviceId, command);
+                    }
+                }
+                break;
+            }
+            case CMD_RAINFALL_DATA: {
+                final DeviceCmdReq devFrame = GSON.fromJson(payload, DeviceCmdReq.class);
+                if (devFrame != null) {
+                    final LinkTapHandler device = LinkTapBridgeHandler.DEV_ID_LOOKUP.getItem(devFrame.deviceId);
+
+                    if (device != null) {
+                        logger.trace("Found device {}", device);
+                        device.processDeviceCommand(command, payload);
+                    } else {
+                        logger.trace("No device modelled to process meter status command");
+                    }
+                }
+                break;
+            }
+            default:
+                logger.warn("Unexpected response frame {} -> {}", command, payload);
+        }
+        return response;
+    }
+
+    public String sendRequest(final LinkTapBridgeHandler handler, final TLGatewayFrame request)
+            throws GatewayIdException, DeviceIdException, CommandNotSupportedException, InvalidParameterException {
+        // Try communication requests 3 times
+        int triesLeft = 3;
+        int retry = 0;
+        while (triesLeft > 0) {
+            try {
+                return sendSingleRequest(handler, request);
+            } catch (TransientCommunicationIssueException tcie) {
+                --triesLeft;
+                try {
+                    Thread.sleep(1000L * retry);
+                } catch (InterruptedException ie) {
+                    return "";
+                }
+                ++retry;
+            }
+        }
+        return "";
+    }
+
+    public String sendSingleRequest(final LinkTapBridgeHandler handler, final TLGatewayFrame request)
+            throws GatewayIdException, DeviceIdException, CommandNotSupportedException, InvalidParameterException,
+            TransientCommunicationIssueException {
+        // We need the hostname from the handler of the bridge
+        UUID uid = UUID.randomUUID();
+        final String targetHost = handler.getHostname();
+        final String payloadJson = GSON.toJson(request);
+        logger.debug("{} = APP -> GW Request {} -> Payload {}", uid, targetHost, payloadJson);
+
+        // Responses can be one of the following types
+        try {
+            String response = API.sendRequest(targetHost, GSON.toJson(request));
+            logger.debug("{} = APP -> GW Response {} -> Payload {}", uid, targetHost, response);
+            GatewayDeviceResponse gatewayFrame = GSON.fromJson(response, GatewayDeviceResponse.class);
+
+            if (gatewayFrame == null) {
+                throw new TransientCommunicationIssueException("Unexpected communication failure");
+            }
+
+            if (!(request.command == CMD_UPDATE_WATER_TIMER_STATUS && gatewayFrame.command == -1)
+                    && request.command != gatewayFrame.command) {
+                logger.warn("Unexpected response from GW (CMD {} != {}", request.command, gatewayFrame.command);
+                throw new TransientCommunicationIssueException("Unexpected communication failure");
+            }
+
+            final ResultStatus rs = gatewayFrame.getRes();
+
+            switch (gatewayFrame.command) {
+                case CMD_ADD_END_DEVICE: // 1
+                case CMD_REMOVE_END_DEVICE: // 2
+                case CMD_UPDATE_WATER_TIMER_STATUS: // 3
+                case CMD_SETUP_WATER_PLAN: // 4
+                case CMD_REMOVE_WATER_PLAN: // 5
+                case CMD_IMMEDIATE_WATER_START: // 6
+                case CMD_IMMEDIATE_WATER_STOP: // 7
+                case CMD_RAINFALL_DATA: // 8
+                case CMD_ALERT_ENABLEMENT: // 10
+                case CMD_ALERT_DISMISS: // 11
+                case CMD_LOCKOUT_STATE: // 12
+                case CMD_DATETIME_READ: // 14
+                case CMD_WIRELESS_CHECK: // 15
+                case CMD_GET_CONFIGURATION: // 16
+                case CMD_SET_CONFIGURATION: // 17
+                case CMD_PAUSE_WATER_PLAN: // 18
+                    switch (rs) {
+                        case RET_SUCCESS:
+                            logger.trace("Request successfully processed");
+                            return response;
+                        case RET_MESSAGE_FORMAT_ERR:
+                        case RET_BAD_PARAMETER:
+                            logger.trace("Request issued incorrectly - format or parameter error");
+                            throw new InvalidParameterException(rs);
+                        case RET_CMD_NOT_SUPPORTED:
+                            logger.trace("Command not supported by device");
+                            throw new CommandNotSupportedException(rs);
+                        case RET_DEVICE_ID_ERROR:
+                        case RET_DEVICE_NOT_FOUND:
+                            logger.trace("Device configuration error - check DEVICE ID in metadata");
+                            throw new DeviceIdException(rs);
+                        case RET_GATEWAY_ID_NOT_MATCHED:
+                            logger.trace("Gateway configuration error - check GATEWAY ID in metadata");
+                            throw new GatewayIdException(rs);
+                        case RET_GATEWAY_BUSY:
+                        case RET_GW_INTERNAL_ERR:
+                            logger.trace("The request can be re-tried");
+                            break;
+                        case RET_CONFLICT_WATER_PLAN:
+                            logger.trace("Gateway rejected command due to water plan conflict");
+                            break;
+                        case INVALID:
+                        default:
+                            logger.warn("Unexpected command result");
+                    }
+                    break;
+                case DEFAULT_INT:
+                    if (request.command == CMD_UPDATE_WATER_TIMER_STATUS) {
+                        return response;
+                    }
+                default:
+                    logger.warn("Unexpected response frame {} -> {}", gatewayFrame.command, GSON.toJson(request));
+                    return "";
+            }
+
+            return response;
+        } catch (NotTapLinkGatewayException e) {
+            logger.warn("NOT TAP LINK GATEWAY EXCEPTION", e);
+        } catch (TransientCommunicationIssueException e) {
+            logger.warn("TRANSIENT COMMUNICATION EXCEPTION", e);
+        }
+        return "";
+    }
+
+    private String generateTimeDateResponse(final String gwId, final int commandId) {
+        final LocalDateTime currentTime = LocalDateTime.now();
+        final HandshakeResp respPayload = new HandshakeResp();
+        respPayload.command = commandId;
+        respPayload.gatewayId = gwId;
+        respPayload.wday = currentTime.getDayOfWeek().getValue();
+        respPayload.date = currentTime.format(DateTimeFormatter.ofPattern("yyyyMMdd"));
+        respPayload.time = currentTime.format(DateTimeFormatter.ofPattern("HHmmss"));
+        return GSON.toJson(respPayload);
+    }
+}
diff --git a/bundles/org.openhab.binding.linktap/src/main/java/org/openhab/binding/linktap/internal/Utils.java b/bundles/org.openhab.binding.linktap/src/main/java/org/openhab/binding/linktap/internal/Utils.java
new file mode 100644
index 0000000000000..fb7caf0f6cb8d
--- /dev/null
+++ b/bundles/org.openhab.binding.linktap/src/main/java/org/openhab/binding/linktap/internal/Utils.java
@@ -0,0 +1,39 @@
+/**
+ * Copyright (c) 2010-2024 Contributors to the openHAB project
+ *
+ * See the NOTICE file(s) distributed with this work for additional
+ * information.
+ *
+ * This program and the accompanying materials are made available under the
+ * terms of the Eclipse Public License 2.0 which is available at
+ * http://www.eclipse.org/legal/epl-2.0
+ *
+ * SPDX-License-Identifier: EPL-2.0
+ */
+package org.openhab.binding.linktap.internal;
+
+import org.eclipse.jdt.annotation.NonNullByDefault;
+
+/**
+ * The {@link Utils} contains static function's for useful functionality.
+ *
+ * @author David Goodyear - Initial contribution
+ */
+@NonNullByDefault
+public final class Utils {
+
+    private Utils() {
+    }
+
+    // Make function to remove all non-printable ascii characters
+    public static String cleanPrintableChars(final String chars) {
+        final StringBuilder stBldr = new StringBuilder(chars.length());
+        for (char ch : chars.toCharArray()) {
+            final byte chBy = (byte) ch;
+            if (chBy >= 32 && chBy <= 126) {
+                stBldr.append(ch);
+            }
+        }
+        return stBldr.toString();
+    }
+}
diff --git a/bundles/org.openhab.binding.linktap/src/main/java/org/openhab/binding/linktap/protocol/frames/AlertStateReq.java b/bundles/org.openhab.binding.linktap/src/main/java/org/openhab/binding/linktap/protocol/frames/AlertStateReq.java
new file mode 100644
index 0000000000000..63e48ff0a0ce6
--- /dev/null
+++ b/bundles/org.openhab.binding.linktap/src/main/java/org/openhab/binding/linktap/protocol/frames/AlertStateReq.java
@@ -0,0 +1,52 @@
+/**
+ * Copyright (c) 2010-2024 Contributors to the openHAB project
+ *
+ * See the NOTICE file(s) distributed with this work for additional
+ * information.
+ *
+ * This program and the accompanying materials are made available under the
+ * terms of the Eclipse Public License 2.0 which is available at
+ * http://www.eclipse.org/legal/epl-2.0
+ *
+ * SPDX-License-Identifier: EPL-2.0
+ */
+package org.openhab.binding.linktap.protocol.frames;
+
+import org.eclipse.jdt.annotation.NonNullByDefault;
+
+import com.google.gson.annotations.Expose;
+import com.google.gson.annotations.SerializedName;
+
+/**
+ * The {@link AlertStateReq} defines the request to enable or disable alerts from a given device.
+ *
+ * @author David Goodyear - Initial contribution
+ */
+@NonNullByDefault
+public class AlertStateReq extends DismissAlertReq {
+
+    public AlertStateReq() {
+    }
+
+    public AlertStateReq(final int alert, final boolean enable) {
+        this.command = CMD_ALERT_ENABLEMENT;
+        this.alert = alert;
+        this.enable = enable;
+    }
+
+    /**
+     * Defines the alert type to be enabled or disabled
+     */
+    @SerializedName("enable")
+    @Expose
+    public boolean enable;
+
+    public String isValid() {
+        final String superRst = super.isValid();
+        if (!superRst.isEmpty()) {
+            return superRst;
+        }
+
+        return EMPTY_STRING;
+    }
+}
diff --git a/bundles/org.openhab.binding.linktap/src/main/java/org/openhab/binding/linktap/protocol/frames/DeviceCmdReq.java b/bundles/org.openhab.binding.linktap/src/main/java/org/openhab/binding/linktap/protocol/frames/DeviceCmdReq.java
new file mode 100644
index 0000000000000..dd9ce728efe97
--- /dev/null
+++ b/bundles/org.openhab.binding.linktap/src/main/java/org/openhab/binding/linktap/protocol/frames/DeviceCmdReq.java
@@ -0,0 +1,56 @@
+/**
+ * Copyright (c) 2010-2024 Contributors to the openHAB project
+ *
+ * See the NOTICE file(s) distributed with this work for additional
+ * information.
+ *
+ * This program and the accompanying materials are made available under the
+ * terms of the Eclipse Public License 2.0 which is available at
+ * http://www.eclipse.org/legal/epl-2.0
+ *
+ * SPDX-License-Identifier: EPL-2.0
+ */
+package org.openhab.binding.linktap.protocol.frames;
+
+import org.eclipse.jdt.annotation.NonNullByDefault;
+
+import com.google.gson.annotations.Expose;
+import com.google.gson.annotations.SerializedName;
+
+/**
+ * The {@link DeviceCmdReq} is a request targetted to a device.
+ *
+ * @provides App: Device ID
+ *
+ * @author David Goodyear - Initial contribution
+ */
+@NonNullByDefault
+public class DeviceCmdReq extends TLGatewayFrame {
+
+    public DeviceCmdReq() {
+    }
+
+    public DeviceCmdReq(final int command) {
+        this.command = command;
+    }
+
+    /**
+     * Defines the targetted device ID
+     */
+    @SerializedName("dev_id")
+    @Expose
+    public String deviceId = EMPTY_STRING;
+
+    public String isValid() {
+        final String superRst = super.isValid();
+        if (!superRst.isEmpty()) {
+            return superRst;
+        }
+
+        if (!DEVICE_ID_PATTERN.matcher(deviceId).matches() && !SUB_DEVICE_ID_PATTERN.matcher(deviceId).matches()) {
+            return "DeviceId invalid";
+        }
+
+        return EMPTY_STRING;
+    }
+}
diff --git a/bundles/org.openhab.binding.linktap/src/main/java/org/openhab/binding/linktap/protocol/frames/DismissAlertReq.java b/bundles/org.openhab.binding.linktap/src/main/java/org/openhab/binding/linktap/protocol/frames/DismissAlertReq.java
new file mode 100644
index 0000000000000..a289d46f43ed2
--- /dev/null
+++ b/bundles/org.openhab.binding.linktap/src/main/java/org/openhab/binding/linktap/protocol/frames/DismissAlertReq.java
@@ -0,0 +1,85 @@
+/**
+ * Copyright (c) 2010-2024 Contributors to the openHAB project
+ *
+ * See the NOTICE file(s) distributed with this work for additional
+ * information.
+ *
+ * This program and the accompanying materials are made available under the
+ * terms of the Eclipse Public License 2.0 which is available at
+ * http://www.eclipse.org/legal/epl-2.0
+ *
+ * SPDX-License-Identifier: EPL-2.0
+ */
+package org.openhab.binding.linktap.protocol.frames;
+
+import org.eclipse.jdt.annotation.NonNullByDefault;
+
+import com.google.gson.annotations.Expose;
+import com.google.gson.annotations.SerializedName;
+
+/**
+ * The {@link DismissAlertReq} defines the request to dismiss alerts from a given device.
+ *
+ * @author David Goodyear - Initial contribution
+ */
+@NonNullByDefault
+public class DismissAlertReq extends DeviceCmdReq {
+
+    public DismissAlertReq() {
+    }
+
+    public DismissAlertReq(final int alert) {
+        this.command = CMD_ALERT_DISMISS;
+        this.alert = alert;
+    }
+
+    /**
+     * Defines the alert type the dismiss is for.
+     */
+    @SerializedName("alert")
+    @Expose
+    public int alert = DEFAULT_INT;
+
+    public String isValid() {
+        final String superRst = super.isValid();
+        if (!superRst.isEmpty()) {
+            return superRst;
+        }
+
+        if (alert < ALERT_TYPES_ALL || alert > ALERT_UNEXPECTED_LOW_FLOW) {
+            return "Alert not in range " + ALERT_TYPES_ALL + " -> " + ALERT_UNEXPECTED_LOW_FLOW;
+        }
+
+        return EMPTY_STRING;
+    }
+
+    /**
+     * Alert - 0. All types of alert
+     */
+    public static final int ALERT_TYPES_ALL = 0;
+
+    /**
+     * Alert - 1. Device fall alert
+     */
+    public static final int ALERT_DEVICE_FALL = 1;
+
+    /**
+     * Alert - 2. Valve shutdown failure alert
+     */
+    public static final int ALERT_VALVE_SHUTDOWN_FAIL = 2;
+
+    /**
+     * Alert - 3. Water cut-off alert
+     */
+    public static final int ALERT_WATER_CUTOFF = 3;
+
+    /**
+     * Alert - 4. Unusually high flow alert
+     */
+    public static final int ALERT_UNEXPECTED_HIGH_FLOW = 4;
+
+    /**
+     * Alert - 5. Unusually low flow alert
+     */
+    public static final int ALERT_UNEXPECTED_LOW_FLOW = 5;
+}
diff --git a/bundles/org.openhab.binding.linktap/src/main/java/org/openhab/binding/linktap/protocol/frames/EndpointDeviceResponse.java b/bundles/org.openhab.binding.linktap/src/main/java/org/openhab/binding/linktap/protocol/frames/EndpointDeviceResponse.java
new file mode 100644
index 0000000000000..f6d4e2b217d5a
--- /dev/null
+++ b/bundles/org.openhab.binding.linktap/src/main/java/org/openhab/binding/linktap/protocol/frames/EndpointDeviceResponse.java
@@ -0,0 +1,51 @@
+/**
+ * Copyright (c) 2010-2024 Contributors to the openHAB project
+ *
+ * See the NOTICE file(s) distributed with this work for additional
+ * information.
+ *
+ * This program and the accompanying materials are made available under the
+ * terms of the Eclipse Public License 2.0 which is available at
+ * http://www.eclipse.org/legal/epl-2.0
+ *
+ * SPDX-License-Identifier: EPL-2.0
+ */
+package org.openhab.binding.linktap.protocol.frames;
+
+import org.eclipse.jdt.annotation.NonNullByDefault;
+
+import com.google.gson.annotations.Expose;
+import com.google.gson.annotations.SerializedName;
+
+/**
+ * The {@link EndpointDeviceResponse} defines the response from the Gateway which includes
+ * the targetted endpoint device ID.
+ *
+ * @author David Goodyear - Initial contribution
+ */
+@NonNullByDefault
+public class EndpointDeviceResponse extends GatewayDeviceResponse {
+
+    public EndpointDeviceResponse() {
+    }
+
+    /**
+     * Defines the Endpoint Device ID the return value is for
+     */
+    @SerializedName("dev_id")
+    @Expose
+    public String deviceId = EMPTY_STRING;
+
+    public String isValid() {
+        final String superRst = super.isValid();
+        if (!superRst.isEmpty()) {
+            return superRst;
+        }
+
+        if (!DEVICE_ID_PATTERN.matcher(deviceId).matches()) {
+            return "DeviceId invalid";
+        }
+
+        return EMPTY_STRING;
+    }
+}
diff --git a/bundles/org.openhab.binding.linktap/src/main/java/org/openhab/binding/linktap/protocol/frames/GatewayConfigResp.java b/bundles/org.openhab.binding.linktap/src/main/java/org/openhab/binding/linktap/protocol/frames/GatewayConfigResp.java
new file mode 100644
index 0000000000000..16d3c435947c4
--- /dev/null
+++ b/bundles/org.openhab.binding.linktap/src/main/java/org/openhab/binding/linktap/protocol/frames/GatewayConfigResp.java
@@ -0,0 +1,73 @@
+/**
+ * Copyright (c) 2010-2024 Contributors to the openHAB project
+ *
+ * See the NOTICE file(s) distributed with this work for additional
+ * information.
+ *
+ * This program and the accompanying materials are made available under the
+ * terms of the Eclipse Public License 2.0 which is available at
+ * http://www.eclipse.org/legal/epl-2.0
+ *
+ * SPDX-License-Identifier: EPL-2.0
+ */
+package org.openhab.binding.linktap.protocol.frames;
+
+import org.eclipse.jdt.annotation.NonNullByDefault;
+
+import com.google.gson.annotations.Expose;
+import com.google.gson.annotations.SerializedName;
+
+/**
+ * The {@link HandshakeResp} informs the Gateway of the current date, time and weekday in response to
+ * a HandshakeReq Frame.
+ *
+ * @provides Gw: Expects response of HandshakeResp, to inform the Gateway of the current local Date and Time
+ * @replyTo HandshakeReq
+ *
+ * @author David Goodyear - Initial contribution
+ */
+@NonNullByDefault
+public class GatewayConfigResp extends HandshakeReq {
+
+    public GatewayConfigResp() {
+    }
+
+    /**
+     * Defines the units of measurement for volume
+     * L = Litres
+     * gal = Gallon
+     */
+    @SerializedName("vol_unit")
+    @Expose
+    public String volumeUnit = EMPTY_STRING;
+
+    /**
+     * Defines the names assigned to each Endpoint device.
+     */
+    @SerializedName("dev_name")
+    @Expose
+    public String[] deviceNames = EMPTY_STRING_ARRAY;
+
+    public String isValid() {
+        final String superRst = super.isValid();
+        if (!superRst.isEmpty()) {
+            return superRst;
+        }
+
+        if (deviceNames.length != endDevices.length) {
+            return "DeviceNames != EndDevices length";
+        }
+
+        return EMPTY_STRING;
+    }
+
+    /**
+     * Unit Volume - Unit tag for gallons
+     */
+    public static final String UNIT_VOL_GALLON = "gal";
+
+    /**
+     * Unit Volume - Unit tag for litres
+     */
+    public static final String UNIT_VOL_LITRES = "L";
+}
diff --git a/bundles/org.openhab.binding.linktap/src/main/java/org/openhab/binding/linktap/protocol/frames/GatewayDeviceResponse.java b/bundles/org.openhab.binding.linktap/src/main/java/org/openhab/binding/linktap/protocol/frames/GatewayDeviceResponse.java
new file mode 100644
index 0000000000000..68cbf54af44bd
--- /dev/null
+++ b/bundles/org.openhab.binding.linktap/src/main/java/org/openhab/binding/linktap/protocol/frames/GatewayDeviceResponse.java
@@ -0,0 +1,176 @@
+/**
+ * Copyright (c) 2010-2024 Contributors to the openHAB project
+ *
+ * See the NOTICE file(s) distributed with this work for additional
+ * information.
+ *
+ * This program and the accompanying materials are made available under the
+ * terms of the Eclipse Public License 2.0 which is available at
+ * http://www.eclipse.org/legal/epl-2.0
+ *
+ * SPDX-License-Identifier: EPL-2.0
+ */
+package org.openhab.binding.linktap.protocol.frames;
+
+import org.eclipse.jdt.annotation.NonNullByDefault;
+import org.eclipse.jdt.annotation.Nullable;
+
+import com.google.gson.annotations.Expose;
+import com.google.gson.annotations.SerializedName;
+
+/**
+ * The {@link GatewayDeviceResponse} defines the response from the Gateway when a status
+ * is given about the state of the requested command.
+ *
+ * @author David Goodyear - Initial contribution
+ */
+@NonNullByDefault
+public class GatewayDeviceResponse extends TLGatewayFrame {
+
+    public GatewayDeviceResponse() {
+    }
+
+    /**
+     * Defines the processing result from the gateway
+     */
+    @SerializedName("ret")
+    @Expose(serialize = false, deserialize = true)
+    private @Nullable Integer returnValue = null;
+    @Expose(serialize = false, deserialize = false)
+    private ResultStatus cachedResEnum = ResultStatus.INVALID;
+
+    public ResultStatus getRes() {
+        if (cachedResEnum == ResultStatus.INVALID) {
+            final Integer retValClone = returnValue;
+            if (retValClone != null) {
+                cachedResEnum = ResultStatus.values()[retValClone.intValue()];
+            }
+        }
+        return cachedResEnum;
+    }
+
+    public boolean isSuccess() {
+        return ResultStatus.RET_SUCCESS == getRes();
+    }
+
+    public boolean isRetryableError() {
+        switch (getRes()) {
+            case RET_CONFLICT_WATER_PLAN: // Conflict with watering plan
+            case RET_GW_INTERNAL_ERR: // Gateway internal error
+                return true;
+            default:
+                return false;
+        }
+    }
+
+    public String isValid() {
+        final String superRst = super.isValid();
+        if (!superRst.isEmpty()) {
+            return superRst;
+        }
+
+        if (ResultStatus.INVALID == getRes()) {
+            return "Res invalid";
+        }
+
+        return EMPTY_STRING;
+    }
+
+    public enum ResultStatus {
+
+        /**
+         * RET_SUCCESS (Ordinal 0).
+         */
+        RET_SUCCESS(0, "Success", false),
+
+        /**
+         * RET_MESSAGE_FORMAT_ERR (Ordinal 1).
+         */
+        RET_MESSAGE_FORMAT_ERR(1, "Message format error", false),
+
+        /**
+         * RET_CMD_NOT_SUPPORTED (Ordinal 2).
+         */
+        RET_CMD_NOT_SUPPORTED(2, "CMD message not supported", false),
+
+        /**
+         * RET_GATEWAY_ID_NOT_MATCHED (Ordinal 3).
+         */
+        RET_GATEWAY_ID_NOT_MATCHED(3, "Gateway ID not matched", false),
+
+        /**
+         * RET_DEVICE_ID_ERROR (Ordinal 4).
+         */
+        RET_DEVICE_ID_ERROR(4, "End device ID error", false),
+
+        /**
+         * RET_DEVICE_NOT_FOUND (Ordinal 5).
+         */
+        RET_DEVICE_NOT_FOUND(5, "End device ID not found", false),
+
+        /**
+         * RET_GW_INTERNAL_ERR (Ordinal 6).
+         */
+        RET_GW_INTERNAL_ERR(6, "Gateway internal error", true),
+
+        /**
+         * RET_CONFLICT_WATER_PLAN (Ordinal 7).
+         */
+        RET_CONFLICT_WATER_PLAN(7, "Conflict with watering plan", false),
+
+        /**
+         * RET_GATEWAY_BUSY (Ordinal 8).
+         */
+        RET_GATEWAY_BUSY(8, "Gateway busy", true),
+
+        /**
+         * RET_BAD_PARAMETER (Ordinal 9).
+         */
+        RET_BAD_PARAMETER(9, "Bad parameter in message", false),
+
+        /**
+         * INVALID (Ordinal -1).
+         */
+        INVALID(-1, "Not Provided", false);
+
+        private final int value;
+        private final String description;
+        private final boolean retry;
+
+        private ResultStatus(final int value, final String description, final boolean retry) {
+            this.value = value;
+            this.description = description;
+            this.retry = retry;
+        }
+
+        public int getValue() {
+            return value;
+        }
+
+        public String getDesc() {
+            return description;
+        }
+
+        public boolean getCanRetry() {
+            return retry;
+        }
+
+        @Override
+        public String toString() {
+            return String.format("%d - %s", value, description);
+        }
+    }
+
+    /*
+     * public final static int RET_SUCCESS = 0;
+     * public final static int RET_MESSAGE_FORMAT_ERR = 1;
+     * public final static int RET_CMD_NOT_SUPPORTED = 2;
+     * public final static int RET_GATEWAY_ID_NOT_MATCHED = 3;
+     * public final static int RET_DEVICE_ID_ERROR = 4;
+     * public final static int RET_DEVICE_NOT_FOUND = 5;
+     * public final static int RET_GW_INTERNAL_ERR = 6;
+     * public final static int RET_CONFLICT_WATER_PLAN = 7;
+     * public final static int RET_GATEWAY_BUSY = 8;
+     * public final static int RET_BAD_PARAMETER = 9;
+     */
+}
diff --git a/bundles/org.openhab.binding.linktap/src/main/java/org/openhab/binding/linktap/protocol/frames/GatewayEndDevListReq.java b/bundles/org.openhab.binding.linktap/src/main/java/org/openhab/binding/linktap/protocol/frames/GatewayEndDevListReq.java
new file mode 100644
index 0000000000000..a46198dcba3c2
--- /dev/null
+++ b/bundles/org.openhab.binding.linktap/src/main/java/org/openhab/binding/linktap/protocol/frames/GatewayEndDevListReq.java
@@ -0,0 +1,66 @@
+/**
+ * Copyright (c) 2010-2024 Contributors to the openHAB project
+ *
+ * See the NOTICE file(s) distributed with this work for additional
+ * information.
+ *
+ * This program and the accompanying materials are made available under the
+ * terms of the Eclipse Public License 2.0 which is available at
+ * http://www.eclipse.org/legal/epl-2.0
+ *
+ * SPDX-License-Identifier: EPL-2.0
+ */
+package org.openhab.binding.linktap.protocol.frames;
+
+import java.util.regex.Pattern;
+
+import org.eclipse.jdt.annotation.NonNullByDefault;
+
+import com.google.gson.annotations.Expose;
+import com.google.gson.annotations.SerializedName;
+
+/**
+ * The {@link GatewayEndDevListReq} is a reusable frame used for multiple commands where a device endpoint list is
+ * included.
+ *
+ * @provides: Endpoint Device ID List
+ *
+ * @author David Goodyear - Initial contribution
+ */
+@NonNullByDefault
+public class GatewayEndDevListReq extends TLGatewayFrame {
+
+    protected static final Pattern FULL_DEVICE_ID_PATTERN = Pattern.compile("[a-zA-Z0-9]{20}");
+
+    public GatewayEndDevListReq() {
+    }
+
+    /**
+     * Defines the endpoint devices added / registered to the Gateway.
+     * Limited to the first 16 digits and letters of the Device ID
+     */
+    @SerializedName("end_dev")
+    @Expose
+    public String[] endDevices = EMPTY_STRING_ARRAY;
+
+    public String isValid() {
+        final String superRst = super.isValid();
+        if (!superRst.isEmpty()) {
+            return superRst;
+        }
+
+        for (String ed : endDevices) {
+            if (command == CMD_ADD_END_DEVICE) {
+                if (!FULL_DEVICE_ID_PATTERN.matcher(ed).matches()) {
+                    return "endDevice " + ed + " invalid";
+                }
+            } else {
+                if (!DEVICE_ID_PATTERN.matcher(ed).matches()) {
+                    return "endDevice " + ed + " invalid";
+                }
+
+            }
+        }
+        return EMPTY_STRING;
+    }
+}
diff --git a/bundles/org.openhab.binding.linktap/src/main/java/org/openhab/binding/linktap/protocol/frames/HandshakeReq.java b/bundles/org.openhab.binding.linktap/src/main/java/org/openhab/binding/linktap/protocol/frames/HandshakeReq.java
new file mode 100644
index 0000000000000..132ae224ff638
--- /dev/null
+++ b/bundles/org.openhab.binding.linktap/src/main/java/org/openhab/binding/linktap/protocol/frames/HandshakeReq.java
@@ -0,0 +1,52 @@
+/**
+ * Copyright (c) 2010-2024 Contributors to the openHAB project
+ *
+ * See the NOTICE file(s) distributed with this work for additional
+ * information.
+ *
+ * This program and the accompanying materials are made available under the
+ * terms of the Eclipse Public License 2.0 which is available at
+ * http://www.eclipse.org/legal/epl-2.0
+ *
+ * SPDX-License-Identifier: EPL-2.0
+ */
+package org.openhab.binding.linktap.protocol.frames;
+
+import org.eclipse.jdt.annotation.NonNullByDefault;
+
+import com.google.gson.annotations.Expose;
+import com.google.gson.annotations.SerializedName;
+
+/**
+ * The {@link HandshakeReq} is a handshake from the Gateway.
+ *
+ * @provides App: Gateway ID, Firmware revision, Registered / Addded Endpoint Device ID List
+ * @response Gw: Expects response of HandshakeResp, to inform the Gateway of the current local Date and Time
+ *
+ * @author David Goodyear - Initial contribution
+ */
+@NonNullByDefault
+public class HandshakeReq extends GatewayEndDevListReq {
+
+    public HandshakeReq() {
+    }
+
+    /**
+     * Defines the firmware version identifier.
+     */
+    @SerializedName("ver")
+    @Expose
+    public String version = EMPTY_STRING;
+
+    public String isValid() {
+        final String superRst = super.isValid();
+        if (!superRst.isEmpty()) {
+            return superRst;
+        }
+
+        if (version.isEmpty()) {
+            return "Version is empty";
+        }
+        return EMPTY_STRING;
+    }
+}
diff --git a/bundles/org.openhab.binding.linktap/src/main/java/org/openhab/binding/linktap/protocol/frames/HandshakeResp.java b/bundles/org.openhab.binding.linktap/src/main/java/org/openhab/binding/linktap/protocol/frames/HandshakeResp.java
new file mode 100644
index 0000000000000..370bcc9957a0a
--- /dev/null
+++ b/bundles/org.openhab.binding.linktap/src/main/java/org/openhab/binding/linktap/protocol/frames/HandshakeResp.java
@@ -0,0 +1,91 @@
+/**
+ * Copyright (c) 2010-2024 Contributors to the openHAB project
+ *
+ * See the NOTICE file(s) distributed with this work for additional
+ * information.
+ *
+ * This program and the accompanying materials are made available under the
+ * terms of the Eclipse Public License 2.0 which is available at
+ * http://www.eclipse.org/legal/epl-2.0
+ *
+ * SPDX-License-Identifier: EPL-2.0
+ */
+package org.openhab.binding.linktap.protocol.frames;
+
+import java.time.LocalDate;
+import java.time.LocalTime;
+import java.time.format.DateTimeFormatter;
+import java.time.format.DateTimeParseException;
+
+import org.eclipse.jdt.annotation.NonNullByDefault;
+
+import com.google.gson.annotations.Expose;
+import com.google.gson.annotations.SerializedName;
+
+/**
+ * The {@link HandshakeResp} informs the Gateway of the current date, time and weekday in response to
+ * a HandshakeReq Frame.
+ *
+ * @provides Gw: Expects response of HandshakeResp, to inform the Gateway of the current local Date and Time
+ * @replyTo HandshakeReq
+ *
+ * @author David Goodyear - Initial contribution
+ */
+@NonNullByDefault
+public class HandshakeResp extends GatewayDeviceResponse {
+
+    public HandshakeResp() {
+    }
+
+    /**
+     * Defines the date in the format YYYYMMDD
+     */
+    @SerializedName("date")
+    @Expose
+    public String date = EMPTY_STRING;
+
+    /**
+     * Defines the time for the GW in the format HHMMSS
+     */
+    @SerializedName("time")
+    @Expose
+    public String time = EMPTY_STRING;
+
+    /**
+     * Defines the weekday for the GW
+     * 1 represents Monday.... 7 represents Sunday
+     */
+    @SerializedName("wday")
+    @Expose
+    public int wday = DEFAULT_INT;
+
+    static final String DATE_PATTERN = "yyyyMMdd";
+    static final DateTimeFormatter DATE_FORMATTER = DateTimeFormatter.ofPattern(DATE_PATTERN);
+
+    static final String TIME_PATTERN = "HHmmss";
+    static final DateTimeFormatter TIME_FORMATTER = DateTimeFormatter.ofPattern(TIME_PATTERN);
+
+    public String isValid() {
+        final String superRst = super.isValid();
+        if (!superRst.isEmpty()) {
+            return superRst;
+        }
+
+        if (wday < 1 || wday > 7) {
+            return "wday not in range 1 -> 7";
+        }
+        try {
+            LocalDate.parse(date, DATE_FORMATTER);
+        } catch (DateTimeParseException e) {
+            return "date invalid";
+        }
+
+        try {
+            LocalTime.parse(time, TIME_FORMATTER);
+        } catch (DateTimeParseException e) {
+            return "time invalid";
+        }
+
+        return EMPTY_STRING;
+    }
+}
diff --git a/bundles/org.openhab.binding.linktap/src/main/java/org/openhab/binding/linktap/protocol/frames/IPayloadValidator.java b/bundles/org.openhab.binding.linktap/src/main/java/org/openhab/binding/linktap/protocol/frames/IPayloadValidator.java
new file mode 100644
index 0000000000000..99f8e6b84e73b
--- /dev/null
+++ b/bundles/org.openhab.binding.linktap/src/main/java/org/openhab/binding/linktap/protocol/frames/IPayloadValidator.java
@@ -0,0 +1,26 @@
+/**
+ * Copyright (c) 2010-2024 Contributors to the openHAB project
+ *
+ * See the NOTICE file(s) distributed with this work for additional
+ * information.
+ *
+ * This program and the accompanying materials are made available under the
+ * terms of the Eclipse Public License 2.0 which is available at
+ * http://www.eclipse.org/legal/epl-2.0
+ *
+ * SPDX-License-Identifier: EPL-2.0
+ */
+package org.openhab.binding.linktap.protocol.frames;
+
+import org.eclipse.jdt.annotation.NonNullByDefault;
+
+/**
+ * The {@link IPayloadValidator} when implemented for frame definitions, allows the payload's to
+ * be validated as accurate data.
+ *
+ * @author David Goodyear - Initial contribution
+ */
+@NonNullByDefault
+public interface IPayloadValidator {
+    String isValid();
+}
diff --git a/bundles/org.openhab.binding.linktap/src/main/java/org/openhab/binding/linktap/protocol/frames/LockReq.java b/bundles/org.openhab.binding.linktap/src/main/java/org/openhab/binding/linktap/protocol/frames/LockReq.java
new file mode 100644
index 0000000000000..050ca36a38a7f
--- /dev/null
+++ b/bundles/org.openhab.binding.linktap/src/main/java/org/openhab/binding/linktap/protocol/frames/LockReq.java
@@ -0,0 +1,69 @@
+/**
+ * Copyright (c) 2010-2024 Contributors to the openHAB project
+ *
+ * See the NOTICE file(s) distributed with this work for additional
+ * information.
+ *
+ * This program and the accompanying materials are made available under the
+ * terms of the Eclipse Public License 2.0 which is available at
+ * http://www.eclipse.org/legal/epl-2.0
+ *
+ * SPDX-License-Identifier: EPL-2.0
+ */
+package org.openhab.binding.linktap.protocol.frames;
+
+import org.eclipse.jdt.annotation.NonNullByDefault;
+
+import com.google.gson.annotations.Expose;
+import com.google.gson.annotations.SerializedName;
+
+/**
+ * The {@link LockReq} defines the request to dismiss alerts from a given device.
+ *
+ * @author David Goodyear - Initial contribution
+ */
+@NonNullByDefault
+public class LockReq extends DeviceCmdReq {
+
+    public LockReq() {
+    }
+
+    public LockReq(final int lock) {
+        this.command = CMD_LOCKOUT_STATE;
+        this.lock = lock;
+    }
+
+    /**
+     * Defines the lock type to reqest
+     */
+    @SerializedName("lock")
+    @Expose
+    public int lock = DEFAULT_INT;
+
+    public String isValid() {
+        final String superRst = super.isValid();
+        if (!superRst.isEmpty()) {
+            return superRst;
+        }
+
+        if (lock < LOCK_UNLOCKED || lock > LOCK_FULL) {
+            return "Lock not in range " + LOCK_UNLOCKED + " -> " + LOCK_FULL;
+        }
+        return EMPTY_STRING;
+    }
+
+    /**
+     * Lock - 0. Device is unlocked
+     */
+    public static final int LOCK_UNLOCKED = 0;
+
+    /**
+     * Lock - 1. Partially locked
+     */
+    public static final int LOCK_PARTIALLY = 1;
+
+    /**
+     * Lock - 2. Completely locked
+     */
+    public static final int LOCK_FULL = 2;
+}
diff --git a/bundles/org.openhab.binding.linktap/src/main/java/org/openhab/binding/linktap/protocol/frames/PauseWateringPlanReq.java b/bundles/org.openhab.binding.linktap/src/main/java/org/openhab/binding/linktap/protocol/frames/PauseWateringPlanReq.java
new file mode 100644
index 0000000000000..985ffc0d44c85
--- /dev/null
+++ b/bundles/org.openhab.binding.linktap/src/main/java/org/openhab/binding/linktap/protocol/frames/PauseWateringPlanReq.java
@@ -0,0 +1,51 @@
+/**
+ * Copyright (c) 2010-2024 Contributors to the openHAB project
+ *
+ * See the NOTICE file(s) distributed with this work for additional
+ * information.
+ *
+ * This program and the accompanying materials are made available under the
+ * terms of the Eclipse Public License 2.0 which is available at
+ * http://www.eclipse.org/legal/epl-2.0
+ *
+ * SPDX-License-Identifier: EPL-2.0
+ */
+package org.openhab.binding.linktap.protocol.frames;
+
+import org.eclipse.jdt.annotation.NonNullByDefault;
+
+import com.google.gson.annotations.Expose;
+import com.google.gson.annotations.SerializedName;
+
+/**
+ * The {@link PauseWateringPlanReq} requests the watering plan is disabled for a duration of hours.
+ *
+ * @author David Goodyear - Initial contribution
+ */
+@NonNullByDefault
+public class PauseWateringPlanReq extends DeviceCmdReq {
+
+    public PauseWateringPlanReq() {
+    }
+
+    /**
+     * Defines the duration the watering plan is to be paused for.
+     * Acceptable range is between 0.1 to 240
+     * Units is hours
+     */
+    @SerializedName("duration")
+    @Expose
+    public Double duration = 0.0;
+
+    public String isValid() {
+        final String superRst = super.isValid();
+        if (!superRst.isEmpty()) {
+            return superRst;
+        }
+
+        if (duration < 0.1 || duration > 240) {
+            return "duration not in range 0.1 -> 240";
+        }
+        return EMPTY_STRING;
+    }
+}
diff --git a/bundles/org.openhab.binding.linktap/src/main/java/org/openhab/binding/linktap/protocol/frames/RainData.java b/bundles/org.openhab.binding.linktap/src/main/java/org/openhab/binding/linktap/protocol/frames/RainData.java
new file mode 100644
index 0000000000000..9bb59ec810b3d
--- /dev/null
+++ b/bundles/org.openhab.binding.linktap/src/main/java/org/openhab/binding/linktap/protocol/frames/RainData.java
@@ -0,0 +1,66 @@
+/**
+ * Copyright (c) 2010-2024 Contributors to the openHAB project
+ *
+ * See the NOTICE file(s) distributed with this work for additional
+ * information.
+ *
+ * This program and the accompanying materials are made available under the
+ * terms of the Eclipse Public License 2.0 which is available at
+ * http://www.eclipse.org/legal/epl-2.0
+ *
+ * SPDX-License-Identifier: EPL-2.0
+ */
+package org.openhab.binding.linktap.protocol.frames;
+
+import org.eclipse.jdt.annotation.NonNullByDefault;
+
+import com.google.gson.annotations.Expose;
+import com.google.gson.annotations.SerializedName;
+
+/**
+ * The {@link DismissAlertReq} defines the payload to represent rainfall data.
+ *
+ * @author David Goodyear - Initial contribution
+ */
+@NonNullByDefault
+public class RainData extends TLGatewayFrame {
+
+    public RainData() {
+    }
+
+    /**
+     * Defines the past rainfall [0] and future rainfull [1] measurements in mm
+     */
+    @SerializedName("rain")
+    @Expose
+    public double[] rainfallData = new double[] { 0.0, 0.0 };
+
+    public void setPastRainfall(final double pastRainMM) {
+        rainfallData[0] = pastRainMM;
+    }
+
+    public double getPastRainfall() {
+        return rainfallData[0];
+    }
+
+    public void setFutureRainfall(final double futureRainMM) {
+        rainfallData[1] = futureRainMM;
+    }
+
+    public double getFutureRainfall() {
+        return rainfallData[1];
+    }
+
+    public String isValid() {
+        final String superRst = super.isValid();
+        if (!superRst.isEmpty()) {
+            return superRst;
+        }
+
+        if (rainfallData.length != 2) {
+            return "RainfallData invalid length";
+        }
+
+        return EMPTY_STRING;
+    }
+}
diff --git a/bundles/org.openhab.binding.linktap/src/main/java/org/openhab/binding/linktap/protocol/frames/RainDataForecast.java b/bundles/org.openhab.binding.linktap/src/main/java/org/openhab/binding/linktap/protocol/frames/RainDataForecast.java
new file mode 100644
index 0000000000000..ac018d881a8dd
--- /dev/null
+++ b/bundles/org.openhab.binding.linktap/src/main/java/org/openhab/binding/linktap/protocol/frames/RainDataForecast.java
@@ -0,0 +1,51 @@
+/**
+ * Copyright (c) 2010-2024 Contributors to the openHAB project
+ *
+ * See the NOTICE file(s) distributed with this work for additional
+ * information.
+ *
+ * This program and the accompanying materials are made available under the
+ * terms of the Eclipse Public License 2.0 which is available at
+ * http://www.eclipse.org/legal/epl-2.0
+ *
+ * SPDX-License-Identifier: EPL-2.0
+ */
+package org.openhab.binding.linktap.protocol.frames;
+
+import org.eclipse.jdt.annotation.NonNullByDefault;
+
+import com.google.gson.annotations.Expose;
+import com.google.gson.annotations.SerializedName;
+
+/**
+ * The {@link DismissAlertReq} defines the payload to represent rainfall forecast data.
+ *
+ * @author David Goodyear - Initial contribution
+ */
+@NonNullByDefault
+public class RainDataForecast extends RainData {
+
+    public RainDataForecast() {
+    }
+
+    /**
+     * Defines the effective time relevant for the rainfall data returned.
+     * Minimum value is 1
+     */
+    @SerializedName("valid_duration")
+    @Expose
+    public int validDuration = DEFAULT_INT;
+
+    public String isValid() {
+        final String superRst = super.isValid();
+        if (!superRst.isEmpty()) {
+            return superRst;
+        }
+
+        if (validDuration < 1) {
+            return "validDuration less than 1";
+        }
+
+        return EMPTY_STRING;
+    }
+}
diff --git a/bundles/org.openhab.binding.linktap/src/main/java/org/openhab/binding/linktap/protocol/frames/SetDeviceConfigReq.java b/bundles/org.openhab.binding.linktap/src/main/java/org/openhab/binding/linktap/protocol/frames/SetDeviceConfigReq.java
new file mode 100644
index 0000000000000..bbf434b2be94b
--- /dev/null
+++ b/bundles/org.openhab.binding.linktap/src/main/java/org/openhab/binding/linktap/protocol/frames/SetDeviceConfigReq.java
@@ -0,0 +1,77 @@
+/**
+ * Copyright (c) 2010-2024 Contributors to the openHAB project
+ *
+ * See the NOTICE file(s) distributed with this work for additional
+ * information.
+ *
+ * This program and the accompanying materials are made available under the
+ * terms of the Eclipse Public License 2.0 which is available at
+ * http://www.eclipse.org/legal/epl-2.0
+ *
+ * SPDX-License-Identifier: EPL-2.0
+ */
+package org.openhab.binding.linktap.protocol.frames;
+
+import org.eclipse.jdt.annotation.NonNullByDefault;
+
+import com.google.gson.annotations.Expose;
+import com.google.gson.annotations.SerializedName;
+
+/**
+ * The {@link SetDeviceConfigReq} sets the configuration parameter specified for a particular device.
+ *
+ * @author David Goodyear - Initial contribution
+ */
+@NonNullByDefault
+public class SetDeviceConfigReq extends DeviceCmdReq {
+
+    public SetDeviceConfigReq() {
+    }
+
+    public SetDeviceConfigReq(final String tag, final int value) {
+        this.command = CMD_SET_CONFIGURATION;
+        this.tag = tag;
+        this.value = value;
+    }
+
+    /**
+     * The value to send for the given tag
+     */
+    @SerializedName("value")
+    @Expose
+    public int value = 0;
+
+    /**
+     * The tag that the value suppied is to be used for
+     */
+    @SerializedName("tag")
+    @Expose
+    public String tag = EMPTY_STRING;
+
+    public String isValid() {
+        final String superRst = super.isValid();
+        if (!superRst.isEmpty()) {
+            return superRst;
+        }
+
+        switch (tag) {
+            case CONFIG_VOLUME_LIMIT:
+            case CONFIG_DURATION_LIMIT:
+                break;
+            default:
+                return "Invalid tag \"" + tag + "\"";
+        }
+
+        return EMPTY_STRING;
+    }
+
+    /**
+     * Config - Water Volume Limit
+     */
+    public static final String CONFIG_VOLUME_LIMIT = "volume_limit";
+
+    /**
+     * Config - Time Duration Limit
+     */
+    public static final String CONFIG_DURATION_LIMIT = "total_duration";
+}
diff --git a/bundles/org.openhab.binding.linktap/src/main/java/org/openhab/binding/linktap/protocol/frames/SetupWaterPlan.java b/bundles/org.openhab.binding.linktap/src/main/java/org/openhab/binding/linktap/protocol/frames/SetupWaterPlan.java
new file mode 100644
index 0000000000000..c9dd4550bec56
--- /dev/null
+++ b/bundles/org.openhab.binding.linktap/src/main/java/org/openhab/binding/linktap/protocol/frames/SetupWaterPlan.java
@@ -0,0 +1,148 @@
+/**
+ * Copyright (c) 2010-2024 Contributors to the openHAB project
+ *
+ * See the NOTICE file(s) distributed with this work for additional
+ * information.
+ *
+ * This program and the accompanying materials are made available under the
+ * terms of the Eclipse Public License 2.0 which is available at
+ * http://www.eclipse.org/legal/epl-2.0
+ *
+ * SPDX-License-Identifier: EPL-2.0
+ */
+package org.openhab.binding.linktap.protocol.frames;
+
+import static org.openhab.binding.linktap.protocol.frames.HandshakeResp.DATE_FORMATTER;
+import static org.openhab.binding.linktap.protocol.frames.WaterMeterStatus.OP_MODE_INSTANT;
+import static org.openhab.binding.linktap.protocol.frames.WaterMeterStatus.OP_MODE_MONTH;
+
+import java.time.LocalDate;
+import java.time.LocalTime;
+import java.time.format.DateTimeParseException;
+
+import org.eclipse.jdt.annotation.NonNullByDefault;
+
+import com.google.gson.annotations.Expose;
+import com.google.gson.annotations.SerializedName;
+
+/**
+ * The {@link SetupWaterPlan} defines the request to dismiss alerts from a given device.
+ *
+ * @author David Goodyear - Initial contribution
+ */
+@NonNullByDefault
+public abstract class SetupWaterPlan extends DeviceCmdReq {
+
+    public SetupWaterPlan() {
+    }
+
+    /**
+     * Defines the unique identifier for the instance of the watering plan
+     * that we are sending.
+     */
+    @SerializedName("plan_sn")
+    @Expose
+    public int planSerialNo = DEFAULT_INT;
+
+    /**
+     * Defines the watering mode which can be:
+     * watering mode (1 - Instant Mode, 2 - Calendar mode, 3 - 7 day mode, 4 - Odd-even mode, 5
+     * - Interval mode, 6 - Month mode).
+     * See OP_MODE_INSTANT....
+     */
+    @SerializedName("mode")
+    @Expose
+    public int mode = DEFAULT_INT;
+
+    /**
+     * Defines the eco mode options... only used by Instant mode but in all payloads
+     * eco: the ECO mode works in a way that the valve opens for X seconds then closes
+     * for Y seconds “X, Y, X, Y, …“. in [X, Y], X denotes the Valve ON duration,
+     * Y denotes Valve OFF duration. The ECO mode will not be applied if either X or Y is zero.
+     */
+    protected int[] eco = new int[] { 0, 0 };
+
+    /**
+     * Defines the watering plan information for the mode specified
+     */
+    @SerializedName("sch")
+    @Expose
+    public WaterSchedule schedule = new WaterSchedule();
+
+    protected class WaterSchedule implements IPayloadValidator {
+        @Override
+        public String isValid() {
+            return EMPTY_STRING;
+        }
+    }
+
+    public String isValid() {
+        final String superRst = super.isValid();
+        if (!superRst.isEmpty()) {
+            return superRst;
+        }
+        if (planSerialNo == DEFAULT_INT) {
+            return "planSerialNo invalid";
+        }
+        if (mode < OP_MODE_INSTANT || mode > OP_MODE_MONTH) {
+            return "mode not in range " + OP_MODE_INSTANT + " -> " + OP_MODE_MONTH;
+        }
+        if (eco.length != 2) {
+            return "eco length invalid";
+        }
+        return schedule.isValid();
+    }
+
+    public class WaterPlanInstant extends WaterSchedule {
+
+        /**
+         * Defines the timestamp (YYYYMMDDHHMMSS) that the Instant Mode will take effect
+         */
+        @SerializedName("timestamp")
+        @Expose
+        public String timestamp = EMPTY_STRING;
+
+        /**
+         * Defines the target capacity for a watering session, measured in liters or gallons
+         * (according to the Volume unit configuration in the gateway management page).
+         * The minimum value is 1. When the water timer has a flow meter connected, if its
+         * value is greater than 0, the watering process is controlled by both "volume" and "duration."
+         * The watering stops when either of these conditions is met.
+         * (Note: G1S does not support "watering by volume". D1, which includes two integrated flow meters,
+         * supports "watering by volume")
+         */
+        @SerializedName("volume")
+        @Expose
+        public int volume = DEFAULT_INT;
+
+        /**
+         * This defines the watering duration in seconds. (Please note: for G1 & G2 models which support "watering
+         * by minute" only, the duration value here needs to be an integral multiple of 60 seconds. For the G1S & G2S
+         * and future models, the duration value can be any integer between 3 and 86399.)
+         */
+        @SerializedName("duration")
+        @Expose
+        public int duration = DEFAULT_INT;
+
+        @Override
+        public String isValid() {
+            if (duration < 3 || duration > 86399) {
+                return "duration not in range 3 -> 86399";
+            }
+            if (volume < 1) {
+                return "volume less than 1";
+            }
+            if (timestamp.length() != 14) {
+                return "timestamp invalid";
+            }
+            try {
+                LocalDate.parse(timestamp.substring(0, 8), DATE_FORMATTER);
+                LocalTime.parse(timestamp.substring(9), DATE_FORMATTER);
+            } catch (DateTimeParseException e) {
+                return "timestamp invalid";
+            }
+
+            return EMPTY_STRING;
+        }
+    }
+}
diff --git a/bundles/org.openhab.binding.linktap/src/main/java/org/openhab/binding/linktap/protocol/frames/StartWateringReq.java b/bundles/org.openhab.binding.linktap/src/main/java/org/openhab/binding/linktap/protocol/frames/StartWateringReq.java
new file mode 100644
index 0000000000000..7f9f6ca2e6d91
--- /dev/null
+++ b/bundles/org.openhab.binding.linktap/src/main/java/org/openhab/binding/linktap/protocol/frames/StartWateringReq.java
@@ -0,0 +1,67 @@
+/**
+ * Copyright (c) 2010-2024 Contributors to the openHAB project
+ *
+ * See the NOTICE file(s) distributed with this work for additional
+ * information.
+ *
+ * This program and the accompanying materials are made available under the
+ * terms of the Eclipse Public License 2.0 which is available at
+ * http://www.eclipse.org/legal/epl-2.0
+ *
+ * SPDX-License-Identifier: EPL-2.0
+ */
+package org.openhab.binding.linktap.protocol.frames;
+
+import org.eclipse.jdt.annotation.NonNullByDefault;
+
+import com.google.gson.annotations.Expose;
+import com.google.gson.annotations.SerializedName;
+
+/**
+ * The {@link DismissAlertReq} defines the request to start watering immediately.
+ *
+ * @author David Goodyear - Initial contribution
+ */
+@NonNullByDefault
+public class StartWateringReq extends DeviceCmdReq {
+
+    public StartWateringReq() {
+    }
+
+    public StartWateringReq(final int durationSecs, final int volume) {
+        this.command = CMD_IMMEDIATE_WATER_START;
+        this.duration = durationSecs;
+        this.volume = volume;
+    }
+
+    /**
+     * Defines the time duration in seconds to water for.
+     * Minimum value 3
+     * Maximum value 86340
+     */
+    @SerializedName("duration")
+    @Expose
+    public int duration = DEFAULT_INT;
+
+    /**
+     * Defines the volume of water to use
+     * Units may be L or gal, depending on the units the device
+     * is operating in.
+     */
+    @SerializedName("volume")
+    @Expose
+    public int volume = DEFAULT_INT;
+
+    public String isValid() {
+        final String superRst = super.isValid();
+        if (!superRst.isEmpty()) {
+            return superRst;
+        }
+
+        if (duration < 3 || duration > 86340) {
+            return "duration not in range 3 -> 86340";
+        }
+
+        return EMPTY_STRING;
+    }
+}
diff --git a/bundles/org.openhab.binding.linktap/src/main/java/org/openhab/binding/linktap/protocol/frames/TLGatewayFrame.java b/bundles/org.openhab.binding.linktap/src/main/java/org/openhab/binding/linktap/protocol/frames/TLGatewayFrame.java
new file mode 100644
index 0000000000000..3ae0a1c75fe55
--- /dev/null
+++ b/bundles/org.openhab.binding.linktap/src/main/java/org/openhab/binding/linktap/protocol/frames/TLGatewayFrame.java
@@ -0,0 +1,251 @@
+/**
+ * Copyright (c) 2010-2024 Contributors to the openHAB project
+ *
+ * See the NOTICE file(s) distributed with this work for additional
+ * information.
+ *
+ * This program and the accompanying materials are made available under the
+ * terms of the Eclipse Public License 2.0 which is available at
+ * http://www.eclipse.org/legal/epl-2.0
+ *
+ * SPDX-License-Identifier: EPL-2.0
+ */
+package org.openhab.binding.linktap.protocol.frames;
+
+import java.util.regex.Pattern;
+
+import org.eclipse.jdt.annotation.NonNullByDefault;
+import org.eclipse.jdt.annotation.Nullable;
+
+import com.google.gson.annotations.Expose;
+import com.google.gson.annotations.SerializedName;
+
+/**
+ * The {@link TLGatewayFrame} defines the common framing data, for requests and responses
+ * from a Gateway device.
+ *
+ * @author David Goodyear - Initial contribution
+ */
+@NonNullByDefault
+public class TLGatewayFrame implements IPayloadValidator {
+
+    public static final int DEFAULT_INT = -1;
+    public static final String EMPTY_STRING = "";
+    public static final String[] EMPTY_STRING_ARRAY = new String[0];
+
+    protected static final Pattern DEVICE_ID_PATTERN = Pattern.compile("[a-zA-Z0-9]{0,16}");
+    protected static final Pattern SUB_DEVICE_ID_PATTERN = Pattern.compile("[a-zA-Z0-9]{0,16}_[0-9]");
+
+    public TLGatewayFrame() {
+    }
+
+    public TLGatewayFrame(final int command) {
+        this.command = command;
+    }
+
+    public @Nullable Class<TLGatewayFrame> getResponseFrame() {
+        return TLGatewayFrame.class;
+    }
+
+    /**
+     * Defines the CMD identifier, that defines the payload type.
+     * Possible values in constants CMD_*
+     */
+    @SerializedName("cmd")
+    @Expose
+    public int command = DEFAULT_INT;
+
+    /**
+     * Defines the gateway identifier.
+     * Limited to the first 16 digits and letters of the Gateway ID
+     */
+    @SerializedName("gw_id")
+    @Expose
+    public String gatewayId = EMPTY_STRING;
+
+    public String isValid() {
+        if (command < CMD_HANDSHAKE || command > CMD_PAUSE_WATER_PLAN) {
+            return "Command not in range " + CMD_HANDSHAKE + " -> " + CMD_PAUSE_WATER_PLAN;
+        }
+        if (!DEVICE_ID_PATTERN.matcher(gatewayId).matches()) {
+            return "GatewayId invalid";
+        }
+        return EMPTY_STRING;
+    }
+
+    // COMMAND Values
+
+    /**
+     * Command - 0. Handshake Message
+     *
+     * @direction GW->Broker->App
+     * @description Handshake message. It is the first message after the Gateway connects to the MQTT Broker.
+     *              </p>
+     *              Gateway acquires its local time base from third-party application, and sends its
+     *              end devices ID list to third-party application, through this message.
+     */
+    public static final int CMD_HANDSHAKE = 0;
+
+    /**
+     * Command - 1. Add / Register End Device
+     *
+     * @direction App->Broker->GW
+     * @description Add's / Registers a new device to the Gateway
+     *              (e.g., water timer) to the Gateway.
+     */
+    public static final int CMD_ADD_END_DEVICE = 1;
+
+    /**
+     * Command - 2. Delete End Device
+     *
+     * @direction App->Broker->GW
+     * @description Removes / De-registers a device (e.g., water timer) from the Gateway.
+     */
+    public static final int CMD_REMOVE_END_DEVICE = 2;
+
+    /**
+     * Command - 3. Update Water Timer Status
+     *
+     * @direction App->Broker->GW
+     * @description Update water timer’s status
+     */
+    public static final int CMD_UPDATE_WATER_TIMER_STATUS = 3;
+
+    /**
+     * Command - 103. Update Water Timer Status Unsolicited
+     *
+     * @direction GW->Broker->App
+     * @description Update water timer’s status
+     */
+    public static final int CMD_UPDATE_WATER_TIMER_STATUS_UNSOLICITED = 103;
+
+    /**
+     * Command - 4. Send / Setup Water Plan
+     *
+     * @direction App->Broker->GW
+     * @description Send / set up watering plan
+     *              (The prerequisite for the correct execution of the watering plan is that
+     *              the Gateway’s local time base has been properly set through
+     *              CMD:0 (CMD_HANDSHAKE) or
+     *              CMD:13)
+     */
+    public static final int CMD_SETUP_WATER_PLAN = 4;
+
+    /**
+     * Command - 5. Delete Water Plan
+     *
+     * @direction App->Broker->GW
+     * @description Deletes the existing water plan
+     */
+    public static final int CMD_REMOVE_WATER_PLAN = 5;
+
+    /**
+     * Command - 6. Start Watering Immediately
+     *
+     * @direction App->Broker->GW
+     * @description Start watering for the immediate duration irrelevant
+     *              of water plan. (Gateway local time base is not required
+     *              for the operation of this mode).
+     */
+    public static final int CMD_IMMEDIATE_WATER_START = 6;
+
+    /**
+     * Command - 7. Stop Watering Immediately
+     *
+     * @direction App->Broker->GW
+     * @description Stop's watering immediately. The water plan will resume at
+     *              the next point as setup.
+     */
+    public static final int CMD_IMMEDIATE_WATER_STOP = 7;
+
+    /**
+     * Command - 8. Fetch / Push Rainfall Data
+     *
+     * @direction GW->Broker->App
+     * @description Request for Rainfall data
+     * @direction App->Broker->GW
+     * @description Push of Rainfall data
+     */
+    public static final int CMD_RAINFALL_DATA = 8;
+
+    /**
+     * Command - 9. Notificaiton of watering has been skipped
+     *
+     * @direction GW->Broker->App
+     * @description Notification that a watering cycle has been skipped due to rainfall
+     */
+    public static final int CMD_NOTIFICATION_WATERING_SKIPPED = 9;
+
+    /**
+     * Command - 10. Alert Enablement / Disablement
+     *
+     * @direction App->Broker->GW
+     * @description Enable or disablement of particular monitoring alerts
+     */
+    public static final int CMD_ALERT_ENABLEMENT = 10;
+
+    /**
+     * Command - 11. Dismiss Alert
+     *
+     * @direction App->Broker->GW
+     * @description Dismisses the given alert
+     */
+    public static final int CMD_ALERT_DISMISS = 11;
+
+    /**
+     * Command - 12 Lockout state setup
+     *
+     * @direction App->Broker->GW
+     * @description Setup lockout state for manual On/Off button (for G15 and G25 models only)
+     */
+    public static final int CMD_LOCKOUT_STATE = 12;
+
+    /**
+     * Command - 13 Gateways Date & Time Sync Request
+     *
+     * @direction GW->Broker->App
+     * @description Request for the current date and time, for the Gateway to apply
+     */
+    public static final int CMD_DATETIME_SYNC = 13;
+
+    /**
+     * Command - 14 Read the Gateways Date & Time
+     *
+     * @direction App->Broker->Gw
+     * @description Fetch Gateway's local datetime
+     */
+    public static final int CMD_DATETIME_READ = 14;
+
+    /**
+     * Command - 15 Test wireless performance of end device
+     *
+     * @direction App->Broker->Gw
+     * @description Request a communications test between the Gateway and End Device
+     */
+    public static final int CMD_WIRELESS_CHECK = 15;
+
+    /**
+     * Command - 16 Get Gateway's configuration
+     *
+     * @direction App->Broker->Gw
+     * @description Request the current Gateway's configuration
+     */
+    public static final int CMD_GET_CONFIGURATION = 16;
+
+    /**
+     * Command - 17 Set Gateway's configuration
+     *
+     * @direction App->Broker->Gw
+     * @description Update the configuration for a device in the Gateway
+     */
+    public static final int CMD_SET_CONFIGURATION = 17;
+
+    /**
+     * Command - 18 Pause Water Plan
+     *
+     * @direction App->Broker->Gw
+     * @description Pause the Water Plan for the given duration
+     *              (0.1 to 240 hours)
+     */
+    public static final int CMD_PAUSE_WATER_PLAN = 18;
+}
diff --git a/bundles/org.openhab.binding.linktap/src/main/java/org/openhab/binding/linktap/protocol/frames/TimeDataResp.java b/bundles/org.openhab.binding.linktap/src/main/java/org/openhab/binding/linktap/protocol/frames/TimeDataResp.java
new file mode 100644
index 0000000000000..2988b40417624
--- /dev/null
+++ b/bundles/org.openhab.binding.linktap/src/main/java/org/openhab/binding/linktap/protocol/frames/TimeDataResp.java
@@ -0,0 +1,32 @@
+/**
+ * Copyright (c) 2010-2024 Contributors to the openHAB project
+ *
+ * See the NOTICE file(s) distributed with this work for additional
+ * information.
+ *
+ * This program and the accompanying materials are made available under the
+ * terms of the Eclipse Public License 2.0 which is available at
+ * http://www.eclipse.org/legal/epl-2.0
+ *
+ * SPDX-License-Identifier: EPL-2.0
+ */
+package org.openhab.binding.linktap.protocol.frames;
+
+import org.eclipse.jdt.annotation.NonNullByDefault;
+
+/**
+ * The {@link TimeDataResp} defines a response that defines the time, date and weekday
+ * from the gateway.
+ *
+ * @author David Goodyear - Initial contribution
+ */
+@NonNullByDefault
+public class TimeDataResp extends HandshakeResp {
+
+    public TimeDataResp() {
+    }
+
+    public String isValid() {
+        return super.isValid();
+    }
+}
diff --git a/bundles/org.openhab.binding.linktap/src/main/java/org/openhab/binding/linktap/protocol/frames/WaterMeterStatus.java b/bundles/org.openhab.binding.linktap/src/main/java/org/openhab/binding/linktap/protocol/frames/WaterMeterStatus.java
new file mode 100644
index 0000000000000..68839ec315d9e
--- /dev/null
+++ b/bundles/org.openhab.binding.linktap/src/main/java/org/openhab/binding/linktap/protocol/frames/WaterMeterStatus.java
@@ -0,0 +1,275 @@
+/**
+ * Copyright (c) 2010-2024 Contributors to the openHAB project
+ *
+ * See the NOTICE file(s) distributed with this work for additional
+ * information.
+ *
+ * This program and the accompanying materials are made available under the
+ * terms of the Eclipse Public License 2.0 which is available at
+ * http://www.eclipse.org/legal/epl-2.0
+ *
+ * SPDX-License-Identifier: EPL-2.0
+ */
+package org.openhab.binding.linktap.protocol.frames;
+
+import java.lang.reflect.Type;
+import java.util.ArrayList;
+import java.util.List;
+
+import org.eclipse.jdt.annotation.NonNullByDefault;
+import org.eclipse.jdt.annotation.Nullable;
+
+import com.google.gson.JsonDeserializationContext;
+import com.google.gson.JsonDeserializer;
+import com.google.gson.JsonElement;
+import com.google.gson.annotations.Expose;
+import com.google.gson.annotations.SerializedName;
+
+/**
+ * The {@link DeviceCmdReq} is a payload representing the current status of the
+ * water timer.
+ *
+ * @author David Goodyear - Initial contribution
+ */
+@NonNullByDefault
+public class WaterMeterStatus extends GatewayDeviceResponse {
+
+    public WaterMeterStatus() {
+    }
+
+    @Override
+    public ResultStatus getRes() {
+        if (super.getRes() == ResultStatus.INVALID) {
+            return ResultStatus.RET_SUCCESS;
+        }
+        return super.getRes();
+    }
+
+    public static class DeviceStatusClassTypeAdapter implements JsonDeserializer<List<DeviceStatus>> {
+        public @Nullable List<DeviceStatus> deserialize(JsonElement json, Type typeOfT,
+                JsonDeserializationContext ctx) {
+            List<DeviceStatus> vals = new ArrayList<>();
+            if (json.isJsonArray()) {
+                for (JsonElement e : json.getAsJsonArray()) {
+                    vals.add(ctx.deserialize(e, DeviceStatus.class));
+                }
+            } else if (json.isJsonObject()) {
+                vals.add(ctx.deserialize(json, DeviceStatus.class));
+            }
+            return vals;
+        }
+    }
+
+    /**
+     * Defines the device stat's for each device
+     */
+    @SerializedName("dev_stat")
+    @Expose
+    public List<DeviceStatus> deviceStatuses = new ArrayList<DeviceStatus>();
+
+    public static class DeviceStatus implements IPayloadValidator {
+        /**
+         * Defines the targetted device ID
+         */
+        @SerializedName("dev_id")
+        @Expose
+        public String deviceId = EMPTY_STRING;
+
+        /**
+         * Defines the currently active plan (Operating Mode)
+         */
+        @SerializedName("plan_mode")
+        @Expose
+        public @Nullable Integer planMode;
+
+        /**
+         * Defines the serial number of the currently active plan
+         */
+        @SerializedName("plan_sn")
+        @Expose
+        public int planSerialNo = DEFAULT_INT;
+
+        /**
+         * Defines if the water timer is connected to the Gateway
+         */
+        @SerializedName("is_rf_linked")
+        @Expose
+        public @Nullable Boolean isRfLinked;
+
+        /**
+         * Defines whether the flow meter is plugin
+         */
+        @SerializedName("is_flm_plugin")
+        @Expose
+        public @Nullable Boolean isFlmPlugin;
+
+        /**
+         * Water timer fall alert status
+         */
+        @SerializedName("is_fall")
+        @Expose
+        public @Nullable Boolean isFall;
+
+        /**
+         * Valve shut-down failure alert status
+         */
+        @SerializedName("is_broken")
+        @Expose
+        public @Nullable Boolean isBroken;
+
+        /**
+         * Water cut-off alert status
+         */
+        @SerializedName("is_cutoff")
+        @Expose
+        public @Nullable Boolean isCutoff;
+
+        /**
+         * Unusually high flow alert status
+         */
+        @SerializedName("is_leak")
+        @Expose
+        public @Nullable Boolean isLeak;
+
+        /**
+         * Unusually low flow alert status
+         */
+        @SerializedName("is_clog")
+        @Expose
+        public @Nullable Boolean isClog;
+
+        /**
+         * Water timer signal reception level
+         */
+        @SerializedName("signal")
+        @Expose
+        public @Nullable Integer signal;
+
+        /**
+         * Water timer battery level
+         */
+        @SerializedName("battery")
+        @Expose
+        public @Nullable Integer battery;
+
+        /**
+         * Defines the lock in operation
+         */
+        @SerializedName("child_lock")
+        @Expose
+        public @Nullable Integer childLock;
+
+        /**
+         * Is manual watering currently on
+         */
+        @SerializedName("is_manual_mode")
+        @Expose
+        public @Nullable Boolean isManualMode;
+
+        /**
+         * Is watering currently on
+         */
+        @SerializedName("is_watering")
+        @Expose
+        public @Nullable Boolean isWatering = false;
+
+        /**
+         * When the ECO mode is enabled, the watering duration is divided into multiple "on-off-on-off" segments.
+         * If is_final is true,it means current watering belongs to the last segment. If both is_watering and is_final
+         * are false,it means that the watering is currently suspended (i.e. in midst of the segments), and there are
+         * subsequent watering seqments to be executed.
+         */
+        @SerializedName("is_final")
+        @Expose
+        public @Nullable Boolean isFinal;
+
+        /**
+         * The duration of the current watering cycle in seconds
+         */
+        @SerializedName("total_duration")
+        @Expose
+        public @Nullable Integer totalDuration;
+
+        /**
+         * The remaining duration of the current watering cycle in seconds
+         */
+        @SerializedName("remain_duration")
+        @Expose
+        public @Nullable Integer remainDuration;
+
+        /**
+         * The failsafe duration of the current watering cycle in seconds
+         */
+        @SerializedName("failsafe_duration")
+        @Expose
+        public @Nullable Integer failsafeDuration;
+
+        /**
+         * The current water flow rate (LPN or GPM)
+         */
+        @SerializedName("speed")
+        @Expose
+        public @Nullable Double speed = 0.0d;
+
+        /**
+         * The accumulated volume of the current watering cycle (Litre or Gallon)
+         */
+        @SerializedName("volume")
+        @Expose
+        public @Nullable Double volume = 0.0d;
+
+        /**
+         * The volume limit of the current watering cycle (Litre or Gallon)
+         */
+        @SerializedName("volume_limit")
+        @Expose
+        public @Nullable Double volumeLimit = 0.0d;
+
+        public String isValid() {
+            final Integer planModeRaw = planMode;
+            if (planModeRaw == null || planModeRaw < 1 || planModeRaw > OP_MODE_DESC.length) {
+                return "planMode not in range 1 -> " + OP_MODE_DESC.length;
+            }
+
+            final Integer signalRaw = signal;
+            if (signalRaw == null || signalRaw < 0 || signalRaw > 100) {
+                return "signal not in range 0 -> 100";
+            }
+            final Integer batteryRaw = battery;
+            if (batteryRaw == null || batteryRaw < 0 || batteryRaw > 100) {
+                return "battery not in range 0 -> 100";
+            }
+            if (planSerialNo == DEFAULT_INT) {
+                return "planSerialNo invalid";
+            }
+            final Integer childLockRaw = childLock;
+            if (childLockRaw == null || childLockRaw < LockReq.LOCK_UNLOCKED || childLockRaw > LockReq.LOCK_FULL) {
+                return "childLock not in range " + LockReq.LOCK_UNLOCKED + " -> " + LockReq.LOCK_FULL;
+            }
+            if (!DEVICE_ID_PATTERN.matcher(deviceId).matches()) {
+                return "deviceId invalid";
+            }
+
+            return EMPTY_STRING;
+        }
+    }
+
+    public String isValid() {
+        return super.isValid();
+    }
+
+    public static final int OP_MODE_INSTANT = 1;
+
+    public static final int OP_MODE_CALENDAR = 2;
+
+    public static final int OP_MODE_WEEK_TIMER = 3;
+
+    public static final int OP_MODE_ODD_EVEN = 4;
+
+    public static final int OP_MODE_INTERVAL = 5;
+
+    public static final int OP_MODE_MONTH = 6;
+
+    public static final String[] OP_MODE_DESC = new String[] { "Instant Mode", "Calendar Mode", "7 Day Mode",
+            "Odd-Even Mode", "Interval Mode", "Month Mode" };
+}
diff --git a/bundles/org.openhab.binding.linktap/src/main/java/org/openhab/binding/linktap/protocol/frames/WateringSkippedNotification.java b/bundles/org.openhab.binding.linktap/src/main/java/org/openhab/binding/linktap/protocol/frames/WateringSkippedNotification.java
new file mode 100644
index 0000000000000..62e6bddcd3011
--- /dev/null
+++ b/bundles/org.openhab.binding.linktap/src/main/java/org/openhab/binding/linktap/protocol/frames/WateringSkippedNotification.java
@@ -0,0 +1,65 @@
+/**
+ * Copyright (c) 2010-2024 Contributors to the openHAB project
+ *
+ * See the NOTICE file(s) distributed with this work for additional
+ * information.
+ *
+ * This program and the accompanying materials are made available under the
+ * terms of the Eclipse Public License 2.0 which is available at
+ * http://www.eclipse.org/legal/epl-2.0
+ *
+ * SPDX-License-Identifier: EPL-2.0
+ */
+package org.openhab.binding.linktap.protocol.frames;
+
+import org.eclipse.jdt.annotation.NonNullByDefault;
+
+import com.google.gson.annotations.Expose;
+import com.google.gson.annotations.SerializedName;
+
+/**
+ * The {@link WateringSkippedNotification} defines the request to dismiss alerts from a given device.
+ *
+ * @author David Goodyear - Initial contribution
+ */
+@NonNullByDefault
+public class WateringSkippedNotification extends DeviceCmdReq {
+
+    public WateringSkippedNotification() {
+    }
+
+    /**
+     * Defines the past rainfall [0] and future rainfull [1] measurements in mm
+     */
+    @SerializedName("rain")
+    @Expose
+    public double[] rainfallData = new double[] { 0.0, 0.0 };
+
+    public void setPastRainfall(final double pastRainMM) {
+        rainfallData[0] = pastRainMM;
+    }
+
+    public double getPastRainfall() {
+        return rainfallData[0];
+    }
+
+    public void setFutureRainfall(final double futureRainMM) {
+        rainfallData[1] = futureRainMM;
+    }
+
+    public double getFutureRainfall() {
+        return rainfallData[1];
+    }
+
+    public String isValid() {
+        final String superRst = super.isValid();
+        if (!superRst.isEmpty()) {
+            return superRst;
+        }
+        if (rainfallData.length != 2) {
+            return "rainfallData invalid length";
+        }
+
+        return EMPTY_STRING;
+    }
+}
diff --git a/bundles/org.openhab.binding.linktap/src/main/java/org/openhab/binding/linktap/protocol/frames/WirelessTestResp.java b/bundles/org.openhab.binding.linktap/src/main/java/org/openhab/binding/linktap/protocol/frames/WirelessTestResp.java
new file mode 100644
index 0000000000000..7815801966d8a
--- /dev/null
+++ b/bundles/org.openhab.binding.linktap/src/main/java/org/openhab/binding/linktap/protocol/frames/WirelessTestResp.java
@@ -0,0 +1,72 @@
+/**
+ * Copyright (c) 2010-2024 Contributors to the openHAB project
+ *
+ * See the NOTICE file(s) distributed with this work for additional
+ * information.
+ *
+ * This program and the accompanying materials are made available under the
+ * terms of the Eclipse Public License 2.0 which is available at
+ * http://www.eclipse.org/legal/epl-2.0
+ *
+ * SPDX-License-Identifier: EPL-2.0
+ */
+package org.openhab.binding.linktap.protocol.frames;
+
+import org.eclipse.jdt.annotation.NonNullByDefault;
+
+import com.google.gson.annotations.Expose;
+import com.google.gson.annotations.SerializedName;
+
+/**
+ * The {@link WirelessTestResp} defines the wireless test result data response
+ *
+ * @author David Goodyear - Initial contribution
+ */
+@NonNullByDefault
+public class WirelessTestResp extends EndpointDeviceResponse {
+
+    public WirelessTestResp() {
+    }
+
+    /**
+     * Defines true if the last packet has been transmitted and
+     * therefore the test is complete
+     */
+    @SerializedName("final")
+    @Expose
+    public boolean testComplete = false;
+
+    /**
+     * Defines how many pings have been sent to the endpoint device
+     */
+    @SerializedName("ping")
+    @Expose
+    public int pingCount = DEFAULT_INT;
+
+    /**
+     * Defines how many pongs have been received from the endpoint device
+     */
+    @SerializedName("pong")
+    @Expose
+    public int pongCount = DEFAULT_INT;
+
+    public String isValid() {
+        final String superRst = super.isValid();
+        if (!superRst.isEmpty()) {
+            return superRst;
+        }
+        if (pingCount == DEFAULT_INT) {
+            return "pingCount invalid";
+        }
+
+        if (pongCount == DEFAULT_INT) {
+            return "pongCount invalid";
+        }
+
+        if (!DEVICE_ID_PATTERN.matcher(deviceId).matches()) {
+            return "DeviceId invalid";
+        }
+
+        return EMPTY_STRING;
+    }
+}
diff --git a/bundles/org.openhab.binding.linktap/src/main/java/org/openhab/binding/linktap/protocol/http/CommandNotSupportedException.java b/bundles/org.openhab.binding.linktap/src/main/java/org/openhab/binding/linktap/protocol/http/CommandNotSupportedException.java
new file mode 100644
index 0000000000000..9c26cf4ec4aa5
--- /dev/null
+++ b/bundles/org.openhab.binding.linktap/src/main/java/org/openhab/binding/linktap/protocol/http/CommandNotSupportedException.java
@@ -0,0 +1,50 @@
+/**
+ * Copyright (c) 2010-2024 Contributors to the openHAB project
+ *
+ * See the NOTICE file(s) distributed with this work for additional
+ * information.
+ *
+ * This program and the accompanying materials are made available under the
+ * terms of the Eclipse Public License 2.0 which is available at
+ * http://www.eclipse.org/legal/epl-2.0
+ *
+ * SPDX-License-Identifier: EPL-2.0
+ */
+package org.openhab.binding.linktap.protocol.http;
+
+import java.io.Serial;
+
+import org.eclipse.jdt.annotation.NonNullByDefault;
+import org.openhab.binding.linktap.protocol.frames.GatewayDeviceResponse;
+
+/**
+ * The {@link CommandNotSupportedException} should be thrown when the endpoint being communicated with
+ * does not appear to be a Tap Link Gateway device.
+ *
+ * @author David Goodyear - Initial contribution
+ */
+@NonNullByDefault
+public class CommandNotSupportedException extends Exception {
+    @Serial
+    private static final long serialVersionUID = -7784829325604153947L;
+
+    public CommandNotSupportedException() {
+        super();
+    }
+
+    public CommandNotSupportedException(final String message) {
+        super(message);
+    }
+
+    public CommandNotSupportedException(final Throwable cause) {
+        super(cause);
+    }
+
+    public CommandNotSupportedException(final String message, final Throwable cause) {
+        super(message, cause);
+    }
+
+    public CommandNotSupportedException(final GatewayDeviceResponse.ResultStatus rs) {
+        super(rs.getDesc());
+    }
+}
diff --git a/bundles/org.openhab.binding.linktap/src/main/java/org/openhab/binding/linktap/protocol/http/DeviceIdException.java b/bundles/org.openhab.binding.linktap/src/main/java/org/openhab/binding/linktap/protocol/http/DeviceIdException.java
new file mode 100644
index 0000000000000..cd7475f737f85
--- /dev/null
+++ b/bundles/org.openhab.binding.linktap/src/main/java/org/openhab/binding/linktap/protocol/http/DeviceIdException.java
@@ -0,0 +1,53 @@
+/**
+ * Copyright (c) 2010-2024 Contributors to the openHAB project
+ *
+ * See the NOTICE file(s) distributed with this work for additional
+ * information.
+ *
+ * This program and the accompanying materials are made available under the
+ * terms of the Eclipse Public License 2.0 which is available at
+ * http://www.eclipse.org/legal/epl-2.0
+ *
+ * SPDX-License-Identifier: EPL-2.0
+ */
+package org.openhab.binding.linktap.protocol.http;
+
+import java.io.Serial;
+
+import org.eclipse.jdt.annotation.NonNullByDefault;
+import org.openhab.binding.linktap.protocol.frames.GatewayDeviceResponse;
+
+/**
+ * The {@link DeviceIdException} should be thrown when the endpoint being communicated with
+ * does not appear to be a Tap Link Gateway device.
+ *
+ * @author David Goodyear - Initial contribution
+ */
+@NonNullByDefault
+public class DeviceIdException extends Exception {
+    @Serial
+    private static final long serialVersionUID = -7786449325604153947L;
+
+    // case RET_DEVICE_ID_ERROR:
+    // case RET_DEVICE_NOT_FOUND:
+
+    public DeviceIdException() {
+        super();
+    }
+
+    public DeviceIdException(final String message) {
+        super(message);
+    }
+
+    public DeviceIdException(final Throwable cause) {
+        super(cause);
+    }
+
+    public DeviceIdException(final String message, final Throwable cause) {
+        super(message, cause);
+    }
+
+    public DeviceIdException(final GatewayDeviceResponse.ResultStatus rs) {
+        super(rs.getDesc());
+    }
+}
diff --git a/bundles/org.openhab.binding.linktap/src/main/java/org/openhab/binding/linktap/protocol/http/GatewayIdException.java b/bundles/org.openhab.binding.linktap/src/main/java/org/openhab/binding/linktap/protocol/http/GatewayIdException.java
new file mode 100644
index 0000000000000..04a2097d77725
--- /dev/null
+++ b/bundles/org.openhab.binding.linktap/src/main/java/org/openhab/binding/linktap/protocol/http/GatewayIdException.java
@@ -0,0 +1,53 @@
+/**
+ * Copyright (c) 2010-2024 Contributors to the openHAB project
+ *
+ * See the NOTICE file(s) distributed with this work for additional
+ * information.
+ *
+ * This program and the accompanying materials are made available under the
+ * terms of the Eclipse Public License 2.0 which is available at
+ * http://www.eclipse.org/legal/epl-2.0
+ *
+ * SPDX-License-Identifier: EPL-2.0
+ */
+package org.openhab.binding.linktap.protocol.http;
+
+import java.io.Serial;
+
+import org.eclipse.jdt.annotation.NonNullByDefault;
+import org.openhab.binding.linktap.protocol.frames.GatewayDeviceResponse;
+
+/**
+ * The {@link GatewayIdException} should be thrown when the endpoint being communicated with
+ * does not appear to be a Tap Link Gateway device.
+ *
+ * @author David Goodyear - Initial contribution
+ */
+@NonNullByDefault
+public class GatewayIdException extends Exception {
+    @Serial
+    private static final long serialVersionUID = -7786449325604153947L;
+
+    // case RET_DEVICE_ID_ERROR:
+    // case RET_DEVICE_NOT_FOUND:
+
+    public GatewayIdException() {
+        super();
+    }
+
+    public GatewayIdException(final String message) {
+        super(message);
+    }
+
+    public GatewayIdException(final Throwable cause) {
+        super(cause);
+    }
+
+    public GatewayIdException(final String message, final Throwable cause) {
+        super(message, cause);
+    }
+
+    public GatewayIdException(final GatewayDeviceResponse.ResultStatus rs) {
+        super(rs.getDesc());
+    }
+}
diff --git a/bundles/org.openhab.binding.linktap/src/main/java/org/openhab/binding/linktap/protocol/http/InvalidParameterException.java b/bundles/org.openhab.binding.linktap/src/main/java/org/openhab/binding/linktap/protocol/http/InvalidParameterException.java
new file mode 100644
index 0000000000000..ad502b535cd43
--- /dev/null
+++ b/bundles/org.openhab.binding.linktap/src/main/java/org/openhab/binding/linktap/protocol/http/InvalidParameterException.java
@@ -0,0 +1,50 @@
+/**
+ * Copyright (c) 2010-2024 Contributors to the openHAB project
+ *
+ * See the NOTICE file(s) distributed with this work for additional
+ * information.
+ *
+ * This program and the accompanying materials are made available under the
+ * terms of the Eclipse Public License 2.0 which is available at
+ * http://www.eclipse.org/legal/epl-2.0
+ *
+ * SPDX-License-Identifier: EPL-2.0
+ */
+package org.openhab.binding.linktap.protocol.http;
+
+import java.io.Serial;
+
+import org.eclipse.jdt.annotation.NonNullByDefault;
+import org.openhab.binding.linktap.protocol.frames.GatewayDeviceResponse;
+
+/**
+ * The {@link InvalidParameterException} should be thrown when the endpoint being communicated with
+ * does not appear to be a Tap Link Gateway device.
+ *
+ * @author David Goodyear - Initial contribution
+ */
+@NonNullByDefault
+public class InvalidParameterException extends Exception {
+    @Serial
+    private static final long serialVersionUID = -7784829499604153947L;
+
+    public InvalidParameterException() {
+        super();
+    }
+
+    public InvalidParameterException(final String message) {
+        super(message);
+    }
+
+    public InvalidParameterException(final Throwable cause) {
+        super(cause);
+    }
+
+    public InvalidParameterException(final String message, final Throwable cause) {
+        super(message, cause);
+    }
+
+    public InvalidParameterException(final GatewayDeviceResponse.ResultStatus rs) {
+        super(rs.getDesc());
+    }
+}
diff --git a/bundles/org.openhab.binding.linktap/src/main/java/org/openhab/binding/linktap/protocol/http/NotTapLinkGatewayException.java b/bundles/org.openhab.binding.linktap/src/main/java/org/openhab/binding/linktap/protocol/http/NotTapLinkGatewayException.java
new file mode 100644
index 0000000000000..52f30fa90e784
--- /dev/null
+++ b/bundles/org.openhab.binding.linktap/src/main/java/org/openhab/binding/linktap/protocol/http/NotTapLinkGatewayException.java
@@ -0,0 +1,51 @@
+/**
+ * Copyright (c) 2010-2024 Contributors to the openHAB project
+ *
+ * See the NOTICE file(s) distributed with this work for additional
+ * information.
+ *
+ * This program and the accompanying materials are made available under the
+ * terms of the Eclipse Public License 2.0 which is available at
+ * http://www.eclipse.org/legal/epl-2.0
+ *
+ * SPDX-License-Identifier: EPL-2.0
+ */
+package org.openhab.binding.linktap.protocol.http;
+
+import java.io.Serial;
+
+import org.eclipse.jdt.annotation.NonNullByDefault;
+
+/**
+ * The {@link NotTapLinkGatewayException} should be thrown when the endpoint being communicated with
+ * does not appear to be a Tap Link Gateway device.
+ *
+ * @author David Goodyear - Initial contribution
+ */
+@NonNullByDefault
+public class NotTapLinkGatewayException extends Exception {
+    @Serial
+    private static final long serialVersionUID = -7786449325604153487L;
+
+    public NotTapLinkGatewayException() {
+        super();
+    }
+
+    public NotTapLinkGatewayException(final String message) {
+        super(message);
+    }
+
+    public NotTapLinkGatewayException(final Throwable cause) {
+        super(cause);
+    }
+
+    public NotTapLinkGatewayException(final String message, final Throwable cause) {
+        super(message, cause);
+    }
+
+    public static final String HEADERS_MISSING = "Missing header markers";
+    public static final String MISSING_API_TITLE = "Not a LinkTap API response";
+    public static final String MISSING_SERVER_TITLE = "Not a LinkTap response";
+    public static final String UNEXPECTED_STATUS_CODE = "Unexpected status code response";
+    public static final String UNEXPECTED_HTTPS = "Unexpected protocol";
+}
diff --git a/bundles/org.openhab.binding.linktap/src/main/java/org/openhab/binding/linktap/protocol/http/TransientCommunicationIssueException.java b/bundles/org.openhab.binding.linktap/src/main/java/org/openhab/binding/linktap/protocol/http/TransientCommunicationIssueException.java
new file mode 100644
index 0000000000000..6fd01b8778436
--- /dev/null
+++ b/bundles/org.openhab.binding.linktap/src/main/java/org/openhab/binding/linktap/protocol/http/TransientCommunicationIssueException.java
@@ -0,0 +1,49 @@
+/**
+ * Copyright (c) 2010-2024 Contributors to the openHAB project
+ *
+ * See the NOTICE file(s) distributed with this work for additional
+ * information.
+ *
+ * This program and the accompanying materials are made available under the
+ * terms of the Eclipse Public License 2.0 which is available at
+ * http://www.eclipse.org/legal/epl-2.0
+ *
+ * SPDX-License-Identifier: EPL-2.0
+ */
+package org.openhab.binding.linktap.protocol.http;
+
+import java.io.Serial;
+
+import org.eclipse.jdt.annotation.NonNullByDefault;
+
+/**
+ * The {@link TransientCommunicationIssueException} should be thrown when the endpoint being communicated with
+ * does not appear to be a Tap Link Gateway device.
+ *
+ * @author David Goodyear - Initial contribution
+ */
+@NonNullByDefault
+public class TransientCommunicationIssueException extends Exception {
+    @Serial
+    private static final long serialVersionUID = -7786449325604143287L;
+
+    public TransientCommunicationIssueException() {
+        super();
+    }
+
+    public TransientCommunicationIssueException(final String message) {
+        super(message);
+    }
+
+    public TransientCommunicationIssueException(final Throwable cause) {
+        super(cause);
+    }
+
+    public TransientCommunicationIssueException(final String message, final Throwable cause) {
+        super(message, cause);
+    }
+
+    public static final String HOST_UNREACHABLE = "Could not connect";
+    public static final String HOST_NOT_RESOLVED = "Could not resolve IP address";
+    public static final String HOST_COMM_TIMEOUT = "Communications Lost";
+}
diff --git a/bundles/org.openhab.binding.linktap/src/main/java/org/openhab/binding/linktap/protocol/http/WebServerApi.java b/bundles/org.openhab.binding.linktap/src/main/java/org/openhab/binding/linktap/protocol/http/WebServerApi.java
new file mode 100644
index 0000000000000..491aa1c1da634
--- /dev/null
+++ b/bundles/org.openhab.binding.linktap/src/main/java/org/openhab/binding/linktap/protocol/http/WebServerApi.java
@@ -0,0 +1,501 @@
+/**
+ * Copyright (c) 2010-2024 Contributors to the openHAB project
+ *
+ * See the NOTICE file(s) distributed with this work for additional
+ * information.
+ *
+ * This program and the accompanying materials are made available under the
+ * terms of the Eclipse Public License 2.0 which is available at
+ * http://www.eclipse.org/legal/epl-2.0
+ *
+ * SPDX-License-Identifier: EPL-2.0
+ */
+package org.openhab.binding.linktap.protocol.http;
+
+import static javax.ws.rs.core.MediaType.APPLICATION_JSON_TYPE;
+import static org.openhab.binding.linktap.internal.LinkTapBindingConstants.BRIDGE_HTTP_API_ENABLED;
+import static org.openhab.binding.linktap.internal.LinkTapBindingConstants.BRIDGE_HTTP_API_EP;
+import static org.openhab.binding.linktap.internal.LinkTapBindingConstants.BRIDGE_PROP_GW_ID;
+import static org.openhab.binding.linktap.internal.LinkTapBindingConstants.BRIDGE_PROP_GW_VER;
+import static org.openhab.binding.linktap.internal.LinkTapBindingConstants.BRIDGE_PROP_HW_MODEL;
+import static org.openhab.binding.linktap.internal.LinkTapBindingConstants.BRIDGE_PROP_MAC_ADDR;
+import static org.openhab.binding.linktap.internal.LinkTapBindingConstants.BRIDGE_PROP_VOL_UNIT;
+import static org.openhab.binding.linktap.protocol.http.NotTapLinkGatewayException.*;
+import static org.openhab.binding.linktap.protocol.http.TransientCommunicationIssueException.*;
+
+import java.net.HttpURLConnection;
+import java.net.InetAddress;
+import java.net.SocketTimeoutException;
+import java.net.URLDecoder;
+import java.net.URLEncoder;
+import java.net.UnknownHostException;
+import java.nio.charset.StandardCharsets;
+import java.util.HashMap;
+import java.util.Map;
+import java.util.Optional;
+import java.util.concurrent.ExecutionException;
+import java.util.concurrent.TimeUnit;
+import java.util.concurrent.TimeoutException;
+
+import javax.net.ssl.SSLHandshakeException;
+import javax.ws.rs.HttpMethod;
+
+import org.eclipse.jdt.annotation.NonNullByDefault;
+import org.eclipse.jdt.annotation.Nullable;
+import org.eclipse.jetty.client.HttpClient;
+import org.eclipse.jetty.client.api.ContentResponse;
+import org.eclipse.jetty.client.api.Request;
+import org.eclipse.jetty.client.util.FormContentProvider;
+import org.eclipse.jetty.client.util.StringContentProvider;
+import org.eclipse.jetty.http.HttpFields;
+import org.jsoup.Jsoup;
+import org.jsoup.nodes.Document;
+import org.jsoup.nodes.Element;
+import org.jsoup.select.Elements;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
+/**
+ * The {@link WebServerApi} defines interactions with the web server interface.
+ *
+ * @author David Goodyear - Initial contribution
+ */
+@NonNullByDefault
+public final class WebServerApi {
+
+    private final Logger logger = LoggerFactory.getLogger(WebServerApi.class);
+
+    private @NonNullByDefault({}) HttpClient httpClient;
+
+    private static final int REQ_TIMEOUT_SECONDS = 3;
+
+    private static final WebServerApi INSTANCE = new WebServerApi();
+
+    private WebServerApi() {
+    }
+
+    public static WebServerApi getInstance() {
+        return INSTANCE;
+    }
+
+    /**
+     * Sets the httpClient object to be used for API calls to Vesync.
+     *
+     * @param httpClient the client to be used.
+     */
+    public void setHttpClient(@Nullable HttpClient httpClient) {
+        if (httpClient != null) {
+            this.httpClient = httpClient;
+        }
+    }
+
+    public Map<String, String> getBridgeProperities(final String hostname)
+            throws NotTapLinkGatewayException, TransientCommunicationIssueException {
+        try {
+            final Request request = httpClient.newRequest(URI_HOST_PREFIX + hostname).method(HttpMethod.GET);
+            final ContentResponse cr = request.timeout(REQ_TIMEOUT_SECONDS, TimeUnit.SECONDS).send();
+            if (HttpURLConnection.HTTP_OK != cr.getStatus()) {
+                throw new NotTapLinkGatewayException(UNEXPECTED_STATUS_CODE);
+            }
+            validateHeaders(cr.getHeaders());
+            final String responseData = cr.getContentAsString();
+            final Document doc = Jsoup.parse(responseData);
+
+            switch (doc.title()) {
+                case TITLE_API_CONFIG_PAGE:
+                    break;
+                case TITLE_API_LOGIN_PAGE:
+                    return Map.of();
+                default:
+                    throw new NotTapLinkGatewayException(MISSING_SERVER_TITLE);
+            }
+            getMdnsEnableArgs(doc);
+            return getMetadataProperties(doc);
+
+        } catch (InterruptedException | TimeoutException e) {
+            throw new TransientCommunicationIssueException(HOST_COMM_TIMEOUT);
+        } catch (ExecutionException e) {
+            final Throwable t = e.getCause();
+            if (t instanceof UnknownHostException) {
+                throw new TransientCommunicationIssueException(HOST_NOT_RESOLVED);
+            } else if (t instanceof SocketTimeoutException) {
+                throw new TransientCommunicationIssueException(HOST_UNREACHABLE);
+            } else if (t instanceof SSLHandshakeException) {
+                throw new NotTapLinkGatewayException(UNEXPECTED_HTTPS);
+            } else {
+                logger.warn("ExecutionException -> {}", e.getMessage());
+            }
+            throw new NotTapLinkGatewayException("Unexpected failure -> " + e.getMessage());
+        }
+    }
+
+    /**
+     * Extract the common properties for all devices, from the given meta-data of a device.
+     *
+     * @param doc the html document returns from the potential Gateway device
+     * @return Map of common props
+     */
+    private Map<String, String> getMetadataProperties(final Document doc) {
+        final Map<String, String> newProps = new HashMap<>(4);
+
+        /*
+         * Extract elements based on td location using the text markers
+         */
+        String firmwareVer = "?";
+        String hwModel = "?";
+        String id = "?";
+        String macAddr = "?";
+
+        final org.jsoup.select.Elements tdEntries = doc.getElementsByTag("td");
+        for (int i = 0; i < tdEntries.size(); ++i) {
+            if (tdEntries.get(i).hasText()) {
+                switch (tdEntries.get(i).text()) {
+                    case "Firmware version":
+                        firmwareVer = tdEntries.get(i + 1).text();
+                        i++;
+                        break;
+                    case "Model":
+                        hwModel = tdEntries.get(i + 1).text();
+                        i++;
+                        break;
+                    case "ID":
+                        id = tdEntries.get(i + 1).text();
+                        i++;
+                        break;
+                    case "MAC address":
+                        macAddr = tdEntries.get(i + 1).text();
+                        i++;
+                        break;
+
+                }
+            }
+        }
+
+        newProps.put(BRIDGE_PROP_GW_ID, id.split("[-]")[0]);
+        newProps.put(BRIDGE_PROP_GW_VER, firmwareVer.split("[_]")[0]);
+        newProps.put(BRIDGE_PROP_MAC_ADDR, macAddr);
+        newProps.put(BRIDGE_PROP_HW_MODEL, hwModel);
+
+        /*
+         * Extract elements based on name markers and attributes
+         */
+        final boolean httpApiEnabled = doc.getElementsByAttributeValue("name", "htapi").hasAttr("checked");
+        final String httpApiEndpoint = doc.getElementsByAttributeValue("name", "URL").attr("value");
+
+        newProps.put(BRIDGE_HTTP_API_ENABLED, String.valueOf(httpApiEnabled));
+        newProps.put(BRIDGE_HTTP_API_EP, httpApiEndpoint);
+
+        Optional<Element> vunitSelections = doc.getElementsByAttributeValue("name", "vunit").stream()
+                .filter(x -> x.hasAttr("checked")).findFirst();
+        if (vunitSelections.isPresent()) {
+            switch (vunitSelections.get().attr("value")) {
+                case "0":
+                    newProps.put(BRIDGE_PROP_VOL_UNIT, "L");
+                    break;
+                case "1":
+                    newProps.put(BRIDGE_PROP_VOL_UNIT, "gal");
+                    break;
+            }
+        }
+
+        return newProps;
+    }
+
+    public Optional<Element> getSection(final Document doc, final String title) {
+        final Elements thead = doc.getElementsByTag("thead");
+        Optional<Element> element = thead.stream()
+                .filter(x -> x.hasText() && x.text().toLowerCase().contains(title.toLowerCase())).findFirst();
+        if (element.isPresent()) {
+            return Optional.of(element.get().parent());
+        }
+        return Optional.empty();
+    }
+
+    public String getUriInputArg(final Element el) {
+        final StringBuilder sb = new StringBuilder();
+        switch (el.attr("type")) {
+            case "checkbox":
+                sb.append(el.attr("name"));
+                sb.append("=");
+                if (el.hasAttr("checked")) {
+                    sb.append(el.attr("value"));
+                } else {
+                    sb.append("0");
+                }
+                break;
+            case "radio":
+                if (el.hasAttr("checked")) {
+                    sb.append(el.attr("name"));
+                    sb.append("=");
+                    sb.append(el.attr("value"));
+                }
+                break;
+            case "text":
+                sb.append(el.attr("name"));
+                sb.append("=");
+                sb.append(URLDecoder.decode(el.attr("value"), StandardCharsets.UTF_8));
+        }
+        return sb.toString();
+    }
+
+    public String getMdnsEnableArgs(final Document doc) {
+        final Optional<Element> miscSection = getSection(doc, "Misc settings");
+        StringBuilder sb = new StringBuilder();
+
+        if (!miscSection.isPresent()) {
+            return sb.toString();
+        }
+        final Elements inputs = miscSection.get().getElementsByTag("input");
+        for (int i = 0; i < inputs.size(); ++i) {
+            final String val = getUriInputArg(inputs.get(i));
+            if (!val.isEmpty() && !sb.isEmpty()) {
+                sb.append("&");
+            }
+            sb.append(val);
+        }
+        // Change the mdns flag to true
+        {
+            final int mdnsIdx = sb.indexOf("mdns=0");
+            if (mdnsIdx != -1) {
+                sb.replace(mdnsIdx, mdnsIdx + 6, "mdns=1");
+                return sb.toString();
+            }
+        }
+
+        return "";
+    }
+
+    public String getLocalHttpApiArgs(final Document doc, final String targetServer) {
+        final Optional<Element> localHttpApiSection = getSection(doc, "Local HTTP API settings");
+        StringBuilder sb = new StringBuilder();
+
+        if (!localHttpApiSection.isPresent()) {
+            return sb.toString();
+        }
+        final Elements inputs = localHttpApiSection.get().getElementsByTag("input");
+        for (int i = 0; i < inputs.size(); ++i) {
+            final String val = getUriInputArg(inputs.get(i));
+            if (!val.isEmpty() && !sb.isEmpty()) {
+                sb.append("&");
+            }
+            sb.append(val);
+        }
+
+        // Change the enable Local HTTP API flag to true
+        final int enableApiIdx = sb.indexOf("htapi=0");
+        if (enableApiIdx != -1) {
+            sb.replace(enableApiIdx, enableApiIdx + 7, "htapi=1");
+        }
+
+        final int urlApiMarker = sb.indexOf("URL=");
+        boolean updatedUri = false;
+        if (urlApiMarker != -1) {
+            final int nextArg = sb.indexOf("&", urlApiMarker);
+            String urlArg = (nextArg == -1) ? sb.substring(urlApiMarker + 4) : sb.substring(urlApiMarker + 4, nextArg);
+            logger.trace("Found existing HTTP URL Server : {}", urlArg);
+            if (!urlArg.equals(targetServer)) {
+                updatedUri = true;
+                sb.replace(urlApiMarker, urlApiMarker + urlArg.length() + 4,
+                        "URL=" + URLEncoder.encode(targetServer, StandardCharsets.UTF_8));
+            }
+        }
+
+        if (enableApiIdx != -1 || updatedUri) {
+            return sb.toString();
+        }
+
+        return "";
+    }
+
+    public boolean configureBridge(final @Nullable String hostname, final Optional<Boolean> mdnsEnable,
+            final Optional<String> localServer)
+            throws NotTapLinkGatewayException, TransientCommunicationIssueException {
+        try {
+            if (hostname == null) {
+                throw new TransientCommunicationIssueException("Hostname invalid - null");
+            }
+            final Request request = httpClient.newRequest(URI_HOST_PREFIX + hostname).method(HttpMethod.GET);
+            final ContentResponse cr = request.timeout(REQ_TIMEOUT_SECONDS, TimeUnit.SECONDS).send();
+            if (HttpURLConnection.HTTP_OK != cr.getStatus()) {
+                throw new NotTapLinkGatewayException(UNEXPECTED_STATUS_CODE);
+            }
+            validateHeaders(cr.getHeaders());
+            final String responseData = cr.getContentAsString();
+            final Document doc = Jsoup.parse(responseData);
+
+            switch (doc.title()) {
+                case TITLE_API_CONFIG_PAGE:
+                    break;
+                case TITLE_API_LOGIN_PAGE:
+                    return false;
+                default:
+                    throw new NotTapLinkGatewayException(MISSING_SERVER_TITLE);
+            }
+            // Send the GET request to configure mdns if it's not enabled
+            boolean rebootReq = false;
+            if (mdnsEnable.isPresent() && mdnsEnable.get()) {
+                logger.trace("Enabling mdns server on gateway");
+                String mdnsEnableReqStr = this.getMdnsEnableArgs(doc);
+                if (!mdnsEnableReqStr.isEmpty()) {
+                    logger.debug("Updating mdns server settings on gateway");
+                    final Request mdnsRequest = httpClient
+                            .newRequest(URI_HOST_PREFIX + hostname + "/index.shtml?flag=4&" + mdnsEnableReqStr)
+                            .method(HttpMethod.GET);
+                    final ContentResponse mdnsCr = mdnsRequest.timeout(REQ_TIMEOUT_SECONDS, TimeUnit.SECONDS).send();
+                    if (HttpURLConnection.HTTP_OK != mdnsCr.getStatus()) {
+                        throw new NotTapLinkGatewayException(UNEXPECTED_STATUS_CODE);
+                    }
+                    rebootReq = true;
+                }
+            }
+
+            if (localServer.isPresent() && !localServer.get().isBlank()) {
+                logger.trace("Setting Local HTTP Api on gateway");
+                String localHttpApiReqStr = this.getLocalHttpApiArgs(doc, localServer.get());
+                if (!localHttpApiReqStr.isEmpty()) {
+                    logger.debug("Updating Local HTTP API server settings on gateway");
+                    final Request lhttpApiRequest = httpClient
+                            .newRequest(URI_HOST_PREFIX + hostname + "/index.shtml?flag=5&" + localHttpApiReqStr)
+                            .method(HttpMethod.GET);
+                    final ContentResponse mdnsCr = lhttpApiRequest.timeout(REQ_TIMEOUT_SECONDS, TimeUnit.SECONDS)
+                            .send();
+                    if (HttpURLConnection.HTTP_OK != mdnsCr.getStatus()) {
+                        throw new NotTapLinkGatewayException(UNEXPECTED_STATUS_CODE);
+                    }
+                    rebootReq = true;
+                }
+            }
+
+            if (rebootReq) {
+                logger.debug("Rebooting gateway to apply new settings");
+                final Request restartReq = httpClient.newRequest(URI_HOST_PREFIX + hostname + "/index.shtml?flag=0")
+                        .method(HttpMethod.GET);
+                final ContentResponse mdnsCr = restartReq.timeout(REQ_TIMEOUT_SECONDS, TimeUnit.SECONDS).send();
+                if (HttpURLConnection.HTTP_OK != mdnsCr.getStatus()) {
+                    throw new NotTapLinkGatewayException(UNEXPECTED_STATUS_CODE);
+                }
+            }
+
+            return rebootReq;
+
+        } catch (InterruptedException | TimeoutException e) {
+            throw new TransientCommunicationIssueException(HOST_COMM_TIMEOUT);
+        } catch (ExecutionException e) {
+            final Throwable t = e.getCause();
+            if (t instanceof UnknownHostException) {
+                throw new TransientCommunicationIssueException(HOST_NOT_RESOLVED);
+            } else if (t instanceof SocketTimeoutException) {
+                throw new TransientCommunicationIssueException(HOST_UNREACHABLE);
+            } else if (t instanceof SSLHandshakeException) {
+                throw new NotTapLinkGatewayException(UNEXPECTED_HTTPS);
+            } else {
+                logger.warn("ExecutionException -> {}", e.getMessage());
+            }
+            throw new NotTapLinkGatewayException("Unexpected failure -> " + e.getMessage());
+        }
+    }
+
+    public boolean unlockWebInterface(final String hostname, final String username, final String password)
+            throws NotTapLinkGatewayException, TransientCommunicationIssueException {
+        try {
+            org.eclipse.jetty.util.Fields fields = new org.eclipse.jetty.util.Fields();
+            fields.put(FIELD_ADMIN_USER, username);
+            fields.put(FIELD_ADMIN_USER_PWD, password);
+            final Request request = httpClient.newRequest(URI_HOST_PREFIX + hostname + "/login.shtml")
+                    .method(HttpMethod.POST).content(new FormContentProvider(fields));
+            final ContentResponse cr = request.timeout(REQ_TIMEOUT_SECONDS, TimeUnit.SECONDS).send();
+            if (HttpURLConnection.HTTP_OK != cr.getStatus()) {
+                throw new NotTapLinkGatewayException(UNEXPECTED_STATUS_CODE);
+            }
+            validateHeaders(cr.getHeaders());
+            return !getBridgeProperities(hostname).isEmpty();
+        } catch (InterruptedException | TimeoutException e) {
+            throw new TransientCommunicationIssueException(HOST_COMM_TIMEOUT);
+        } catch (ExecutionException e) {
+            final Throwable t = e.getCause();
+            if (t instanceof UnknownHostException) {
+                throw new TransientCommunicationIssueException(HOST_NOT_RESOLVED);
+            } else if (t instanceof SocketTimeoutException) {
+                throw new TransientCommunicationIssueException(HOST_UNREACHABLE);
+            } else if (t instanceof SSLHandshakeException) {
+                throw new NotTapLinkGatewayException(UNEXPECTED_HTTPS);
+            } else {
+                logger.warn("ExecutionException -> {}", e.getMessage());
+            }
+            throw new NotTapLinkGatewayException("Unexpected failure -> " + e.getMessage());
+        }
+    }
+
+    /**
+     * Returns whether a response from the HTTP endpoint reached, appears to have the correct
+     * header markers for a Link Tap Gateway device.
+     *
+     * @param headers the http headers from the response to be checked
+     * @throws NotTapLinkGatewayException if the response does not appear to be from a Link Tap Gateway
+     */
+    private void validateHeaders(final HttpFields headers) throws NotTapLinkGatewayException {
+        if (!headers.contains(HEADER_SERVER, HEADER_GW_SERVER_NAME)) {
+            throw new NotTapLinkGatewayException(HEADERS_MISSING);
+        }
+    }
+
+    public String sendRequest(final String hostname, final String requestBody)
+            throws NotTapLinkGatewayException, TransientCommunicationIssueException {
+        try {
+            final InetAddress address = InetAddress.getByName(hostname);
+            logger.trace("API Endpoint: {}", URI_HOST_PREFIX + address.getHostAddress() + "/api.shtml");
+            final Request request = httpClient.POST(URI_HOST_PREFIX + address.getHostAddress() + "/api.shtml");
+            request.content(new StringContentProvider(requestBody), APPLICATION_JSON_TYPE.toString());
+
+            final ContentResponse cr = request.timeout(REQ_TIMEOUT_SECONDS, TimeUnit.SECONDS).send();
+            if (HttpURLConnection.HTTP_OK != cr.getStatus()) {
+                throw new NotTapLinkGatewayException(UNEXPECTED_STATUS_CODE);
+            }
+            validateHeaders(cr.getHeaders());
+            String responseData = cr.getContentAsString();
+            final Document doc = Jsoup.parse(responseData);
+            final String docTitle = doc.title();
+            if (!docTitle.equals(TITLE_API_RESPONSE)) {
+                throw new NotTapLinkGatewayException(MISSING_API_TITLE);
+            }
+            responseData = doc.body().text();
+            return responseData;
+        } catch (InterruptedException | TimeoutException | UnknownHostException e) {
+            throw new TransientCommunicationIssueException(HOST_COMM_TIMEOUT);
+        } catch (ExecutionException e) {
+            final Throwable t = e.getCause();
+            if (t instanceof UnknownHostException) {
+                throw new TransientCommunicationIssueException(HOST_NOT_RESOLVED);
+            } else if (t instanceof SocketTimeoutException) {
+                throw new TransientCommunicationIssueException(HOST_UNREACHABLE);
+            } else if (t instanceof SSLHandshakeException) {
+                throw new NotTapLinkGatewayException(UNEXPECTED_HTTPS);
+            } else {
+                logger.warn("ExecutionException -> {}", e.getMessage());
+            }
+            throw new NotTapLinkGatewayException("Unexpected failure -> " + e.getMessage());
+        }
+    }
+
+    public static final String URI_SCHEME = "http";
+    public static final String URI_HOST_PREFIX = URI_SCHEME + "://";
+
+    /**
+     * Headers
+     */
+    public static final String HEADER_SERVER = "Server";
+    public static final String HEADER_GW_SERVER_NAME = "LinkTap Gateway";
+
+    /**
+     * HTML title field mappings to use cases
+     */
+    private static final String TITLE_API_RESPONSE = "api";
+    private static final String TITLE_API_CONFIG_PAGE = "LinkTap Gateway";
+    private static final String TITLE_API_LOGIN_PAGE = "LinkTap Gateway Login";
+
+    /**
+     * Field names for form submission API's
+     */
+    private static final String FIELD_ADMIN_USER = "admin";
+    private static final String FIELD_ADMIN_USER_PWD = "adminpwd";
+}
diff --git a/bundles/org.openhab.binding.linktap/src/main/java/org/openhab/binding/linktap/protocol/servers/BindingServlet.java b/bundles/org.openhab.binding.linktap/src/main/java/org/openhab/binding/linktap/protocol/servers/BindingServlet.java
new file mode 100644
index 0000000000000..268ac9cad0d44
--- /dev/null
+++ b/bundles/org.openhab.binding.linktap/src/main/java/org/openhab/binding/linktap/protocol/servers/BindingServlet.java
@@ -0,0 +1,237 @@
+/**
+ * Copyright (c) 2010-2024 Contributors to the openHAB project
+ *
+ * See the NOTICE file(s) distributed with this work for additional
+ * information.
+ *
+ * This program and the accompanying materials are made available under the
+ * terms of the Eclipse Public License 2.0 which is available at
+ * http://www.eclipse.org/legal/epl-2.0
+ *
+ * SPDX-License-Identifier: EPL-2.0
+ */
+package org.openhab.binding.linktap.protocol.servers;
+
+import static org.openhab.binding.linktap.protocol.frames.TLGatewayFrame.EMPTY_STRING;
+
+import java.io.IOException;
+import java.io.InputStreamReader;
+import java.io.Reader;
+import java.nio.charset.StandardCharsets;
+import java.util.ArrayList;
+import java.util.List;
+
+import javax.servlet.ServletException;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+import org.eclipse.jdt.annotation.NonNullByDefault;
+import org.eclipse.jdt.annotation.Nullable;
+import org.eclipse.jetty.http.HttpStatus;
+import org.openhab.binding.linktap.internal.LinkTapBindingConstants;
+import org.openhab.binding.linktap.internal.TransactionProcessor;
+import org.openhab.binding.linktap.protocol.frames.TLGatewayFrame;
+import org.openhab.core.thing.Thing;
+import org.osgi.service.http.HttpService;
+import org.osgi.service.http.NamespaceException;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
+/**
+ * The {@link BindingServlet} defines the request to enable or disable alerts from a given device.
+ *
+ * @author David Goodyear - Initial contribution
+ */
+@NonNullByDefault
+public class BindingServlet extends HttpServlet {
+    private static final long serialVersionUID = -23L;
+
+    private final Logger logger = LoggerFactory.getLogger(BindingServlet.class);
+
+    public static final String SERVLET_URL_WITHOUT_ROOT = "linkTap";
+    private static final String SERVLET_URL = "/" + SERVLET_URL_WITHOUT_ROOT;
+    @Nullable
+    HttpService httpService;
+
+    volatile boolean registered;
+    List<Thing> accountHandlers = new ArrayList<>();
+
+    public static final BindingServlet INSTANCE = new BindingServlet();
+
+    public static final BindingServlet getInstance() {
+        return INSTANCE;
+    }
+
+    public void setHttpService(final HttpService httpService) {
+        this.httpService = httpService;
+    }
+
+    public static String getServletAddress(final String hostname) {
+        final String httpPortStr = System.getProperty("org.osgi.service.http.port");
+        final String httpsPortStr = System.getProperty("org.osgi.service.https.port");
+        final Logger logger = LoggerFactory.getLogger(BindingServlet.class);
+        if (httpPortStr == null || httpPortStr.isEmpty()) {
+            logger.warn("HTTP Server port is not running, cannot use for API callbacks");
+            if (httpsPortStr != null && !httpsPortStr.isEmpty()) {
+                logger.warn("Looks like HTTPS is enabled - the device needs HTTP for efficient comm's");
+            }
+            return EMPTY_STRING;
+        }
+        return "http://" + hostname + ":" + httpPortStr + SERVLET_URL;
+    }
+
+    public void registerServlet() {
+        final HttpService srv = httpService;
+        if (!registered && srv != null) {
+            try {
+                srv.registerServlet(SERVLET_URL, this, null, srv.createDefaultHttpContext());
+                registered = true;
+                logger.trace("Registered servlet " + SERVLET_URL);
+            } catch (NamespaceException | ServletException e) {
+                logger.warn("Register servlet failed for {}", SERVLET_URL, e);
+            }
+        }
+    }
+
+    public void unregisterServlet() {
+        final HttpService srv = httpService;
+        if (registered && srv != null) {
+            srv.unregister(SERVLET_URL);
+            registered = false;
+            logger.trace("Unregistered servlet");
+        }
+    }
+
+    @Override
+    protected void doGet(@Nullable HttpServletRequest req, @Nullable HttpServletResponse resp)
+            throws ServletException, IOException {
+        if (req == null) {
+            return;
+        }
+        /*
+         * if (BridgeManager.getInstance().isEmpty()) {
+         * resp.setStatus(HttpStatus.NOT_FOUND_404);
+         * resp.setContentLength(0);
+         * resp.flushBuffer();
+         * }
+         */
+
+        logger.warn("Got GET request from {}", req.getRemoteAddr());
+        logger.warn("Got GET request from {}", req.getRemoteHost());
+
+        StringBuilder html = new StringBuilder();
+        html.append("<html><head><title>" + "My first page" + "</title><head><body>");
+        html.append("<h1>" + "Some Heading" + "</h1>");
+
+        html.append("<body><b>Remote Host</b>").append(req.getRemoteHost()).append("</body>");
+        html.append("<body><b>Remote Addr</b>").append(req.getRemoteAddr()).append("</body>");
+        html.append("<body><b>Remote User</b>").append(req.getRemoteUser()).append("</body>");
+        html.append("<body><b>Remote Port</b>").append(req.getRemotePort()).append("</body>");
+
+        if (resp == null) {
+            return;
+        }
+
+        String requestUri = req.getRequestURI();
+        if (requestUri == null) {
+            return;
+        }
+        String uri = requestUri.substring(SERVLET_URL.length());
+        String queryString = req.getQueryString();
+        if (queryString != null && queryString.length() > 0) {
+            uri += "?" + queryString;
+        }
+        logger.debug("doGet {}", uri);
+
+        // if (!"/".equals(uri)) {
+        // String newUri = req.getServletPath() + "/";
+        // resp.sendRedirect(newUri);
+        // return;
+        // }
+
+        html.append("</body></html>");
+
+        resp.addHeader("content-type", "text/html;charset=UTF-8");
+        try {
+            resp.getWriter().write(html.toString());
+        } catch (IOException e) {
+            logger.warn("return html failed with uri syntax error", e);
+        }
+    }
+
+    @Override
+    protected void doPost(@Nullable HttpServletRequest req, @Nullable HttpServletResponse resp)
+            throws ServletException, IOException {
+        if (req == null) {
+            return;
+        }
+
+        /*
+         * if (BridgeManager.getInstance().isEmpty()) {
+         * resp.setStatus(HttpStatus.NOT_FOUND_404);
+         * resp.setContentLength(0);
+         * resp.flushBuffer();
+         * }
+         */
+
+        // logger.warn("Got request from {}", req.getRemoteAddr());
+        // logger.warn("Got request from {}", req.getRemoteHost());
+        // Enumeration<String> headers = req.getHeaderNames();
+        /*
+         * if (headers != null) {
+         * for (Iterator<String> it = headers.asIterator(); it.hasNext();) {
+         * String header = it.next();
+         * // logger.warn("Got header {} with value {}", header, req.getHeader(header));
+         * }
+         * }
+         */
+
+        int bufferSize = 1000; // The payload string is technically limited to 768 characters - this should be enough
+                               // for one buffer for the whole lot
+        char[] buffer = new char[bufferSize];
+        StringBuilder out = new StringBuilder();
+        Reader in = new InputStreamReader(req.getInputStream(), StandardCharsets.UTF_8);
+        for (int numRead; (numRead = in.read(buffer, 0, buffer.length)) > 0;) {
+            out.append(buffer, 0, numRead);
+        }
+
+        String payload = out.toString();
+        // logger.warn("Output {}", payload);
+        final TLGatewayFrame tlFrame = LinkTapBindingConstants.GSON.fromJson(payload, TLGatewayFrame.class);
+        // if (tlFrame.command == DEFAULT_INT) {
+        // logger.warn("Unsolicited frame - Mapping to CMD 3");
+        // } else {
+        String result = "";
+        if (tlFrame != null) {
+            // logger.warn("Got Command {}", tlFrame.command);
+            TransactionProcessor tp = TransactionProcessor.getInstance();
+            result = tp.processGwRequest(req.getRemoteAddr(), tlFrame.command, payload);
+        }
+        // resp.setStatus(HttpServletResponse.SC_OK);
+        // resp.setContentType("application/json");
+        // resp.setContentLength(result.length());
+        // resp.setCharacterEncoding("UTF-8");
+        // resp.getWriter().write(result);
+        // resp.getWriter().flush();
+        // resp.getWriter().close();
+        // resp.flushBuffer();
+        // }
+        // logger.warn("SENDING RESPONSE BODY {}", result);
+        // resp.addHeader("content-type", "text/html;charset=UTF-8");
+        // try {
+        // resp.getWriter().write(result);
+        // } catch (IOException e) {
+        // logger.warn("return html failed with uri syntax error", e);
+        // }
+        if (resp == null) {
+            return;
+        }
+        // logger.warn("SENDING RESPONSE BODY 2 {}", result);
+
+        resp.setContentType("application/json");
+        resp.setStatus(HttpStatus.OK_200);
+        resp.getWriter().append(result);
+        resp.getWriter().close();
+    }
+}
diff --git a/bundles/org.openhab.binding.linktap/src/main/java/org/openhab/binding/linktap/protocol/servers/IHttpClientProvider.java b/bundles/org.openhab.binding.linktap/src/main/java/org/openhab/binding/linktap/protocol/servers/IHttpClientProvider.java
new file mode 100644
index 0000000000000..3c304a3bd1ef0
--- /dev/null
+++ b/bundles/org.openhab.binding.linktap/src/main/java/org/openhab/binding/linktap/protocol/servers/IHttpClientProvider.java
@@ -0,0 +1,26 @@
+/**
+ * Copyright (c) 2010-2024 Contributors to the openHAB project
+ *
+ * See the NOTICE file(s) distributed with this work for additional
+ * information.
+ *
+ * This program and the accompanying materials are made available under the
+ * terms of the Eclipse Public License 2.0 which is available at
+ * http://www.eclipse.org/legal/epl-2.0
+ *
+ * SPDX-License-Identifier: EPL-2.0
+ */
+package org.openhab.binding.linktap.protocol.servers;
+
+import org.eclipse.jdt.annotation.NonNullByDefault;
+import org.eclipse.jdt.annotation.Nullable;
+import org.eclipse.jetty.client.HttpClient;
+
+/**
+ * @author David Goodyear - Initial contribution
+ */
+@NonNullByDefault
+public interface IHttpClientProvider {
+    @Nullable
+    HttpClient getHttpClient();
+}
diff --git a/bundles/org.openhab.binding.linktap/src/main/resources/OH-INF/addon/addon.xml b/bundles/org.openhab.binding.linktap/src/main/resources/OH-INF/addon/addon.xml
new file mode 100644
index 0000000000000..0941d8cee26e3
--- /dev/null
+++ b/bundles/org.openhab.binding.linktap/src/main/resources/OH-INF/addon/addon.xml
@@ -0,0 +1,28 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<addon:addon id="linktap" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
+	xmlns:addon="https://openhab.org/schemas/addon/v1.0.0"
+	xsi:schemaLocation="https://openhab.org/schemas/addon/v1.0.0 https://openhab.org/schemas/addon-1.0.0.xsd">
+
+	<type>binding</type>
+	<name>LinkTap Binding</name>
+	<description>This is the binding for LinkTap.</description>
+
+	<discovery-methods>
+		<discovery-method>
+			<service-type>mdns</service-type>
+			<discovery-parameters>
+				<discovery-parameter>
+					<name>mdnsServiceType</name>
+					<value>_http._tcp.local.</value>
+				</discovery-parameter>
+			</discovery-parameters>
+			<match-properties>
+				<match-property>
+					<name>name</name>
+					<regex>^(LinkTapGw_)</regex>
+				</match-property>
+			</match-properties>
+		</discovery-method>
+	</discovery-methods>
+
+</addon:addon>
diff --git a/bundles/org.openhab.binding.linktap/src/main/resources/OH-INF/i18n/linktap.properties b/bundles/org.openhab.binding.linktap/src/main/resources/OH-INF/i18n/linktap.properties
new file mode 100644
index 0000000000000..0c2f44015a92d
--- /dev/null
+++ b/bundles/org.openhab.binding.linktap/src/main/resources/OH-INF/i18n/linktap.properties
@@ -0,0 +1,3 @@
+# FIXME: please add all English translations to this file so the texts can be translated using Crowdin
+# FIXME: to generate the content of this file run: mvn i18n:generate-default-translations
+# FIXME: see also: https://www.openhab.org/docs/developer/utils/i18n.html
diff --git a/bundles/org.openhab.binding.linktap/src/main/resources/OH-INF/thing/channel-types.xml b/bundles/org.openhab.binding.linktap/src/main/resources/OH-INF/thing/channel-types.xml
new file mode 100644
index 0000000000000..1081a4f4dc35b
--- /dev/null
+++ b/bundles/org.openhab.binding.linktap/src/main/resources/OH-INF/thing/channel-types.xml
@@ -0,0 +1,223 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<thing:thing-descriptions bindingId="linktap"
+	xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
+	xmlns:thing="https://openhab.org/schemas/thing-description/v1.0.0"
+	xsi:schemaLocation="https://openhab.org/schemas/thing-description/v1.0.0 https://openhab.org/schemas/thing-description-1.0.0.xsd">
+
+	<channel-type id="deviceMode">
+		<item-type>String</item-type>
+		<label>Watering mode</label>
+		<description>The watering mode</description>
+		<category>Time</category>
+		<state readOnly="false">
+			<options>
+				<option value="0">Off</option>
+				<option value="1">Instant</option>
+				<option value="2">Calendar</option>
+				<option value="3">Day</option>
+				<option value="4">Odd-even</option>
+				<option value="5">Interval</option>
+				<option value="6">Month</option>
+			</options>
+		</state>
+	</channel-type>
+
+	<channel-type id="deviceManMode">
+		<item-type>Switch</item-type>
+		<label>Manual watering</label>
+		<description>Manual watering mode status</description>
+		<category>Water</category>
+		<state readOnly="false"/>
+	</channel-type>
+
+	<channel-type id="deviceWatering">
+		<item-type>Switch</item-type>
+		<label>Watering</label>
+		<description>Active watering status</description>
+		<category>Water</category>
+		<state readOnly="false"/>
+	</channel-type>
+
+	<channel-type id="deviceRfLinked">
+		<item-type>Switch</item-type>
+		<label>RF Linked</label>
+		<description>Is the device RF linked</description>
+		<category>Switch</category>
+		<state readOnly="true"/>
+	</channel-type>
+
+	<channel-type id="deviceFlmLinked">
+		<item-type>Switch</item-type>
+		<label>FLM Linked</label>
+		<description>The device has a included flow meter</description>
+		<category>Switch</category>
+		<state readOnly="true"/>
+	</channel-type>
+
+	<channel-type id="deviceIsLeak">
+		<item-type>Switch</item-type>
+		<label>High Flow Detected</label>
+		<description>Unusually high flow rate detected alert</description>
+		<category>Alarm</category>
+		<state readOnly="false"/>
+	</channel-type>
+
+	<channel-type id="deviceIsClog">
+		<item-type>Switch</item-type>
+		<label>Low Flow Detected</label>
+		<description>Unusually low flow rate detected alert</description>
+		<category>Alarm</category>
+		<state readOnly="false"/>
+	</channel-type>
+
+	<channel-type id="deviceFallStatus">
+		<item-type>Switch</item-type>
+		<label>Fallen status</label>
+		<description>The device has fallen</description>
+		<category>Alarm</category>
+		<state readOnly="false"/>
+	</channel-type>
+
+	<channel-type id="deviceFailStatus">
+		<item-type>Switch</item-type>
+		<label>Shutdown value failed</label>
+		<description>The device has failed to close the valve</description>
+		<category>Alarm</category>
+		<state readOnly="false"/>
+	</channel-type>
+
+	<channel-type id="deviceFinalSegment">
+		<item-type>Switch</item-type>
+		<label>Final ECO Segment</label>
+		<description>In ECO mode this is true when the final ON watering on segment is running</description>
+		<category>Switch</category>
+		<state readOnly="true"/>
+	</channel-type>
+
+	<channel-type id="deviceSignalLevel">
+		<item-type unitHint="%">Number:Dimensionless</item-type>
+		<label>Signal Level</label>
+		<description>Reception Signal Strength</description>
+		<category>QualityOfService</category>
+		<state readOnly="true" pattern="%.0f %%"/>
+	</channel-type>
+
+	<channel-type id="deviceBatteryLevel">
+		<item-type unitHint="%">Number:Dimensionless</item-type>
+		<label>Battery Level</label>
+		<description>Battery Remaining Level</description>
+		<category>BatteryLevel</category>
+		<state readOnly="true" pattern="%.0f %%"/>
+	</channel-type>
+
+	<channel-type id="deviceWaterCutoff">
+		<item-type>Switch</item-type>
+		<label>Water Cutoff</label>
+		<description>Water cut-off alert</description>
+		<category>Alarm</category>
+		<state readOnly="false"/>
+	</channel-type>
+
+	<channel-type id="deviceFlowRate">
+		<item-type unitHint="l/min">Number:VolumetricFlowRate</item-type>
+		<label>Flow Rate</label>
+		<description>Current water flow rate</description>
+		<category>Flow</category>
+		<state readOnly="true" pattern="%.2f %unit%"/>
+	</channel-type>
+
+	<channel-type id="deviceVolume">
+		<item-type unitHint="l">Number:Volume</item-type>
+		<label>Current Watering Volume</label>
+		<description>Accumulated volume of current watering cycle</description>
+		<category>Water</category>
+		<state readOnly="true" pattern="%.2f %unit%"/>
+	</channel-type>
+
+	<channel-type id="deviceVolumeLimit">
+		<item-type unitHint="l">Number:Volume</item-type>
+		<label>Current Watering Limit</label>
+		<description>Volume limit for the current watering cycle</description>
+		<category>Water</category>
+		<state readOnly="false" pattern="%.2f %unit%"/>
+	</channel-type>
+
+	<channel-type id="deviceTotalDuration">
+		<item-type unitHint="s">Number:Time</item-type>
+		<label>Watering Cycle Duration</label>
+		<description>Total duration of current watering cycle</description>
+		<category>Time</category>
+		<state readOnly="false" pattern="%.2f %unit%"/>
+	</channel-type>
+
+	<channel-type id="deviceRemainingDuration">
+		<item-type unitHint="s">Number:Time</item-type>
+		<label>Watering Cycle Remaining</label>
+		<description>Remaining duration of the current watering cycle</description>
+		<category>Time</category>
+		<state readOnly="true" pattern="%.2f %unit%"/>
+	</channel-type>
+
+	<channel-type id="deviceFailsafeDuration">
+		<item-type unitHint="s">Number:Time</item-type>
+		<label>Watering Cycle Failsafe</label>
+		<description>Failsafe duration of the current watering cycle</description>
+		<category>Time</category>
+		<state readOnly="true" pattern="%.2f %unit%"/>
+	</channel-type>
+
+	<channel-type id="deviceChildLockMode">
+		<item-type>String</item-type>
+		<label>Child-lock mode</label>
+		<description>The child lock mode</description>
+		<category>Lock</category>
+		<state readOnly="false">
+			<options>
+				<option value="0">Unlocked</option>
+				<option value="1">Partially locked</option>
+				<option value="2">Completely locked</option>
+			</options>
+		</state>
+	</channel-type>
+
+	<channel-type id="ohInstantDuration">
+		<item-type unitHint="s">Number:Time</item-type>
+		<label>OH Instance On Duration</label>
+		<description>Max duration allowed for the immediate watering</description>
+		<category>Time</category>
+		<state readOnly="false" pattern="%.2f %unit%"/>
+	</channel-type>
+
+	<channel-type id="ohInstantVolumeLimit">
+		<item-type unitHint="l">Number:Volume</item-type>
+		<label>OH Instance On Watering Limit</label>
+		<description>Max Volume limit for immediate watering</description>
+		<category>Water</category>
+		<state readOnly="false" pattern="%.2f %unit%"/>
+	</channel-type>
+
+	<channel-type id="waterSkipPrevRain">
+		<item-type unitHint="mm">Number:Length</item-type>
+		<label>Watering Skipped Previous Rain</label>
+		<description>Previous rainfall calculated when watering was skipped</description>
+		<category>Rain</category>
+		<state readOnly="true" pattern="%.2f %unit%"/>
+	</channel-type>
+
+	<channel-type id="waterSkipFutureRain">
+		<item-type unitHint="mm">Number:Length</item-type>
+		<label>Watering Skipped Future Rain</label>
+		<description>Future rainfall calculated when watering was skipped</description>
+		<category>Rain</category>
+		<state readOnly="true" pattern="%.2f %unit%"/>
+	</channel-type>
+
+	<channel-type id="waterSkipDateTime">
+		<item-type>DateTime</item-type>
+		<label>Watering Skipped Timestamp</label>
+		<description>Time when watering was skipped</description>
+		<category>Time</category>
+		<state readOnly="true"/>
+	</channel-type>
+
+</thing:thing-descriptions>
diff --git a/bundles/org.openhab.binding.linktap/src/main/resources/OH-INF/thing/thing-types.xml b/bundles/org.openhab.binding.linktap/src/main/resources/OH-INF/thing/thing-types.xml
new file mode 100644
index 0000000000000..2bcc5f9fc7761
--- /dev/null
+++ b/bundles/org.openhab.binding.linktap/src/main/resources/OH-INF/thing/thing-types.xml
@@ -0,0 +1,108 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<thing:thing-descriptions bindingId="linktap"
+	xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
+	xmlns:thing="https://openhab.org/schemas/thing-description/v1.0.0"
+	xsi:schemaLocation="https://openhab.org/schemas/thing-description/v1.0.0 https://openhab.org/schemas/thing-description-1.0.0.xsd">
+
+	<bridge-type id="bridge">
+		<label>LinkTap Bridge</label>
+		<description>The LinkTap bridge represents a LinkTap gateway device</description>
+
+		<properties>
+			<property name="Gateway Id"/>
+			<property name="Hardware Model"/>
+			<property name="Version"/>
+			<property name="MAC Address"/>
+			<property name="HTTP API Enabled"/>
+			<property name="HTTP API Callback URI"/>
+			<property name="Volume Unit"/>
+		</properties>
+
+		<config-description>
+			<parameter name="host" type="text">
+				<context>email</context>
+				<required>true</required>
+				<label>Hostname / IP</label>
+				<description>The hostname / IP address of the gateway device</description>
+			</parameter>
+			<parameter name="username" type="text">
+				<required>false</required>
+				<label>Device Username</label>
+				<description>The username if set for the gateway device</description>
+			</parameter>
+			<parameter name="password" type="text">
+				<context>password</context>
+				<required>false</required>
+				<label>Device Password</label>
+				<description>The password if set for the gateway device</description>
+			</parameter>
+			<parameter name="enableMDNS" type="boolean">
+				<label>Enable mDNS responder</label>
+				<description>On connection whether the mDNS responder should be enabled on the gateway device</description>
+				<default>true</default>
+				<advanced>true</advanced>
+			</parameter>
+		</config-description>
+	</bridge-type>
+
+	<thing-type id="device">
+
+		<supported-bridge-type-refs>
+			<bridge-type-ref id="bridge"/>
+		</supported-bridge-type-refs>
+
+		<label>LinkTap Binding Thing</label>
+		<description>LinkTap Binding Device</description>
+
+		<channels>
+			<channel id="mode" typeId="deviceMode"/>
+			<channel id="manual-watering" typeId="deviceManMode"/>
+			<channel id="active-watering" typeId="deviceWatering"/>
+			<channel id="rf-linked" typeId="deviceRfLinked"/>
+			<channel id="flm-linked" typeId="deviceFlmLinked"/>
+			<channel id="water-cut" typeId="deviceWaterCutoff"/>
+			<channel id="fall-status" typeId="deviceFallStatus"/>
+			<channel id="shutdown-failure" typeId="deviceFailStatus"/>
+			<channel id="high-flow" typeId="deviceIsLeak"/>
+			<channel id="low-flow" typeId="deviceIsClog"/>
+			<channel id="eco-final" typeId="deviceFinalSegment"/>
+			<channel id="signal" typeId="deviceSignalLevel"/>
+			<channel id="battery" typeId="deviceBatteryLevel"/>
+			<channel id="child-lock" typeId="deviceChildLockMode"/>
+			<channel id="flow-rate" typeId="deviceFlowRate"/>
+			<channel id="volume" typeId="deviceVolume"/>
+			<channel id="duration" typeId="deviceTotalDuration"/>
+			<channel id="remaining" typeId="deviceRemainingDuration"/>
+			<channel id="dur-limit" typeId="deviceFailsafeDuration"/>
+			<channel id="vol-limit" typeId="deviceVolumeLimit"/>
+			<channel id="oh-dur-limit" typeId="ohInstantDuration"/>
+			<channel id="oh-vol-limit" typeId="ohInstantVolumeLimit"/>
+			<channel id="water-skip-prev" typeId="waterSkipPrevRain"/>
+			<channel id="water-skip-next" typeId="waterSkipFutureRain"/>
+			<channel id="water-skip-ts" typeId="waterSkipDateTime"/>
+		</channels>
+
+		<representation-property>deviceId</representation-property>
+
+		<config-description>
+			<parameter name="id" type="text">
+				<required>false</required>
+				<label>Device Id</label>
+				<description>The Device Id for the device under the gateway</description>
+			</parameter>
+			<parameter name="name" type="text">
+				<required>false</required>
+				<label>Device Name</label>
+				<description>The name allocated to the device by the app. (Must be unique if used)</description>
+			</parameter>
+			<parameter name="enableAlerts" type="boolean">
+				<required>false</required>
+				<label>Auto Enable Alerts</label>
+				<description>If enabled, during device initialisation all alerts are enabled</description>
+				<default>true</default>
+			</parameter>
+		</config-description>
+
+	</thing-type>
+
+</thing:thing-descriptions>
diff --git a/bundles/org.openhab.binding.linktap/src/main/tests/org/openhab/binding/linktap/protocol/frames/Command0Test.java b/bundles/org.openhab.binding.linktap/src/main/tests/org/openhab/binding/linktap/protocol/frames/Command0Test.java
new file mode 100644
index 0000000000000..ed55b558385d9
--- /dev/null
+++ b/bundles/org.openhab.binding.linktap/src/main/tests/org/openhab/binding/linktap/protocol/frames/Command0Test.java
@@ -0,0 +1,71 @@
+/**
+ * Copyright (c) 2010-2024 Contributors to the openHAB project
+ *
+ * See the NOTICE file(s) distributed with this work for additional
+ * information.
+ *
+ * This program and the accompanying materials are made available under the
+ * terms of the Eclipse Public License 2.0 which is available at
+ * http://www.eclipse.org/legal/epl-2.0
+ *
+ * SPDX-License-Identifier: EPL-2.0
+ */
+package org.openhab.binding.linktap.protocol.frames;
+
+import org.eclipse.jdt.annotation.NonNullByDefault;
+import org.junit.Test;
+import org.openhab.binding.linktap.internal.LinkTapBindingConstants;
+
+import java.util.Arrays;
+import java.util.Properties;
+import java.util.Vector;
+
+import static org.junit.Assert.assertTrue;
+import static org.junit.jupiter.api.Assertions.assertEquals;
+import static org.openhab.binding.linktap.protocol.frames.TLGatewayFrame.CMD_HANDSHAKE;
+
+/**
+ * Command 0: Handshake
+ * Flow 1 --> GW->Broker->App: First message after connection with system device mappings
+ */
+@NonNullByDefault
+public class Command0Test {
+
+    /**
+     * Command 0:
+     * Flow 1 --> GW->Broker->App: First handshake message decoding test
+     */
+    @Test
+    public void HandshakeRequestDecoding() {
+        final HandshakeReq decoded = LinkTapBindingConstants.GSON.fromJson("{ \"cmd\":0, \"gw_id\":\"CCCCDDDDEEEEFFFF\", \"ver\":\"G0404172103261024C\", \"end_dev\":[ \"1111222233334444\", \"7777888933336666\", \"2245222233334444\", \"3333999993333555\"\n]\n}",HandshakeReq.class);
+
+        assertEquals(CMD_HANDSHAKE,decoded.command);
+        assertEquals("CCCCDDDDEEEEFFFF",decoded.gatewayId );
+        assertEquals("G0404172103261024C",decoded.version);
+        assertEquals(4,decoded.endDevices.length);
+        assertTrue(Arrays.asList(decoded.endDevices).contains("1111222233334444"));
+        assertTrue(Arrays.asList(decoded.endDevices).contains("7777888933336666"));
+        assertTrue(Arrays.asList(decoded.endDevices).contains("2245222233334444"));
+        assertTrue(Arrays.asList(decoded.endDevices).contains("3333999993333555"));
+    }
+
+    /**
+     * Command 0:
+     * Flow 1 --> GW->Broker->App: First handshake message response encoding test
+     */
+    @Test
+    public void HandshakeResponseEncoding() {
+        HandshakeResp reply = new HandshakeResp();
+        reply.command = CMD_HANDSHAKE;
+        reply.gatewayId = "CCCCDDDDEEEEFFFF";
+        reply.date = "20210501";
+        reply.time = "123055";
+        reply.wday = 6;
+
+        String encoded = LinkTapBindingConstants.GSON.toJson(reply);
+
+        assertEquals("{\"date\":\"20210501\",\"time\":\"123055\",\"wday\":6,\"cmd\":0,\"gw_id\":\"CCCCDDDDEEEEFFFF\"}",
+                encoded);
+    }
+
+}
diff --git a/bundles/org.openhab.binding.linktap/src/main/tests/org/openhab/binding/linktap/protocol/frames/Command10Test.java b/bundles/org.openhab.binding.linktap/src/main/tests/org/openhab/binding/linktap/protocol/frames/Command10Test.java
new file mode 100644
index 0000000000000..09512f81caa14
--- /dev/null
+++ b/bundles/org.openhab.binding.linktap/src/main/tests/org/openhab/binding/linktap/protocol/frames/Command10Test.java
@@ -0,0 +1,64 @@
+/**
+ * Copyright (c) 2010-2024 Contributors to the openHAB project
+ *
+ * See the NOTICE file(s) distributed with this work for additional
+ * information.
+ *
+ * This program and the accompanying materials are made available under the
+ * terms of the Eclipse Public License 2.0 which is available at
+ * http://www.eclipse.org/legal/epl-2.0
+ *
+ * SPDX-License-Identifier: EPL-2.0
+ */
+package org.openhab.binding.linktap.protocol.frames;
+
+import org.eclipse.jdt.annotation.NonNullByDefault;
+import org.junit.Test;
+import org.openhab.binding.linktap.internal.LinkTapBindingConstants;
+
+import static org.junit.jupiter.api.Assertions.assertEquals;
+import static org.openhab.binding.linktap.protocol.frames.TLGatewayFrame.CMD_ALERT_DISMISS;
+import static org.openhab.binding.linktap.protocol.frames.TLGatewayFrame.CMD_ALERT_ENABLEMENT;
+
+/**
+ * Command 10: Enable or Disable alert type
+ * Flow 1 --> App->Broker->GW: Enable or Disable the given alert type
+ */
+@NonNullByDefault
+public class Command10Test {
+
+    /**
+     * Command 10: Enable or Disable alert type
+     * Flow 1 --> App->Broker->GW: Enable or Disable the given alert type
+     */
+    @Test
+    public void ChangeAlertStateGenerationTest() {
+        AlertStateReq req = new AlertStateReq();
+        req.command = CMD_ALERT_ENABLEMENT;
+        req.gatewayId = "CCCCDDDDEEEEFFFF";
+        req.deviceId = "1111222233334444";
+        req.alert = 0;
+        req.enable = true;
+
+        String encoded = LinkTapBindingConstants.GSON.toJson(req);
+
+        assertEquals("{\"enable\":true,\"alert\":0,\"dev_id\":\"1111222233334444\",\"cmd\":10,\"gw_id\":\"CCCCDDDDEEEEFFFF\"}",
+                encoded);
+    }
+
+    /**
+     * Command 11: Dismiss Alert
+     * Flow 1 --> App->Broker->GW: Dismiss the specified alert type reply
+     */
+    @Test
+    public void ChangeAlertStateResponseDecoding() {
+        final EndpointDeviceResponse decoded = LinkTapBindingConstants.GSON.fromJson("{ \"cmd\":10, \"gw_id\":\"CCCCDDDDEEEEFFFF\", \"dev_id\":\"1111222233334444\", \"ret\":0\n}",EndpointDeviceResponse.class);
+
+        assertEquals(CMD_ALERT_ENABLEMENT,decoded.command);
+        assertEquals("CCCCDDDDEEEEFFFF",decoded.gatewayId );
+        assertEquals("1111222233334444",decoded.deviceId );
+        assertEquals(GatewayDeviceResponse.ResultStatus.RET_SUCCESS,decoded.getRes());
+    }
+
+
+}
diff --git a/bundles/org.openhab.binding.linktap/src/main/tests/org/openhab/binding/linktap/protocol/frames/Command11Test.java b/bundles/org.openhab.binding.linktap/src/main/tests/org/openhab/binding/linktap/protocol/frames/Command11Test.java
new file mode 100644
index 0000000000000..29a67970a1e1e
--- /dev/null
+++ b/bundles/org.openhab.binding.linktap/src/main/tests/org/openhab/binding/linktap/protocol/frames/Command11Test.java
@@ -0,0 +1,63 @@
+/**
+ * Copyright (c) 2010-2024 Contributors to the openHAB project
+ *
+ * See the NOTICE file(s) distributed with this work for additional
+ * information.
+ *
+ * This program and the accompanying materials are made available under the
+ * terms of the Eclipse Public License 2.0 which is available at
+ * http://www.eclipse.org/legal/epl-2.0
+ *
+ * SPDX-License-Identifier: EPL-2.0
+ */
+package org.openhab.binding.linktap.protocol.frames;
+
+import org.eclipse.jdt.annotation.NonNullByDefault;
+import org.junit.Test;
+import org.openhab.binding.linktap.internal.LinkTapBindingConstants;
+
+import static org.junit.jupiter.api.Assertions.assertEquals;
+import static org.openhab.binding.linktap.protocol.frames.TLGatewayFrame.CMD_ALERT_DISMISS;
+import static org.openhab.binding.linktap.protocol.frames.TLGatewayFrame.CMD_RAINFALL_DATA;
+
+/**
+ * Command 11: Dismiss Alert
+ * Flow 1 --> App->Broker->GW: Dismiss the specified alert type
+ */
+@NonNullByDefault
+public class Command11Test {
+
+    /**
+     * Command 11: Dismiss Alert
+     * Flow 1 --> App->Broker->GW: Dismiss the specified alert type
+     */
+    @Test
+    public void DismissAlertGenerationTest() {
+        DismissAlertReq req = new DismissAlertReq();
+        req.command = CMD_ALERT_DISMISS;
+        req.gatewayId = "CCCCDDDDEEEEFFFF";
+        req.deviceId = "1111222233334444";
+        req.alert = 0;
+
+        String encoded = LinkTapBindingConstants.GSON.toJson(req);
+
+        assertEquals("{\"alert\":0,\"dev_id\":\"1111222233334444\",\"cmd\":11,\"gw_id\":\"CCCCDDDDEEEEFFFF\"}",
+                encoded);
+    }
+
+    /**
+     * Command 11: Dismiss Alert
+     * Flow 1 --> App->Broker->GW: Dismiss the specified alert type reply
+     */
+    @Test
+    public void DismissAlertResponseDecoding() {
+        final EndpointDeviceResponse decoded = LinkTapBindingConstants.GSON.fromJson("{ \"cmd\":11, \"gw_id\":\"CCCCDDDDEEEEFFFF\", \"dev_id\":\"1111222233334444\", \"ret\":0\n}",EndpointDeviceResponse.class);
+
+        assertEquals(CMD_ALERT_DISMISS,decoded.command);
+        assertEquals("CCCCDDDDEEEEFFFF",decoded.gatewayId );
+        assertEquals("1111222233334444",decoded.deviceId );
+        assertEquals(GatewayDeviceResponse.ResultStatus.RET_SUCCESS,decoded.getRes());
+    }
+
+
+}
diff --git a/bundles/org.openhab.binding.linktap/src/main/tests/org/openhab/binding/linktap/protocol/frames/Command12Test.java b/bundles/org.openhab.binding.linktap/src/main/tests/org/openhab/binding/linktap/protocol/frames/Command12Test.java
new file mode 100644
index 0000000000000..8a4b1e9299bc6
--- /dev/null
+++ b/bundles/org.openhab.binding.linktap/src/main/tests/org/openhab/binding/linktap/protocol/frames/Command12Test.java
@@ -0,0 +1,62 @@
+/**
+ * Copyright (c) 2010-2024 Contributors to the openHAB project
+ *
+ * See the NOTICE file(s) distributed with this work for additional
+ * information.
+ *
+ * This program and the accompanying materials are made available under the
+ * terms of the Eclipse Public License 2.0 which is available at
+ * http://www.eclipse.org/legal/epl-2.0
+ *
+ * SPDX-License-Identifier: EPL-2.0
+ */
+package org.openhab.binding.linktap.protocol.frames;
+
+import org.eclipse.jdt.annotation.NonNullByDefault;
+import org.junit.Test;
+import org.openhab.binding.linktap.internal.LinkTapBindingConstants;
+
+import static org.junit.jupiter.api.Assertions.assertEquals;
+import static org.openhab.binding.linktap.protocol.frames.TLGatewayFrame.CMD_ALERT_DISMISS;
+import static org.openhab.binding.linktap.protocol.frames.TLGatewayFrame.CMD_LOCKOUT_STATE;
+
+/**
+ * Command 12: Set lock state
+ * Flow 1 --> App->Broker->GW: Request lock status is changed - G15 and G25 models only
+ */
+@NonNullByDefault
+public class Command12Test {
+
+    /**
+     * Command 12: Set lock state
+     * Flow 1 --> App->Broker->GW: Request lock status is changed - G15 and G25 models only
+     */
+    @Test
+    public void SetLockStateGenerationTest() {
+        LockReq req = new LockReq();
+        req.command = CMD_LOCKOUT_STATE;
+        req.gatewayId = "CCCCDDDDEEEEFFFF";
+        req.deviceId = "1111222233334444";
+        req.lock = 0;
+
+        String encoded = LinkTapBindingConstants.GSON.toJson(req);
+
+        assertEquals("{\"lock\":0,\"dev_id\":\"1111222233334444\",\"cmd\":12,\"gw_id\":\"CCCCDDDDEEEEFFFF\"}",
+                encoded);
+    }
+
+    /**
+     * Command 12: Set lock state
+     * Flow 1 --> App->Broker->GW: Request lock status is changed response decoding
+     */
+    @Test
+    public void SetLockStateResponseDecoding() {
+        final EndpointDeviceResponse decoded = LinkTapBindingConstants.GSON.fromJson("{ \"cmd\":12, \"gw_id\":\"CCCCDDDDEEEEFFFF\", \"dev_id\":\"1111222233334444\", \"ret\":0\n}",EndpointDeviceResponse.class);
+
+        assertEquals(CMD_LOCKOUT_STATE,decoded.command);
+        assertEquals("CCCCDDDDEEEEFFFF",decoded.gatewayId );
+        assertEquals("1111222233334444",decoded.deviceId );
+        assertEquals(GatewayDeviceResponse.ResultStatus.RET_SUCCESS,decoded.getRes());
+    }
+    
+}
diff --git a/bundles/org.openhab.binding.linktap/src/main/tests/org/openhab/binding/linktap/protocol/frames/Command13Test.java b/bundles/org.openhab.binding.linktap/src/main/tests/org/openhab/binding/linktap/protocol/frames/Command13Test.java
new file mode 100644
index 0000000000000..9dbe24dcb1615
--- /dev/null
+++ b/bundles/org.openhab.binding.linktap/src/main/tests/org/openhab/binding/linktap/protocol/frames/Command13Test.java
@@ -0,0 +1,59 @@
+/**
+ * Copyright (c) 2010-2024 Contributors to the openHAB project
+ *
+ * See the NOTICE file(s) distributed with this work for additional
+ * information.
+ *
+ * This program and the accompanying materials are made available under the
+ * terms of the Eclipse Public License 2.0 which is available at
+ * http://www.eclipse.org/legal/epl-2.0
+ *
+ * SPDX-License-Identifier: EPL-2.0
+ */
+package org.openhab.binding.linktap.protocol.frames;
+
+import org.eclipse.jdt.annotation.NonNullByDefault;
+import org.junit.Test;
+import org.openhab.binding.linktap.internal.LinkTapBindingConstants;
+
+import static org.junit.jupiter.api.Assertions.assertEquals;
+import static org.openhab.binding.linktap.protocol.frames.TLGatewayFrame.*;
+
+/**
+ * Command 13: Sync Gateway time
+ * Flow 1 --> GW->Broker->App: Request from Gateway for the current system time
+ */
+@NonNullByDefault
+public class Command13Test {
+
+    /**
+     * Command 13: Sync Gateway time
+     * Flow 1 --> GW->Broker->App: Response sent from the App to the Gateway with the time information
+     */
+    @Test
+    public void ResponseForAppTimeRequestGenerationTest() {
+        HandshakeResp req = new HandshakeResp();
+        req.gatewayId = "CCCCDDDDEEEEFFFF";
+        req.command = CMD_DATETIME_SYNC;
+        req.date = "20210501";
+        req.time = "123055";
+        req.wday = 6;
+
+        String encoded = LinkTapBindingConstants.GSON.toJson(req);
+
+        assertEquals("{\"date\":\"20210501\",\"time\":\"123055\",\"wday\":6,\"cmd\":13,\"gw_id\":\"CCCCDDDDEEEEFFFF\"}",
+                encoded);
+    }
+
+    /**
+     * Command 13: Sync Gateway time
+     * Flow 1 --> GW->Broker->App: Request from Gateway for the current system time
+     */
+    @Test
+    public void RequestForAppTimeDecoding() {
+        final TLGatewayFrame decoded = LinkTapBindingConstants.GSON.fromJson("{ \"cmd\":13, \"gw_id\":\"CCCCDDDDEEEEFFFF\"\n}",EndpointDeviceResponse.class);
+        assertEquals(CMD_DATETIME_SYNC,decoded.command);
+        assertEquals("CCCCDDDDEEEEFFFF",decoded.gatewayId );
+    }
+    
+}
diff --git a/bundles/org.openhab.binding.linktap/src/main/tests/org/openhab/binding/linktap/protocol/frames/Command14Test.java b/bundles/org.openhab.binding.linktap/src/main/tests/org/openhab/binding/linktap/protocol/frames/Command14Test.java
new file mode 100644
index 0000000000000..b1ea9670b9f34
--- /dev/null
+++ b/bundles/org.openhab.binding.linktap/src/main/tests/org/openhab/binding/linktap/protocol/frames/Command14Test.java
@@ -0,0 +1,60 @@
+/**
+ * Copyright (c) 2010-2024 Contributors to the openHAB project
+ *
+ * See the NOTICE file(s) distributed with this work for additional
+ * information.
+ *
+ * This program and the accompanying materials are made available under the
+ * terms of the Eclipse Public License 2.0 which is available at
+ * http://www.eclipse.org/legal/epl-2.0
+ *
+ * SPDX-License-Identifier: EPL-2.0
+ */
+package org.openhab.binding.linktap.protocol.frames;
+
+import org.eclipse.jdt.annotation.NonNullByDefault;
+import org.junit.Test;
+import org.openhab.binding.linktap.internal.LinkTapBindingConstants;
+
+import static org.junit.jupiter.api.Assertions.assertEquals;
+import static org.openhab.binding.linktap.protocol.frames.TLGatewayFrame.CMD_DATETIME_READ;
+import static org.openhab.binding.linktap.protocol.frames.TLGatewayFrame.CMD_DATETIME_SYNC;
+
+/**
+ * Command 14: Read Gateway time
+ * Flow 1 --> App->Broker->GW: Request from Gateway its current system time
+ */
+@NonNullByDefault
+public class Command14Test {
+
+    /**
+     * Command 14: Read Gateway time
+     * Flow 1 --> App->Broker->GW: Request from Gateway its current system time
+     */
+    @Test
+    public void ResponseForGwTimeRequestGenerationTest() {
+        HandshakeResp req = new HandshakeResp();
+        req.gatewayId = "CCCCDDDDEEEEFFFF";
+        req.command = CMD_DATETIME_READ;
+        req.date = "20210501";
+        req.time = "123055";
+        req.wday = 6;
+
+        String encoded = LinkTapBindingConstants.GSON.toJson(req);
+
+        assertEquals("{\"date\":\"20210501\",\"time\":\"123055\",\"wday\":6,\"cmd\":14,\"gw_id\":\"CCCCDDDDEEEEFFFF\"}",
+                encoded);
+    }
+
+    /**
+     * Command 14: Read Gateway time
+     * Flow 1 --> App->Broker->GW: Request from Gateway its current system time
+     */
+    @Test
+    public void RequestForGwTimeDecoding() {
+        final TLGatewayFrame decoded = LinkTapBindingConstants.GSON.fromJson("{ \"cmd\":14, \"gw_id\":\"CCCCDDDDEEEEFFFF\"\n}",EndpointDeviceResponse.class);
+        assertEquals(CMD_DATETIME_READ,decoded.command);
+        assertEquals("CCCCDDDDEEEEFFFF",decoded.gatewayId );
+    }
+    
+}
diff --git a/bundles/org.openhab.binding.linktap/src/main/tests/org/openhab/binding/linktap/protocol/frames/Command15Test.java b/bundles/org.openhab.binding.linktap/src/main/tests/org/openhab/binding/linktap/protocol/frames/Command15Test.java
new file mode 100644
index 0000000000000..e4a4bfa8c6d82
--- /dev/null
+++ b/bundles/org.openhab.binding.linktap/src/main/tests/org/openhab/binding/linktap/protocol/frames/Command15Test.java
@@ -0,0 +1,64 @@
+/**
+ * Copyright (c) 2010-2024 Contributors to the openHAB project
+ *
+ * See the NOTICE file(s) distributed with this work for additional
+ * information.
+ *
+ * This program and the accompanying materials are made available under the
+ * terms of the Eclipse Public License 2.0 which is available at
+ * http://www.eclipse.org/legal/epl-2.0
+ *
+ * SPDX-License-Identifier: EPL-2.0
+ */
+package org.openhab.binding.linktap.protocol.frames;
+
+import org.eclipse.jdt.annotation.NonNullByDefault;
+import org.junit.Test;
+import org.openhab.binding.linktap.internal.LinkTapBindingConstants;
+
+import static org.junit.jupiter.api.Assertions.assertEquals;
+import static org.junit.jupiter.api.Assertions.assertFalse;
+import static org.openhab.binding.linktap.protocol.frames.TLGatewayFrame.CMD_DATETIME_SYNC;
+import static org.openhab.binding.linktap.protocol.frames.TLGatewayFrame.CMD_WIRELESS_CHECK;
+
+/**
+ * Command 15: Test wireless performance of end device
+ * Flow 1 --> App->Broker->GW: Request a ping pong test is done to measure wireless performance for a end device
+ */
+@NonNullByDefault
+public class Command15Test {
+
+    /**
+     * Command 15: Test wireless performance of end device
+     * Flow 1 --> App->Broker->GW: Request a ping pong test is done to measure wireless performance for a end device
+     */
+    @Test
+    public void RequestWirelessCheckGenerationTest() {
+        DeviceCmdReq req = new DeviceCmdReq();
+        req.gatewayId = "CCCCDDDDEEEEFFFF";
+        req.deviceId = "1111222233334444";
+        req.command = CMD_WIRELESS_CHECK;
+
+        String encoded = LinkTapBindingConstants.GSON.toJson(req);
+
+        assertEquals("{\"dev_id\":\"1111222233334444\",\"cmd\":15,\"gw_id\":\"CCCCDDDDEEEEFFFF\"}",
+                encoded);
+    }
+
+    /**
+     * Command 15: Test wireless performance of end device
+     * Flow 1 --> App->Broker->GW: Request a ping pong test is done to measure wireless performance for a end device response
+     */
+    @Test
+    public void RequestWirelessCheckResponseDecoding() {
+        final WirelessTestResp decoded = LinkTapBindingConstants.GSON.fromJson("{ \"cmd\":15, \"gw_id\":\"CCCCDDDDEEEEFFFF\", \"dev_id\":\"1111222233334444\", \"ret\":0, \"final\":false, \"ping\":5, \"pong\":4\n}",WirelessTestResp.class);
+        assertEquals(CMD_WIRELESS_CHECK,decoded.command);
+        assertEquals("CCCCDDDDEEEEFFFF",decoded.gatewayId );
+        assertEquals("1111222233334444",decoded.deviceId );
+        assertEquals(GatewayDeviceResponse.ResultStatus.RET_SUCCESS,decoded.getRes());
+        assertFalse(decoded.testComplete);
+        assertEquals(5, decoded.pingCount);
+        assertEquals(4, decoded.pongCount);
+    }
+    
+}
diff --git a/bundles/org.openhab.binding.linktap/src/main/tests/org/openhab/binding/linktap/protocol/frames/Command16Test.java b/bundles/org.openhab.binding.linktap/src/main/tests/org/openhab/binding/linktap/protocol/frames/Command16Test.java
new file mode 100644
index 0000000000000..61b2950c1e6f4
--- /dev/null
+++ b/bundles/org.openhab.binding.linktap/src/main/tests/org/openhab/binding/linktap/protocol/frames/Command16Test.java
@@ -0,0 +1,71 @@
+/**
+ * Copyright (c) 2010-2024 Contributors to the openHAB project
+ *
+ * See the NOTICE file(s) distributed with this work for additional
+ * information.
+ *
+ * This program and the accompanying materials are made available under the
+ * terms of the Eclipse Public License 2.0 which is available at
+ * http://www.eclipse.org/legal/epl-2.0
+ *
+ * SPDX-License-Identifier: EPL-2.0
+ */
+package org.openhab.binding.linktap.protocol.frames;
+
+import org.eclipse.jdt.annotation.NonNullByDefault;
+import org.junit.Test;
+import org.openhab.binding.linktap.internal.LinkTapBindingConstants;
+
+import java.util.Arrays;
+
+import static org.junit.Assert.assertTrue;
+import static org.junit.jupiter.api.Assertions.assertEquals;
+import static org.junit.jupiter.api.Assertions.assertFalse;
+import static org.openhab.binding.linktap.protocol.frames.TLGatewayFrame.CMD_GET_CONFIGURATION;
+import static org.openhab.binding.linktap.protocol.frames.TLGatewayFrame.CMD_WIRELESS_CHECK;
+
+/**
+ * Command 16: Get gateway configuration
+ * Flow 1 --> App->Broker->GW: Request the configuration of the Gateway
+ */
+@NonNullByDefault
+public class Command16Test {
+
+    /**
+     * Command 16: Get gateway configuration
+     * Flow 1 --> App->Broker->GW: Request the configuration of the Gateway
+     */
+    @Test
+    public void RequestGatewayConfigGenerationTest() {
+        TLGatewayFrame req = new TLGatewayFrame();
+        req.gatewayId = "CCCCDDDDEEEEFFFF";
+        req.command = CMD_GET_CONFIGURATION;
+
+        String encoded = LinkTapBindingConstants.GSON.toJson(req);
+
+        assertEquals("{\"cmd\":16,\"gw_id\":\"CCCCDDDDEEEEFFFF\"}",
+                encoded);
+    }
+
+    /**
+     * Command 16: Get gateway configuration
+     * Flow 1 --> App->Broker->GW: Request the configuration of the Gateway
+     */
+    @Test
+    public void RequestGatewayConfigResponseDecoding() {
+        final GatewayConfigResp decoded = LinkTapBindingConstants.GSON.fromJson("{ \"cmd\":16, \"gw_id\":\"1234E607004B1200\", \"ver\":\"G0608062305191832I\", \"vol_unit\":\"gal\", \"end_dev\":[ \"1234A923004B1200\", \"56787022004B1200\", \"ABCD6D13004B1200\"], \"dev_name\":[ \"Name_Of_Device_1234A923004B1200\", \"Name_Of_Device_56787022004B1200\", \"Name_Of_Device_ABCD6D13004B1200\"] }",GatewayConfigResp.class);
+        assertEquals(CMD_GET_CONFIGURATION,decoded.command);
+        assertEquals("1234E607004B1200",decoded.gatewayId );
+        assertEquals("G0608062305191832I",decoded.version );
+        assertEquals("gal", decoded.volumeUnit);
+        assertEquals(3, decoded.endDevices.length);
+        assertTrue(Arrays.asList(decoded.endDevices).contains("1234A923004B1200"));
+        assertTrue(Arrays.asList(decoded.endDevices).contains("56787022004B1200"));
+        assertTrue(Arrays.asList(decoded.endDevices).contains("ABCD6D13004B1200"));
+        assertEquals(3, decoded.deviceNames.length);
+        assertTrue(Arrays.asList(decoded.deviceNames).contains("Name_Of_Device_1234A923004B1200"));
+        assertTrue(Arrays.asList(decoded.deviceNames).contains("Name_Of_Device_56787022004B1200"));
+        assertTrue(Arrays.asList(decoded.deviceNames).contains("Name_Of_Device_ABCD6D13004B1200"));
+    }
+    
+}
diff --git a/bundles/org.openhab.binding.linktap/src/main/tests/org/openhab/binding/linktap/protocol/frames/Command17Test.java b/bundles/org.openhab.binding.linktap/src/main/tests/org/openhab/binding/linktap/protocol/frames/Command17Test.java
new file mode 100644
index 0000000000000..95cc64c623c68
--- /dev/null
+++ b/bundles/org.openhab.binding.linktap/src/main/tests/org/openhab/binding/linktap/protocol/frames/Command17Test.java
@@ -0,0 +1,63 @@
+/**
+ * Copyright (c) 2010-2024 Contributors to the openHAB project
+ *
+ * See the NOTICE file(s) distributed with this work for additional
+ * information.
+ *
+ * This program and the accompanying materials are made available under the
+ * terms of the Eclipse Public License 2.0 which is available at
+ * http://www.eclipse.org/legal/epl-2.0
+ *
+ * SPDX-License-Identifier: EPL-2.0
+ */
+package org.openhab.binding.linktap.protocol.frames;
+
+import org.eclipse.jdt.annotation.NonNullByDefault;
+import org.junit.Test;
+import org.openhab.binding.linktap.internal.LinkTapBindingConstants;
+
+import static org.junit.jupiter.api.Assertions.assertEquals;
+import static org.openhab.binding.linktap.protocol.frames.SetDeviceConfigReq.CONFIG_VOLUME_LIMIT;
+import static org.openhab.binding.linktap.protocol.frames.TLGatewayFrame.CMD_PAUSE_WATER_PLAN;
+import static org.openhab.binding.linktap.protocol.frames.TLGatewayFrame.CMD_SET_CONFIGURATION;
+
+/**
+ * Command 17: Set Device Configuration parameter
+ * Flow 1 --> App->Broker->GW: Sets the given device configuration parameter
+ */
+@NonNullByDefault
+public class Command17Test {
+
+    /**
+     * Command 17: Set Device Configuration parameter
+     * Flow 1 --> App->Broker->GW: Sets the given device configuration parameter
+     */
+    @Test
+    public void RequestConfigUpdateGenerationTest() {
+        SetDeviceConfigReq req = new SetDeviceConfigReq();
+        req.gatewayId = "CCCCDDDDEEEEFFFF";
+        req.deviceId = "1111222233334444";
+        req.command = CMD_SET_CONFIGURATION;
+        req.tag = CONFIG_VOLUME_LIMIT;
+        req.value = 123;
+
+        String encoded = LinkTapBindingConstants.GSON.toJson(req);
+
+        assertEquals("{\"value\":123,\"tag\":\"volume_limit\",\"dev_id\":\"1111222233334444\",\"cmd\":17,\"gw_id\":\"CCCCDDDDEEEEFFFF\"}",
+                encoded);
+    }
+
+    /**
+     * Command 17: Set Device Configuration parameter
+     * Flow 1 --> App->Broker->GW: Sets the given device configuration parameter
+     */
+    @Test
+    public void RequestConfigUpdateResponseDecoding() {
+        final EndpointDeviceResponse decoded = LinkTapBindingConstants.GSON.fromJson("{ \"cmd\":17, \"gw_id\":\"CCCCDDDDEEEEFFFF\", \"dev_id\":\"1122334455667788\", \"ret\":0\n}",EndpointDeviceResponse.class);
+        assertEquals(CMD_SET_CONFIGURATION,decoded.command);
+        assertEquals("CCCCDDDDEEEEFFFF",decoded.gatewayId );
+        assertEquals("1122334455667788",decoded.deviceId );
+        assertEquals(GatewayDeviceResponse.ResultStatus.RET_SUCCESS,decoded.getRes());
+    }
+    
+}
diff --git a/bundles/org.openhab.binding.linktap/src/main/tests/org/openhab/binding/linktap/protocol/frames/Command18Test.java b/bundles/org.openhab.binding.linktap/src/main/tests/org/openhab/binding/linktap/protocol/frames/Command18Test.java
new file mode 100644
index 0000000000000..861e83addbdf7
--- /dev/null
+++ b/bundles/org.openhab.binding.linktap/src/main/tests/org/openhab/binding/linktap/protocol/frames/Command18Test.java
@@ -0,0 +1,62 @@
+/**
+ * Copyright (c) 2010-2024 Contributors to the openHAB project
+ *
+ * See the NOTICE file(s) distributed with this work for additional
+ * information.
+ *
+ * This program and the accompanying materials are made available under the
+ * terms of the Eclipse Public License 2.0 which is available at
+ * http://www.eclipse.org/legal/epl-2.0
+ *
+ * SPDX-License-Identifier: EPL-2.0
+ */
+package org.openhab.binding.linktap.protocol.frames;
+
+import org.eclipse.jdt.annotation.NonNullByDefault;
+import org.junit.Test;
+import org.openhab.binding.linktap.internal.LinkTapBindingConstants;
+
+import static org.junit.jupiter.api.Assertions.assertEquals;
+import static org.junit.jupiter.api.Assertions.assertFalse;
+import static org.openhab.binding.linktap.protocol.frames.TLGatewayFrame.CMD_PAUSE_WATER_PLAN;
+import static org.openhab.binding.linktap.protocol.frames.TLGatewayFrame.CMD_WIRELESS_CHECK;
+
+/**
+ * Command 18: Pause watering plan for given duration
+ * Flow 1 --> App->Broker->GW: Pause watering plan for given duration 0.1 -> 240 hours
+ */
+@NonNullByDefault
+public class Command18Test {
+
+    /**
+     * Command 18: Pause watering plan for given duration
+     * Flow 1 --> App->Broker->GW: Pause watering plan for given duration 0.1 -> 240 hours
+     */
+    @Test
+    public void RequestWateringPlanPauseGenerationTest() {
+        PauseWateringPlanReq req = new PauseWateringPlanReq();
+        req.gatewayId = "CCCCDDDDEEEEFFFF";
+        req.deviceId = "1111222233334444";
+        req.command = CMD_PAUSE_WATER_PLAN;
+        req.duration = 12d;
+
+        String encoded = LinkTapBindingConstants.GSON.toJson(req);
+
+        assertEquals("{\"duration\":12.0,\"dev_id\":\"1111222233334444\",\"cmd\":18,\"gw_id\":\"CCCCDDDDEEEEFFFF\"}",
+                encoded);
+    }
+
+    /**
+     * Command 18: Pause watering plan for given duration
+     * Flow 1 --> App->Broker->GW: Pause watering plan for given duration 0.1 -> 240 hours
+     */
+    @Test
+    public void RequestWateringPlanPauseResponseDecoding() {
+        final EndpointDeviceResponse decoded = LinkTapBindingConstants.GSON.fromJson("{ \"cmd\":18, \"gw_id\":\"CCCCDDDDEEEEFFFF\", \"dev_id\":\"1122334455667788\", \"ret\":0\n}",EndpointDeviceResponse.class);
+        assertEquals(CMD_PAUSE_WATER_PLAN,decoded.command);
+        assertEquals("CCCCDDDDEEEEFFFF",decoded.gatewayId );
+        assertEquals("1122334455667788",decoded.deviceId );
+        assertEquals(GatewayDeviceResponse.ResultStatus.RET_SUCCESS,decoded.getRes());
+    }
+    
+}
diff --git a/bundles/org.openhab.binding.linktap/src/main/tests/org/openhab/binding/linktap/protocol/frames/Command1Test.java b/bundles/org.openhab.binding.linktap/src/main/tests/org/openhab/binding/linktap/protocol/frames/Command1Test.java
new file mode 100644
index 0000000000000..5fafb07004c35
--- /dev/null
+++ b/bundles/org.openhab.binding.linktap/src/main/tests/org/openhab/binding/linktap/protocol/frames/Command1Test.java
@@ -0,0 +1,63 @@
+/**
+ * Copyright (c) 2010-2024 Contributors to the openHAB project
+ *
+ * See the NOTICE file(s) distributed with this work for additional
+ * information.
+ *
+ * This program and the accompanying materials are made available under the
+ * terms of the Eclipse Public License 2.0 which is available at
+ * http://www.eclipse.org/legal/epl-2.0
+ *
+ * SPDX-License-Identifier: EPL-2.0
+ */
+package org.openhab.binding.linktap.protocol.frames;
+
+import org.eclipse.jdt.annotation.NonNullByDefault;
+import org.junit.Test;
+import org.openhab.binding.linktap.internal.LinkTapBindingConstants;
+
+import java.util.Arrays;
+
+import static org.junit.Assert.assertTrue;
+import static org.junit.jupiter.api.Assertions.assertEquals;
+import static org.openhab.binding.linktap.protocol.frames.TLGatewayFrame.CMD_ADD_END_DEVICE;
+
+/**
+ * Command 1: Add / Register Endpoint Device to Gateway
+ * Flow 1 --> App->Broker->GW: Add specified water timer to gateway
+ */
+@NonNullByDefault
+public class Command1Test {
+
+    /**
+     * Command 1:
+     * Flow 1 --> App->Broker->GW: Add specified water timer to gateway encoding test
+     */
+    @Test
+    public void AddDeviceRequestEncoding() {
+        final GatewayEndDevListReq req = new GatewayEndDevListReq();
+        req.command = CMD_ADD_END_DEVICE;
+        req.gatewayId = "CCCCDDDDEEEEFFFF";
+        req.endDevices = new String[] {"11112222333344448888","77778889333366661111"};
+
+        String encoded = LinkTapBindingConstants.GSON.toJson(req);
+
+        assertEquals("{\"end_dev\":[\"11112222333344448888\",\"77778889333366661111\"],\"cmd\":1,\"gw_id\":\"CCCCDDDDEEEEFFFF\"}",
+                encoded);
+    }
+
+    /**
+     * Command 1:
+     * Flow 1 --> App->Broker->GW: Add specified water timer to gateway response decoding test
+     */
+    @Test
+    public void AddDeviceRequestResponseDecoding() {
+        final GatewayDeviceResponse decoded = LinkTapBindingConstants.GSON.fromJson("{ \"cmd\":1, \"gw_id\":\"CCCCDDDDEEEEFFFF\", \"ret\":0\n" +
+                "}",GatewayDeviceResponse.class);
+
+        assertEquals(CMD_ADD_END_DEVICE,decoded.command);
+        assertEquals("CCCCDDDDEEEEFFFF",decoded.gatewayId );
+        assertEquals(GatewayDeviceResponse.ResultStatus.RET_SUCCESS,decoded.getRes());
+    }
+
+}
diff --git a/bundles/org.openhab.binding.linktap/src/main/tests/org/openhab/binding/linktap/protocol/frames/Command2Test.java b/bundles/org.openhab.binding.linktap/src/main/tests/org/openhab/binding/linktap/protocol/frames/Command2Test.java
new file mode 100644
index 0000000000000..63ee1df156df7
--- /dev/null
+++ b/bundles/org.openhab.binding.linktap/src/main/tests/org/openhab/binding/linktap/protocol/frames/Command2Test.java
@@ -0,0 +1,59 @@
+/**
+ * Copyright (c) 2010-2024 Contributors to the openHAB project
+ *
+ * See the NOTICE file(s) distributed with this work for additional
+ * information.
+ *
+ * This program and the accompanying materials are made available under the
+ * terms of the Eclipse Public License 2.0 which is available at
+ * http://www.eclipse.org/legal/epl-2.0
+ *
+ * SPDX-License-Identifier: EPL-2.0
+ */
+package org.openhab.binding.linktap.protocol.frames;
+
+import org.eclipse.jdt.annotation.NonNullByDefault;
+import org.junit.Test;
+import org.openhab.binding.linktap.internal.LinkTapBindingConstants;
+
+import static org.junit.jupiter.api.Assertions.assertEquals;
+import static org.openhab.binding.linktap.protocol.frames.TLGatewayFrame.CMD_REMOVE_END_DEVICE;
+
+/**
+ * Command 2: Delete / Unregister Endpoint Device to Gateway
+ * Flow 1 --> App->Broker->GW: Delete specified water timer to gateway
+ */
+@NonNullByDefault
+public class Command2Test {
+
+    /**
+     * Command 1:
+     * Flow 1 --> App->Broker->GW: Delete specified water timer to gateway encoding test
+     */
+    @Test
+    public void DeleteDeviceRequestEncoding() {
+        final GatewayEndDevListReq req = new GatewayEndDevListReq();
+        req.command = CMD_REMOVE_END_DEVICE;
+        req.gatewayId = "CCCCDDDDEEEEFFFF";
+        req.endDevices = new String[] {"1111222233334444","7777888933336666"};
+
+        String encoded = LinkTapBindingConstants.GSON.toJson(req);
+
+        assertEquals("{\"end_dev\":[\"1111222233334444\",\"7777888933336666\"],\"cmd\":2,\"gw_id\":\"CCCCDDDDEEEEFFFF\"}",
+                encoded);
+    }
+
+    /**
+     * Command 2:
+     * Flow 2 --> App->Broker->GW: Delete specified water timer to gateway response decoding test
+     */
+    @Test
+    public void DeleteDeviceRequestResponseDecoding() {
+        final GatewayDeviceResponse decoded = LinkTapBindingConstants.GSON.fromJson("{ \"cmd\":2, \"gw_id\":\"CCCCDDDDEEEEFFFF\", \"ret\":0\n}",GatewayDeviceResponse.class);
+
+        assertEquals(CMD_REMOVE_END_DEVICE,decoded.command);
+        assertEquals("CCCCDDDDEEEEFFFF",decoded.gatewayId );
+        assertEquals(GatewayDeviceResponse.ResultStatus.RET_SUCCESS,decoded.getRes());
+    }
+
+}
diff --git a/bundles/org.openhab.binding.linktap/src/main/tests/org/openhab/binding/linktap/protocol/frames/Command3Test.java b/bundles/org.openhab.binding.linktap/src/main/tests/org/openhab/binding/linktap/protocol/frames/Command3Test.java
new file mode 100644
index 0000000000000..2937e51b66592
--- /dev/null
+++ b/bundles/org.openhab.binding.linktap/src/main/tests/org/openhab/binding/linktap/protocol/frames/Command3Test.java
@@ -0,0 +1,136 @@
+/**
+ * Copyright (c) 2010-2024 Contributors to the openHAB project
+ *
+ * See the NOTICE file(s) distributed with this work for additional
+ * information.
+ *
+ * This program and the accompanying materials are made available under the
+ * terms of the Eclipse Public License 2.0 which is available at
+ * http://www.eclipse.org/legal/epl-2.0
+ *
+ * SPDX-License-Identifier: EPL-2.0
+ */
+package org.openhab.binding.linktap.protocol.frames;
+
+import org.eclipse.jdt.annotation.NonNullByDefault;
+import org.junit.Test;
+import org.openhab.binding.linktap.internal.LinkTapBindingConstants;
+
+import static org.junit.jupiter.api.Assertions.*;
+import static org.openhab.binding.linktap.protocol.frames.TLGatewayFrame.CMD_UPDATE_WATER_TIMER_STATUS;
+
+/**
+ * Command 3: Water Timer Status Update Notification
+ * Flow 1 --> GW->Broker->App: Notification that there is a update to one or more water timer's
+ *   Default format --> object's within an array
+ *   Optional format --> object not wrapped within an array
+ * Flow 2 --> App->Broker->GW: Request Water Timer Status
+ *
+ * (ret is only provided in case of an error so -1 would be the same as if 0 was provided)
+ */
+@NonNullByDefault
+public class Command3Test {
+
+    /**
+     * Command 3: Water Timer Status Update Notification
+     * Flow 1 --> GW->Broker->App: Notification that there is a update to one or more water timer's
+     *   Default format --> object's within an array
+     *   Optional format --> object not wrapped within an array
+     * Flow 2 --> App->Broker->GW: Request Water Timer Status
+     */
+    @Test
+    public void NotificationTimerUpdateRequest1Decoding() {
+        final WaterMeterStatus decoded = LinkTapBindingConstants.GSON.fromJson("{ \"cmd\":3, \"gw_id\":\"CCCCDDDDEEEEFFFF\", \"dev_stat\": [ { \"dev_id\":\"1111222233334444\", \"plan_mode\":2, \"plan_sn\":3134, \"is_rf_linked\":true, \"is_flm_plugin\":false, \"is_fall\":false, \"is_broken\":false, \"is_cutoff\":false, \"is_leak\":false, \"is_clog\":false, \"signal\":100, \"battery\":0, \"child_lock\":0, \"is_manual_mode\":false, \"is_watering\":false, \"is_final\":true, \"total_duration\":0, \"remain_duration\":0, \"speed\":0, \"volume\":0\n} ]\n}",WaterMeterStatus.class);
+
+        assertEquals(CMD_UPDATE_WATER_TIMER_STATUS,decoded.command);
+        assertEquals("CCCCDDDDEEEEFFFF",decoded.gatewayId );
+        assertNotNull(decoded.deviceStatuses);
+        assertEquals(1,decoded.deviceStatuses.size());
+        assertEquals("1111222233334444",decoded.deviceStatuses.get(0).deviceId);
+        assertEquals(2,decoded.deviceStatuses.get(0).planMode);
+        assertEquals(3134,decoded.deviceStatuses.get(0).planSerialNo);
+        assertTrue(decoded.deviceStatuses.get(0).isRfLinked);
+        assertFalse(decoded.deviceStatuses.get(0).isFlmPlugin);
+        assertFalse(decoded.deviceStatuses.get(0).isBroken);
+        assertFalse(decoded.deviceStatuses.get(0).isCutoff);
+        assertFalse(decoded.deviceStatuses.get(0).isLeak);
+        assertFalse(decoded.deviceStatuses.get(0).isClog);
+        assertEquals(100,decoded.deviceStatuses.get(0).signal);
+        assertEquals(0,decoded.deviceStatuses.get(0).battery);
+        assertEquals(0,decoded.deviceStatuses.get(0).childLock);
+        assertFalse(decoded.deviceStatuses.get(0).isManualMode);
+        assertFalse(decoded.deviceStatuses.get(0).isWatering);
+        assertTrue(decoded.deviceStatuses.get(0).isFinal);
+        assertEquals(0,decoded.deviceStatuses.get(0).totalDuration);
+        assertEquals(0,decoded.deviceStatuses.get(0).remainDuration);
+        assertEquals(0,decoded.deviceStatuses.get(0).speed);
+        assertEquals(0,decoded.deviceStatuses.get(0).volume);
+        assertEquals(GatewayDeviceResponse.ResultStatus.RET_SUCCESS,decoded.getRes()); // Only given in case of error
+        assertEquals(GatewayDeviceResponse.ResultStatus.RET_SUCCESS,decoded.getRes());
+    }
+
+    /**
+     * Command 3: Water Timer Status Update Notification
+     * Flow 1 --> GW->Broker->App: Notification that there is a update to one water timer
+     * Optional format --> object's without array wrapper
+     */
+    @Test
+    public void NotificationTimerUpdateRequest2Decoding() {
+        final WaterMeterStatus decoded = LinkTapBindingConstants.GSON.fromJson("{ \"cmd\":3, \"gw_id\":\"CCCCDDDDEEEEFFFF\", \"dev_stat\": { \"dev_id\":\"1111222233334444\", \"plan_mode\":2, \"plan_sn\":3134, \"is_rf_linked\":true, \"is_flm_plugin\":false, \"is_fall\":false, \"is_broken\":false, \"is_cutoff\":false, \"is_leak\":false, \"is_clog\":false, \"signal\":100, \"battery\":0, \"child_lock\":0, \"is_manual_mode\":false, \"is_watering\":false, \"is_final\":true, \"total_duration\":0, \"remain_duration\":0, \"speed\":0, \"volume\":0\n}\n}",WaterMeterStatus.class);
+
+        assertEquals(CMD_UPDATE_WATER_TIMER_STATUS,decoded.command);
+        assertEquals("CCCCDDDDEEEEFFFF",decoded.gatewayId );
+        assertEquals(1,decoded.deviceStatuses.size());
+        assertEquals("1111222233334444",decoded.deviceStatuses.get(0).deviceId);
+        assertEquals(2,decoded.deviceStatuses.get(0).planMode);
+        assertEquals(3134,decoded.deviceStatuses.get(0).planSerialNo);
+        assertTrue(decoded.deviceStatuses.get(0).isRfLinked);
+        assertFalse(decoded.deviceStatuses.get(0).isFlmPlugin);
+        assertFalse(decoded.deviceStatuses.get(0).isBroken);
+        assertFalse(decoded.deviceStatuses.get(0).isCutoff);
+        assertFalse(decoded.deviceStatuses.get(0).isLeak);
+        assertFalse(decoded.deviceStatuses.get(0).isClog);
+        assertEquals(100,decoded.deviceStatuses.get(0).signal);
+        assertEquals(0,decoded.deviceStatuses.get(0).battery);
+        assertEquals(0,decoded.deviceStatuses.get(0).childLock);
+        assertFalse(decoded.deviceStatuses.get(0).isManualMode);
+        assertFalse(decoded.deviceStatuses.get(0).isWatering);
+        assertTrue(decoded.deviceStatuses.get(0).isFinal);
+        assertEquals(0,decoded.deviceStatuses.get(0).totalDuration);
+        assertEquals(0,decoded.deviceStatuses.get(0).remainDuration);
+        assertEquals(0,decoded.deviceStatuses.get(0).speed);
+        assertEquals(0,decoded.deviceStatuses.get(0).volume);
+        assertEquals(GatewayDeviceResponse.ResultStatus.RET_SUCCESS,decoded.getRes()); // Only given in case of error
+        assertEquals(GatewayDeviceResponse.ResultStatus.RET_SUCCESS,decoded.getRes());
+    }
+
+    /**
+     * Command 3: Water Timer Status Update Notification
+     * Flow 2 --> App->Broker->GW: Request Water Timer Status
+     */
+    @Test
+    public void RequestWaterMeterStatusGenerationTest() {
+        DeviceCmdReq req = new DeviceCmdReq();
+        req.gatewayId = "CCCCDDDDEEEEFFFF";
+        req.deviceId = "1111222233334444";
+        req.command = CMD_UPDATE_WATER_TIMER_STATUS;
+
+        String encoded = LinkTapBindingConstants.GSON.toJson(req);
+
+        assertEquals("{\"dev_id\":\"1111222233334444\",\"cmd\":3,\"gw_id\":\"CCCCDDDDEEEEFFFF\"}",
+                encoded);
+    }
+
+    /**
+     * Command 3: Water Timer Status Update Notification
+     * Flow 2 --> App->Broker->GW: Request Water Timer Status
+     */
+    @Test
+    public void RequestWaterMeterStatusErrorResponseDecoding() {
+        final WaterMeterStatus decoded = LinkTapBindingConstants.GSON.fromJson("{ \"cmd\":3, \"gw_id\":\"CCCCDDDDEEEEFFFF\", \"ret\":5\n}",WaterMeterStatus.class);
+
+        assertEquals(CMD_UPDATE_WATER_TIMER_STATUS,decoded.command);
+        assertEquals("CCCCDDDDEEEEFFFF",decoded.gatewayId );
+        assertEquals(GatewayDeviceResponse.ResultStatus.RET_DEVICE_NOT_FOUND,decoded.getRes());
+    }
+}
diff --git a/bundles/org.openhab.binding.linktap/src/main/tests/org/openhab/binding/linktap/protocol/frames/Command5Test.java b/bundles/org.openhab.binding.linktap/src/main/tests/org/openhab/binding/linktap/protocol/frames/Command5Test.java
new file mode 100644
index 0000000000000..eacc35b697c21
--- /dev/null
+++ b/bundles/org.openhab.binding.linktap/src/main/tests/org/openhab/binding/linktap/protocol/frames/Command5Test.java
@@ -0,0 +1,60 @@
+/**
+ * Copyright (c) 2010-2024 Contributors to the openHAB project
+ *
+ * See the NOTICE file(s) distributed with this work for additional
+ * information.
+ *
+ * This program and the accompanying materials are made available under the
+ * terms of the Eclipse Public License 2.0 which is available at
+ * http://www.eclipse.org/legal/epl-2.0
+ *
+ * SPDX-License-Identifier: EPL-2.0
+ */
+package org.openhab.binding.linktap.protocol.frames;
+
+import org.eclipse.jdt.annotation.NonNullByDefault;
+import org.junit.Test;
+import org.openhab.binding.linktap.internal.LinkTapBindingConstants;
+
+import static org.junit.jupiter.api.Assertions.assertEquals;
+import static org.openhab.binding.linktap.protocol.frames.TLGatewayFrame.CMD_REMOVE_WATER_PLAN;
+
+/**
+ * Command 5: Delete Watering Plan from Device Endpoint
+ * Flow 1 --> App->Broker->GW: Delete existing watering plan from device
+ */
+@NonNullByDefault
+public class Command5Test {
+
+    /**
+     * Command 5:
+     * Flow 1 --> App->Broker->GW: Delete existing watering plan from device encoding test
+     */
+    @Test
+    public void DeleteWateringPlanRequestEncoding() {
+        final DeviceCmdReq req = new DeviceCmdReq();
+        req.command = CMD_REMOVE_WATER_PLAN;
+        req.gatewayId = "CCCCDDDDEEEEFFFF";
+        req.deviceId = "1111222233334444";
+
+        String encoded = LinkTapBindingConstants.GSON.toJson(req);
+
+        assertEquals("{\"dev_id\":\"1111222233334444\",\"cmd\":5,\"gw_id\":\"CCCCDDDDEEEEFFFF\"}",
+                encoded);
+    }
+
+    /**
+     * Command 5:
+     * Flow 1 --> App->Broker->GW: Delete existing watering plan from device response decoding test
+     */
+    @Test
+    public void DeleteWateringPlanRequestResponseDecoding() {
+        final EndpointDeviceResponse decoded = LinkTapBindingConstants.GSON.fromJson("{ \"cmd\":5, \"gw_id\":\"CCCCDDDDEEEEFFFF\", \"dev_id\":\"1111222233334444\", \"ret\":0\n}",EndpointDeviceResponse.class);
+
+        assertEquals(CMD_REMOVE_WATER_PLAN,decoded.command);
+        assertEquals("CCCCDDDDEEEEFFFF",decoded.gatewayId );
+        assertEquals("1111222233334444",decoded.deviceId);
+        assertEquals(GatewayDeviceResponse.ResultStatus.RET_SUCCESS,decoded.getRes());
+    }
+
+}
diff --git a/bundles/org.openhab.binding.linktap/src/main/tests/org/openhab/binding/linktap/protocol/frames/Command6Test.java b/bundles/org.openhab.binding.linktap/src/main/tests/org/openhab/binding/linktap/protocol/frames/Command6Test.java
new file mode 100644
index 0000000000000..acd15f6d39415
--- /dev/null
+++ b/bundles/org.openhab.binding.linktap/src/main/tests/org/openhab/binding/linktap/protocol/frames/Command6Test.java
@@ -0,0 +1,63 @@
+/**
+ * Copyright (c) 2010-2024 Contributors to the openHAB project
+ *
+ * See the NOTICE file(s) distributed with this work for additional
+ * information.
+ *
+ * This program and the accompanying materials are made available under the
+ * terms of the Eclipse Public License 2.0 which is available at
+ * http://www.eclipse.org/legal/epl-2.0
+ *
+ * SPDX-License-Identifier: EPL-2.0
+ */
+package org.openhab.binding.linktap.protocol.frames;
+
+import org.eclipse.jdt.annotation.NonNullByDefault;
+import org.junit.Test;
+import org.openhab.binding.linktap.internal.LinkTapBindingConstants;
+
+import static org.junit.jupiter.api.Assertions.assertEquals;
+import static org.openhab.binding.linktap.protocol.frames.TLGatewayFrame.CMD_IMMEDIATE_WATER_START;
+import static org.openhab.binding.linktap.protocol.frames.TLGatewayFrame.CMD_IMMEDIATE_WATER_STOP;
+
+/**
+ * Command 6: Start watering immediately
+ * Flow 1 --> App->Broker->GW: Start watering immediately, once time only for the given parameters
+ */
+@NonNullByDefault
+public class Command6Test {
+
+    /**
+     * Command 6:
+     * Flow 1 --> App->Broker->GW: Start watering immediately, once time only for the given parameters
+     */
+    @Test
+    public void StartWateringRequestEncoding() {
+        final StartWateringReq req = new StartWateringReq();
+        req.command = CMD_IMMEDIATE_WATER_START;
+        req.gatewayId = "CCCCDDDDEEEEFFFF";
+        req.deviceId = "1111222233334444";
+        req.duration = 60;
+        req.volume = 0;
+
+        String encoded = LinkTapBindingConstants.GSON.toJson(req);
+
+        assertEquals("{\"duration\":60,\"volume\":0,\"dev_id\":\"1111222233334444\",\"cmd\":6,\"gw_id\":\"CCCCDDDDEEEEFFFF\"}",
+                encoded);
+    }
+
+    /**
+     * Command 6:
+     * Flow 1 --> App->Broker->GW: Start watering immediately, once time only for the given parameters
+     */
+    @Test
+    public void StartWateringRequestResponseDecoding() {
+        final EndpointDeviceResponse decoded = LinkTapBindingConstants.GSON.fromJson("{ \"cmd\":6, \"gw_id\":\"CCCCDDDDEEEEFFFF\", \"dev_id\":\"1111222233334444\", \"ret\":0\n}",EndpointDeviceResponse.class);
+
+        assertEquals(CMD_IMMEDIATE_WATER_START,decoded.command);
+        assertEquals("CCCCDDDDEEEEFFFF",decoded.gatewayId );
+        assertEquals("1111222233334444",decoded.deviceId);
+        assertEquals(GatewayDeviceResponse.ResultStatus.RET_SUCCESS,decoded.getRes());
+    }
+
+}
diff --git a/bundles/org.openhab.binding.linktap/src/main/tests/org/openhab/binding/linktap/protocol/frames/Command7Test.java b/bundles/org.openhab.binding.linktap/src/main/tests/org/openhab/binding/linktap/protocol/frames/Command7Test.java
new file mode 100644
index 0000000000000..2b6fd9a36957e
--- /dev/null
+++ b/bundles/org.openhab.binding.linktap/src/main/tests/org/openhab/binding/linktap/protocol/frames/Command7Test.java
@@ -0,0 +1,61 @@
+/**
+ * Copyright (c) 2010-2024 Contributors to the openHAB project
+ *
+ * See the NOTICE file(s) distributed with this work for additional
+ * information.
+ *
+ * This program and the accompanying materials are made available under the
+ * terms of the Eclipse Public License 2.0 which is available at
+ * http://www.eclipse.org/legal/epl-2.0
+ *
+ * SPDX-License-Identifier: EPL-2.0
+ */
+package org.openhab.binding.linktap.protocol.frames;
+
+import org.eclipse.jdt.annotation.NonNullByDefault;
+import org.junit.Test;
+import org.openhab.binding.linktap.internal.LinkTapBindingConstants;
+
+import static org.junit.jupiter.api.Assertions.assertEquals;
+import static org.openhab.binding.linktap.protocol.frames.TLGatewayFrame.CMD_IMMEDIATE_WATER_STOP;
+import static org.openhab.binding.linktap.protocol.frames.TLGatewayFrame.CMD_REMOVE_WATER_PLAN;
+
+/**
+ * Command 7: Stop watering immediately
+ * Flow 1 --> App->Broker->GW: Stop watering immediately, next cycled watering plan will still run
+ */
+@NonNullByDefault
+public class Command7Test {
+
+    /**
+     * Command 7:
+     * Flow 1 --> App->Broker->GW: Stop watering immediately, next cycled watering plan will still run
+     */
+    @Test
+    public void StopWateringRequestEncoding() {
+        final DeviceCmdReq req = new DeviceCmdReq();
+        req.command = CMD_IMMEDIATE_WATER_STOP;
+        req.gatewayId = "CCCCDDDDEEEEFFFF";
+        req.deviceId = "1111222233334444";
+
+        String encoded = LinkTapBindingConstants.GSON.toJson(req);
+
+        assertEquals("{\"dev_id\":\"1111222233334444\",\"cmd\":7,\"gw_id\":\"CCCCDDDDEEEEFFFF\"}",
+                encoded);
+    }
+
+    /**
+     * Command 7:
+     * Flow 1 --> App->Broker->GW: Stop watering immediately, next cycled watering plan will still run
+     */
+    @Test
+    public void StopWateringRequestResponseDecoding() {
+        final EndpointDeviceResponse decoded = LinkTapBindingConstants.GSON.fromJson("{ \"cmd\":7, \"gw_id\":\"CCCCDDDDEEEEFFFF\", \"dev_id\":\"1111222233334444\", \"ret\":0\n}",EndpointDeviceResponse.class);
+
+        assertEquals(CMD_IMMEDIATE_WATER_STOP,decoded.command);
+        assertEquals("CCCCDDDDEEEEFFFF",decoded.gatewayId );
+        assertEquals("1111222233334444",decoded.deviceId);
+        assertEquals(GatewayDeviceResponse.ResultStatus.RET_SUCCESS,decoded.getRes());
+    }
+
+}
diff --git a/bundles/org.openhab.binding.linktap/src/main/tests/org/openhab/binding/linktap/protocol/frames/Command8Test.java b/bundles/org.openhab.binding.linktap/src/main/tests/org/openhab/binding/linktap/protocol/frames/Command8Test.java
new file mode 100644
index 0000000000000..7090c535f6b89
--- /dev/null
+++ b/bundles/org.openhab.binding.linktap/src/main/tests/org/openhab/binding/linktap/protocol/frames/Command8Test.java
@@ -0,0 +1,96 @@
+/**
+ * Copyright (c) 2010-2024 Contributors to the openHAB project
+ *
+ * See the NOTICE file(s) distributed with this work for additional
+ * information.
+ *
+ * This program and the accompanying materials are made available under the
+ * terms of the Eclipse Public License 2.0 which is available at
+ * http://www.eclipse.org/legal/epl-2.0
+ *
+ * SPDX-License-Identifier: EPL-2.0
+ */
+package org.openhab.binding.linktap.protocol.frames;
+
+import static org.junit.jupiter.api.Assertions.*;
+import static org.openhab.binding.linktap.protocol.frames.TLGatewayFrame.CMD_RAINFALL_DATA;
+
+import org.eclipse.jdt.annotation.NonNullByDefault;
+import org.junit.Test;
+import org.openhab.binding.linktap.internal.LinkTapBindingConstants;
+
+/**
+ * Command 8: Rain Data
+ * Flow 1 --> GW->Broker->App: Request for rain data
+ * Flow 2 --> App->Broker->GW: Push to update rain data
+ */
+@NonNullByDefault
+public class Command8Test {
+
+    /**
+     * Command 8:
+     * Flow 1 --> GW->Broker->App: Request for Rain Data Decoding Test
+     */
+    @Test
+    public void RainDataRequestDecoding() {
+        final TLGatewayFrame decoded = LinkTapBindingConstants.GSON.fromJson("{ \"cmd\":8, \"gw_id\":\"CCCCDDDDEEEEFFFF\"\n" +
+                "}",TLGatewayFrame.class);
+
+        assertEquals(CMD_RAINFALL_DATA,decoded.command);
+        assertEquals("CCCCDDDDEEEEFFFF",decoded.gatewayId );
+    }
+
+    /**
+     * Command 8:
+     * Flow 1 --> GW->Broker->App: Response serialisation test for Rain Data reply
+     */
+    @Test
+    public void RainDataRequestResponseGenerationTest() {
+        RainDataForecast forecastReply = new RainDataForecast();
+        forecastReply.command = CMD_RAINFALL_DATA;
+        forecastReply.gatewayId = "CCCCDDDDEEEEFFFF";
+        forecastReply.setPastRainfall(2.5);
+        forecastReply.setFutureRainfall(6.3);
+        forecastReply.validDuration = 60;
+
+        String encoded = LinkTapBindingConstants.GSON.toJson(forecastReply);
+
+        assertEquals("{\"valid_duration\":60,\"rain\":[2.5,6.3],\"cmd\":8,\"gw_id\":\"CCCCDDDDEEEEFFFF\"}",
+                encoded);
+    }
+
+    /**
+     * Command 8:
+     * Flow 2 --> App->Broker->GW: Push of Rain Data to Gateway request serialisation
+     */
+    @Test
+    public void RainDataPushGenerationTest() {
+        RainDataForecast req = new RainDataForecast();
+        req.command = CMD_RAINFALL_DATA;
+        req.gatewayId = "CCCCDDDDEEEEFFFF";
+        req.setPastRainfall(2.5);
+        req.setFutureRainfall(6.3);
+        req.validDuration = 60;
+
+        String encoded = LinkTapBindingConstants.GSON.toJson(req);
+
+        assertEquals("{\"valid_duration\":60,\"rain\":[2.5,6.3],\"cmd\":8,\"gw_id\":\"CCCCDDDDEEEEFFFF\"}",
+                encoded);
+    }
+
+    /**
+     * Command 8:
+     * Flow 2 --> App->Broker->GW: Response decoding test for Rain Data Push reply
+     */
+    @Test
+    public void RainDataPushResponseDecoding() {
+        final GatewayDeviceResponse decoded = LinkTapBindingConstants.GSON.fromJson("{ \"cmd\":8, \"gw_id\":\"CCCCDDDDEEEEFFFF\", \"ret\":0\n" +
+                "}",GatewayDeviceResponse.class);
+
+        assertEquals(CMD_RAINFALL_DATA,decoded.command);
+        assertEquals("CCCCDDDDEEEEFFFF",decoded.gatewayId );
+        assertEquals(GatewayDeviceResponse.ResultStatus.RET_SUCCESS,decoded.getRes());
+    }
+
+
+}
diff --git a/bundles/org.openhab.binding.linktap/src/main/tests/org/openhab/binding/linktap/protocol/frames/Command9Test.java b/bundles/org.openhab.binding.linktap/src/main/tests/org/openhab/binding/linktap/protocol/frames/Command9Test.java
new file mode 100644
index 0000000000000..2051ad4ba5730
--- /dev/null
+++ b/bundles/org.openhab.binding.linktap/src/main/tests/org/openhab/binding/linktap/protocol/frames/Command9Test.java
@@ -0,0 +1,46 @@
+/**
+ * Copyright (c) 2010-2024 Contributors to the openHAB project
+ *
+ * See the NOTICE file(s) distributed with this work for additional
+ * information.
+ *
+ * This program and the accompanying materials are made available under the
+ * terms of the Eclipse Public License 2.0 which is available at
+ * http://www.eclipse.org/legal/epl-2.0
+ *
+ * SPDX-License-Identifier: EPL-2.0
+ */
+package org.openhab.binding.linktap.protocol.frames;
+
+import org.eclipse.jdt.annotation.NonNullByDefault;
+import org.junit.Test;
+import org.openhab.binding.linktap.internal.LinkTapBindingConstants;
+
+import static org.junit.jupiter.api.Assertions.assertEquals;
+import static org.junit.jupiter.api.Assertions.assertNotNull;
+import static org.openhab.binding.linktap.protocol.frames.TLGatewayFrame.CMD_NOTIFICATION_WATERING_SKIPPED;
+
+/**
+ * Command 9: Watering Skipped Notification
+ * Flow 1 --> App->Broker->GW: Notification that watering was skipped with the rainfall data
+ */
+@NonNullByDefault
+public class Command9Test {
+
+    /**
+     * Command 9:
+     * Flow 1 --> GW->Broker->App: Notification that watering was skipped with the rainfall data
+     */
+    @Test
+    public void NotificationWateringSkippedRequestDecoding() {
+        final WateringSkippedNotification decoded = LinkTapBindingConstants.GSON.fromJson("{ \"cmd\":9, \"gw_id\":\"CCCCDDDDEEEEFFFF\",\n\"dev_id\":\"1111222233334444\", \"rain\":[2.5,6.3]\n}",WateringSkippedNotification.class);
+
+        assertNotNull(decoded);
+        assertEquals(CMD_NOTIFICATION_WATERING_SKIPPED,decoded.command);
+        assertEquals("CCCCDDDDEEEEFFFF",decoded.gatewayId );
+        assertEquals("1111222233334444", decoded.deviceId);
+        assertEquals(2, decoded.rainfallData.length);
+        assertEquals(2.5,decoded.rainfallData[0]);
+        assertEquals(6.3,decoded.rainfallData[1]);
+    }
+}
diff --git a/bundles/pom.xml b/bundles/pom.xml
index 33b950b9ec09c..2cbee578bc025 100644
--- a/bundles/pom.xml
+++ b/bundles/pom.xml
@@ -7,7 +7,7 @@
   <parent>
     <groupId>org.openhab.addons</groupId>
     <artifactId>org.openhab.addons.reactor</artifactId>
-    <version>4.2.0-SNAPSHOT</version>
+    <version>4.3.0-SNAPSHOT</version>
   </parent>
 
   <groupId>org.openhab.addons.bundles</groupId>
@@ -55,12 +55,14 @@
     <module>org.openhab.binding.allplay</module>
     <module>org.openhab.binding.amazondashbutton</module>
     <module>org.openhab.binding.amazonechocontrol</module>
+    <module>org.openhab.binding.amberelectric</module>
     <module>org.openhab.binding.ambientweather</module>
     <module>org.openhab.binding.amplipi</module>
     <module>org.openhab.binding.androiddebugbridge</module>
     <module>org.openhab.binding.androidtv</module>
     <module>org.openhab.binding.anel</module>
     <module>org.openhab.binding.anthem</module>
+    <module>org.openhab.binding.argoclima</module>
     <module>org.openhab.binding.astro</module>
     <module>org.openhab.binding.asuswrt</module>
     <module>org.openhab.binding.atlona</module>
@@ -129,6 +131,7 @@
     <module>org.openhab.binding.electroluxair</module>
     <module>org.openhab.binding.elerotransmitterstick</module>
     <module>org.openhab.binding.elroconnects</module>
+    <module>org.openhab.binding.emotiva</module>
     <module>org.openhab.binding.energenie</module>
     <module>org.openhab.binding.energidataservice</module>
     <module>org.openhab.binding.enigma2</module>
@@ -224,6 +227,7 @@
     <module>org.openhab.binding.lifx</module>
     <module>org.openhab.binding.linky</module>
     <module>org.openhab.binding.linuxinput</module>
+	<module>org.openhab.binding.linktap</module>
     <module>org.openhab.binding.liquidcheck</module>
     <module>org.openhab.binding.lirc</module>
     <module>org.openhab.binding.livisismarthome</module>
@@ -244,6 +248,7 @@
     <module>org.openhab.binding.meteoalerte</module>
     <module>org.openhab.binding.meteoblue</module>
     <module>org.openhab.binding.meteostick</module>
+    <module>org.openhab.binding.mffan</module>
     <module>org.openhab.binding.miele</module>
     <module>org.openhab.binding.mielecloud</module>
     <module>org.openhab.binding.mihome</module>
@@ -309,8 +314,10 @@
     <module>org.openhab.binding.orvibo</module>
     <module>org.openhab.binding.panasonicbdp</module>
     <module>org.openhab.binding.paradoxalarm</module>
+    <module>org.openhab.binding.pegelonline</module>
     <module>org.openhab.binding.pentair</module>
     <module>org.openhab.binding.phc</module>
+    <module>org.openhab.binding.pihole</module>
     <module>org.openhab.binding.pilight</module>
     <module>org.openhab.binding.pioneeravr</module>
     <module>org.openhab.binding.pixometer</module>
@@ -358,6 +365,7 @@
     <module>org.openhab.binding.serialbutton</module>
     <module>org.openhab.binding.shelly</module>
     <module>org.openhab.binding.silvercrestwifisocket</module>
+    <module>org.openhab.binding.siemenshvac</module>
     <module>org.openhab.binding.siemensrds</module>
     <module>org.openhab.binding.sinope</module>
     <module>org.openhab.binding.sleepiq</module>
@@ -372,6 +380,7 @@
     <module>org.openhab.binding.solaredge</module>
     <module>org.openhab.binding.solarforecast</module>
     <module>org.openhab.binding.solarlog</module>
+    <module>org.openhab.binding.solarman</module>
     <module>org.openhab.binding.solarmax</module>
     <module>org.openhab.binding.solarwatt</module>
     <module>org.openhab.binding.solax</module>
@@ -398,6 +407,8 @@
     <module>org.openhab.binding.teleinfo</module>
     <module>org.openhab.binding.tellstick</module>
     <module>org.openhab.binding.tesla</module>
+    <module>org.openhab.binding.teslapowerwall</module>
+    <module>org.openhab.binding.teslascope</module>
     <module>org.openhab.binding.tibber</module>
     <module>org.openhab.binding.tivo</module>
     <module>org.openhab.binding.touchwand</module>
@@ -467,6 +478,7 @@
     <module>org.openhab.voice.voicerss</module>
     <module>org.openhab.voice.voskstt</module>
     <module>org.openhab.voice.watsonstt</module>
+    <module>org.openhab.voice.whisperstt</module>
   </modules>
 
   <properties>