diff --git a/.gitignore b/.gitignore
index 663c1ed..dc80c9d 100644
--- a/.gitignore
+++ b/.gitignore
@@ -2,6 +2,7 @@
 *.pyc
 *.sublime-*
 __pycache__
+build/*
 dist/*
 homie.egg-info/*
 MANIFEST
diff --git a/homie-python.json.example b/examples/homie-python.json.example
similarity index 100%
rename from homie-python.json.example
rename to examples/homie-python.json.example
diff --git a/relay_switch.py b/examples/relay_switch.py
similarity index 52%
rename from relay_switch.py
rename to examples/relay_switch.py
index 2be6514..14dc307 100755
--- a/relay_switch.py
+++ b/examples/relay_switch.py
@@ -6,24 +6,24 @@
 logger = logging.getLogger(__name__)
 
 config = homie.loadConfigFile("homie-python.json")
-Homie = homie.Homie(config)
-switchNode = Homie.Node("switch", "switch")
+device = homie.Device(config)
+switchNode = device.addNode("switch", "switch", "switch")
+switchProperty = switchNode.addProperty("on")
 
-
-def switchOnHandler(mqttc, obj, msg):
-    payload = msg.payload.decode("UTF-8").lower()
-    if payload == 'true':
+def switchOnHandler(property, value):
+    if value == 'true':
         logger.info("Switch: ON")
-        switchNode.setProperty("on").send("true")
+        property.update("true")
     else:
         logger.info("Switch: OFF")
-        switchNode.setProperty("on").send("false")
+        property.update("false")
 
 
 def main():
-    Homie.setFirmware("relay-switch", "1.0.0")
-    switchNode.advertise("on").settable(switchOnHandler)
-    Homie.setup()
+    device.setFirmware("relay-switch", "1.0.0")
+    switchProperty.settable(switchOnHandler)
+    
+    device.setup()
 
     while True:
         time.sleep(1)
diff --git a/relay_switch_with_config.py b/examples/relay_switch_with_config.py
similarity index 60%
rename from relay_switch_with_config.py
rename to examples/relay_switch_with_config.py
index 538dfcf..986536b 100755
--- a/relay_switch_with_config.py
+++ b/examples/relay_switch_with_config.py
@@ -17,24 +17,23 @@
     "TOPIC": "homie"
 }
 
-Homie = homie.Homie(config)
-switchNode = Homie.Node("switch", "switch")
+device = homie.Device(config)
+switchNode = device.addNode("switch", "switch", "switch")
+switchProperty = switchNode.addProperty("on")
 
-
-def switchOnHandler(mqttc, obj, msg):
-    payload = msg.payload.decode("UTF-8").lower()
-    if payload == 'true':
+def switchOnHandler(property, value):
+    if value == 'true':
         logger.info("Switch: ON")
-        switchNode.setProperty("on").send("true")
+        property.update("true")
     else:
         logger.info("Switch: OFF")
-        switchNode.setProperty("on").send("false")
+        property.update("false")
 
 
 def main():
-    Homie.setFirmware("relay-switch", "1.0.0")
-    switchNode.advertise("on").settable(switchOnHandler)
-    Homie.setup()
+    device.setFirmware("relay-switch", "1.0.0")
+    switchProperty.settable(switchOnHandler)
+    device.setup()
 
     while True:
         time.sleep(1)
diff --git a/examples/remote_with_config.py b/examples/remote_with_config.py
new file mode 100644
index 0000000..6260db4
--- /dev/null
+++ b/examples/remote_with_config.py
@@ -0,0 +1,50 @@
+#!/usr/bin/env python
+import time
+import random
+import homie
+import logging
+logging.basicConfig(level=logging.INFO)
+logger = logging.getLogger(__name__)
+
+config = {
+    "HOST": "iot.eclipse.org",
+    "PORT": 1883,
+    "KEEPALIVE": 10,
+    "USERNAME": "",
+    "PASSWORD": "",
+    "CA_CERTS": "",
+    "DEVICE_ID": "remote-control",
+    "DEVICE_NAME": "xxxxxxxx",
+    "TOPIC": "homie"
+}
+
+device = homie.Device(config)
+remoteNode = device.addNode("remote", "Remote", "Buttons")
+playButtonProperty = remoteNode.addProperty("play", "Play Button", datatype="enum", format="PRESSED,RELEASED", retained=False)
+nextButtonProperty = remoteNode.addProperty("next", "Next Button", datatype="enum", format="PRESSED,RELEASED", retained=False)
+prevButtonProperty = remoteNode.addProperty("prev", "Prev Button", datatype="enum", format="PRESSED,RELEASED", retained=False)
+
+
+def main():
+    device.setFirmware("remote-control", "1.0.0")
+
+    device.setup()
+
+    buttonPressFrecuency = 30
+    lastButtonPressTime = 0
+
+    while True:
+        # We simulate that the button is pressed (and released) every 30 seconds
+        if (time.time() - lastButtonPressTime) > buttonPressFrecuency:
+            playButtonProperty.update("PRESSED")
+            time.sleep(0.3)
+            playButtonProperty.update("RELEASED")
+            logger.info("Play button pressed and released")
+            lastButtonPressTime = time.time()
+        time.sleep(1)
+
+if __name__ == '__main__':
+    try:
+        main()
+    except (KeyboardInterrupt, SystemExit):
+        logger.info("Quitting.")
\ No newline at end of file
diff --git a/temperatureDS18B20_raspi.py b/examples/temperatureDS18B20_raspi.py
similarity index 79%
rename from temperatureDS18B20_raspi.py
rename to examples/temperatureDS18B20_raspi.py
index 23433e6..a815942 100644
--- a/temperatureDS18B20_raspi.py
+++ b/examples/temperatureDS18B20_raspi.py
@@ -19,8 +19,9 @@
 TEMPERATURE_INTERVAL = 60
 
 config = homie.loadConfigFile("homie-python.json")
-Homie = homie.Homie(config)
-temperatureNode = Homie.Node("temperature", "temperature")
+device = homie.Device(config)
+temperatureNode = device.addNode("temperature", "temperature", "temperature")
+temperatureProperty = temperatureNode.addProperty("temperature", "Temperature value", "ºC", "float")
 
 def read_temp_raw():
     f = open(device_file, 'r')
@@ -41,15 +42,14 @@ def read_temp():
         return temp_c
 
 def main():
-    Homie.setFirmware("raspi-temperatureDS18B20", "1.0.0")
-    temperatureNode.advertise("degrees")
+    device.setFirmware("raspi-temperatureDS18B20", "1.0.0")
 
-    Homie.setup()
+    device.setup()
 
     while True:
         temperature = read_temp()
         logger.info("Temperature: {:0.2f} °C".format(temperature))
-        temperatureNode.setProperty("degrees").send(temperature)
+        temperatureProperty.update(temperature)
         time.sleep(TEMPERATURE_INTERVAL)
 
 if __name__ == '__main__':
diff --git a/temperature_raspi.py b/examples/temperature_raspi.py
similarity index 68%
rename from temperature_raspi.py
rename to examples/temperature_raspi.py
index c1db48e..0921ecc 100755
--- a/temperature_raspi.py
+++ b/examples/temperature_raspi.py
@@ -9,8 +9,9 @@
 TEMPERATURE_INTERVAL = 60
 
 config = homie.loadConfigFile("homie-python.json")
-Homie = homie.Homie(config)
-temperatureNode = Homie.Node("temperature", "temperature")
+device = homie.Device(config)
+temperatureNode = device.addNode("temperature", "temperature", "temperature")
+temperatureProperty = temperatureNode.addProperty("temperature", "Temperature value", "ºC", "float")
 
 
 def getCpuTemperature():
@@ -21,15 +22,14 @@ def getCpuTemperature():
 
 
 def main():
-    Homie.setFirmware("raspi-temperature", "1.0.0")
-    temperatureNode.advertise("degrees")
+    device.setFirmware("raspi-temperature", "1.0.0")
 
-    Homie.setup()
+    device.setup()
 
     while True:
         temperature = getCpuTemperature()
         logger.info("Temperature: {:0.2f} °C".format(temperature))
-        temperatureNode.setProperty("degrees").send(temperature)
+        temperatureProperty.update(temperature)
         time.sleep(TEMPERATURE_INTERVAL)
 
 if __name__ == '__main__':
diff --git a/temperature_sensor.py b/examples/temperature_sensor.py
similarity index 51%
rename from temperature_sensor.py
rename to examples/temperature_sensor.py
index e5ccc27..e3d9840 100755
--- a/temperature_sensor.py
+++ b/examples/temperature_sensor.py
@@ -6,30 +6,30 @@
 logging.basicConfig(level=logging.INFO)
 logger = logging.getLogger(__name__)
 
-TEMPERATURE_INTERVAL = 3
+TEMPERATURE_INTERVAL = 60
 
 config = homie.loadConfigFile("homie-python.json")
-Homie = homie.Homie(config)
-temperatureNode = Homie.Node("temperature", "temperature")
-humidityNode = Homie.Node("humidity", "humidity")
+device = homie.Device(config)
+temperatureNode = device.addNode("temperature", "temperature", "temperature")
+humidityNode = device.addNode("humidity", "humidity", "humidity")
+temperatureProperty = temperatureNode.addProperty("temperature", "Temperature value", "ºC", "float")
+humidityProperty = humidityNode.addProperty("humidity", "Humidity value", "%", "float", "0.0:100.0")
 
 
 def main():
-    Homie.setFirmware("awesome-temperature", "1.0.0")
-    temperatureNode.advertise("degrees")
-    humidityNode.advertise("humidity")
+    device.setFirmware("awesome-temperature", "1.0.0")
 
-    Homie.setup()
+    device.setup()
 
     while True:
         temperature = 22.0
         humidity = 60.0
 
         logger.info("Temperature: {:0.2f} °C".format(temperature))
-        temperatureNode.setProperty("degrees").send(temperature)
+        temperatureProperty.update(temperature)
 
         logger.info("Humidity: {:0.2f} %".format(humidity))
-        humidityNode.setProperty("humidity").send(humidity)
+        humidityProperty.update(humidity)
 
         time.sleep(TEMPERATURE_INTERVAL)
 
diff --git a/examples/thermostat_with_config.py b/examples/thermostat_with_config.py
new file mode 100644
index 0000000..e82b8be
--- /dev/null
+++ b/examples/thermostat_with_config.py
@@ -0,0 +1,60 @@
+#!/usr/bin/env python
+import time
+import random
+import homie
+import logging
+logging.basicConfig(level=logging.INFO)
+logger = logging.getLogger(__name__)
+
+config = {
+    "HOST": "iot.eclipse.org",
+    "PORT": 1883,
+    "KEEPALIVE": 10,
+    "USERNAME": "",
+    "PASSWORD": "",
+    "CA_CERTS": "",
+    "DEVICE_ID": "xxxxxxxx",
+    "DEVICE_NAME": "xxxxxxxx",
+    "TOPIC": "homie"
+}
+
+device = homie.Device(config)
+thermostatNode = device.addNode("thermostat", "Thermostat", "thermostat")
+temperatureProperty = thermostatNode.addProperty("temperature", "Indoor Temperature", "ºC", "float", "0:50")
+setpointProperty = thermostatNode.addProperty("setpoint", "Setpoint", "ºC", "float", "10:30")
+modeProperty = thermostatNode.addProperty("mode", "Thermostat Mode", datatype="enum", format="NORMAL,COLD,HEAT")
+
+def modeHandler(property, value):
+    logger.info("Changing thermostat mode to {}".format(value))
+    property.update(value)
+
+def setpointHandler(property, value):
+    logger.info("Changing thermostat setpoint to {}ºC".format(value))
+    property.update(value)
+
+
+def main():
+    device.setFirmware("thermostat", "1.0.0")
+    modeProperty.settable(modeHandler)
+    setpointProperty.settable(setpointHandler)
+
+    device.setup()
+
+    reportFrecuency = 60
+    lastTemperatureTime = 0
+
+    setpointProperty.update(21.5)
+    modeProperty.update("NORMAL")
+    while True:
+        if (time.time() - lastTemperatureTime) > reportFrecuency:
+            temperature = random.uniform(20,25)
+            temperatureProperty.update("{0:.2f}".format(temperature))
+            logger.info("New temperature value: {0:.2f}ºC".format(temperature))
+            lastTemperatureTime = time.time()
+        time.sleep(1)
+
+if __name__ == '__main__':
+    try:
+        main()
+    except (KeyboardInterrupt, SystemExit):
+        logger.info("Quitting.")
diff --git a/homie/helpers.py b/homie/helpers.py
index 1791da1..af6c1e4 100644
--- a/homie/helpers.py
+++ b/homie/helpers.py
@@ -13,9 +13,53 @@ def generateDeviceId():
     return "{:02x}".format(get_mac())
 
 
-def isIdFormat(idString):
+def isValidId(idString):
     """Validate device Id."""
     logger.debug("isIdFormat")
     if isinstance(idString, str):
         r = re.compile('(^(?!\-)[a-z0-9\-]+(?<!\-)$)')
         return True if r.match(idString) else False
+
+def isValidDatatype(datatype):
+    """Validate datatype"""
+    valid_datatypes = ("integer", "float", "boolean", "string", "enum", "color")
+    if datatype in valid_datatypes:
+        return True
+    return False
+
+def isValidFormat(datatype, format):
+    """Validate format"""
+    # False if there is a format without datatype
+    if not datatype and format:
+        return False
+    # True if there is no format but the datatype is "string", "integer", "float" or "boolean"
+    if not format and datatype in ("string", "integer", "float", "boolean"):
+        return True
+    if datatype == "color":
+        allowed_formats = ("rgb", "hsv")
+        return True if format in allowed_formats else False
+    elif datatype == "enum":
+        # Expression: value,value,value
+        # Examples: A,B,C or ON,OFF,PAUSE
+        r = re.compile(r'^(\w+,)*\w+$')
+        return True if r.match(format) else False
+    elif datatype == "integer":
+        # Expression: int:int
+        # Examples: 10:15 or -1:5
+        r = re.compile(r'^[-]?\d+[:][-]?\d+$')
+        return True if r.match(format) else False
+    elif datatype == "float":
+        # Expression: float:float
+        # Example: 3.14:15 or -1.1:-1.2
+        r = re.compile(r'^[+-]?([0-9]*[.])?[0-9]+[:][+-]?([0-9]*[.])?[0-9]+$')
+        return True if r.match(format) else False
+    return True
+
+def isValidUnit(unit):
+    """Validate unit"""
+    recommended_units = ("ºC", "ºF", "º", "L", "gal", "V", "W", "A", "%", "m",
+                        "ft", "Pa", "psi", "#")
+    if unit not in recommended_units:
+        logger.warning("Unit '{}' is not one of the recommended ones".format(unit))
+    return True
+    
\ No newline at end of file
diff --git a/homie/main.py b/homie/main.py
index ab3196d..3b066ee 100755
--- a/homie/main.py
+++ b/homie/main.py
@@ -11,10 +11,10 @@
 from homie.timer import HomieTimer
 from homie.node import HomieNode
 from homie.networkinformation import NetworkInformation
-from homie.helpers import isIdFormat, generateDeviceId
+from homie.helpers import isValidId, generateDeviceId
 logger = logging.getLogger(__name__)
 
-HOMIE_VERSION = "2.0.1"
+HOMIE_VERSION = "3.0.1"
 DEFAULT_PREFS = {
     "CA_CERTS": {"key": "ca_certs", "val": None},
     "DEVICE_ID": {"key": "deviceId", "val": "xxxxxxxx"},
@@ -49,14 +49,13 @@ def loadConfigFile(configFile):
     return config
 
 
-class Homie(object):
-    """docstring for Homie"""
+class Device(object):
+    """docstring for Device"""
 
     def __init__(self, config):
-        super(Homie, self).__init__()
+        super(Device, self).__init__()
         atexit.register(self._exitus)
 
-        self.deviceId = None
         self.deviceName = None
         self.host = None
         self.port = None
@@ -75,9 +74,10 @@ def __init__(self, config):
         self.startTime = time.time()
         self.fwname = None
         self.fwversion = None
-        self.nodes = []
+        self.nodes = {}
         self.timers = []
         self.subscriptions = []
+        self.subscriptions_handlers = {}
         self.subscribe_all_forced = False
         self.statsInterval = 60
 
@@ -101,9 +101,9 @@ def Timer(self, *args, **kwargs):
         self.timers.append(homieTimer)
         return(homieTimer)
 
-    def Node(self, nodeId, nodeType):
-        homieNode = HomieNode(self, nodeId, nodeType)
-        self.nodes.append(homieNode)
+    def addNode(self, nodeId, nodeName, nodeType):
+        homieNode = HomieNode(self, nodeId, nodeName, nodeType)
+        self.nodes[nodeId] = homieNode
         return(homieNode)
 
     def _initAttrs(self, config):
@@ -143,7 +143,7 @@ def _initialize(self):
         self.mqtt.on_disconnect = self._disconnected
 
         self.mqtt.will_set(
-            self.mqtt_topic + "/$online", payload="false", retain=True)
+            self.mqtt_topic + "/$state", payload="lost", retain=True)
 
         if self.username:
             self.mqtt.username_pw_set(self.username, password=self.password)
@@ -185,21 +185,27 @@ def _connected(self, *args):
             self._subscribe()
 
         self.publish(
-            self.mqtt_topic + "/$online",
-            payload="true", retain=True)
+            self.mqtt_topic + "/$state",
+            payload="init", retain=True)
         self.publish(
             self.mqtt_topic + "/$name",
             payload=self.deviceName, retain=True)
 
         self.publishHomieVersion()
+        self.publishLocalipAndMac()
         self.publishFwname()
         self.publishFwversion()
-        self.publishNodes()
-        self.publishLocalipAndMac()
+        self.publishImplementation()
+        self.publishStats()
         self.publishStatsInterval()
         self.publishUptime()
         self.publishSignal()
-        self.publishImplementation()
+        self.publishNodes()
+
+        self.publish(
+            self.mqtt_topic + "/$state",
+            payload="ready", retain=True
+        )
 
     def _subscribed(self, *args):
         # logger.debug("_subscribed: {}".format(args))
@@ -221,10 +227,13 @@ def setup(self):
         # init and connect MQTT
         self._initialize()
 
+        self.intervalTimer = self.Timer(
+            self.statsInterval, self.publishStatsInterval, name="intervalTimer")
         self.uptimeTimer = self.Timer(
             self.statsInterval, self.publishUptime, name="uptimeTimer")
         self.signalTimer = self.Timer(
             self.statsInterval, self.publishSignal, name="signalTimer")
+        self.intervalTimer.start()
         self.uptimeTimer.start()
         self.signalTimer.start()
 
@@ -244,31 +253,15 @@ def setNodeProperty(self, homieNode, prop, val, retain=True):
         ])
         self.publish(topic, payload=val, retain=retain)
 
-    def subscribe(self, homieNode, attr, callback, qos=None):
-        """ Register new subscription and add a callback """
-        self._checkBeforeSetup()
-
-        # user qos prefs
-        if qos is None:
-            qos = int(self.qos)
-
-        subscription = str("/".join(
-            [
-                self.mqtt_topic,
-                homieNode.nodeId,
-                attr,
-                "set"
-            ]))
-
-        logger.debug("subscribe: {} {}".format(subscription, qos))
+    def subscribePropertyHandler(self, mqttc, obj, msg):
+        topic = msg.topic
+        value = msg.payload.decode("UTF-8")
 
-        if not self.subscribe_all:
-            self.subscriptions.append((subscription, qos))
-
-        if self.mqtt_connected:
-            self._subscribe()
-
-        self.mqtt.message_callback_add(subscription, callback)
+        if topic in self.subscriptions_handlers:
+            nodeId = topic.split("/")[-3]
+            propertyId = topic.split("/")[-2]
+            property = self.nodes[nodeId].properties[propertyId]
+            self.subscriptions_handlers[topic](property, value)
 
     def subscribeProperty(self, homieNode, attr, callback, qos=None):
         """ Register new subscription for property and add a callback """
@@ -282,18 +275,20 @@ def subscribeProperty(self, homieNode, attr, callback, qos=None):
             [
                 self.mqtt_topic,
                 homieNode.nodeId,
-                attr
+                attr,
+                "set"
             ]))
 
         logger.debug("subscribe: {} {}".format(subscription, qos))
 
         if not self.subscribe_all:
             self.subscriptions.append((subscription, qos))
+            self.subscriptions_handlers[subscription] = callback
 
         if self.mqtt_connected:
             self._subscribe()
 
-        self.mqtt.message_callback_add(subscription, callback)
+        self.mqtt.message_callback_add(subscription, self.subscribePropertyHandler)
 
     def publish(self, topic, payload, retain=True, qos=None, **kwargs):
         """ Publish messages to MQTT, if connected """
@@ -321,13 +316,13 @@ def publish(self, topic, payload, retain=True, qos=None, **kwargs):
     def publishNodes(self):
         """ Publish registered nodes and their properties to MQTT """
         payload = ",".join(
-            [str(x.nodeId) for x in self.nodes])
+            list(self.nodes.keys()))
         self.publish(
             self.mqtt_topic + "/$nodes",
             payload=payload, retain=True)
 
-        for node in self.nodes:
-            node.sendProperties()
+        for node in self.nodes.values():
+            node.publishProperties()
 
     def publishLocalipAndMac(self):
         """Publish local IP and MAC Addresses to MQTT."""
@@ -343,6 +338,16 @@ def publishLocalipAndMac(self):
             self.mqtt_topic + "/$mac",
             payload=local_mac, retain=True)
 
+    def publishStats(self):
+        """Publish stats info"""
+        payload = ",".join([
+            "signal"
+        ])
+        self.publish(
+            self.mqtt_topic + "/$stats",
+            payload=payload, retain=True
+        )
+
     def publishStatsInterval(self):
         """ Publish /$stats/interval to MQTT """
         payload = self.statsInterval
@@ -426,7 +431,7 @@ def deviceId(self):
 
     @deviceId.setter
     def deviceId(self, deviceId):
-        if isIdFormat(deviceId):
+        if isValidId(deviceId):
             self._deviceId = deviceId
         else:
             self._deviceId = generateDeviceId()
@@ -456,8 +461,8 @@ def _exitus(self):
         """ Clean up before exit """
 
         self.publish(
-            self.mqtt_topic + "/$online",
-            payload="false", retain=True)
+            self.mqtt_topic + "/$state",
+            payload="disconnected", retain=True)
 
         self.mqtt.loop_stop()
         self.mqtt.disconnect()
diff --git a/homie/node.py b/homie/node.py
index 3f2f877..8308e4a 100755
--- a/homie/node.py
+++ b/homie/node.py
@@ -1,154 +1,87 @@
 #!/usr/bin/env python
 import logging
-from homie.helpers import isIdFormat
+from homie.helpers import isValidId
+from homie.property import HomieNodeProperty
+from homie.property import HomieNodePropertyRange
 logger = logging.getLogger(__name__)
 
-
-class HomieNodeProperty(object):
-    """docstring for HomieNodeProp"""
-
-    def setSubscribe(self, func):
-        self.subscribe = func
-
-    def __init__(self, node, propertyId):
-        super(HomieNodeProperty, self).__init__()
-        self.node = node  # stores ref to node
-        self._propertyId = None
-        self.propertyId = propertyId
-        self.handler = None
-        self._settable = False
-
-    def settable(self, handler):
-        self.handler = handler
-        self.subscribe(self.node, self.propertyId, handler)
-        self._settable = True
-
-    def send(self, value):
-        self.node.homie.publish(
-            "/".join([
-                self.node.homie.baseTopic,
-                self.node.homie.deviceId,
-                self.node.nodeId,
-                self.propertyId,
-            ]),
-            value,
-        )
-
-    def representation(self):
-        repr = self.propertyId
-        if self._settable:
-            repr += ":settable"
-        return repr
-
-    @property
-    def propertyId(self):
-        return self._propertyId
-
-    @propertyId.setter
-    def propertyId(self, propertyId):
-        if isIdFormat(propertyId):
-            self._propertyId = propertyId
-        else:
-            logger.warning("'{}' has no valid ID-Format".format(propertyId))
-
-
-class HomieNodeRange(HomieNodeProperty):
-    """docstring for HomieNodeRange"""
-
-    def __init__(self, node, propertyId, lower, upper):
-        super(HomieNodeRange, self).__init__(node, propertyId)
-        self.node = node
-        self._range = range(lower, upper + 1)
-        self.range = None
-        self.lower = lower
-        self.upper = upper
-        self.range_names = [(propertyId + "_" + str(x)) for x in self._range]
-
-    def settable(self, handler):
-        self.handler = handler
-        for x in self._range:
-            self.subscribe(self.node, "{}_{}".format(self.propertyId, x), handler)
-
-    def setRange(self, lower, upper):
-        # Todo: validate input
-        if lower in self._range and upper in self._range:
-            self.range = range(lower, upper + 1)
-            return self
-        else:
-            logger.warning("Specified range out of announced range.")
-
-    def send(self, value):
-        if self.range is None:
-            raise ValueError("Please specify a range.")
-
-        for x in self.range:
-            self.node.homie.publish(
-                "/".join([
-                    self.node.homie.baseTopic,
-                    self.node.homie.deviceId,
-                    self.node.nodeId,
-                    self.propertyId + "_" + str(x),
-                ]),
-                value,
-            )
-
-    def representation(self):
-        repr = "{}[{}-{}]".format(self.propertyId, self.lower, self.upper)
-        if self._settable:
-            repr += ":settable"
-        return repr
-
-
 class HomieNode(object):
     """docstring for HomieNode"""
 
-    def __init__(self, homie, nodeId, nodeType):
+    def __init__(self, homie, nodeId, nodeName, nodeType):
         super(HomieNode, self).__init__()
         self.homie = homie
         self.nodeId = nodeId
+        self.nodeName = nodeName
         self.nodeType = nodeType
         self.properties = {}
 
-    def advertise(self, propertyId):
-        if propertyId not in self.properties:
-            homieNodeProperty = HomieNodeProperty(self, propertyId)
-            homieNodeProperty.setSubscribe(self.homie.subscribe)
+    def addProperty(self, id=None, name=None, unit=None, datatype=None, format=None, retained=True):
+        if not id:
+            logger.error("'id' required for HomieNodeProperty")
+            return
+        if id not in self.properties:
+            homieNodeProperty = HomieNodeProperty(self, id, name, unit, datatype, format, retained)
+            homieNodeProperty.setSubscribe(self.homie.subscribeProperty)
             if homieNodeProperty:
-                self.properties[propertyId] = homieNodeProperty
-                return(homieNodeProperty)
+                self.properties[id] = homieNodeProperty
+            return homieNodeProperty
         else:
-            logger.warning("Property '{}' already announced.".format(propertyId))
-
-    def advertiseRange(self, propertyId, lower, upper):
-        if propertyId not in self.properties:
-            homieNodeRange = HomieNodeRange(self, propertyId, lower, upper)
-            homieNodeRange.setSubscribe(self.homie.subscribe)
-            if homieNodeRange:
-                self.properties[propertyId] = homieNodeRange
-                return(homieNodeRange)
+            logger.warning("Property '{}' already created.".format(id))
+            return self.properties[id]
+
+    def addPropertyRange(self, id=None, lower=None, upper=None, name=None, unit=None, datatype=None, format=None, retained=True):
+        if not id:
+            logger.error("'id' value required for HomieNodePropertyRange")
+            return
+        if not lower or not upper:
+            logger.error("'lower' and 'upper' values required for HomieNodePropertyRange")
+            return
+        if id not in self.properties:
+            homieNodePropertyRange = HomieNodePropertyRange(self, id, lower, upper, name, unit, datatype, format, retained)
+            homieNodePropertyRange.setSubscribe(self.homie.subscribeProperty)
+            if homieNodePropertyRange:
+                self.properties[id] = homieNodePropertyRange
+            return homieNodePropertyRange
         else:
-            logger.warning("Property '{}' already announced.".format(propertyId))
+            logger.warning("PropertyRange '{}' alread created.".format(id))
+            return self.properties[id]
 
-    def setProperty(self, propertyId):
+    def getProperty(self, propertyId):
         if propertyId not in self.properties:
             raise ValueError("Property '{}' does not exist".format(propertyId))
         return self.properties[propertyId]
 
-    def sendProperties(self):
+    def publishProperties(self):
         nodeTopic = "/".join([self.homie.baseTopic, self.homie.deviceId, self.nodeId])
 
+        self.homie.publish(nodeTopic + "/$name", self.nodeName)
         self.homie.publish(nodeTopic + "/$type", self.nodeType)
 
         payload = ",".join([property.representation() for id, property in self.properties.items()])
         self.homie.publish(nodeTopic + "/$properties", payload)
 
+        for property in self.properties.values():
+            property.publishAttributes()
+
     @property
     def nodeId(self):
         return self._nodeId
 
     @nodeId.setter
     def nodeId(self, nodeId):
-        self._nodeId = nodeId
+        if isValidId(nodeId):
+            self._nodeId = nodeId
+        else:
+            raise ValueError("'{}' is not a valid ID for a node".format(nodeId))
+
+    @property
+    def nodeName(self):
+        return self._nodeName
+
+    @nodeName.setter
+    def nodeName(self, nodeName):
+        self._nodeName = nodeName
 
     @property
     def nodeType(self):
diff --git a/homie/property.py b/homie/property.py
new file mode 100644
index 0000000..449b9d2
--- /dev/null
+++ b/homie/property.py
@@ -0,0 +1,183 @@
+#!/usr/bin/env python
+# -*- coding: UTF-8 -*-
+import logging
+from homie.helpers import isValidId, isValidDatatype, isValidFormat, isValidUnit
+logger = logging.getLogger(__name__)
+
+class HomieNodeProperty(object):
+    """docstring for HomieNodeProp"""
+
+    def setSubscribe(self, func):
+        self.subscribe = func
+
+    def __init__(self, node, id, name=None, unit=None, datatype=None, format=None, retained=True):
+        super(HomieNodeProperty, self).__init__()
+        self.node = node  # stores ref to node
+        self._id = None
+        self._propertyName = None
+        self._propertyUnit = None
+        self._propertyDatatype = None
+        self._propertyFormat = None
+        self._retained = True
+        self.id = id
+        self.propertyName = name
+        self.propertyUnit = unit
+        self.propertyDatatype = datatype
+        self.propertyFormat = format
+        self.retained = retained
+        self.handler = None
+        self._settable = False
+
+    def settable(self, handler):
+        self.handler = handler
+        self.subscribe(self.node, self.id, handler)
+        self._settable = True
+
+    def update(self, value):
+        self.node.homie.publish(
+            "/".join([
+                self.node.homie.baseTopic,
+                self.node.homie.deviceId,
+                self.node.nodeId,
+                self.id,
+            ]),
+            value,
+            self._retained
+        )
+
+    def representation(self):
+        return self.id
+
+    def publishAttribute(self, name, value):
+        self.node.homie.publish(
+            "/".join([
+                self.node.homie.baseTopic,
+                self.node.homie.deviceId,
+                self.node.nodeId,
+                self.id,
+                "${}".format(name)
+            ]),
+            value,
+        )
+
+    def publishAttributes(self):
+        if self._propertyName:
+            self.publishAttribute("name", self._propertyName)
+        if self._settable:
+            self.publishAttribute("settable", str(self._settable).lower())
+        if self._propertyUnit:
+            self.publishAttribute("unit", self._propertyUnit)
+        if self._propertyDatatype:
+            self.publishAttribute("datatype", self._propertyDatatype)
+        if self._propertyFormat:
+            self.publishAttribute("format", self._propertyFormat)
+        if not self._retained:
+            self.publishAttribute("retained", str(self._retained).lower())
+
+    @property
+    def id(self):
+        return self._id
+
+    @id.setter
+    def id(self, id):
+        if isValidId(id):
+            self._id = id
+        else:
+            raise ValueError("'{}' is not a valid ID for a property".format(id))
+
+    @property
+    def propertyName(self):
+        return self._propertyName
+
+    @propertyName.setter
+    def propertyName(self, name):
+        self._propertyName = name
+
+    @property
+    def propertyUnit(self):
+        return self._propertyUnit
+
+    @propertyUnit.setter
+    def propertyUnit(self, unit):
+        if unit:
+            if isValidUnit(unit):
+                self._propertyUnit = unit
+            else:
+                logger.warning("'{}' is not a valid unit".format(unit))
+
+    @property
+    def propertyDatatype(self):
+        return self._propertyDatatype
+
+    @propertyDatatype.setter
+    def propertyDatatype(self, datatype):
+        if datatype:
+            if isValidDatatype(datatype):
+                self._propertyDatatype = datatype
+            else:
+                logger.warning("'{}' is not a valid datatype".format(datatype))
+
+    @property
+    def propertyFormat(self):
+        return self._propertyFormat
+
+    @propertyFormat.setter
+    def propertyFormat(self, format):
+        if format or self._propertyDatatype:
+            if isValidFormat(self._propertyDatatype, format):
+                self._propertyFormat = format 
+            else:
+                logger.warning("'{}' is not a valid format for {}".format(format, self._propertyDatatype))
+
+    @property
+    def retained(self):
+        return self._retained
+
+    @retained.setter
+    def retained(self, retained):
+        self._retained = retained
+
+class HomieNodePropertyRange(HomieNodeProperty):
+    """docstring for HomieNodeRange"""
+
+    def __init__(self, node, id, lower, upper, name=None, unit=None, datatype=None, format=None, retained=True):
+        super(HomieNodePropertyRange, self).__init__(node, id, name, unit, datatype, format, retained)
+        self.node = node
+        self._range = range(lower, upper + 1)
+        self.range = None
+        self.lower = lower
+        self.upper = upper
+        self.range_names = [(id + "_" + str(x)) for x in self._range]
+
+    def settable(self, handler):
+        self.handler = handler
+        for x in self._range:
+            self.subscribe(self.node, "{}_{}".format(self.id, x), handler)
+
+    def setRange(self, lower, upper):
+        # Todo: validate input
+        if lower in self._range and upper in self._range:
+            self.range = range(lower, upper + 1)
+            return self
+        else:
+            logger.warning("Specified range out of announced range.")
+
+    def send(self, value):
+        if self.range is None:
+            raise ValueError("Please specify a range.")
+
+        for x in self.range:
+            self.node.homie.publish(
+                "/".join([
+                    self.node.homie.baseTopic,
+                    self.node.homie.deviceId,
+                    self.node.nodeId,
+                    self.id + "_" + str(x),
+                ]),
+                value,
+            )
+
+    def representation(self):
+        repr = "{}[{}-{}]".format(self.id, self.lower, self.upper)
+        return repr
+
diff --git a/setup.py b/setup.py
index ea4b276..b5d7b5d 100755
--- a/setup.py
+++ b/setup.py
@@ -2,7 +2,7 @@
 """Provide a setup routine."""
 from setuptools import setup
 
-version = "0.4.1"
+version = "0.5.0"
 
 setup(
     name="homie",