Import ESP_UniClock (upstream 1189810)

Vendored from https://github.com/gpeter62/ESP_UniClock: the sketch source, the web UI and the libraries the ESP8266 build needs, unpacked from the bundled zips. Adds a PlatformIO project for the ESP-12. The source is unchanged; local changes follow as separate commits. Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-10-25 20:48:04 +01:00
1 parent 8efa810e4e
commit b347f1c63f
@@ -0,0 +1,66 @@
+#include <Ethernet.h>
+#include <ArduinoHA.h>
+
+#define INPUT_PIN       9
+#define BROKER_ADDR     IPAddress(192,168,0,17)
+
+byte mac[] = {0x00, 0x10, 0xFA, 0x6E, 0x38, 0x4A};
+unsigned long lastReadAt = millis();
+unsigned long lastAvailabilityToggleAt = millis();
+bool lastInputState = false;
+
+EthernetClient client;
+HADevice device(mac, sizeof(mac));
+HAMqtt mqtt(client, device);
+
+// "input" is unique ID of the sensor. You should define you own ID.
+// "door" is device class (based on the class HA displays different icons in the panel)
+// "true" is initial state of the sensor. In this example it's "true" as we use pullup resistor
+HABinarySensor sensor("input", "door", true);
+
+void setup() {
+    pinMode(INPUT_PIN, INPUT_PULLUP);
+    lastInputState = digitalRead(INPUT_PIN);
+
+    // you don't need to verify return status
+    Ethernet.begin(mac);
+
+    lastReadAt = millis();
+    lastAvailabilityToggleAt = millis();
+
+    // set device's details (optional)
+    device.setName("Arduino");
+    device.setSoftwareVersion("1.0.0");
+
+    sensor.setName("Door sensor"); // optional
+
+    // This method enables availability for all device types registered on the device.
+    // For example, if you have 5 sensors on the same device, you can enable
+    // shared availability and change availability state of all sensors using
+    // single method call "device.setAvailability(false|true)"
+    device.enableSharedAvailability();
+
+    // Optionally, you can enable MQTT LWT feature. If device will lose connection
+    // to the broker, all device types related to it will be marked as offline in
+    // the Home Assistant Panel.
+    device.enableLastWill();
+
+    mqtt.begin(BROKER_ADDR);
+}
+
+void loop() {
+    Ethernet.maintain();
+    mqtt.loop();
+
+    if ((millis() - lastReadAt) > 30) { // read in 30ms interval
+        // library produces MQTT message if a new state is different than the previous one
+        sensor.setState(digitalRead(INPUT_PIN));
+        lastInputState = sensor.getState();
+        lastReadAt = millis();
+    }
+
+    if ((millis() - lastAvailabilityToggleAt) > 5000) {
+        device.setAvailability(!device.isOnline());
+        lastAvailabilityToggleAt = millis();
+    }
+}
@@ -0,0 +1,33 @@
+# Home Assistant availability example
+
+This example shows how to use "availability" feature of the Home Assistant.
+It's supported only by following device types:
+* Binary sensor
+* Sensor
+* Switch
+* HVACs
+* Fans
+
+## Initialization and usage
+
+Availability feature is turned off by default. In order to turn it on for the specific
+sensor/switch you need to set initial state of the unit by calling `setAvailability` method.
+
+Example:
+```cpp
+...
+HABinarySensor sensor("input", "door", true, mqtt);
+
+void setup() {
+    // ...
+
+    // method must be called before `mqtt.begin(...)`
+    sensor.setAvailability(false); // offline
+
+    mqtt.begin(BROKER_ADDR);
+}
+...
+```
+
+After availability is set for the very first time you can call `setAvailability` in any time.
+Each time the method is called, the device will publish MQTT message to the broker.
@@ -0,0 +1,59 @@
+#include <Ethernet.h>
+#include <ArduinoHA.h>
+
+#define INPUT_PIN       9
+#define BROKER_ADDR     IPAddress(192,168,0,17)
+
+byte mac[] = {0x00, 0x10, 0xFA, 0x6E, 0x38, 0x4A};
+unsigned long lastReadAt = millis();
+unsigned long lastAvailabilityToggleAt = millis();
+bool lastInputState = false;
+
+EthernetClient client;
+HADevice device(mac, sizeof(mac));
+HAMqtt mqtt(client, device);
+
+// "input" is unique ID of the sensor. You should define you own ID.
+// "door" is device class (based on the class HA displays different icons in the panel)
+// "true" is initial state of the sensor. In this example it's "true" as we use pullup resistor
+HABinarySensor sensor("input", "door", true);
+
+void setup() {
+    pinMode(INPUT_PIN, INPUT_PULLUP);
+    lastInputState = digitalRead(INPUT_PIN);
+
+    // you don't need to verify return status
+    Ethernet.begin(mac);
+
+    // turn on "availability" feature
+    // this method also sets initial availability so you can use "true" or "false"
+    sensor.setAvailability(false);
+
+    lastReadAt = millis();
+    lastAvailabilityToggleAt = millis();
+
+    // set device's details (optional)
+    device.setName("Arduino");
+    device.setSoftwareVersion("1.0.0");
+
+    sensor.setName("Door sensor"); // optional
+
+    mqtt.begin(BROKER_ADDR);
+}
+
+void loop() {
+    Ethernet.maintain();
+    mqtt.loop();
+
+    if ((millis() - lastReadAt) > 30) { // read in 30ms interval
+        // library produces MQTT message if a new state is different than the previous one
+        sensor.setState(digitalRead(INPUT_PIN));
+        lastInputState = sensor.getState();
+        lastReadAt = millis();
+    }
+
+    if ((millis() - lastAvailabilityToggleAt) > 5000) {
+        sensor.setAvailability(!sensor.isOnline());
+        lastAvailabilityToggleAt = millis();
+    }
+}
@@ -0,0 +1,46 @@
+#include <Ethernet.h>
+#include <ArduinoHA.h>
+
+#define INPUT_PIN       9
+#define BROKER_ADDR     IPAddress(192,168,0,17)
+
+byte mac[] = {0x00, 0x10, 0xFA, 0x6E, 0x38, 0x4A};
+unsigned long lastReadAt = millis();
+bool lastInputState = false;
+
+EthernetClient client;
+HADevice device(mac, sizeof(mac));
+HAMqtt mqtt(client, device);
+
+// "input" is unique ID of the sensor. You should define you own ID.
+// "door" is device class (based on the class HA displays different icons in the panel)
+// "true" is initial state of the sensor. In this example it's "true" as we use pullup resistor
+HABinarySensor sensor("input", "door", true);
+
+void setup() {
+    pinMode(INPUT_PIN, INPUT_PULLUP);
+    lastInputState = digitalRead(INPUT_PIN);
+
+    // you don't need to verify return status
+    Ethernet.begin(mac);
+
+    // set device's details (optional)
+    device.setName("Arduino");
+    device.setSoftwareVersion("1.0.0");
+
+    sensor.setName("Door sensor"); // optional
+
+    mqtt.begin(BROKER_ADDR);
+}
+
+void loop() {
+    Ethernet.maintain();
+    mqtt.loop();
+
+    if ((millis() - lastReadAt) > 30) { // read in 30ms interval
+        // library produces MQTT message if a new state is different than the previous one
+        sensor.setState(digitalRead(INPUT_PIN));
+        lastInputState = sensor.getState();
+        lastReadAt = millis();
+    }
+}
@@ -0,0 +1,49 @@
+#include <Ethernet.h>
+#include <ArduinoHA.h>
+
+#define BROKER_ADDR     IPAddress(192,168,0,17)
+
+byte mac[] = {0x00, 0x10, 0xFA, 0x6E, 0x38, 0x4A};
+
+EthernetClient client;
+HADevice device(mac, sizeof(mac));
+HAMqtt mqtt(client, device);
+HACover cover("my-cover"); // "my-cover" is unique ID of the cover. You should define your own ID.
+
+void onCoverCommand(HACover::CoverCommand cmd) {
+    if (cmd == HACover::CommandOpen) {
+        Serial.println("Command: Open");
+        cover.setState(HACover::StateOpening);
+    } else if (cmd == HACover::CommandClose) {
+        Serial.println("Command: Close");
+        cover.setState(HACover::StateClosing);
+    } else if (cmd == HACover::CommandStop) {
+        Serial.println("Command: Stop");
+        cover.setState(HACover::StateStopped);
+    }
+
+    // Available states:
+    // HACover::StateClosed
+    // HACover::StateClosing
+    // HACover::StateOpen
+    // HACover::StateOpening
+    // HACover::StateStopped
+
+    // You can also report position using setPosition() method
+}
+
+void setup() {
+    Serial.begin(9600);
+    Ethernet.begin(mac);
+
+    cover.onCommand(onCoverCommand);
+    cover.setName("My cover"); // optional
+    // cover.setRetain(true); // optionally you can set retain flag
+
+    mqtt.begin(BROKER_ADDR);
+}
+
+void loop() {
+    Ethernet.maintain();
+    mqtt.loop();
+}
@@ -0,0 +1,53 @@
+#include <Ethernet.h>
+#include <ArduinoHA.h>
+
+#define BROKER_ADDR     IPAddress(192,168,0,17)
+
+byte mac[] = {0x00, 0x10, 0xFA, 0x6E, 0x38, 0x4A};
+
+EthernetClient client;
+HADevice device(mac, sizeof(mac));
+HAMqtt mqtt(client, device);
+
+// HAFan::SpeedsFeature enables support for setting different speeds of fan.
+// You can skip this argument if you don't need speed management.
+// "ventilation" is unique ID of the fan. You should define your own ID.
+HAFan fan("ventilation", HAFan::SpeedsFeature);
+
+void onStateChanged(bool state) {
+    Serial.print("State: ");
+    Serial.println(state);
+}
+
+void onSpeedChanged(uint16_t speed) {
+    Serial.print("Speed: ");
+    Serial.println(speed);
+}
+
+void setup() {
+    Serial.begin(9600);
+
+    // you don't need to verify return status
+    Ethernet.begin(mac);
+
+    // set device's details (optional)
+    device.setName("Arduino");
+    device.setSoftwareVersion("1.0.0");
+
+    // configure fan (optional)
+    fan.setName("Bathroom");
+    fan.setRetain(true);
+    fan.setSpeedRangeMin(1);
+    fan.setSpeedRangeMax(100);
+
+    // handle fan states
+    fan.onStateChanged(onStateChanged);
+    fan.onSpeedChanged(onSpeedChanged);
+
+    mqtt.begin(BROKER_ADDR);
+}
+
+void loop() {
+    Ethernet.maintain();
+    mqtt.loop();
+}
@@ -0,0 +1,102 @@
+#include <ESP8266WiFi.h>
+#include <ArduinoHA.h>
+
+#define BROKER_ADDR     IPAddress(192,168,0,17)
+#define WIFI_SSID       "MyNetwork"
+#define WIFI_PASSWORD   "MyPassword"
+
+WiFiClient client;
+HADevice device;
+HAMqtt mqtt(client, device);
+
+// see src/device-types/HAHVAC.h header for more details
+HAHVAC hvac("my_name", HAHVAC::AuxHeatingFeature | HAHVAC::AwayModeFeature | HAHVAC::HoldFeature);
+
+unsigned long lastTempPublishAt = 0;
+double lastTemp = 0;
+
+void onAuxHeatingStateChanged(bool state) {
+    Serial.print("Aux heating: ");
+    Serial.println(state);
+}
+
+void onAwayStateChanged(bool state) {
+    Serial.print("Away state: ");
+    Serial.println(state);
+}
+
+void onHoldStateChanged(bool state) {
+    Serial.print("Hold state: ");
+    Serial.println(state);
+}
+
+void onTargetTemperatureChanged(double temp) {
+    Serial.print("Target temperature: ");
+    Serial.println(temp);
+}
+
+void onModeChanged(HAHVAC::Mode mode) {
+    Serial.print("Mode: ");
+    if (mode == HAHVAC::OffMode) {
+        Serial.println("off");
+    } else if (mode == HAHVAC::AutoMode) {
+        Serial.println("auto");
+    } else if (mode == HAHVAC::CoolMode) {
+        Serial.println("cool");
+    } else if (mode == HAHVAC::HeatMode) {
+        Serial.println("heat");
+    } else if (mode == HAHVAC::DryMode) {
+        Serial.println("dry");
+    } else if (mode == HAHVAC::FanOnlyMode) {
+        Serial.println("fan only");
+    }
+}
+
+void setup() {
+    Serial.begin(9600);
+    Serial.println("Starting...");
+
+    // Unique ID must be set!
+    byte mac[WL_MAC_ADDR_LENGTH];
+    WiFi.macAddress(mac);
+    device.setUniqueId(mac, sizeof(mac));
+
+    // connect to wifi
+    WiFi.begin(WIFI_SSID, WIFI_PASSWORD);
+    while (WiFi.status() != WL_CONNECTED) {
+        Serial.print(".");
+        delay(500); // waiting for the connection
+    }
+    Serial.println();
+    Serial.println("Connected to the network");
+
+    // set device's details (optional)
+    device.setName("NodeMCU");
+    device.setSoftwareVersion("1.0.0");
+
+    // assign callbacks (optional)
+    hvac.onAuxHeatingStateChanged(onAuxHeatingStateChanged);
+    hvac.onAwayStateChanged(onAwayStateChanged);
+    hvac.onHoldStateChanged(onHoldStateChanged);
+    hvac.onTargetTemperatureChanged(onTargetTemperatureChanged);
+    hvac.onModeChanged(onModeChanged);
+
+    // configure HVAC (optional)
+    hvac.setName("My HVAC");
+    hvac.setMinTemp(10);
+    hvac.setMaxTemp(30);
+    hvac.setTempStep(0.5);
+    hvac.setRetain(true);
+
+    mqtt.begin(BROKER_ADDR);
+}
+
+void loop() {
+    mqtt.loop();
+
+    if ((millis() - lastTempPublishAt) > 3000) {
+        hvac.setCurrentTemperature(lastTemp);
+        lastTempPublishAt = millis();
+        lastTemp += 0.5;
+    }
+}
@@ -0,0 +1,50 @@
+#include <Ethernet.h>
+#include <ArduinoHA.h>
+
+#define LED_PIN         9
+#define BROKER_ADDR     IPAddress(192,168,0,17)
+
+byte mac[] = {0x00, 0x10, 0xFA, 0x6E, 0x38, 0x4A};
+
+EthernetClient client;
+HADevice device(mac, sizeof(mac));
+HAMqtt mqtt(client, device);
+HASwitch led("led", false); // "led" is unique ID of the switch. You should define your own ID.
+
+void onBeforeSwitchStateChanged(bool state, HASwitch* s)
+{
+    // this callback will be called before publishing new state to HA
+    // in some cases there may be delay before onStateChanged is called due to network latency
+}
+
+void onSwitchStateChanged(bool state, HASwitch* s)
+{
+    digitalWrite(LED_PIN, (state ? HIGH : LOW));
+}
+
+void setup() {
+    pinMode(LED_PIN, OUTPUT);
+    digitalWrite(LED_PIN, LOW);
+
+    // you don't need to verify return status
+    Ethernet.begin(mac);
+
+    // set device's details (optional)
+    device.setName("Arduino");
+    device.setSoftwareVersion("1.0.0");
+
+    // set icon (optional)
+    led.setIcon("mdi:lightbulb");
+    led.setName("My LED");
+
+    // handle switch state
+    led.onBeforeStateChanged(onBeforeSwitchStateChanged); // optional
+    led.onStateChanged(onSwitchStateChanged);
+
+    mqtt.begin(BROKER_ADDR);
+}
+
+void loop() {
+    Ethernet.maintain();
+    mqtt.loop();
+}
@@ -0,0 +1,56 @@
+#include <Ethernet.h>
+#include <ArduinoHA.h>
+
+#define BROKER_ADDR         IPAddress(192,168,0,17)
+
+byte mac[] = {0x00, 0x10, 0xFA, 0x6E, 0x38, 0x4A};
+
+EthernetClient client;
+HADevice device(mac, sizeof(mac));
+HAMqtt mqtt(client, device);
+
+void onMqttMessage(const char* topic, const uint8_t* payload, uint16_t length) {
+    // This callback is called when message from MQTT broker is received.
+    // Please note that you should always verify if the message's topic is the one you expect.
+    // For example: if (memcmp(topic, "myCustomTopic") == 0) { ... }
+
+    Serial.print("New message on topic: ");
+    Serial.println(topic);
+    Serial.print("Data: ");
+    Serial.println((const char*)payload);
+
+    mqtt.publish("myPublishTopic", "hello");
+}
+
+void onMqttConnected() {
+    Serial.println("Connected to the broker!");
+
+    // You can subscribe to custom topic if you need
+    mqtt.subscribe("myCustomTopic");
+}
+
+void onMqttConnectionFailed() {
+    Serial.println("Failed to connect to the broker!");
+}
+
+void setup() {
+    Serial.begin(9600);
+    Ethernet.begin(mac);
+
+    mqtt.onMessage(onMqttMessage);
+    mqtt.onConnected(onMqttConnected);
+    mqtt.onConnectionFailed(onMqttConnectionFailed);
+
+    // If you use custom discovery prefix you can change it as following:
+    // mqtt.setDiscoveryPrefix("customPrefix");
+
+    // If you want to change prefix only for non-discovery prefix:
+    // mqtt.setDataPrefix("data");
+
+    mqtt.begin(BROKER_ADDR);
+}
+
+void loop() {
+    Ethernet.maintain();
+    mqtt.loop();
+}
@@ -0,0 +1,42 @@
+#include <Ethernet.h>
+#include <ArduinoHA.h>
+
+#define LED_PIN             9
+#define BROKER_ADDR         IPAddress(192,168,0,17)
+#define BROKER_USERNAME     "user" // replace with your credentials
+#define BROKER_PASSWORD     "pass"
+
+byte mac[] = {0x00, 0x10, 0xFA, 0x6E, 0x38, 0x4A};
+
+EthernetClient client;
+HADevice device(mac, sizeof(mac));
+HAMqtt mqtt(client, device);
+HASwitch led("led", false); // "led" is unique ID of the switch. You should define your own ID.
+
+void onSwitchStateChanged(bool state, HASwitch* s)
+{
+    digitalWrite(LED_PIN, (state ? HIGH : LOW));
+}
+
+void setup() {
+    pinMode(LED_PIN, OUTPUT);
+    digitalWrite(LED_PIN, LOW);
+
+    // you don't need to verify return status
+    Ethernet.begin(mac);
+
+    // set device's details (optional)
+    device.setName("Arduino");
+    device.setSoftwareVersion("1.0.0");
+
+    // handle switch state
+    led.onStateChanged(onSwitchStateChanged);
+    led.setName("My LED"); // optional
+
+    mqtt.begin(BROKER_ADDR, BROKER_USERNAME, BROKER_PASSWORD);
+}
+
+void loop() {
+    Ethernet.maintain();
+    mqtt.loop();
+}
@@ -0,0 +1,52 @@
+#include <Ethernet.h>
+#include <ArduinoHA.h>
+
+// This example uses JC Button library
+// https://github.com/JChristensen/JC_Button
+#include <JC_Button.h>
+
+#define BUTTON_PIN      9
+#define BUTTON_NAME     "mybtn"
+#define BROKER_ADDR     IPAddress(192,168,0,17)
+
+byte mac[] = {0x00, 0x10, 0xFA, 0x6E, 0x38, 0x4A};
+
+EthernetClient client;
+HADevice device(mac, sizeof(mac));
+HAMqtt mqtt(client, device);
+HATriggers triggers;
+Button btn(BUTTON_PIN);
+bool holdingBtn = false;
+
+void setup() {
+    // you don't need to verify return status
+    Ethernet.begin(mac);
+
+    // set device's details (optional)
+    device.setName("Arduino");
+    device.setSoftwareVersion("1.0.0");
+
+    // setup triggers
+    triggers.add("button_short_press", BUTTON_NAME);
+    triggers.add("button_long_press", BUTTON_NAME);
+    btn.begin();
+
+    mqtt.begin(BROKER_ADDR);
+}
+
+void loop() {
+    Ethernet.maintain();
+    mqtt.loop();
+    btn.read();
+
+    if (btn.pressedFor(3000) && !holdingBtn) {
+        triggers.trigger("button_long_press", BUTTON_NAME);
+        holdingBtn = true;
+    } else if (btn.wasReleased()) {
+        if (holdingBtn) {
+            holdingBtn = false;
+        } else {
+            triggers.trigger("button_short_press", BUTTON_NAME);
+        }
+    }
+}
@@ -0,0 +1,53 @@
+#include <WiFiNINA.h>
+#include <ArduinoHA.h>
+
+#define LED_PIN         9
+#define BROKER_ADDR     IPAddress(192,168,0,17)
+#define WIFI_SSID       "MyNetwork"
+#define WIFI_PASSWORD   "MyPassword"
+
+WiFiClient client;
+HADevice device;
+HAMqtt mqtt(client, device);
+HASwitch led("led", false); // "led" is unique ID of the switch. You should define your own ID.
+
+void onSwitchStateChanged(bool state, HASwitch* s)
+{
+    digitalWrite(LED_PIN, (state ? HIGH : LOW));
+}
+
+void setup() {
+    Serial.begin(9600);
+    Serial.println("Starting...");
+
+    // Unique ID must be set!
+    byte mac[WL_MAC_ADDR_LENGTH];
+    WiFi.macAddress(mac);
+    device.setUniqueId(mac, sizeof(mac));
+
+    pinMode(LED_PIN, OUTPUT);
+    digitalWrite(LED_PIN, LOW);
+
+    // connect to wifi
+    WiFi.begin(WIFI_SSID, WIFI_PASSWORD);
+    while (WiFi.status() != WL_CONNECTED) {
+        Serial.print(".");
+        delay(500); // waiting for the connection
+    }
+    Serial.println();
+    Serial.println("Connected to the network");
+
+    // set device's details (optional)
+    device.setName("Nano 33 IoT");
+    device.setSoftwareVersion("1.0.0");
+
+    // handle switch state
+    led.onStateChanged(onSwitchStateChanged);
+    led.setName("My LED"); // optional
+
+    mqtt.begin(BROKER_ADDR);
+}
+
+void loop() {
+    mqtt.loop();
+}
@@ -0,0 +1,60 @@
+#include <ESP8266WiFi.h>
+#include <ArduinoHA.h>
+
+#define LED_PIN         D0
+#define BROKER_ADDR     IPAddress(192,168,0,17)
+#define WIFI_SSID       "MyNetwork"
+#define WIFI_PASSWORD   "MyPassword"
+
+WiFiClient client;
+HADevice device;
+HAMqtt mqtt(client, device);
+HASwitch led("led", false); // "led" is unique ID of the switch. You should define your own ID.
+
+void onBeforeSwitchStateChanged(bool state, HASwitch* s)
+{
+    // this callback will be called before publishing new state to HA
+    // in some cases there may be delay before onStateChanged is called due to network latency
+}
+
+void onSwitchStateChanged(bool state, HASwitch* s)
+{
+    digitalWrite(LED_PIN, (state ? HIGH : LOW));
+}
+
+void setup() {
+    Serial.begin(9600);
+    Serial.println("Starting...");
+
+    // Unique ID must be set!
+    byte mac[WL_MAC_ADDR_LENGTH];
+    WiFi.macAddress(mac);
+    device.setUniqueId(mac, sizeof(mac));
+
+    pinMode(LED_PIN, OUTPUT);
+    digitalWrite(LED_PIN, LOW);
+
+    // connect to wifi
+    WiFi.begin(WIFI_SSID, WIFI_PASSWORD);
+    while (WiFi.status() != WL_CONNECTED) {
+        Serial.print(".");
+        delay(500); // waiting for the connection
+    }
+    Serial.println();
+    Serial.println("Connected to the network");
+
+    // set device's details (optional)
+    device.setName("NodeMCU");
+    device.setSoftwareVersion("1.0.0");
+
+    // handle switch state
+    led.onBeforeStateChanged(onBeforeSwitchStateChanged); // optional
+    led.onStateChanged(onSwitchStateChanged);
+    led.setName("My LED"); // optional
+
+    mqtt.begin(BROKER_ADDR);
+}
+
+void loop() {
+    mqtt.loop();
+}
@@ -0,0 +1,54 @@
+#include <Ethernet.h>
+#include <ArduinoHA.h>
+
+#define BROKER_ADDR IPAddress(192,168,0,17)
+
+byte mac[] = {0x00, 0x10, 0xFA, 0x6E, 0x38, 0x4A};
+unsigned long lastSentAt = millis();
+double lastValue = 0;
+
+EthernetClient client;
+HADevice device(mac, sizeof(mac));
+HAMqtt mqtt(client, device);
+HASensor temp("temp"); // "temp" is unique ID of the sensor. You should define your own ID.
+
+void onBeforeSwitchStateChanged(bool state, HASwitch* s)
+{
+    // this callback will be called before publishing new state to HA
+    // in some cases there may be delay before onStateChanged is called due to network latency
+}
+
+void setup() {
+    // you don't need to verify return status
+    Ethernet.begin(mac);
+
+    // set device's details (optional)
+    device.setName("Arduino");
+    device.setSoftwareVersion("1.0.0");
+
+    // configure sensor (optional)
+    temp.setUnitOfMeasurement("°C");
+    temp.setDeviceClass("temperature");
+    temp.setIcon("mdi:home");
+    temp.setName("Home temperature");
+
+    mqtt.begin(BROKER_ADDR);
+}
+
+void loop() {
+    Ethernet.maintain();
+    mqtt.loop();
+
+    if ((millis() - lastSentAt) >= 5000) {
+        lastSentAt = millis();
+        lastValue = lastValue + 0.5;
+        temp.setValue(lastValue);
+
+        // Supported data types:
+        // uint32_t (uint16_t, uint8_t)
+        // int32_t (int16_t, int8_t)
+        // double
+        // float
+        // const char*
+    }
+}