The Hacktoberfest is over now. Home Assistant made the 2nd and the 3rd place out of almost 30’000 participating repositories with a total of 528 pull requests closed - that’s an average of 17 pull requests a day! Thanks to all the contributors but also to the team of reviewers. This wouldn’t been possible without you 👏 .
+ +This release has improved the reporting when a config validation error occurs. Thanks to @kellerza you will now get a persistent notification added to your UI when this happens.
+ +This release contains the first asynchronous sensor and camera platforms. @pvizeli and @fabaff ported most of the “internal” sensors to async programming. We hope that you will enjoy the new speed.
+ +@balloob and @pvizeli worked a lot on the improvement of the core itself.
+ +For a long time we have had a bunch of weather sensors but it’s getting better: There is now a Weather component. Sorry, not much more to tell right now. The plans are to create a weather UI element and to improve the initial implementation.
+ +
entity_picture (@armills)hass.data to store internal data (@balloob)send_delay feature (@janLo)known_devices (@kellerza)We’ve added a warning to 0.32 to catch platforms accidentally slowing down Home Assistant. Our aim is to fix these quickly when reported, so here is 0.32.1 with all reported platforms fixed.
+ +Our website has now an additional category called “Ecosystem”. This will become the place where tools, apps, and other helper for the Home Assistant ecosystem can store their documentation or guides.
+ + + +garage_door, rollershutter, thermostat, and hvac have been removed.…don’t hesitate to use our Forum or join us for a little chat. The release notes have comments enabled but it’s preferred if you the former communication channels. Thanks.
+ +]]>This change was driven by two important factors.
+ +As a user, you will be able to be notified if you are running a Home Assistant version that includes components that have known security flaws.
+ +Although we hope to not have to use this feature often, it is important for us to be able to reach out to impacted users. We had the need for such a feature once in the past. Due to a bug the forecast.io sensor was making a huge amount of API requests causing some of our users to get charged because they went over the free quota.
+ +Please note that this functionality is not done yet but will be available in a future release.
+ +As developers of Home Assistant, we will be able to see in what kind of environments Home Assistant is running. Here’s a few data points we didn’t have until now:
+ +We store the city so that we can see where our users are from. This information will be used to give us a better insight in where our users are from. This will help us gather data to see if we should for example prioritize internationalization. In addition, we previously had a nasty bug with the sun component in which users above a certain latitude were having crashes multiple times a day. Had the updater component been in place we could have targeted a special priority update notification only to them.
As stated in the release blog post, the location information is not provided by your local Home Assistant installation but is instead gathered by comparing your IP address against the GeoLite2 data created by MaxMind. From their documentation:
+ +++ +IP geolocation is inherently imprecise. Locations are often near the center of the population. Any location provided by a GeoIP database should not be used to identify a particular address or household.
+
We decided to have it enabled by default because we consider the information that is gathered not harmful. We understand that not everyone will agree with us and so we have provided multiple ways to opt out.
+ +It is in our short-term planning to add an option to control this to our frontend.
+ +The source code of our updater AWS Lambda function is now available here.
+ +]]>How are you? Having a good day? We sure are. If you aren’t having a good day, this might cheer you up…
+ +Every other weekend around here gets a little hectic leading to a big sigh of relief as we release a new version of Home Assistant to the world. And this time is no different. Our developer community has once again built us a beautiful new release with lots of new features and improvements. We hope you like it.
+ +One last thing before we get going though, I should warn you… @balloob got a bit lazy this week and let me (@robbiet480) step up to the plate again to write the blog post and do the release. I guess I didn’t do such a bad job in 0.27. You’ll never know what surprises I have in store. Now that i’ve got all that stuff out of the way, let’s get started…
+ +Sadly, no big amazing stats to update you with this time, but we did recently pass 7,000 commits! This release featured submissions from 45 contributors. Hopefully with the new updater component we will be able to give you some really good stats in the 0.32 blog post.
+ +
October means Hacktoberfest time and our community has really come through with some excellent improvements and additions. As of this writing, we have 194 merged and 41 open pull requests to the home-assistant repository and 209 merged/28 open pull requests submitted to the home-assistant.github.io repository. If you want to get in on the fun check out our Hacktoberfest blog post or the Hacktoberfest website. You get an awesome t-shirt for free if you have 4 pull requests merged in the month of October! We even have tasks that a non-developer can easily accomplish with a tiny bit of work. Better hurry up though, only 9 days left and most of the easy tasks are gone!
+ +This release includes an update to our updater component. The responsibility of the updater component is to check if a new version is available and notify the user if this is the case.
+ +It used to be that this component would check with PyPi (the Python package manager) to see if a new update was available. This had a couple of problems:
+ +So to work around these problems, we decided to start hosting the version check service ourselves. Since we had to get some infrastructure spun up anyway, we figured we would take it a step further. Which leads me to this bit of the update (the most important part):
+ +Remember how I mentioned that up there in the title that there is some serious business in this release? Well, we also added some basic analytics to the updater component which get sent to the server and stored so that we get a better idea of our user base.
+ +Each Home Assistant instance running the updater component will generate a unique ID (based on UUIDv4) that will be used for the updater to be able to differentiate between instances. This UUID will be stored in your config directory in a file called .uuid.
There are two ways to opt-out. The first way is by using the new opt_out option for the updater. This way the updater will continue to check for updates, but no information about your system will be shared with us.
updater:
+ reporting: no
+You can also disable the updater component entirely by removing updater: from your configuration.yaml although we would not suggest you do this as you would miss any critical updates.
Finally, you can also reset your unique identifier by deleting the .uuid file and restarting Home Assistant.
Here is what my production Home Assistant instance looks like from the server side:
+ +| Name | +Description | +Example | +
|---|---|---|
arch |
+ CPU Architecture | +x86_64 |
+
distribution |
+ Linux Distribution name (only Linux) | +Ubuntu |
+
docker |
+ True if running inside Docker | +false |
+
os_name |
+ Operating system name | +Darwin |
+
os_version |
+ Operating system version | +10.12 |
+
python_version |
+ Python version | +3.5.2 |
+
timezone |
+ Timezone | +America/Los_Angeles |
+
user_agent |
+ User agent used to submit analytics | +python-requests/2.11.1 |
+
uuid |
+ Unique identifier | +10321ee6094d4a2ebb5ed55c675d5f5e |
+
version |
+ Home Assistant version | +0.31.0 |
+
virtualenv |
+ True if running inside virtualenv | +true |
+
In addition to the above collected data, the server will also use your IP address to do a geographic IP address lookup to determine the city that you are from. To be extremely, extremely clear about this bit: The Home Assistant updater does not: store your IP address in a database and also does not submit the location information from your configuration.yaml.
+ 
+ Geo-lookup on my IP resolves to Oakland with latitude/longitude pointing at the geographical center of the city.
+
The server also adds two timestamps to the data: the original date your instance UUID was first seen and the timestamp of the last time we have seen your instance. This gives us the following extra data:
+ +| Name | +Description | +Example | +
|---|---|---|
first_seen_datetime |
+ First time instance ID was submitted | +2016-10-22T19:56:03.542Z |
+
geo_city |
+ GeoIP determined city | +Oakland |
+
geo_country_code |
+ GeoIP determined country code | +US |
+
geo_country_name |
+ GeoIP determined country name | +United States |
+
geo_latitude |
+ GeoIP determined latitude (of the city) | +37.8047 |
+
geo_longitude |
+ GeoIP determined longitude (of the city) | +-122.2124 |
+
geo_metro_code |
+ GeoIP determined metro code | +807 |
+
geo_region_code |
+ GeoIP determined region code | +CA |
+
geo_region_name |
+ GeoIP determined region name | +California |
+
geo_time_zone |
+ GeoIP determined time zone | +America/Los_Angeles |
+
geo_zip_code |
+ GeoIP determined zip code | +94602 |
+
last_seen_datetime |
+ Most recent time instance ID was submitted | +2016-10-22T19:56:03.542Z |
+
This data is held in the highest security. The update system runs in a secured Amazon Web Services account owned by me (@robbiet480). I personally have 5 years of experience with complex AWS deployments and have an extensive security background. I have audited the entire system and made sure to take every step to protect the data, including limiting who has access (just @balloob and myself). While not directly personally identifiable we absolutely understand some users hesistance to giving this information out. Please understand that we are only collecting this information to better understand our user base to provide better long term support and feature development then is currently possible.
+ +We currently have no plans to publicly expose any of this information. If we did do such a thing in the future we would of course notify you in advance. It must also be stated that we will never sell or allow the use of this information for non-Home Assistant purposes.
+ +We thank you for understanding why we are collecting this data and hope that you leave the feature enabled but fully understand if you feel uncomfortable with this.
+ +This section was updated on October 24 to be more clear about geo-lookups being on the city level. See original version.
+ +Now, back to the fun stuff…
+ +Home Assistant got a crazy idea recently that it couldn’t do enough already and wanted to challenge itself even more. I really don’t understand how it came up with this kooky idea, but it now thinks that its newest hobby should be a minor career in journalism.
+ +0.31 adds support for the brand spanking new Alexa Flash Briefing API, allowing you to get updates from Home Assistant anytime you ask Alexa to read your flash briefing. What’s the use case you ask? Well, now when I wake up in the morning and get my flash briefing, Home Assistant adds this to the end of it for me:
+ +++ +Drive time with traffic is 35 minutes. There is an UberPOOL that will cost $11.52, estimated to be 2 minutes away, for a total of 37 minutes. BART is currently estimated to take 29 minutes. You should take BART, as it is estimated to be faster by 8 minutes.
+
Now I know how to best get to my real job (no, Home Assistant is not my real job, it does seem like it sometimes though) every morning. Obviously not the best home automation example, but I think you get the idea. I could see this being used to tell you any major events that happened in your home overnight or reading you your hyperlocal weather report. Thanks to the audio support you could even replace all of the default Alexa Flash Briefing sources with your own news feeds. Home Assistant supports both text and audio content as well as displaying data in the Alexa app. I also want to point out that unlike the existing Skill integration, the Flash Briefing API does not require HTTPS (but you should still be using HTTPS if possible). For more information, check out the new docs.
+ +
+ 
+ You stay classy, San Diego. (It’s funny, because balloob lives in San Diego))
+
A rather nasty Z-Wave issue was discovered recently by @lukas-hetzenecker. There was a somewhat large chance that if you had multiple of the same model Z-Wave device they may both try to use the same entity IDs. To fix the issue the internal Z-Wave index is now appended to the end of all Z-Wave entity IDs.
+ +What this means for all you Z-Wave users is that you will need to update your configurations to reflect the change. I personally have quite a few (17) Z-Wave devices and went through the process this week. Here’s what I had to do:
+ +zwave.customize sectionemulated_hue with Alexa and emulated_hue uses the entity ID as a unique identifier I also had to remove all Z-Wave devices from Alexa and re-add them.Your todo list may be a little different from mine, I just wanted to outline the steps I took to give you an idea of what you need to think about. It’s not a very hard process, especially when using global find and replace in Sublime Text but did take me about 20 minutes to complete.
+ +This is super annoying, I know, especially since we had said in 0.12 that Z-Wave IDs should hopefully never change again, but we are now forced to eat those words. I will state again that Z-Wave IDs shouldn’t change in the future but obviously we see how that went. To sum up on this section… sorry but it had to happen.
+ +approved_ips from string to CIDR validation (@mweinelt)known_devices.yaml reading and writing tweaks and fixes (@kellerza)fail filter added to templates to raise on UndefinedError (@jaharkes)…don’t hesitate to use our Forum or join us for a little chat. The release notes have comments enabled but it’s preferred if you the former communication channels. Thanks.
+ +Thanks for reading all of the above, especially since this week was a pretty long post. We should be back with a new post around November 5th announcing the arrival of 0.32.
+ +– Robbie
+ +]]>We guess that you already know: The Raspberry Pi image is available now. For Hassbian, @Landrash has combined the most essential parts for a Home Assistant setup in an easy-to-use image for the Raspberry Pi device family. Hassbian is quite young, thus we are looking forward to recieve feedback, issue report, and suggestions to improve it.
+ +A large amount of resources of the development are still focusing on the effort to move Home Assistant further to asynchronous programming. It’s a labor-intensive task, comes with segmentation faults, and unstable instances when certain combinations of sensors are used. The benefit will be more speed in the near future.
+ +To reduce the run-time of your tests, @balloob did a lot of tweaking. For now the RFXtrx tests are excluded which cut the needed time for running on your Pull Request in half.
+ +All configuration sample entries are now minimized. This should help to avoid problem for starters and newbies as they only get what’s needed and not a full sample with all optional entries. If there is an issue with an entry in your configuration.yaml file the error message will provide you an URL that point to the documentation.
+ 
+
As soon as the Hacktoberfest started there were a lot of incoming Pull Requests for the documentation. A huge “Thank you” to all participants. Especially, we would like to give a cookie to @hillaryfraley. She created around a dozen Pull Requests so far and didn’t only fix typos but complete sections. The Hacktoberfest is still on-going and we are looking forward to get more Pull Requests.
+ +With the statistics sensor we would like to introduce a new sensor that is similar to the template sensor or the trend sensor. This sensor is consuming values from another sensor and is doing some statistical analysis of the data. Over a group of samples is the average/mean, the min/max, the total, the standard deviation, and the variance calculated which can be used in your automation rules. If the source is a binary sensor then the state changes are counted.
+ +
+ 
+
As the results are processed on-the-fly you still need to use the data from your database for a in-depth analysis of your stored information. Check the latest notebook for doing statistics with your Home Assistant database.
+ +There was a lot of work done on our implementation which are working with RESTful APIs. @w1ll1am23 extended the aREST platforms to display if an aREST unit is available or not. The aREST implementations are now covered by the configuration check as well. Please check the Breaking changes section for more details.
+ +The REST sensor supports now HTTP authentication (basic and digest) and custom headers. This will allow you to access resources which are protected. This sample sensor will access GitHub and retrieve the latest release number while by-passing the rate limit for non-authenticated requests.
+ +sensor
+ - platform: rest
+ resource: https://api.github.com/repos/home-assistant/home-assistant/releases/latest
+ username: YOUR_GITHUB_USERNAME
+ password: YOUR_GITHUB_ACCESS_TOKEN
+ authentication: basic
+ value_template: '{{ value_json.tag_name }}'
+ headers:
+ Accept: application/vnd.github.v3+json
+ Content-Type: application/json
+ User-Agent: Home Assistant REST sensor
+
known_device.yaml file is now validated (@kellerza)known_devices.yaml validation is now more accepting (@kellerza)notify.html5_unnamed_device_2) the target was not submitted to the platform as a list causing iteration over every character in the string. (@robbiet480)automation have been removed (deprecated since May and have printed warnings to your console):
+ use_trigger_values is gone. You have to copy your triggers to conditions and adjust for the correct config.condition_type is gone. Use condition: or instead.condition: instead of platform:.- platform: forecast with - platform: darksky.…don’t hesitate to use our Forum or join us for a little chat. The release notes have comments enabled but it’s preferred if you the former communication channels. Thanks.
+ +]]>Why contribute to Home Assistant:
+ +Resources to get started:
+ +Are you not a programmer but still want to contribute to Home Assistant? Check out our list of entry-level issues for the Home Assistant website.
+ +
This image comes pre-installed with everything you need to get started with Home Assistant right away.
+ +To get started, check out the installation instructions in the getting started section or watch the latest video by BRUHAutomation:
+ +It’s based on Raspbian Lite and generated with a fork of the same script that builds the official Raspbian images. For installation of HASS it follows the same install instructions as the Manual installation. Please note that this project has no association with the Raspberry Pi foundation or their projects.
+ +On first boot the latest release of Home Assistant will be installed and can be reached after 3~5 minutes. Pre-installed on this image is the MQTT broker Mosquitto, Bluetooth support and settings for the homeassistant account to use the GPIO pins of the Raspberry Pi. Mosquitto is not activated by default.
As it is today there is no pre-compiled Z-Wave support but it can be installed by following the Getting started instructions for Z-Wave.
+ +Happy Automating!
+ +]]>This is a big release as we’ve completely overhauled the internals of Home Assistant. When I initially wrote Home Assistant, still figuring out the ins and outs of Python, I went for an approach that I was familiar with for an application with many moving parts: threads and locks. This approach has served us well over the years but it was slower than it needed to be, especially on limited hardware.
+ +This all changed when @bbangert came around and took on the tough job to migrate the core over to use asynchronous programming. He did an amazing job and I am happy to say that the initial port has been done and is included in this release! On top of that, we have been able to keep our simple and straightforward API at the same time. We are still in the process of migrating more and more components over to the asynchronous API, so expect more speedups and awesome features in the upcoming releases.
+ +There now is support for two new super cool things: Beds and license plates. @technicalpickles created a SleepIQ component that let you monitor the sensor data of your bed. @pvizeli has added license plate recognition based on OpenALPR! This means that you can now be notified about which car is parked on your driveway or in your garage. I also would like to use this opportunity to give a big shoutout to @pvizeli for being such an awesome member of our community. He joined us at the end of June and has helped crush bugs and add awesome features ever since (65 pull requests already!).
+ +On the voluptuous front we have also made great progress. We were able to fully remove the legacy config helpers and have migrated 323 of the 346 components and platforms that needed migrating! This does mean that for some components the configuration has slightly changed, make sure to check out the breaking changes section at the bottom for more info. Thanks everybody for reviewing the Pull requests, testing the changes, and reporting issues.
+ +As you might have noticed, this release has been delayed by 5 days. This was due to a rare, difficult to reproduce problem with the Python interpreter. A huuuuge thanks to all the people that have helped countless hours in researching, debugging and fixing this issue: @bbangert, @turbokongen, @lwis, @kellerza, @technicalpickles, @pvizeli, @persandstrom and @joyrider3774. I am grateful to have all of you as part of the Home Assistant community.
+ +Since 0.28 automation rules can be reloaded directly from the frontend. By default all automation rules are shown. If you want to hide an automation rule, use hide_entity: True.
data_template would incorrectly get cached (@balloob)now and utcnow have been changed from variables to methods. To get the current time replace now with now().yahooweather default name is now yweather. Also min and max temperature are now correctly called Temperature Min and Temperature Max.ffmpeg is now a component for manage some things central. All ffmpeg_bin options have moved to this compoment from platforms.…don’t hesitate to use our Forum or join us for a little chat. The release notes have comments enabled but it’s preferred if you the former communication channels. Thanks.
+ +]]>This release brings you a huge improvement of the automation and group handling. Both can be reloaded without a Home Assistant restart by calling their new reload services. The automations can be controlled directly from the frontend.
+ +
+ 
+
Singleboard computers are very popular to run Home Assistant. To support this fact, the installation documentation for the Raspberry Pi devices was re-written to get users started as quickly as possible. @Landrash took the lead with on this tasks with help from @kellerza and @MartinHjelmare.
+ +There are countless bugfixes included in this release which will make your experience with the climate and the cover platforms better. Two week ago was the biggest merger of implementations released that ever happened in the history of Home Assistant. Thanks to @turbokongen, @pvizeli, @djbanks, @danielperna84, and others the improvements on the code and the frontend side is continuing…
The Home Assistant API Documentation is a great addition to the already exisiting user documentation. The focus is not end-users but developers who whant to get details about the code without actually browsing the code on Github.
+ +The validation of the configuration is still on-going. Approximatly 80 % is done. This means that we will propably talk about this topic in the next release notes again. To align the configuration of components and platforms we needed to break some. Please refer to the Breaking changes section to check if you need to update your configuration or simple check your log for configuration validation errors. Thanks to @kellerza, @fabaff, @Teagan42, and @pvizeli for your effort!
+ +
known_devices file (@kellerza)link_names for sending Slack message (@salt-lick)data_template (@pvizeli)check_config: Improve yaml fault tolerance and handle border cases (@kellerza)write_registers Modbus service (@persandstrom)sensor.owm_temperature. Previously they were like sensor.weather_temperature. Apologies for this change, but we needed to make OpenWeatherMap more generic now that we have many weather platforms.BaseNotificationService need to be aware that kwargs.get(ATTR_TITLE) will now return None if a title has not been set, and will need to specify kwargs.get(ATTR_TITLE, ATTR_TITLE_DEFAULT) if they always require a title.…don’t hesitate to use our Forum or join us for a little chat.
+ +]]>
+So, part 1 of ESP8266 and MicroPython was pretty lame, right? Instead of getting information out of Home Assistant we are going a step forward and create our own sensor which is sending details about its state to a Home Assistant instance.
+
+
+
+Beside HTTP POST requests, MQTT is the quickest way (from the author’s point of view) to publish information with DIY devices.
+ +You have to make a decision: Do you want to pull or to poll? For slowly changing values like temperature it’s perfectly fine to wait a couple of seconds to retrieve the value. If it’s a motion detector the state change should be available instantly. This means the sensor must take initiative.
+ +An example for pulling is aREST. This is a great way to work with the ESP8266 based units and the Ardunio IDE.
+ +You can find a simple examples for publishing and subscribing with MQTT in the MicroPython library overview in the section for umqtt.
+ +The example below is adopted from the work of @davea as we don’t want to re-invent the wheel. The configuration feature is crafty and simplyfies the code with the usage of a file called /config.json which stores the configuration details. The ESP8266 device will send the value of a pin every 5 seconds.
import machine
+import time
+import ubinascii
+import webrepl
+
+from umqtt.simple import MQTTClient
+
+# These defaults are overwritten with the contents of /config.json by load_config()
+CONFIG = {
+ "broker": "192.168.1.19",
+ "sensor_pin": 0,
+ "client_id": b"esp8266_" + ubinascii.hexlify(machine.unique_id()),
+ "topic": b"home",
+}
+
+client = None
+sensor_pin = None
+
+def setup_pins():
+ global sensor_pin
+ sensor_pin = machine.ADC(CONFIG['sensor_pin'])
+
+def load_config():
+ import ujson as json
+ try:
+ with open("/config.json") as f:
+ config = json.loads(f.read())
+ except (OSError, ValueError):
+ print("Couldn't load /config.json")
+ save_config()
+ else:
+ CONFIG.update(config)
+ print("Loaded config from /config.json")
+
+def save_config():
+ import ujson as json
+ try:
+ with open("/config.json", "w") as f:
+ f.write(json.dumps(CONFIG))
+ except OSError:
+ print("Couldn't save /config.json")
+
+def main():
+ client = MQTTClient(CONFIG['client_id'], CONFIG['broker'])
+ client.connect()
+ print("Connected to {}".format(CONFIG['broker']))
+ while True:
+ data = sensor_pin.read()
+ client.publish('{}/{}'.format(CONFIG['topic'],
+ CONFIG['client_id']),
+ bytes(str(data), 'utf-8'))
+ print('Sensor state: {}'.format(data))
+ time.sleep(5)
+
+if __name__ == '__main__':
+ load_config()
+ setup_pins()
+ main()
+Subscribe to the topic home/# or create a MQTT sensor to check if the sensor values are published.
$ mosquitto_sub -h 192.168.1.19 -v -t "home/#"
+sensor:
+ - platform: mqtt
+ state_topic: "home/esp8266_[last part of the MAC address]"
+ name: "MicroPython"
+@davea created sonoff-mqtt. This code will work on ESP8622 based devices too and shows how to use a button to control a relay.
+ +]]>or maybe#supersized
+ +Keep reading to see what #Amazing things we have in store for you this week 😄! And make sure you read all the way to the end, because I left a present down there for those committed few among you :)
+ +But first…
+ +Paulus (@balloob) is on vacation in Europe this week, so you will all have to deal with me, Robbie (@robbiet480) for this release blog post. Don’t worry, Paulus will be back to tearing apart your pull requests in no time 😈.
+ +Special thanks to my awesome helpers for this week’s release who are looking over my shoulder to make sure I’m crossing my t’s and dotting my i’s: @Teagan42, @infamy and @fabaff.
+ +For my next trick, let’s hand out some…
+ +I felt that I had to 1-up Paulus (@balloob) somehow with his 500,000 pageviews stat he shared in the 0.26 blog post, so I pushed myself and our development community as a whole super hard the last two weeks to put a lot of love into Home Assistant to bring you not just one, but six #Amazing stats for this release. As of 0.27, we have now surpassed the following milestones:
+ +In addition,
+ +Now that we have that great news out of the way, onto this week’s release which is going to keep the #Amazing gravy train rolling right along and get to the stuff you all really are here for.
+ +While this release is #Amazing, we had to break a few eggs (now you understand the title reference!) to make a beautiful omelette (using home automation obviously) so some platforms and components have needed to introduce breaking changes. Please make sure to read the Breaking Changes section below.
+ +Thanks to @mgbowen we now have the functionality previously provided by @blocke’s ha-local-echo built right into Home Assistant! This means that for those of you with devices that either lack or have a subpar integration with Home Assistant (looking at you Amazon Echo) you can now have a better experience by having your Home Assistant pretend to be a Hue Bridge. Personally, I have used @auchter’s Haaska previously but found that it was slow to respond and sometimes failed entirely. With the new emulated_hue component, you can have local control of entities through Amazon Echo.
We have some excellent upgrades to the notification system coming to you in 0.27, courtesy of me, @robbiet480.
+ +This release adds support for HTML5 push notifications on Chrome/Firefox/Opera on both desktop and Android devices. This means that you can send a notification to your phone even when your Home Assistant is not open in your mobile browser. When using Chrome you can even include 2 action buttons so that you can control your Home Assistant from your phone’s lock screen, allowing you to do things like sound alarms or unlock your front door, all without leaving the notification. Thanks again to me (@robbiet480) and Paulus (@balloob) for all the hard work on this!
+ +
+ 
+
Using the new notify group platform allows you to cut down a lot of duplicate automation logic by combining multiple notification platforms and targets into a single notify service. Check out the docs for more info.
target is no longer needed!For platforms that support it, starting with the new HTML5 platform, any targets that are available will be exposed as individual services, so no more having to remember which targets to use. Please note that the existing services also still exist so you can keep using target if you wish.
Ever restarted Home Assistant to test a configuration change just to find out there is a validation error? Well, not anymore! @kellerza has added a command line script that will validate your configuration as if you started Home Assistant.
+ +$ hass --script check_config
+This release includes a big push on making sure all platforms contain proper configuration validation. This should help in getting your configuration right. Thanks to @fabaff, @pavoni, @pvizeli, @nkgilley for all the hard work on this, you all rock!
+ +
+ 
+
It’s now possible to use FFMpeg to monitor a video stream and detect motion thanks to a new binary sensor platform by @pvizeli.
+ +Due to our wild growth we ended up with a few components that had a lot of overlapping functionality. @turbokongen took on the hard job on merging them. Thermostat and HVAC platforms are now combined under the new Climate component. Rollershutter and Garage Door platforms are now combined under the new Cover component. You can easily upgrade by just swapping out the name. For example replace thermostat with climate. The old components have been deprecated and will be removed in the near future.
fan componentAlong with the new climate component, @Teagan42 and I (@robbiet480) decided we needed something simpler to just control a fan. Currently it has support for controlling Insteon fans. MQTT support will appear in 0.28.0. I tried to get it implemented before 0.27.0 but spent too long writing this blog post 😢.
sensor.forecastio_temperature. Previously they were like sensor.weather_temperature. Apologies for this change, but we needed to make Forecast.io more generic now that we have many weather platforms.type: is no longer required for monitored variables.username instead of user.thermostat and hvac components has been deprecated. Please migrate to the new climate component. (just change the component name, the configurations are compatible)rollershutter and garage_door components have also been deprecated. Please migrate to the new cover component. (just change the component name, the configurations are compatible)Thanks all for sticking with me to the end. I’ll be taking over a lot of Paulus’s (@balloob) work while he is gone, but as I said, don’t worry because he’ll be back well before 0.28.0 comes out. Hopefully you didn’t find this jovial blog post too jarring from our standard style, I just wrote a lot of this at 2am after being awake for almost 20 hours, so I’m a little loopy hahaha 😴.
+ +Also, thanks as always to our developer contributors, documentation contributors, but most of all our users! This would’ve just been a script that Paulus (@balloob) used to control his lights at home if we didn’t have your enthusiasm.
+ +Feel free to let me know what you thought of this blog post and release on Gitter or my Twitter, or even the Home Assistant Twitter. Did I mention we have a brand new Facebook page that you should absolutely Like? There’s a convenient Facebook Like and Twitter follow button right on the sidebar.
+ +I almost forgot about your 🎁 for reading all the way to here: a 🍪! Hope you enjoy it in good health 😄.
+ +Talk to you soon on Gitter and in your pull request comments!
+ +– Robbie
+ +(p.s. To those of you that scrolled directly to the bottom to get your present, just know that you didn’t earn it like the others did. 😄)
+ +
+
+Heatmap
+
AppDaemon is a python daemon that consumes events from Home Assistant and feeds them to snippets of python code called “Apps”. An App is a Python class that is instantiated possibly multiple times from AppDaemon and registers callbacks for various system events. It is also able to inspect and set state and call services. The API provides a rich environment suited to home automation tasks that can also leverage all the power of Python.
+
+
+
+If you haven’t yet read Paulus’ excellent Blog entry on Perfect Home Automation I would encourage you to take a look. As a veteran of several Home Automation systems with varying degrees success, it was this article more than anything else that convinced me that Home Assistant had the right philosophy behind it and was on the right track. One of the most important points made is that being able to control your lights from your phone, 9 times out of 10 is harder than using a lightswitch - where Home Automation really comes into its own is when you start removing the need to use a phone or the switch - the “Automation” in Home Automation. A surprisingly large number of systems out there miss this essential point and have limited abilities to automate anything which is why a robust and open system such as Home Assistant is such an important part of the equation to bring this all together in the vast and chaotic ecosystem that is the “Internet of Things”.
+ +So given the importance of Automation, what should Automation allow us to do? I am a pragmatist at heart so I judge individual systems by the ease of accomplishing a few basic but representative tasks:
+ +In my opinion, Home Assistant accomplishes the majority of these very well with a combination of Automations, Scripts and Templates, and it’s Restful API.
+ +So why AppDaemon? AppDaemon is not meant to replace Home Assistant Automations and Scripts, rather complement them. For a lot of things, automations work well and can be very succinct. However, there is a class of more complex automations for which they become harder to use, and appdeamon then comes into its own. It brings quite a few things to the table:
AppDaemon Apps are a much more natural fit for this. Recent enhancements to Home Assistant scripts and templates have made huge strides, but for the most complex scenarios, Apps can do things that Automations can’tAppDaemon’s API is full of helper functions that make programming as easy and natural as possible. The functions and their operation are as “Pythonic” as possible, experienced Python programmers should feel right at home.AppDaemon has been designed from the start to enable the user to make changes without requiring a restart of Home Assistant, thanks to it’s loose coupling. However, it is better than that - the user can make changes to code and AppDaemon will automatically reload the code, figure out which Apps were using it and restart them to use the new code without the need to restart AppDaemon itself. It is also possible to change parameters for an individual or multiple apps and have them picked up dynamically, and for a final trick, removing or adding apps is also picked up dynamically. Testing cycles become a lot more efficient as a result.It is in fact a testament to Home Assistant’s open nature that a component like AppDaemon can be integrated so neatly and closely that it acts in all ways like an extension of the system, not a second class citizen. Part of the strength of Home Assistant’s underlying design is that it makes no assumptions whatever about what it is controlling or reacting to, or reporting state on. This is made achievable in part by the great flexibility of Python as a programming environment for Home Assistant, and carrying that forward has enabled me to use the same philosophy for AppDaemon - it took surprisingly little code to be able to respond to basic events and call services in a completely open ended manner - the bulk of the work after that was adding additonal functions to make things that were already possible easier.
The best way to show what AppDaemon does is through a few simple examples.
Lets start with a simple App to turn a light on every night at sunset and off every morning at sunrise. Every App when first started will have its initialize() function called which gives it a chance to register a callback for AppDaemons’s scheduler for a specific time. In this case we are using run_at_sunrise() and run_at_sunset() to register 2 separate callbacks. The argument 0 is the number of seconds offset from sunrise or sunset and can be negative or positive. For complex intervals it can be convenient to use Python’s datetime.timedelta class for calculations. When sunrise or sunset occurs, the appropriate callback function, sunrise_cb() or sunset_cb() is called which then makes a call to Home Assistant to turn the porch light on or off by activating a scene. The variables args["on_scene"] and args["off_scene"] are passed through from the configuration of this particular App, and the same code could be reused to activate completely different scenes in a different version of the App.
import appapi
+
+class OutsideLights(appapi.AppDaemon):
+
+ def initialize(self):
+ self.run_at_sunrise(self.sunrise_cb, 0)
+ self.run_at_sunset(self.sunset_cb, 0)
+
+ def sunrise_cb(self, args, kwargs):
+ self.turn_on(self.args["off_scene"])
+
+ def sunset_cb(self, args, kwargs):
+ self.turn_on(self.args["on_scene"])
+This is also fairly easy to achieve with Home Assistant automations, but we are just getting started.
+ +Our next example is to turn on a light when motion is detected and it is dark, and turn it off after a period of time. This time, the initialize() function registers a callback on a state change (of the motion sensor) rather than a specific time. We tell AppDaemon that we are only interested in state changes where the motion detector comes on by adding an additional parameter to the callback registration - new = "on". When the motion is detected, the callack function motion() is called, and we check whether or not the sun has set using a built-in convenience function: sun_down(). Next, we turn the light on with turn_on(), then set a timer using run_in() to turn the light off after 60 seconds, which is another call to the scheduler to execute in a set time from now, which results in AppDaemon calling light_off() 60 seconds later using the turn_off() call to actually turn the light off. This is still pretty simple in code terms:
import appapi
+
+class MotionLights(appapi.AppDaemon):
+
+ def initialize(self):
+ self.listen_state(self.motion, "binary_sensor.drive", new = "on")
+
+ def motion(self, entity, attribute, old, new, kwargs):
+ if self.sun_down():
+ self.turn_on("light.drive")
+ self.run_in(self.light_off, 60)
+
+ def light_off(self, kwargs):
+ self.turn_off("light.drive")
+This is starting to get a little more complex in Home Assistant automations requiring an Automation rule and two separate scripts.
+ +Now lets extend this with a somewhat artificial example to show something that is simple in AppDaemon but very difficult if not impossible using automations. Lets warn someone inside the house that there has been motion outside by flashing a lamp on and off 10 times. We are reacting to the motion as before by turning on the light and setting a timer to turn it off again, but in addition, we set a 1 second timer to run flash_warning() which when called, toggles the inside light and sets another timer to call itself a second later. To avoid re-triggering forever, it keeps a count of how many times it has been activated and bales out after 10 iterations.
import appapi
+
+class FlashyMotionLights(appapi.AppDaemon):
+
+ def initialize(self):
+ self.listen_state(self.motion, "binary_sensor.drive", new = "on")
+
+ def motion(self, entity, attribute, old, new, kwargs):
+ if self.self.sun_down():
+ self.turn_on("light.drive")
+ self.run_in(self.light_off, 60)
+ self.flashcount = 0
+ self.run_in(self.flash_warning, 1)
+
+ def light_off(self, kwargs):
+ self.turn_off("light.drive")
+
+ def flash_warning(self, kwargs):
+ self.toggle("light.living_room")
+ self.flashcount += 1
+ if self.flashcount < 10:
+ self.run_in(self.flash_warning, 1)
+Of course if I wanted to make this App or its predecessor reusable I would have provided parameters for the sensor, the light to activate on motion, the warning light and even the number of flashes and delay between flashes.
+ +In addition, Apps can write to AppDaemon’s logfiles, and there is a system of constraints that allows yout to control when and under what circumstances Apps and callbacks are active to keep the logic clean and simple.
I have spent the last few weeks moving all of my (fairly complex) automations over to APPDaemon and so far it is working very reliably.
Some people will maybe look at all of this and say “what use is this, I can already do all of this”, and that is fine, as I said this is an alternative not a replacement, but I am hopeful that for some users this will seem a more natural, powerful and nimble way of building potentially very complex automations.
+ +If this has whet your appetite, feel free to give it a try. You can find it, here, including full installation instructions, an API reference, and a number of fully fleshed out examples.
+ +Happy Automating!
+]]>This release includes code contributed by 31 different people. The biggest change in this release is a new unit system. Instead of picking Celsius or Fahrenheit you’ll have to pick imperial or metric now. This influences the units for your temperature, distance, and weight. This will simplify any platform or component that needs to know this information. Big thanks to @Teagan42 for her hard work on this!
+ +
# Configuration.yaml example
+homeassistant:
+ # 'metric' for the metric system, 'imperial' for the imperial system
+ unit_system: metric
+TL; DR: Don’t hack the framework, separate responsibilities, ship less, use service workers, use (future) web standards.
+ +This year at Google I/O I saw Monica from the Polymer team talk about web components and performance. In her talk she mentions a mantra that they use in the Polymer team to make things fast: Do less and be lazy.
+ +Do less and be lazy. It sounds so obvious and it took a while before it started to dawn on me. I think most of the code I write is pretty fast, but I don’t often stop to take a harder look at how and when it runs in practice. When do we need the result, can it be postponed?
+ +And thus started my journey to take a critical look at how the Home Assistant app was working and how to make things faster. Below is the list of the different things that I did to make it fast.
+ +I hope this list can be useful to other people, as a guide for optimizing their own apps or for avoiding pitfalls when building a new one.
+ +The first thing to do is to measure. The Home Assistant front end is a mobile web app, so we shouldn’t measure this on a machine with 8 cores and gigabytes of ram but instead measure on devices you expect a mobile web app to run: phones. Below are two timelines recorded with Home Assistant 0.18.2 (pre-optimizations) and Google Chrome 53. On my Mac the app starts in 1400 miliseconds and on my Nexus 5x in ~6500 miliseconds (~4.5 times slower!).
+ +
+ 
+
Although the app takes 6500 milliseconds to load on my phone, it would perform well afterwards. Still, that initial load is unacceptable. You expect to open an app on your phone and be able to use it, quickly. After I applied all the changes described below, I managed to reduce startup time to 900 miliseconds (-35%) on my Mac and 2400 miliseconds (-63%) on my Nexus 5x. Check out the demo here.
+ +
+ 
+ 
+
The Home Assistant front end consists of two parts. There is Home Assistant JS, which controls all data and interaction between JavaScript and the server. It is a Flux architecture using NuclearJS and ImmutableJS. The UI is implemented by Home Assistant Polymer using Polymer and web components.
+ +I thought to be smart. I split out the JavaScript part of all web components and bundled them separately using Webpack so that I could use ES2015 via BabelJS (architecture). This is not how Polymer components are written and it meant that I was unable to use any of the tooling that is available in the community or easily split up the bundle (more on this later).
+ +So I went ahead and backported all my web components back from shiny beautiful ES6 to ES5. And you know what? It’s not that bad. Yes, not being able to use the concise object notation and arrow functions make your code more verbose. But in the end it is the same code that is running in browsers.
+ +Another benefit of having each web component contain their own script tag is that the browser will process them one by one, allowing the browser to render our loading spinner animation in between.
+ +As you can see in the timelines, we were able to get rid of most of the blocking component loading.
+ +
+ 
+
Whenever you learn a new technology, you feel like you’ve learned a new superpower. Wow, I can do all this with only 2 lines?! I had the same with bundling.
+ +I was initially very focused on shipping just a single file with everything that my app needed. The entry point would be my main component which would require all of its Flux and UI dependencies. Then, just before it all would be rendered, it would check if there is authentication and start the data fetching.
+ +This is a very bad pattern. This means that you will not start any data fetching until your UI is ready to render. Instead, you want your data to be fetched as soon as possible, and while the request is out to the server you want the page to load all your UI components.
+ +To accomplish this I extracted the application core out of the main bundle. In the current optimized version it’s 31.1kb gzip’d. It is loaded before any other scripts so that it can start fetching data as soon as possible.
+ +
+ 
+
When the data does come back before the UI is done loading, we can process it before we start rendering the UI because of all the web components being processed individually. This means that we don’t have to show a loading screen the first time our components render – we can just render the components with the data they require.
+ +The theory behind this one is simple: if we manage to ship less code, the browser has to process less code and it will start faster.
+ +The Home Assistant mobile web application has 10 different panels (pages). Besides that, it also has a dialog for each type of device to show more info. That’s a lot of components and screens of which only a very small set is needed at the start. That means that we are shipping a lot of unnecessary data that the browser has to process before our initial render!
+ +I broke up each panel of the app into a separate bundle that will be loaded on demand. This saved 250 kilobytes (pre-gzip) on just the embedded map alone! This change, however, required some significant changes to our build process.
+ +Breaking up an app in JavaScript is complex because each module explicitly imports their dependencies. This has to continue to work in your browser after breaking it up in multiple files. Web components do not have this problem as it’s part of the platform and thus your browser is the registry! An unregistered web component will be rendered as an empty span element until the element gets registered. Loading order is not important.
+ +// Example of the flexibility of web components.
+var spinner = document.createElement('paper-spinner');
+spinner.active = true;
+document.body.appendChild(spinner);
+Because the browser tracks your web components, creating standalone bundles for parts of the app is easy:
+ +The build script that bundles and minifies the main bundle and panel bundles is <100 lines.
+ +Core.js is still pure JavaScript and requires bundling. In my journey to get a smaller bundle, I went from Webpack to Webpack 2 to Rollup. At each step the bundle got smaller. Rollup is the big winner here because it doesn’t wrap all your modules in function calls but instead concatenates all files with minimal changes to make it work. This not only reduces the file size but also the loading speed. This is because the JavaScript engine will no longer have to invoke a function to resolve each import, it’s doing less work. This might not mean much for a computer but on a phone, everything counts.
+ +If the goal is to ship less, it’s time to take a good look at dependencies. It’s so often that we decide to fall back to yet another NPM package that makes our life a little easier but comes at the cost of size – size usually taken up by functionality that you might never need.
+ +I realized that I only used a few methods of lodash. Lodash (and previously underscore) used to be one of the dependencies that would always be one of the first things that I would add to any project I start. But I could no longer justify it in the case of Home Assistant. Even with dead tree shaking it was not worth including it. Yes, they support a lot of edge cases but those were not relevant to my use case. And standalone lodash packages are still huge. The only thing that I couldn’t replace with a few lines of my own code was debounce. However I found a 40 line replacement.
+ +Moment.js is one of those power libraries. It is able to handle any date problem that you can throw at it. But this obviously comes at the cost of size. Fecha is a date formatting library at ~8% the size of moment.js (only 4.7kb pre-gzip). The only thing that it does not contain is date manipulation, which was something that was not being used.
+ +Using a service worker we’re able to store all app components and core javascript in the browser. This means that after their first visit, the browser will only have to go to the network to fetch the latest data from the server.
+ +Creating a service worker is easy using sw-precache, a service worker generation tool.
+ +When a browser does not support service workers, Home Assistant will serve fingerprinted assets that are aggressively cached. Only when the content changes will the client redownload the asset.
+ +Using fingerprinting with sw-precache required jumping through a few hoops. The final build script can be found here.
+ +This one is more psychological: no one likes staring at a white screen because white screens are ambiguous: are we loading something, is there a crappy connection or maybe even a script error? That’s why it is very important to render something on the screen to show that the rest is being loaded, and as quickly as possible.
+ +The Home Assistant landing page contains just enough CSS and HTML to render the loading screen minus the animations.
+ +Now that the app is fast enough, I might swap out moving from a lite loading screen to drawing an empty toolbar. This makes it look like the UI is almost there.
+ +I left this to the end of the list, mainly because I had no influence on this. Polymer just happened to ship an update while I was optimizing the application which gave a big boost to the loading time.
+ +By using Polymer we have the ability to use tomorrow’s web standards today. This is powered by polyfills. A polyfill will use JavaScript to simulate the behavior that the web standard would have taken care of. As browsers progress, more work can move from the polyfills back to the browsers. This is great because browsers will be able to optimize the work better and thus be faster.
+ +Polymer 1.6 was introduced at the end of June and allowed the app to take advantage of native CSS variables in Chrome and Firefox. It also introduced lazy registration. Both greatly sped up our loading times.
+ +A lot of optimizations have been applied but this journey will never be over. There are still a lot of opportunities to make things even faster. Some ideas that are on my list to explore:
+ +<link rel="preload" …>Today I’ll show you how I used Home Assistant, a NodeMCU (ESP8266), and a couple of accelerometers to automate our laundry room. This is a rewrite of an old post where I did the same thing using a Moteino & Raspberry Pi. This version only requires a NodeMCU.
+ +We have an older washer and dryer which doesn’t have any form of notification when cycles complete. Home Assistant was the obvious solution, I just needed to create sensors for the washer and dryer. I tried using sound sensors but found them unreliable. I ended up using an accelerometer attached to the back of each appliance. I also added magnetic reed switches on the doors of the washer and dryer to detect whether they’re open or closed. I connected the accelerometers and reed switches to an NodeMCU which will relay the data to my MQTT broker.
+ +
+ 
+ Block diagram of schematic
+
After taking some sample data from the accelerometers while each appliance was in operation, I decided to plot the data to help determine the proper thresholds of when the devices were running or off. I had to do this in order to get precise ranges so the dryer sensor wouldn’t get tripped by the washer or vice versa. In the plot below you can see the acceleration in each direction for the accelerometer connected to the dryer. It’s easy to see when the dryer is in operation here. I used the same technique for the washer’s accelerometer.
+ +
+ 
+ Graph showing the accelerometer data
+
Next it was just a matter of integrating everything with Home Assistant. I was able to use the MQTT component to read the washer and dryer states from the Moteino and display it in Home Assistant.
+ +
+ 
+ Status of the dryer and washer in Home Assistant
+
Next I wrote scripts that are run whenever the washer or dryer completes a load. This is triggered by the automation component. When the laundry is complete I have the lights in the house turn red and notify me via Join. Once the door is opened and laundry emptied another script runs that sets the lights back to normal. So far it has been very helpful and very reliable.
+ +
+
+ 
+
+ NodeMCU connected to MPU-6050 accelerometer.
+
Materials used:
+ +Sketch for the NodeMCU is available here.
+ +Home Assistant Configuration:
+ +mqtt:
+ broker: 192.168.1.100
+ port: 1883
+ keepalive: 60
+ qos: 0
+
+sensor:
+ - platform: mqtt
+ name: "Dryer Status"
+ state_topic: "sensor/dryer"
+ unit_of_measurement: ""
+
+ - platform: mqtt
+ name: "Washer Status"
+ state_topic: "sensor/washer"
+ unit_of_measurement: ""
+
+automation:
+ - alias: Washer complete
+ trigger:
+ platform: state
+ entity_id: sensor.washer_status
+ from: 'Running'
+ to: 'Complete'
+ action:
+ service: script.turn_on
+ entity_id: script.washer_complete
+
+ - alias: Washer emptied
+ trigger:
+ platform: state
+ entity_id: sensor.washer_status
+ from: 'Complete'
+ to: 'Empty'
+ action:
+ service: scene.turn_on
+ entity_id: scene.normal
+
+script:
+ washer_complete:
+ alias: Washer Complete
+ sequence:
+ - alias: Join Notification
+ service: notify.join
+ data:
+ message: "The washing machine has finished its cycle, please empty it!"
+ - alias: Living Room Lights Blue
+ service: scene.turn_on
+ data:
+ entity_id: scene.blue
+Resources used:
+ + + +]]>Starting with this release, we are extending our extensability to the frontend. Starting this release, any component can add it’s own page to the frontend. Examples of this today are the map, logbook and history. We are looking forward to all the crazy panels you’ll come up with!
+ +We have also seen an exciting trend of people starting to visualize their Internet of Things data using Jupyter Notebooks, which are a great way to create and share documents that contain code, visualizations, and explanatory text. In case you missed it, the blog post by @kireyeu shows an advanced usecase while our Notebooks in the Home Assistant Notebooks repository cover the basics.
+ +This release also includes a bunch of new integrations, among others three new media player platforms. This means that today Home Assistant can talk to 26 different media players!
+ +The brand-new iFrame panel component allows you to add other websites as pages in the Home Assistant frontend. They will show up in the sidebar and can be used the same way as you open the frontend in your browser but all within one view.
+ +I would like to do a shoutout to @fabianhjr. He has started adding typing data (PEP484) to the Home Assistant core. This will help us identify issues before they are released.
+ +
timestamp_local and timestamp_utc) (@fabaff)location extension for Telegram and photo bug fixed (@keatontaylor and @pvizeli)
+The first release of Micropython for ESP8266 was delivered a couple of weeks ago. The documentation covers a lot of ground. This post is providing only a little summary which should get you started.
+
+Until a couple of weeks ago, the pre-built MicroPython binary for the ESP8266 was only available to backers of the Kickstarter campaign. This has changed now and it is available to the public for download.
+ + + +The easiest way is to use esptool.py for firmware handling tasks. First erase the flash:
+ +$ sudo python esptool.py --port /dev/ttyUSB0 erase_flash
+esptool.py v1.0.2-dev
+Connecting...
+Erasing flash (this may take a while)...
+and then load the firmware. You may adjust the file name of the firmware binary.
+ +$ sudo python esptool.py --port /dev/ttyUSB0 --baud 460800 write_flash --flash_size=8m 0 esp8266-2016-07-10-v1.8.2.bin
+esptool.py v1.2-dev
+Connecting...
+Running Cesanta flasher stub...
+Flash params set to 0x0020
+Writing 540672 @ 0x0... 540672 (100 %)
+Wrote 540672 bytes at 0x0 in 13.1 seconds (330.8 kbit/s)...
+Leaving...
+Now reset the device. You should then be able to use the REPL (Read Evaluate Print Loop). On Linux there is minicom or picocom, on a Mac you can use screen (eg. screen /dev/tty.SLAB_USBtoUART 115200), and on Windows there is Putty to open a serial connection and get the REPL prompt.
The WebREPL work over a wireless connection and allows easy access to a prompt in your browser. An instance of the WebREPL client is hosted at http://micropython.org/webrepl. Alternatively, you can create a local clone of their GitHub repository. This is neccessary if your want to use the command-line tool webrepl_cli.py which is mentionend later in this post.
$ sudo minicom -D /dev/ttyUSB0
+#4 ets_task(4020e374, 29, 3fff70e8, 10)
+WebREPL daemon started on ws://192.168.4.1:8266
+Started webrepl in setup mode
+could not open file 'main.py' for reading
+
+#5 ets_task(4010035c, 3, 3fff6360, 4)
+MicroPython v1.8.2-9-g805c2b9 on 2016-07-10; ESP module with ESP8266
+Type "help()" for more information.
+>>>
++The public build of the firmware may be different than the firmware distributed to the backers of the Kickstarter campaign. Especially in regard of the available modules, turned on debug messages, and alike. Also, the WebREPL may not be started by default. +
+ +Connect a LED to pin 5 (or another pin of your choosing) to check if the ESP8266 is working as expected.
+ +>>> import machine
+>>> pin = machine.Pin(5, machine.Pin.OUT)
+>>> pin.high()
+You can toogle the LED by changing its state with pin.high() and pin.low().
Various ESP8266 development board are shipped with an onboard photocell or a light dependent resistors (LDR) connected to the analog pin of your ESP8266 check if you are able to obtain a value.
+ +>>> import machine
+>>> brightness = machine.ADC(0)
+>>> brightness.read()
+Make sure that you are familiar with REPL and WebREPL because this will be needed soon. Keep in mind the password for the WebREPL access.
+ +Read the instructions about how to setup your wireless connection. Basically you need to upload a boot.py file to the microcontroller and this file is taking care of the connection setup. Below you find a sample which is more or less the same as shown in the documentation.
def do_connect():
+ import network
+
+ SSID = 'SSID'
+ PASSWORD = 'PASSWORD'
+
+ sta_if = network.WLAN(network.STA_IF)
+ ap_if = network.WLAN(network.AP_IF)
+ if ap_if.active():
+ ap_if.active(False)
+ if not sta_if.isconnected():
+ print('connecting to network...')
+ sta_if.active(True)
+ sta_if.connect(SSID, PASSWORD)
+ while not sta_if.isconnected():
+ pass
+ print('Network configuration:', sta_if.ifconfig())
+Upload this file with webrepl_cli.py or the WebREPL:
$ python webrepl_cli.py boot.py 192.168.4.1:/boot.py
+If you reboot, you should see your current IP address in the terminal.
+ +>>> Network configuration: ('192.168.0.10', '255.255.255.0', '192.168.0.1', '192.168.0.1')
+First let’s create a little consumer for Home Assistant sensor’s state. The code to place in main.py is a mixture of code from above and the RESTful API of Home Assistant. If the temperature in the kitchen is higher than 20 °C then the LED connected to pin 5 is switched on.
+If a module is missing then you need to download it from the MicroPython Library overview and upload it to the ESP8266 with webrepl_cli.py manually.
+
# Sample code to request the state of a Home Assistant entity.
+
+API_PASSWORD = 'YOUR_PASSWORD'
+URL = 'http://192.168.0.5:8123/api/states/'
+ENTITY = 'sensor.kitchen_temperature'
+TIMEOUT = 30
+PIN = 5
+
+def get_data():
+ import urequests
+ url = '{}{}'.format(URL, ENTITY)
+ headers = {'x-ha-access': API_PASSWORD,
+ 'content-type': 'application/json'}
+ resp = urequests.get(URL, headers=headers)
+ return resp.json()['state']
+
+def main():
+ import machine
+ import time
+
+ pin = machine.Pin(PIN, machine.Pin.OUT)
+ while True:
+ try:
+ if int(get_data()) >= 20:
+ pin.high()
+ else:
+ pin.low()
+ except TypeError:
+ pass
+ time.sleep(TIMEOUT)
+
+if __name__ == '__main__':
+ print('Get the state of {}'.format(ENTITY))
+ main()
+Upload main.py the same way as boot.py. After a reboot (>>> import machine and >>> machine.reboot()) or power-cycling your physical notifier is ready.
If you run into trouble, press “Ctrl+c” in the REPL to stop the execution of the code, enter >>> import webrepl and >>> webrepl.start(), and upload your fixed file.
As we learned in the recent blog post by Fabian, all operational data of your Home Assistant application is stored locally and is available for exploration. Our first steps were querying data with the DB Browser for SQLite, exporting the data extract as a CSV file and graphing in LibreOffice. But what else can be done with this data and what tools are there available?
+ +This post will help you get set up using a few popular data scientist tools to allow you to locally process your data:
+ +
+
+One of the graphs created with this tutorial.
+
TL; DR: Use this Jupyter Notebook to visualize of your data
+ + + +In order to run the provided Jupyter notebook, please make sure you have the following applications/libraries installed on your computer:
+ +As a Windows user myself, I find the easiest, quickest and most hassle-free way of installing all of these dependencies is to use WinPython. This free open-source portable distribution includes all of the dependencies required for this notebook, as well as a few other essential Python libraries you may require for data exploration in the future.
+ +While all Home Assistant implementations can have varying setup, components and scripts, the underlying data structure is standardized and well-defined. This allows us to write Python code that is environmentally agnostic. Wrapping it in a Jupyter notebook ensures the code, visualizations and directions/explanations are kept digestible and neatly-packaged. One of the amazing features of Jupyter is the ability to change code as you go along, customizing all outputs and visualizations on the fly!
+ +This tutorial is based around a heavily commented Jupyter Notebook that we created. So to get started, you will have to open that:
+ +DB_URL at the beginning of the notebook to point at your Home Assistant databaseThat’s it! The included code will walk you through importing the required libraries, show running raw SQL against your local database, plotting basic data from the states table, and in the end output a few plots of changes for every entity in your system as well as the mean daily value for the past 20 days.
+ +After just those few steps, you will be greeted with beautiful formatted data like this:
+ +
+
+One of the graphs created with this tutorial.
+
Thanks to the magic of Jupyter, all of the code is customizable: want to selectively display your data, only covering a specific entity? Sure thing! Want to change the properties of the plots? No problem!
+ +While you learn and explore your IoT data, we will be working on providing more ready-to-use Jupyter Notebooks. Feel free to ask questions or provide suggestions. Would you like to see a specific visualization? Is there a particular facet of data you’re interested in? Let’s talk about it, let’s dive into the world of data together!
+]]>
+
+The history component is tracking everything that is going on within Home Assistant. This means that you have access to all stored information about your home. Our history is not a full-fledged graphical processing and visualization component as you may know from systems and network monitoring tools. The current limitation is that you only can select a day for a visual output of your information and not a period. Also, there is no possibility to drill down on a specific entity.
+ +This blog post will show you ways to export data for reporting, visualization, or further analysis of automation rules.
+ + + +In this blog post I use the temperature of the Aare river close to where I live as a show case. The temperatures were recorded with the Swiss Hydrological Data sensor and the name of the sensor is sensor.aare.
The database is stored at <path to config dir>/.homeassistant/home-assistant_v2.db as SQLite database. In all examples we are going to use the path: /home/ha/.homeassistant/home-assistant_v2.db
If you are just curious what’s stored in your database then you can use the sqlite3 command-line tool or a graphical one like DB Browser for SQLite.
The table that is holding the states is called states. The events tables is responsible for storing the events which occurred. So, we will first check how many entries there are in the states table. sqlite3 needs to know where the databases is located. To work with your database make sure that Home Assistant is not running or create a copy of the existing database. It’s recommended to work with a copy.
$ sqlite3 /home/ha/.homeassistant/home-assistant_v2.db
+SQLite version 3.11.0 2016-02-15 17:29:24
+sqlite> SELECT count(*) FROM states;
+24659
+Let’s have a look at a sample SQL query. This query will show all states in a period for the sensor sensor.aare.
SELECT state, last_changed FROM states
+ WHERE
+ entity_id = 'sensor.aare'
+ AND
+ last_changed BETWEEN
+ '2016-07-05 00:00:00.000000' AND '2016-07-07 00:00:00.000000';
+The SQL statement can be formed that it fits exactly what you need. This means that you can process the data in any way you want for further use. Often it makes sense to eliminate certain entries like Unknown or peaks.
If the above query is executed in DB Browser for SQLite you would be able to save the sensor’s graph as png.
+ +
+ 
+ Visualization with DB Browser for SQLite
+
You may ask: Why not do this with LibreOffice Calc or another spreadsheet application? As most spreadsheet applications are not able to work directly with SQLite database we are going to export the data from the database to CSV.
+ +$ sqlite3 -header -csv /home/ha/.homeassistant/home-assistant_v2.db "SELECT last_changed, state FROM states WHERE entity_id = 'sensor.aare' AND last_changed BETWEEN '2016-07-05 00:00:00.000000' AND '2016-07-07 00:00:00.000000';" > sensor.csv
+The ordering for the SELECT was changed to get the time stamps first and then the state. Now we can import the CSV file into the application of your choice, here it’s LibreOffice Calc.
+ 
+ Import of the CSV file
+
After the import a graph can be created over the existing data.
+ +
+ 
+ Graph in LibreOffice
+
You can also use matplotlib to generate graphs as an alternative to a spreadsheet application. This is a powerful Python 2D plotting library. With the built-in support for SQLite in Python it will only take a couple lines of code to visualize your data.
+ +import sqlite3
+from matplotlib import dates
+import matplotlib.pyplot as plt
+
+import homeassistant.util.dt as dt
+
+values = []
+timestamps = []
+
+conn = sqlite3.connect('/home/ha/.homeassistant/home-assistant_v2.db')
+data = conn.execute("SELECT state, last_changed FROM states WHERE "
+ "entity_id = 'sensor.aare' AND last_changed BETWEEN "
+ "'2016-07-05 00:00:00.000000' AND "
+ "'2016-07-07 00:00:00.000000'")
+
+for x in data:
+ timestamps.append(dates.date2num(dt.parse_datetime(x[1])))
+ values.append(float(x[0]))
+
+plt.plot_date(x=timestamps, y=values, fmt="r-")
+plt.ylabel('Temperature')
+plt.xlabel('Time line')
+
+plt.savefig('sensor.png')
+Creating a connection to the database and executing a query is similar to the ways already seen. The return values from the query are splitted into two lists. The time stamps must be converted in an value which is accepted by matplotlib and then the graph is generated and saved as image.
+ +
+
+ Sensor graph generated by matplotlib
+
Most of the graphs are pretty ugly. So, further beautification will be needed. If you have created a nice report including some amazing graphs then the Home Assistant community would be grateful for sharing them in our forum.
+ +]]>MapQuest discontinued their free and direct tile access by Monday, July 11, 2016. With CARTO we found a very cool and suitable solution. They allow us to use their tile for the map. Thank you, CARTO.
+ +Roy Hooper did an amazing job migrating the history support from being tied to SQLite to use the ORM SQLAlchemy instead. This means that you can now use any SQL backend for the history. So besides SQLite you can now databases like MySQL or PostgreSQL. However, this does require that you install SQLAlchemy and run a command to migrate your existing history over. We tried to make the process as seamless as possible by introducing a new command line script:
+ +$ pip3 install SQLAlchemy
+$ hass --script db_migrator --config /path/to/config
+You can omit the --config option if you use the default configuration directory. Run the script with --help to get more options.
Quick hot fix after we found a bug in the migrator where it wouldn’t work with a database in a non-standard location. Thanks to @n8henrie and @AlucardZero.
+ +configuration.yaml file.I finally took the time to setup a simple website to help people getting started with Home Assistant. The process was super smooth thanks to the great tools Jekyll and Octopress and the great services GitHub Pages and CloudFlare.
+The internet has been buzzing over the last year about home automation. A lot of different terms fly around like the internet of things, home automation and the smart home. +This article will try to explain how they all relate.
+ +The first thing to introduce is the Internet of Things (IoT). This refers to a new generation of devices that cannot only be controlled by humans via buttons or remotes but also provide an interface to communicate with other devices and applications. For example, an IoT-capable coffee machine could receive commands to create different types of coffee and be able to broadcast the amount of water left in its resevoir.
+ +There is no widely adopted open standard for smart device communication. This prevents a lot of devices to communicate with one another. And even if they could, most devices are not designed to manage other devices. To solve this we need a device to be able to communicate with and manage all these connected devices. This device is called a hub.
+ +As a bare minimum a hub has to keep track of the state of each device and should be able to control them if possible. For example, it has to know which lights are on or off and offer a way to control the lights. For a sensor it only has to know the value. A hub with these capabilities offers home control.
+ +
+
+ 
+
+ Example of a hub’s dashboard. Showing the state of 2 persons, 4 lights and the sun.
+
A step up from home control is to have the user setup triggers to send commands based on information in the home control layer. For example, to turn on the lights when a person arrives home. A hub with these capabilities is capable of home automation.
+ +Most hubs on the market today offer this in various degrees of functionality and usability. Some IoT-capable devices offer this too, but only control themselves and are usually limited to location and time-based events.
+ +The last category, and this is still very much in the future, is the smart home. A self-learning and adopting system that will decide which events should impact other devices.
+ +An example of a smart home in action is that it observes that when person A comes home, the lights in the living room and the kitchen switch on. While if person B comes home, the lights in the living room and the study room are switched on. The next time person A or B comes home, the smart home will turn on its preferred lights without any configuration being set by the user.
+ +A glimpse today at how the future can look is the Nest thermostat. A thermostat smart enough to learn your schedule and adjust its own temperature accordingly.
+ +All this results in the following overview of Home Automation.
+ +
+
+ 
+
+ Overview of the home automation landscape.
+
You are probably wondering, this all seems relatively simple, why don’t I have my very own smart home yet? There are a couple of challenges today that keep us from stepping into the future.
+ +The majority of the IoT products out there are either lights, switches or presence detection. That’s not enough for your home to be very smart about. We need televisions, fridges, ovens and more to join the party to increase the number of devices that we can control.
+ +Most first generation IoT devices are only exposing information that is needed for controlling it. We need to be able to track all interactions with each device for our smart home to learn how interaction with devices influence other things. For example, we need to be able to track how many cups of coffee were made or how often the fridge was open. This will increase the information flow and open up a whole bunch of new possibilities. For example, the smart home can order new coffee when you’re running low.
+ +To increase adoption we will need people to trust their smart home system. It will be very tough to convince people to upgrade all their devices and upload all interactions with each of them to the cloud. This data could reveal their whole life including all bad habits. That’s why such a system should be simple and open-source so people can validate that their data generated at home stays home.
+ +Anoter important booster for adoption is that the software should be easy to set up and use by the average user. A lot of people are not burning their hands yet on Home Automation because they are scared of configurating it.
+ +Home Assistant is trying to be this software. It is not there yet but trying hard. Device discovery and a user interface for configuring home automation are problems we hope to tackle in 2015 while not sacrificing any modularity or usability.
+ +Happy new year!
+One of the things that was missing in Home Assistant for a while was a way to communicate with users. Wouldn’t it be nice to get a message when important events happen like the lights being turned on while no one is home? Since the Home Assistant frontend runs as a web application on the phone, we have no way to bring ourselves to the front. This is where the new notify component comes in, powered by PushBullet.
+ +The new notify component will take in messages and tells them to the user. For now this will be powered by the very awesome PushBullet but any other messaging platform can be easily added.
+ +
+ 
+ A message triggered by the simple_alarm component is shown by PushBullet on the Moto360.
+
Read on to learn how to enable the notify component and integrate it with other components.
+ + + +To enable the new notify component, add the following to your home-assistant.conf:
+ [notify]
+platform=pushbullet
+api_key=ABCDEFGHJKLMNOPQRSTUVXYZ
+You can get your api key from your account page on PushBullet.com.
+ +To be able to send messages, the notify component has to be loaded and initialized successfully.
+ +import homeassistant.loader as loader
+
+def setup(hass, config):
+ notify = loader.get_component('notify')
+ notify.send_message(hass, "Hello from my component!")
+Most people do not like configuring things. Things just have to work, out of the box. Reaching this scenario is the goal of what we are about to introduce: our new discovery component.
+ +The discovery component will scan the WiFi network from time to time for connected zeroconf/mDNS and uPnP devices. The intial introduction is mainly focussed on getting the right architecture in place and discovers Belkin WeMo switches and Google Chromecasts connected to your network. When found, it will load and notify the appropritate component and it will be ready to use within seconds.
+ +Most devices still require some sort of interaction from the user after being discovered - be it a button being pressed or some sort of authentication. This is a challenge that will be solved in the future.
+ +To enable the discovery component, add the following to your home-assistant.conf:
[discovery]
+A new discovery section has been added to the Adding a new platform page with instructions how to make your platform discoverable.
+For thet majority of its existence, Home Assistant primary focus was on presence detection, lights and switches. But not anymore as we’re expanding the supported devices. Today, we’re proud to introduce Nest Thermostat integration for Home Assistant contributed by Stefano Fiorini!
+ +
+ 
+
The new integration exists out of two parts: a generic thermostat component and a Nest platform implementation. The initial version implements provides a read-only card and services to control it. The plan is in the future to add temperature and away mode controls from the thermostat card and more info dialog. Internally, we are using the Python package python-nest by jkoelker to talk to the Nest.
+ +If you own a Nest thermostat, add the following lines to your home-assistant.conf:
[thermostat]
+platform=nest
+username=YOUR_USERNAME
+password=YOUR_PASSWORD
+I have just merged the latest version of the development branch into master. Here are some of the highlights of this release:
+ +Configuration via the frontend
+Phliips Hue will now be auto discovered and uses the new configurator component to interact with the user to finish the setup process.
Wink Hub support
+Thanks to the work done by John McLaughlin and Geoff Norton we now support the lights, switches and sensors that are connected to the Wink hub.
The getting started guide and component page have been reorganized
+The getting started instructions have been split into separate pages per component and a general overview page. The goal is to have a page per component that describes:
More reasonable errors
+Home Assistant should now throw better errors and offer solutions if you do not have the right version of Python 3, forgot to clone the git submodules or install the dependencies.
Streamlined first launch
+Home Assistant now supports --open-ui and --demo-mode command line properties to open the browser automatically and have something to show. Home Assistant now supports to be run without a password, allowing the interface to login automatically on launch.
Ever since the launch of Home Assistant you have been able to track the state of your house. But the view has always been limited to what the current state is. Not what it was. Today we are going to change that by introducing two brand new components:
+ +By adding this view into the past, we are adding an extra dimension into the state of your house. This brings great new possibilities for future features. The focus of todays release is on getting the recording component to you to start recording and getting some data. To show what is being recorded a view has been added that shows the last 24 hours of your house. Expect more extensive tools to explore your history in the future.
+ +Adding history to the UI was a challenge on itself because the old UI did not support easy navigation. So to add to the awesomeness of this release, Home Assistant also got a face lift.
+ +The history component will be enabled for new users by default. For current users, run scripts/update to upgrade to the latest version and add [history] to your home-assistant.conf file.
+
+ 
+
+
+Events are saved in a local database. Google Graphs is used to draw the graph. Drawing is happening 100% in your browser - no data is transfered to anyone at any time. +
+ + + +Tracking history is an exciting next step for Home Assistant and will power the next generation of features. Here a list of some of the cool things that can now be build:
+ +Home Assistant has learned a new trick to get the latest information from the server: streaming updates. No longer will the frontend poll every 30 seconds for updates but instead it will keep a connection open and get the latest changes pushed as soon as they happen.
+ +A new toggle has been added ot the sidebar to turn streaming updates on and off. This preference will be saved on a per-browser basis using local storage. The toggle will also indicate when there is an error setting up a stream after which it will fall back to use polling.
+ +
Streaming updates has been implemented using the HTML5 EventSource tag. Implementation is pretty straight forward as all the reconnection logic will be handled by the event source tag. The server-side code is 50 lines and the client-side code is 80 lines of code.
All events that happen on the server will now also be sent to the browser. This turns any browser running the UI into a fully functioning slave instance of Home Assistant. This opens up new possibilities for Home Assistant components that live completely client-side.
+ +Implementing EventSource was not without challenges. Here are some of the issues that had to be solved:
+ +A connection can go stale in Chrome without any event handler being called. This happens when a device goes into standby. For computers this is rare but for phones this occurs quite often. This has been solved by sending a regular ping from the server. The frontend will assume the connection has gone stale when it hasn’t heard any communication for a while. Sending a ping will also help the server detect broken connections and clean them up.
+ +Another issue that I encountered is that Safari and Firefox would not fire the open event when the connection has been opened but when the first message has been received. To work around this the server will now fire a ping when the connection gets opened.
Home Assistant is now using YAML for it’s configuration file. YAML allows the use of lists, which should make the configuration file a bit more flexible and useful. The new configuration file format is backwards compatible with existing components. Because of this, there is no need for component developers to update their components.
+ +The new file is named configuration.yaml and if it can’t be found in your config directory, Home Assistant will instead try to find the old configuration file, home-assistant.conf.
+ +The home-assistant.conf.example has been replaced with an updated configuration.yaml.example.
+ +Users of Home Assistant should migrate as the old configuration format is deprecated.
+It is well known that you are either a good programmer or a good designer. It’s rare you’ll meet someone that is both. That’s why it wasn’t surprising to anyone that the logo that I made was mediocre — at best. Luckily, Jeremy Geltman has come to the rescue and contributed a brand new logo for Home Assistant.
+ +The new logo follows Googles material design spec. It uses the blue color that Home Assistant uses in the interface and it comes in two versions: a high detailed version (for homescreen icon etc) and a simple version (for favicon etc).
+ +
+
+The old logo, the new detailed logo and the new simple logo.
+
It has only been a little over a week since Theodor introduced YAML support for Home Assistant but so much has already happened that it is time for a summary of recent changes. Before mentioning the highlights I want to thank andythigpen, jamespcole and theolind for numerous bug fixes, enhancements and new contributions. Thanks!
+ +Monitor local resources.
+Theodor has contributed a new sensor platform to allow you to monitor disk usage, memory usage, CPU usage and running processes. This platform has superseded the process component which is now considered deprecated.
# Example configuration.yaml entry
+sensor:
+ - platform: systemmonitor
+ resources:
+ - type: disk_use_percent
+ arg: /home
+ - type: memory_free
+ - type: process
+ arg: kodi
+Experimental Z-Wave support
+There is now experimental support for connecting Z-Wave networks using a Z-Wave USB stick. Right now it only integrates Z-Wave sensors into Home Assistant. Our goal is to get this tested by more people before adding support for other Z-Wave devices.
The new component is built on top of python-openzwave. This package is currently not distributed on PyPi so we’ve added a script scripts/build_python_openzwave to install it on your machine. Alternatively you can use the Docker image which is ready to go.
The development was done using an AEON Z-Wave USB stick and an AEON Z-Wave MultiSensor.
+ +# Example configuration.yaml entry
+zwave:
+ usb_path: /dev/ttyUSB0
+Voice control
+An initial version of voice control for Home Assistant has landed. The current implementation consists of two parts.
The first part is a component called conversation that exposes the service conversation/process. This service is capable of processing text and translating them into commands for devices. For now it will only support commands in the format of Turn <Friendly Name> <on/off>.
The second part is an upgrade to the frontend to use the speech-to-text in Chrome to allow users to speak commands. If you’re using Chrome, you can test this out in the demo.
+ +# Example configuration.yaml entry
+conversation:
+A new version of Home Assistant has just been pushed out. It contains bugfixes contributed by jamespcole, andythigpen, trainman419 and me. It also adds a bunch of great new features:
+ +Script
+Andythigpen has contributed a script component. This allows users to create a sequence of service calls and delays. Scripts can be started using the service script/turn_on and interrupted using the service script/turn_off. A separate page has been added to the frontend to see the status of your scripts.
# Example configuration.yaml entry
+script:
+ # Turns on the bedroom lights and then the living room lights 1 minute later
+ wakeup:
+ alias: Wake Up
+ sequence:
+ - alias: Bedroom lights on
+ execute_service: light.turn_on
+ service_data:
+ entity_id: group.bedroom
+ - delay:
+ # supports seconds, milliseconds, minutes, hours, etc.
+ minutes: 1
+ - alias: Living room lights on
+ execute_service: light.turn_on
+ service_data:
+ entity_id: group.living_room
+Scene +I (Paulus) have contributed a scene component. A user can create scenes that capture the states you want certain entities to be. For example a scene can contain that light A should be turned on and light B should be bright red. Deactivating a scene will restore the previous state from before the scene was activated. Just like scripts, scenes have their own separate page to see which scenes are on.
+ +# Example configuration.yaml entry
+scene:
+ - name: Romantic
+ entities:
+ light.tv_back_light: on
+ light.ceiling:
+ state: on
+ color: [0.33, 0.66]
+ brightness: 200
+
+SABnzbd
+
James Cole has contributed support to integrate SABnzbd. This will allow you to monitor your downloads from within Home Assistant and setup automation based on the information.
# Example configuration.yaml entry
+sensor:
+ - platform: sabnzbd
+ name: SAB
+ api_key: YOUR_API_KEY
+ # Example: http://192.168.1.32:8124/
+ base_url: YOUR_SABNZBD_BASE_URL
+ monitored_variables:
+ - type: 'current_status'
+ - type: 'speed'
+ - type: 'queue_size'
+ - type: 'queue_remaining'
+ - type: 'disk_size'
+ - type: 'disk_free'
+
+PushOver
+
James Cole has also contributed support for the PushOver service as a platform for the notify component. This allows components to send messages to the user using PushOver.
# Example configuration.yaml entry
+notify:
+ platform: pushover
+ # Get this by registering a new application on https://pushover.net
+ api_key: ABCDEFGHJKLMNOPQRSTUVXYZ
+ # Get this by logging into your account on https://pushover.net
+ user_key: ABCDEFGHJKLMNOPQRSTUVXYZ
+It’s been a month since the latest update and a lot has happened again. Here a quick overview of the new things.
+ +Line Charts +James has upgraded the history in the frontend to support line graphs. Line graphs will be shown for any entity that has a unit of measurement. The line graphs will also be shown in the more info card of an entity. See the demo for a live example.
+ +
+
+
ISY994 hub support
+
Ryan has contributed support to integrate the ISY994 hub by Universal Devices. This allows you to integrate your X10/Insteon sensors, switches and lights.
He has created an extensive getting started guide which can be found on the ISY994 component page.
+ +# Example configuration.yaml entry
+isy994:
+Logbook
+
I (Paulus) have added a logbook component. The logbook component provides a different perspective on the history of your house by showing all the changes that happened to your house in chronological order. See the demo for a live example.
+
# Example configuration.yaml entry
+logbook:
+Transmission support
+
James has also contributed support for integrating Transmission into Home Assistant.
# Example configuration.yaml entry
+sensor:
+ platform: transmission
+ name: Transmission
+ host: 192.168.1.26
+ port: 9091
+ username: YOUR_USERNAME
+ password: YOUR_PASSWORD
+ monitored_variables:
+ - type: 'current_status'
+ - type: 'download_speed'
+ - type: 'upload_speed'
+Modbus support +Kixam has contributed support for modbus, a serial communication protocol to control PLCs. It currently supports sensors and switches which can be controlled over serial, TCP and UDP connections.
+ +# Example configuration.yaml entry
+modbus:
+ type: serial
+ method: rtu
+ port: /dev/ttyUSB0
+ baudrate: 9600
+ stopbits: 1
+ bytesize: 8
+ parity: N
+
+sensor:
+ platform: modbus
+ slave: 1
+ registers:
+ 16:
+ name: My integer sensor
+ unit: C
+ 24:
+ bits:
+ 0:
+ name: My boolean sensor
+ 2:
+ name: My other boolean sensor
+
+switch:
+ platform: modbus
+ slave: 1
+ registers:
+ 24:
+ bits:
+ 0:
+ name: My switch
+ 2:
+ name: My other switch
+I have recently merged code to refactor Home Assistant to use only UTC times internally. A much needed refactor. I’ve added some extra test coverage to time sensitive parts to ensure stability. The code has been live in the dev branch for the last 9 days and will be soon released to the master branch.
+ +From now on all internal communication will be done in UTC: time changed events, datetime attributes of states, etc. To get the current time in UTC you can call homeassistant.util.dt.utcnow(). This is a timezone aware UTC datetime object. homeassistant.util.dt is a new util package with date helpers.
There is also such a thing as local time. Local time is based on the time zone that you have setup in your configuration.yaml. Local times should only be used for user facing information: logs, frontend and automation settings in configuration.yaml.
Setting up a time zone happens in configuration.yaml. If you have no time zone setup, it will be auto detected using the existing detection code using freegeoip.net. You can find a list of compatible time zones on Wikipedia.
homeassistant:
+ time_zone: America/Los_Angeles
+The changes to the code are mostly backwards compatible. The old hass.track_time_change and hass.track_point_in_time use now internally two new methods: hass.track_utc_time_change and hass.track_point_in_utc_time. The usage of the old methods have not changed and should be backwards compatible.
This refactor adds a new migration for the database adding a utc_offset column to events and states. This information is currently not used but can prove useful in the future when we start analyzing the historical data.
All built-in components have been upgraded. The following list is only for people that run custom components:
+ +hass.track_time_change and hass.track_point_in_time will now return a time zone aware datetime object. Python does not allow comparing a naive with an aware datetime object.sun.next_rising(hass) and sun.next_setting(hass) are backwards compatible, just be careful if you used to read the raw attributes.Almost three busy weeks have past since the last release. We used this time to finally make the overhaul to use UTC as the internal date time format. We added a bunch of test coverage in the process to make sure the transition went smoothly. Pleas see the blog post about the UTC refactor for backwards incompatible changes.
+ +This release includes a significant startup boost for the frontend and a fix for Wemo discovery after their latest firmware upgrade.
+ +I would like to give a big shout out to our newest contributor fabaff for taking the time to improve the documentation.
+ +
+To update to the latest version, run scripts/update. Please report any issues on GitHub.
+
Overwriting Entity Attributes +Before diving into the newly supported devices and services, I want to highlight an awesome configuration enhancement by rmkraus: overwriting entity attributes.
+ +These new configuration settings allow you to overwrite entity state attributes. The main usage for this is being able to overwrite attributes that influence how an entity is shown in the interface.
+ +# Example configuration.yaml entry
+homeassistant:
+ customize:
+ light.bowl:
+ # hides this entity from the interface
+ hidden: true
+ light.ceiling:
+ # Replaces the state badge with given picture
+ entity_picture: http://graph.facebook.com/schoutsen/picture
+MySensors
+
Andythigpen and Theolind have added support for the MySensors platform to Home Assistant.
# Example configuration.yaml entry
+sensor:
+ platform: mysensors
+ port: /dev/ttyACM0
+OpenWeatherMap
+
Fabaff has contributed support for OpenWeatherMap. This will allow you to integrate local meteorological data into Home Assistant.
# Example configuration.yaml entry
+sensor:
+ platform: openweathermap
+ api_key: YOUR_API_KEY
+ monitored_variables:
+ - type: 'weather'
+ - type: 'temperature'
+ - type: 'wind_speed'
+ - type: 'humidity'
+ - type: 'pressure'
+ - type: 'clouds'
+ - type: 'rain'
+ - type: 'snow'
+InstaPush
+
Fabaff has contributed support for InstaPush. This will allow you send messages from Home Assistant to your iOS and Android devices.
# Example configuration.yaml entry
+notify:
+ platform: instapush
+ # Get those by creating a new application, event, and tracker on https://instapush.im
+ api_key: ABCDEFGHJKLMNOPQRSTUVXYZ
+ app_secret: ABCDEFGHJKLMNOPQRSTUVXYZ
+ event: ABCDEFGHJKLMNOPQRSTUVXYZ
+ tracker: ABCDEFGHJKLMNOPQRSTUVXYZ
+XMPP
+
Fabaff has contributed support for Jabber/XMPP. This will allow you send messages from Home Assistant to anyone on Jabber/XMPP.
# Example configuration.yaml entry
+notify:
+ platform: xmpp
+ sender: YOUR_JID
+ password: YOUR_JABBER_ACCOUNT_PASSWORD
+ recipient: YOUR_RECIPIENT
+Notify My Android
+
Fabaff has contributed support for Notify My Android. This will allow you to send messages from Home Assistant to your Android device.
# Example configuration.yaml entry
+notify:
+ platform: nma
+ # Get this by registering a new application on http://www.notifymyandroid.com/
+ api_key: ABCDEFGHJKLMNOPQRSTUVXYZ
+Time & Date sensor +Fabaff has contributed a time & date sensor. This will allow you to show the current time/date on the dashboard.
+ +# Example configuration.yaml entry
+sensor:
+ platform: time_date
+ monitored_variables:
+ - type: 'time'
+ - type: 'date'
+ - type: 'date_time'
+ - type: 'time_date'
+Wow, almost a month has gone by since the last release and this release is packed. The biggest part of this release is probably one that you won’t notice: the frontend has been upgraded from Polymer 0.5 to the brand new released Polymer 1.0. Polymer has been declared stable by the Google overlords which will allow us to expand functionality that was waiting for this moment to arrive.
+ +This release sets a record for the amount of people involved: 8! Andythigpen, Jamespcole, Azelphur, Fabaff, Dutchy-, Fbradyirl, wind-rider and ettisan, thanks a lot for your contributions!
+ +A big improvement has been brought this release by wind-rider. He took the time to revive the Chromecast support and started improving the media player integration. This triggered other people to join in resulting in a revamped media player experience and support for the Music Player Daemon.
+ +
+ 
Example of the new media player cards
+
+To update to the latest version, run scripts/update. Please report any issues on GitHub.
+
Before jumping into the newly supported platforms, here are the other improvements that are landing this release:
+ +!include keyword by @andythigpenMusic Player Daemon
+
Fabaff has contributed MusicPlayerDaemon support. The mpd platform allows you to control a Music Player Daemon from Home Assistant. Right now, only playback is supported and not playlist manipulation.
# Example configuration.yaml entry
+media_player:
+ platform: mpd
+ server: 127.0.0.1
+ port: 6600
+ location: bedroom
+Command line switch +A switch platform that issues specific commands when it is turned on and off. This might very well become our most popular platform as it allows anyone to integrate any type of switch into Home Assistant that can be controlled from the command line, including calling other scripts!
+ +# Example configuration.yaml entry
+switch:
+ platform: command_switch
+ switches:
+ - kitchen_light:
+ oncmd: switch_command on kitchen
+ offcmd: switch_command off kitchen
+LimitlessLED +This new platform can control your LimitlessLED lights from within Home Assistant. The lights are also known as EasyBulb, AppLight, AppLamp, MiLight, LEDme, dekolight or iLight.
+ +# Example configuration.yaml entry
+light:
+ platform: limitlessled
+ host: 192.168.1.10
+ group_1_name: Living Room
+ group_2_name: Bedroom
+ group_3_name: Office
+ group_4_name: Kitchen
+Bitcoin sensor
+
The bitcoin platform displays various details about the Bitcoin network. If you have an online wallet from Blockchain.info the sensor is capable to show your current balance.
# Example configuration.yaml entry
+sensor:
+ platform: bitcoin
+ wallet: 'YOUR WALLET_ID'
+ password: YOUR_ACCOUNT_PASSWORD
+ currency: YOUR CURRENCY
+ display_options:
+ - exchangerate
+ - trade_volume_btc
+ - miners_revenue_usd
+ - btc_mined
+ - trade_volume_usd
+ - difficulty
+ - minutes_between_blocks
+ - number_of_transactions
+ - hash_rate
+ - timestamp
+ - mined_blocks
+ - blocks_size
+ - total_fees_btc
+ - total_btc_sent
+ - estimated_btc_sent
+ - total_btc
+ - total_blocks
+ - next_retarget
+ - estimated_transaction_volume_usd
+ - miners_revenue_btc
+ - market_price_usd
+SMTP notificatoin platform
+
The smtp platform allows you to deliver notifications from Home Assistant to an e-mail recipient.
# Example configuration.yaml entry
+notify:
+ platform: mail
+ server: MAIL_SERVER
+ port: YOUR_SMTP_PORT
+ sender: SENDER_EMAIL_ADDRESS
+ starttls: 1 or 0
+ username: YOUR_SMTP_USERNAME
+ password: YOUR_SMTP_PASSWORD
+ recipient: YOUR_RECIPIENT
+Syslog notification platform +The syslog platform allows you to deliver notifications from Home Assistant to the local syslog.
+ +# Example configuration.yaml entry
+notify:
+ platform: syslog
+Swiss Public transport sensor +The swiss public transport sensor will give you the next two departure times from a given location to another one in Switzerland. See the component page for more information how to set it up.
+ +Transmission turtle mode switch
+ The transmission platform allows you to control your Transmission client from within Home Assistant. The platform enables you switch to your ‘Alternative Speed Limits’ (aka ‘Turtle mode’) setting.
# Example configuration.yaml entry
+switch:
+ platform: transmission
+ name: Transmission
+ host: 192.168.1.26
+ port: 9091
+ username: YOUR_USERNAME
+ password: YOUR_PASSWORD
+Hikvision camera motion detection support +This switch platform allows you to control your motion detection setting on your Hikvision camera.
+ +# Example configuration.yaml entry
+switch:
+ platform: hikvisioncam
+ name: Hikvision Cam 1 Motion Detection
+ host: 192.168.1.26
+ username: YOUR_USERNAME
+ password: YOUR_PASSWORD
+Another month has passed and some great new features have landed in Home Assistant. This month release has been made possible by balloob, ettisan, fabaff, gyran, jamespcole, michaelarnauts, miniconfig and rmkraus.
+ +This release includes some architectural changes by me. The first is that the frontend is now based on a NuclearJS JavaScript backend. This has greatly helped to organize and optimize the frontend code. Another change is that Home Assistant will now install dependencies on-demand instead of installing dependencies for all supported devices.
+ +IP Camera Support +James has worked very hard to add support for IP cameras to Home Assistant which is included in this release. The initial release focusses on providing generic IP camera support. This means that any webcam that can exposes a JPEG image via a url can be integrated.
+ +Home Assistant will route the requests to your camera via the server allowing you to expose IP camera’s inside your network via the Home Assistant app.
+ +# Example configuration.yaml entry
+camera:
+ platform: generic
+ name: my sample camera
+ username: MY_USERNAME
+ password: MY_PASSWORD
+ still_image_url: http://194.218.96.92/jpg/image.jpg
+
+To update to the latest version, run scripts/update. Please report any issues on GitHub.
+
Arduino
+
Fabian has contributed support for interfacing with Arduinos. This makes it possible to connect your Arduino via USB and expose pins as sensor data and write to pins via switches. Have a look at the docs for an extensive guide to get started.
# Example configuration.yaml entry
+switch:
+ platform: arduino
+ pins:
+ 11:
+ name: Fan Office
+ type: digital
+ 12:
+ name: Light Desk
+ type: digital
+
+sensor:
+ platform: arduino
+ pins:
+ 1:
+ name: Door switch
+ type: analog
+ 0:
+ name: Brightness
+ type: analog
+Kodi (XBMC)
+
Ettisan has contributed a Kodi (XBMC) platform for the media player component. This allows you to track all the media that you are playing and allow you to control it.
# Example configuration.yaml entry
+media_player:
+ platform: kodi
+ name: Kodi
+ url: http://192.168.0.123/jsonrpc
+ user: kodi
+ password: my_secure_password
+TP-Link
+
Michael has added TP-Link support to the device tracker. This allows you to now detect presence if you have a TP-Link router.
# Example configuration.yaml entry
+device_tracker:
+ platform: tplink
+ host: YOUR_ROUTER_IP
+ username: YOUR_ADMIN_USERNAME
+ password: YOUR_ADMIN_PASSWORD
+Efergy energy monitor
+
Miniconfig has contributed support for the Efergy energy meters. To get an app token, log in to your efergy account, go to the Settings page, click on App tokens, and click “Add token”.
# Example configuration.yaml entry
+sensor:
+ platform: efergy
+ app_token: APP_TOKEN
+ utc_offset: UTC_OFFSET
+ monitored_variables:
+ - type: instant_readings
+ - type: budget
+ - type: cost
+ period: day
+ currency: $
+Forecast.io
+Fabian has added support for Forecast.io to get weather forecasts for Home Assistant. You need an API key which is free but requires a registration. To add Forecast.io to your installation, add the following to your configuration.yaml file:
# Example configuration.yaml entry
+sensor:
+ platform: forecast
+ api_key: YOUR_APP_KEY
+ monitored_conditions:
+ - summary
+ - precip_type
+ - precip_intensity
+ - temperature
+ - dew_point
+ - wind_speed
+ - wind_bearing
+ - cloud_cover
+ - humidity
+ - pressure
+ - visibility
+ - ozone
+It’s time for the August release and there is some serious good stuff this time. The core of Home Assistant has gone some serious clean up and a bump in test coverage thanks to @balloob. If you’re a developer, make sure you read up on the deprecation notices. @fabaff did another great round of documentating all the various components.
+ +MQTT Support
+
The big new addition in this release is the support for the MQTT protocol by @fabaff with some help from @balloob. It will now be possible to integrate any IoT device that talks via MQTT. For the initial release we support connecting Home Assistant to a broker (no TLS yet). Components can now subscribe and publish to MQTT topics (see the example) and also support for the automation component has been added. For more information, see the MQTT component page.
# Example configuration.yaml entry
+mqtt:
+ broker: IP_ADDRESS_BROKER
+ # All the other options are optional:
+ port: 1883
+ keepalive: 60
+ qos: 0
+ username: your_username
+ password: your_secret_password
+Raspberry PI GPIO Support
+
@gbarba has contributed support to use the general purpose input and output pins on a Raspberry PI as switches inside Home Assistant.
# Example configuration.yaml entry
+switch:
+ platform: rpi_gpio
+ ports:
+ 11: Fan Office
+ 12: Light Desk
+ASUSWRT based routers
+
@persandstrom has contributed support to do prescence detection using ASUSWRT based routers.
# Example configuration.yaml entry
+device_tracker:
+ platform: asuswrt
+ host: YOUR_ROUTER_IP
+ username: YOUR_ADMIN_USERNAME
+ password: YOUR_ADMIN_PASSWORD
+Logitech Squeezebox media player support
+
@persandstrom also contributed support for the Logitech Squeezebox media player. This allows you to control your Logitech Squeezebox from Home Assistant.
# Example configuration.yaml entry
+media_player:
+ platform: squeezebox
+ host: 192.168.1.21
+ port: 9090
+ username: user
+ password: password
+Slack notification support
+
@jamespcole has contributed a Slack platform for the notification platform. This allows you to deliver messages to any channel.
# Example configuration.yaml entry
+notify:
+ platform: slack
+ api_key: ABCDEFGHJKLMNOPQRSTUVXYZ
+ default_channel: '#general'
+Edimax Smart Switches support
+
@rkabadi has contributed support for integrating Edimax Smart Switches into Home Assistant.
# Example configuration.yaml entry
+switch:
+ platform: edimax
+ host: 192.168.1.32
+ username: YOUR_USERNAME
+ password: YOUR_PASSWORD
+ name: Edimax Smart Plug
+RFXtrx sensor support +@danielhiversen has contributed support for RFXtrx sensors. It supports sensors that communicate in the frequency range of 433.92 MHz.
+ +# Example configuration.yaml entry
+sensor:
+ - platform: rfxtrx
+ device: PATH_TO_DEVICE
+The path to your device, e.g. /dev/serial/by-id/usb-RFXCOM_RFXtrx433_A1Y0NJGR-if00-port0
TEMPer temperature sensor support +Support for Temper temperature sensors has been contributed by @rkabadi.
+ +# Example configuration.yaml entry
+sensor:
+ platform: temper
+A minor bug fix release to fix some issues that have come up since the last release. Please upgrade as soon as possible by running git pull from the Home Assistant directory.
This release is a major milestone in our test coverage as we’ve crossed into the 80s! It has to be noted that this covers mainly the core and automation components. Platforms that communicate with IoT devices have been excluded.
+ +As we didn’t want to just push out bug fixes, this release includes a few additions:
+ +Verisure Support
+
Home Assistant support to integrate your Verisure alarms, hygrometers, sensors and thermometers has been contributed by @persandstrom.
# Example configuration.yaml entry
+verisure:
+ username: user@example.com
+ password: password
+ alarm: 1
+ hygrometers: 0
+ smartplugs: 1
+ thermometers: 0
+This is a guest post by Home Assistant user and contributor Nolan Gilley.
+ +In our house, laundry has been a struggle for quite some time. Our washer and dryer both lack a buzzer which leads to forgotten laundry, and stinky mess that needs to be rewashed. I decided to create a solution by monitoring the washer and dryer myself with some cheap electronics.
+ +As an avid user of Home Assistant, I decided it would be the perfect application to manage the UI and notification system. Now all I needed was a way to monitor the washer and dryer. I tried using sound sensors but found them unreliable. I ended up opting for an accelerometer attached to the back of each appliance. I also added magnetic reed switches on the doors of the washer and dryer to detect if the doors are open or closed. I connected the accelerometers and reed switches to a Moteino, an arduino clone with an RF transceiver. The Moteino can perform the logic to figure out which state the appliances are in and wirelessly communicate that data with another Moteino that is connected via serial to my Raspberry Pi. The Raspberry Pi reads the serial data and repeats it over MQTT for Home Assistant to use. This is great because I don’t have to run Home Assistant on the Raspberry Pi. I can run it on a faster machine and point the MQTT component to my Raspberry Pi.
+ +After taking some sample data from the accelerometers while each appliance was in operation, I decided to plot the data to help determine the proper thresholds of when the devices were running or off. I had to do this in order to get precise ranges so the dryer sensor wouldn’t get tripped by the washer or vice versa. In the plot below you can see the acceleration in the x direction for the accelerometer connected to the washing machine. It’s easy to see when the washing machine is in operation here. I used the same technique for the dryer’s accelerometer.
+ +
+
+ 
+
+ Graph showing the accelerometer data
+
Next it was just a matter of integrating everything with Home Assistant. I was able to use the MQTT component to read the washer and dryer states from the Moteino and display it in Home Assistant.
+ +
+ 
+ Status of the dryer and washer in Home Assistant
+
Next I wrote scripts that are run whenever the washer or dryer completes a load. This is triggered by the automation component. When the laundry is complete I have the lights in the house turn red and notify me via PushBullet. Once the laundry is taken care of another script runs that sets the lights back to normal. So far it has been very helpful and very reliable.
+ +
+
+ 
+
+ Top left: reed switch. Bottom left: moteino. Right: Accelerometer.
+
Materials used:
+ + + +Sketch for the Moteino is available here.
+ +Home Assistant Configuration:
+ ++The automation and script syntax here is using a deprecated and no longer supported format. +
+ +mqtt:
+ broker: 192.168.1.100
+ port: 1883
+ keepalive: 60
+ qos: 0
+
+sensor:
+ platform: mqtt
+ name: "Dryer Status"
+ state_topic: "sensor/dryer"
+ unit_of_measurement: ""
+
+sensor 2:
+ platform: mqtt
+ name: "Washer Status"
+ state_topic: "sensor/washer"
+ unit_of_measurement: ""
+
+automation:
+ alias: Dryer complete
+
+ platform: state
+ state_entity_id: sensor.dryer_status
+ state_from: 'Running'
+ state_to: 'Complete'
+
+ execute_service: script.turn_on
+ service_entity_id: script.dryer_complete
+
+automation 2:
+ alias: Dryer emptied
+
+ platform: state
+ state_entity_id: sensor.dryer_status
+ state_from: 'Complete'
+ state_to: 'Empty'
+
+ execute_service: script.turn_on
+ service_entity_id: script.dryer_cleared
+
+script:
+ dryer_complete:
+ alias: Dryer Complete Script
+ sequence:
+ - alias: Pushbullet Notification
+ execute_service: notify.notify
+ service_data:
+ message: "The dryer has finished its cycle, please empty it!"
+ - alias: Living Room Lights Red
+ execute_service: scene.turn_on
+ service_data:
+ entity_id: scene.red
+ - delay:
+ seconds: 1
+ - alias: Living Room Lights Off
+ execute_service: light.turn_off
+ service_data:
+ entity_id: group.living_room
+ - delay:
+ seconds: 1
+ - alias: Living Room Lights Red
+ execute_service: scene.turn_on
+ service_data:
+ entity_id: scene.red
+
+ dryer_cleared:
+ alias: Dryer Cleared Script
+ sequence:
+ - alias: Living Room Lights Off
+ execute_service: light.turn_off
+ service_data:
+ entity_id: group.living_room
+ - delay:
+ seconds: 1
+ - alias: Living Room Lights Normal
+ execute_service: scene.turn_on
+ service_data:
+ entity_id: scene.normal
+Resources used:
+ + +As Home Assistant is gaining more and more users we started to feel the pain from not having a proper release mechanism. We had no version numbering and required users to checkout the source using Git to get started. On top of that, as the number of devices that we support keeps raising, so did the number of dependencies that are used. That’s why we decided to change the way we roll. From now on:
+ +hass.config in the current working directory to ~/.homeassistant (%APPDATA%/.homeassistant on Windows).<config-dir>/lib.A huge shout out to Ryan Kraus for making this all possible. Please make sure you read the full blog post for details on how to migrate your existing setup.
+ +And while Ryan was fixing distribution, I have been hard at work in giving Home Assistant a face lift. We already looked pretty good but lacked proper form of organization for users with many devices. The new UI moves away from a card per entity and has cards per group and domain instead. The demo has been updated so give it a spin.
+ +
+
+ 
+
+ Screenshots of the new UI
+
For this example, let’s say we have an old Home Assistant installation in /home/paulus/home-assistant.
If you want to migrate your existing configuration to be used as the default configuration:
+ +$ cp -r /home/paulus/home-assistant ~/.homeassistant
+It If you want to have the configuration in a different location, for example /home/paulus/home-assistant-config, you will have to point Home Assistant at this configuration folder when launching:
$ hass --config /home/paulus/home-assistant-config
+And last, but not least: new platforms!
+ +MQTT Sensors and Switches
+ @sfam has blessed us with two more MQTT platforms to extend our integration with MQTTT: sensor and switch. Both platforms require the MQTT component to be connected to a broker.
# Example configuration.yml entr
+sensor:
+ platform: mqtt
+ name: "MQTT Sensor"
+ state_topic: "home/bedroom/temperature"
+ unit_of_measurement: "ºC"
+
+switch:
+ platform: mqtt
+ name: "Bedroom Switch"
+ state_topic: "home/bedroom/switch1"
+ command_topic: "home/bedroom/switch1/set"
+ payload_on: "ON"
+ payload_off: "OFF"
+ optimistic: false
+Actiontec MI424WR Verizon FIOS Wireless router
+
Nolan has contributed support for Actiontec wireless routers.
# Example configuration.yaml entry
+device_tracker:
+ platform: actiontec
+ host: YOUR_ROUTER_IP
+ username: YOUR_ADMIN_USERNAME
+ password: YOUR_ADMIN_PASSWORD
+DHT temperature and humidty sensors +@MakeMeASandwich has contributed support for DHT temperature and humidity sensors. It allows you to get the current temperature and humidity from a DHT11, DHT22, or AM2302 device.
+ +# Example configuration.yaml entry
+sensor:
+ platform: dht
+ sensor: DHT22
+ pin: 23
+ monitored_conditions:
+ - temperature
+ - humidity
+Aruba device tracker +Michael Arnauts has contributed support for Aruba wireless routers for presence detection.
+ +# Example configuration.yaml entry
+device_tracker:
+ platform: aruba
+ host: YOUR_ACCESS_POINT_IP
+ username: YOUR_ADMIN_USERNAME
+ password: YOUR_ADMIN_PASSWORD
+ MQTT support was added to Home Assistant recently. The MQTT component will enable you to do all sort of things. Most likely you will use it to communicate with your devices. But Home Assistant doesn’t care where the data is coming from or is limited to real hardware as long as there is MQTT support. This means that it doesn’t matter if the data is coming from a human, a web service, or a device.
A great example is shown in a Laundry Automation post in this blog.
+ +This post will give you a small overview of some other possibilities on how to use MQTT with Home Assistant.
+ + + +The simplest but not the coolest way as a human to interact with a Home Assistant sensor is launching a command manually. Let’s create a “Mood” sensor. For simplicity Home Assistant and the MQTT broker are both running on the same host. The needed configuration snipplets to add to the configuration.yaml file consists of two parts: one for the broker and one for the sensor.
mqtt:
+ broker: 127.0.0.1
+
+sensor:
+ - platform: mqtt
+ name: "Fabian's Mood"
+ state_topic: "home-assistant/fabian/mood"
+After a restart of Home Assistant the “Mood” sensor will show up in the frontend. For more details about the configuration of MQTT itself and the sensor, please refer to the MQTT component or the MQTT sensor documentation.
+ +Now we can set the mood. The commandline tool (mosquitto_pub) which is shipped with mosquitto is used to send an MQTT message.
$ mosquitto_pub -h 127.0.0.1 -t "home-assistant/fabian/mood" -m "bad"
+
+ 
+ The Mood sensor
+
This is a really bad example. Don’t do this in the real world because you won’t be able to create diagrams of historical data. Better use a numerical value.
+ +The last section was pretty boring, I know. Nobody wants to send MQTT messages by hand if there is a computer on the desk. If you are playing the lottery this section is for you. If not, read it anyway because the lottery is just an example :-).
+ +This example is using the Paho MQTT Python binding because those binding should be available on the host where Home Assistant is running. If you want to use this example on another machine, please make sure that the bindings are installed (pip3 install paho-mqtt).
The first step is to add an additional MQTT sensor to the configuration.yaml file. The sensor will be called “Lottery” and the unit of measurement will be “No.”.
- platform: mqtt
+ name: "Lottery"
+ state_topic: "home-assistant/lottery/number"
+ unit_of_measurement: "No."
+Don’t forget to restart Home Assistant to make the configuration active.
+ +To play, we need numbers from 1 to 49 which can be marked on the ticket. Those numbers should be random and displayed in the Home Assistant frontend. The Python script below is another simple example on how to send MQTT messages from the commandline; this time in a loop. For further information and examples please check the Paho MQTT documentation.
+ +#!/usr/bin/python3
+#
+import time
+import random
+import paho.mqtt.client as mqtt
+import paho.mqtt.publish as publish
+
+broker = '127.0.0.1'
+state_topic = 'home-assistant/lottery/number'
+delay = 5
+
+# Send a single message to set the mood
+publish.single('home-assistant/fabian/mood', 'good', hostname=broker)
+
+# Send messages in a loop
+client = mqtt.Client("ha-client")
+client.connect(broker)
+client.loop_start()
+
+while True:
+ client.publish(state_topic, random.randrange(0, 50, 1))
+ time.sleep(delay)
+Every 5 seconds a message with a new number is sent to the broker and picked up by Home Assistant. By the way, my mood is much better now.
+ +
+ 
+ The Lottery sensor
+
With only a few lines of Python and an MQTT broker you can create your own “smartdevice” or send information to Home Assistant which you haven’t think of. Of course this is not limited to Python. If there is an MQTT library available, the device can be used with Home Assistant now.
+ +To get started with real hardware that is capable to send MQTT messages, the Arduino platform is an inexpensive way to do it. In this section an Arduino UNO with an Ethernet shield and a photo resistor is used. The photo resistor is connected to analog pin 0 (A0) and has an output from 0 to 1024.
+ +
+ 
+ The Arduino UNO with Ethernet shield and photo resistor
+
The MQTT client for the Arduino needs to be available in your Arduino IDE. Below you will find a sketch which could act as a starting point. Please modify the IP addresses, the MAC address, and the pin as needed and upload the sketch to your Arduino.
+ +/*
+ This sketch is based on the basic MQTT example by
+ http://knolleary.github.io/pubsubclient/
+*/
+
+#include <SPI.h>
+#include <Ethernet.h>
+#include <PubSubClient.h>
+
+#define DEBUG 1 // Debug output to serial console
+
+// Device settings
+IPAddress deviceIp(192, 168, 0, 43);
+byte deviceMac[] = { 0xAB, 0xCD, 0xFE, 0xFE, 0xFE, 0xFE };
+char* deviceId = "sensor01"; // Name of the sensor
+char* stateTopic = "home-assistant/sensor01/brightness"; // MQTT topic where values are published
+int sensorPin = A0; // Pin to which the sensor is connected to
+char buf[4]; // Buffer to store the sensor value
+int updateInterval = 1000; // Interval in miliseconds
+
+// MQTT server settings
+IPAddress mqttServer(192, 168, 0, 12);
+int mqttPort = 1883;
+
+EthernetClient ethClient;
+PubSubClient client(ethClient);
+
+void reconnect() {
+ while (!client.connected()) {
+#if DEBUG
+ Serial.print("Attempting MQTT connection...");
+#endif
+ if (client.connect(deviceId)) {
+#if DEBUG
+ Serial.println("connected");
+#endif
+ } else {
+#if DEBUG
+ Serial.print("failed, rc=");
+ Serial.print(client.state());
+ Serial.println(" try again in 5 seconds");
+#endif
+ delay(5000);
+ }
+ }
+}
+
+void setup() {
+ Serial.begin(57600);
+ client.setServer(mqttServer, mqttPort);
+ Ethernet.begin(deviceMac, deviceIp);
+ delay(1500);
+}
+
+void loop() {
+ if (!client.connected()) {
+ reconnect();
+ }
+ client.loop();
+
+ int sensorValue = analogRead(sensorPin);
+#if DEBUG
+ Serial.print("Sensor value: ");
+ Serial.println(sensorValue);
+#endif
+ client.publish(stateTopic, itoa(sensorValue, buf, 10));
+ delay(updateInterval);
+}
+The Arduino will send the value of the sensor every second. To use the data in Home Assistant, add an additional MQTT sensor to the configuration.yaml file.
- platform: mqtt
+ name: "Brightness"
+ state_topic: "home-assistant/sensor01/brightness"
+ unit_of_measurement: "cd"
+After a restart of Home Assistant the values of your Arduino will be available.
+ +
+ 
+ The Brightness sensor
+
I hope that this post could give you some ideas about the usage Home Assistant and MQTT. If you are working on a cool project that includes Home Assistant, please let us now.
+Today we announce the release of Home Assistant v0.7.2 which includes brand new support by @sfam to integrate with IFTTT. IFTTT stands for If This, Then That and is a webservice that integrates with almost every possible webservice out there. Adding Home Assistant to this mix means Home Assistant can connect with all via IFTTT.
+ +It is now possible to disable your irregation system if it is going to be cloudy tomorrow or tweet if your smoke alarm goes off.
+ +
+ 
+
Head over to the setup instructions to get started with IFTTT. Click the read more button for some example recipes.
+ + + +In each of the following examples, make sure to replace the XXX in the url with your correct host address and api password.
+ +
+ 
+
Maker channel setup:
+ +| Field | +Value | +
|---|---|
| URL | +http://xxx.xxx.xxx.xxx:8123/api/services/switch/turn_off?api_password=xxxxxxxx | +
| METHOD | +POST | +
| CONTENT TYPE | +application/json | +
| BODY | +{ “entity_id”: “switch.irrigation” } | +
+ 
+
This will tweet a message when an MQTT message is received that the smoke alarm has been triggered. Setup Maker channel with event name HA_FIRE_ALARM and Twitter channel to tweet the message in value1.
# Configuration.yaml entry
+automation:
+- alias: Post a tweet when fire alarm is triggered
+ trigger:
+ platform: mqtt
+ mqtt_topic: home/alarm/fire
+ mqtt_payload: 'on'
+
+ action:
+ service: ifttt.trigger
+ data: {"event":"HA_FIRE_ALARM", "value1":"The fire alarm just triggered!"}
+
+ 
+
Maker channel setup:
+ +| Field | +Value | +
|---|---|
| URL | +http://xxx.xxx.xxx.xxx:8123/api/services/light/turn_on?api_password=xxxxxxxx | +
| METHOD | +POST | +
| CONTENT TYPE | +application/json | +
| BODY | +{ “entity_id”: “light.kitchen” } | +
+ 
+
Maker channel setup:
+ +| Field | +Value | +
|---|---|
| URL | +http://xxx.xxx.xxx.xxx:8123/api/services/light/turn_on?api_password=xxxxxxxx | +
| METHOD | +POST | +
| CONTENT TYPE | +application/json | +
| BODY | +{ “entity_id”: “group.all_lights”, “flash”:”yes” } | +
+ 
+
Maker channel setup:
+ +| Field | +Value | +
|---|---|
| URL | +http://xxx.xxx.xxx.xxx:8123/api/events/do_button_pressed?api_password=xxxxxxxx | +
| METHOD | +POST | +
| CONTENT TYPE | +application/json | +
+Inspried by a feature requests I started looking into the available options to do monitoring of remote hosts. The feature request is about displaying system information in a similar way than the systemmonitor sensor does it for the local system. After a while I started to think that it would be a nice addition for a small home network where no full-blown system monitoring setup is present.
The basic problem is to get the data from the remote host. Starting with psutil that is used by the systemmonitor sensor, a possible solution is only a click away and named Glances. Glances has a nice curses-based interface and a RESTful API.
+ +The Glances sensor sensor uses that API to get all needed data.
+ +In this post a default Fedora 22 Workstation installation is used on the host that should be monitored. In fact, it doesn’t matter if the system is the local one or a remote one as long as Glances is available. With some adjustments it should work on your own systems too. The difference will be the package and the firewall management tools.
+ +First some extra packages are needed beside Glances, especially the bottle webserver. I guess that Glances is available for your distribution as well. Otherwise follow those instructions.
+ +$ sudo dnf -y install glances python-bottle
+On Fedora the Firewall settings are strict. Let’s open port 61208 to allow other hosts to connect to that port. This is not needed if you just want to observe your local machine.
+ +$ sudo firewall-cmd --permanent --add-port=61208/tcp
+$ sudo firewall-cmd --reload
+Launch glances and keep an eye on the output.
$ glances -w
+Glances web server started on http://0.0.0.0:61208/
+Now browse to http://IP_ADRRESS:61208/. You should see the webified view of Glances.
+ +
+ 
+ Glances web interface
+
Another check is to access the API located at http://IP_ADRRESS:61208/api/2/mem/used and to confirm that a detail about your memory usage is provided as a JSON response. If so, you are good to proceed.
+ +$ curl -X GET http://IP_ADDRESS:61208/api/2/mem/used
+{"used": 203943936}
+Add the glances sensor entry to your configuration.yaml file and restart Home Assistant then.
# Example configuration.yaml entry
+ - platform: glances
+ name: NAS
+ host: IP_ADDRESS
+ resources:
+ - 'disk_use_percent'
+ - 'disk_use'
+ - 'disk_free'
+If there are no error in the log file then you should see your new sensors.
+ +
+ 
+ The Glances sensors
+
Glances has a couple of optional dependencies which are extenting the range of provided information. This means that it would be possible to get details about the RAID system, HDD temperature, IP addresses, sensors, etc., please create a Pull request with your additions or a Feature request if you want see more details in your Home Assistant frontend.
+It’s like someone opened a can of rock solid developers and emptied it above our chat channel because it exploded with great conversations and solid contributions. Featured in release 0.7.3: Sonos, iTunes, Alarm component and Automation upgrade.
+ +See GitHub for more detailed release notes.
+ +Migration note: the scheduler component has been removed in favor of the automation component.
Sonos
+
Sonos support has been added by @rhooper and @SEJeff. Home Assistant is now able to automatically detect Sonos devices in your network and set them up for you. It will allow you to control music playing on your Sonos and change the volume.
iTunes and airplay speakers
+
@maddox has contributed support for controlling iTunes and airplay speakers. For this to work you will have to run itunes-api on your Mac as middleware.
# Example configuration.yaml entry
+media_player:
+ platform: itunes
+ name: iTunes
+ host: http://192.168.1.50
+ port: 8181
+Automation +Automation has gotten a lot of love. It now supports conditions, multiple triggers and new types of triggers. The best to get started with it is to head over to the new getting started with automation page.
+ +# Example of entry in configuration.yaml
+automation:
+ alias: Light on in the evening
+ trigger:
+ - platform: sun
+ event: sunset
+ offset: "-01:00:00"
+ - platform: state
+ entity_id: group.all_devices
+ state: home
+ condition:
+ - platform: state
+ entity_id: group.all_devices
+ state: home
+ - platform: time
+ after: "16:00:00"
+ before: "23:00:00"
+ action:
+ service: homeassistant.turn_on
+ entity_id: group.living_room
+Verisure Alarms
+ We now support arming and disarming your verisure alarm from within Home Assistant thanks to added support by @persandstrom.
A few weeks have past and it is time again for another release: version 0.7.4. This time we’re very glad to be able to introduce brand new integration with OwnTracks to allow tracking of people on a map. The geo support consists of three different parts:
+ +We have added a new getting started section to get up and running.
+ +
+
+Map in Home Assistant showing two people and three zones (home, school, work)
+
Ofcourse more things happened in the last three weeks. I’m moving away from my usual long post to a short summary of highlights:
+ + + +I recently learned about the ESP8266, a $5 chip that includes WiFi and is Arduino compatible. This means that all your DIY projects can now be done for a fraction of the price.
+ +For this tutorial, I’ll walk through how to get going with ESP8266, get the temperature and humidity and report it to MQTT where Home Asssistant can pick it up.
+ +
+
+Picture of the final setup (+ 2 LED for decoration)
+
+
+Home Assistant will keep track of historical values and allow you to integrate it into automation.
+
I’ve been using Adafruit for my shopping:
+ +Besides this, you will need the usual hardware prototype equipment: a breadboard, some wires, soldering iron + wire, Serial USB cable.
+ +Since this article has been published the HDC1008 has been discontinued. Updated sketches are available for the following alternatives:
+ +On your breadboard, make the following connections from your ESP8266 to the HDC1008:
+ +| ESP8266 | +HDC1008 | +
|---|---|
| GND | +GND | +
| 3V | +Vin | +
| 14 | +SCL | +
| #2 | +SDA | +
I picked #2 and 14 myself, you can configure them in the sketch.
Follow these instructions on how to install and prepare the Arduino IDE for ESP8266 development.
+ +After you’re done installing, open the Arduino IDE, in the menu click on sketch -> include library -> manage libraries and install the following libraries:
If you have followed the previous steps, you’re all set.
+ +File -> New)Tools -> Serial Monitor) to see the output from your deviceThis sketch will connect to your WiFi network and MQTT broker. It will read the temperature and humidity from the sensor every second. It will report it to the MQTT server if the difference is > 1 since last reported value. Reports to the MQTT broker are sent with retain set to True. This means that anyone connecting to the MQTT topic will automatically be notified of the last reported value.
#include <ESP8266WiFi.h>
+#include <Wire.h>
+#include <PubSubClient.h>
+#include <Adafruit_HDC1000.h>
+
+#define wifi_ssid "YOUR WIFI SSID"
+#define wifi_password "WIFI PASSWORD"
+
+#define mqtt_server "YOUR_MQTT_SERVER_HOST"
+#define mqtt_user "your_username"
+#define mqtt_password "your_password"
+
+#define humidity_topic "sensor/humidity"
+#define temperature_topic "sensor/temperature"
+
+WiFiClient espClient;
+PubSubClient client(espClient);
+Adafruit_HDC1000 hdc = Adafruit_HDC1000();
+
+void setup() {
+ Serial.begin(115200);
+ setup_wifi();
+ client.setServer(mqtt_server, 1883);
+
+ // Set SDA and SDL ports
+ Wire.begin(2, 14);
+
+ // Start sensor
+ if (!hdc.begin()) {
+ Serial.println("Couldn't find sensor!");
+ while (1);
+ }
+}
+
+void setup_wifi() {
+ delay(10);
+ // We start by connecting to a WiFi network
+ Serial.println();
+ Serial.print("Connecting to ");
+ Serial.println(wifi_ssid);
+
+ WiFi.begin(wifi_ssid, wifi_password);
+
+ while (WiFi.status() != WL_CONNECTED) {
+ delay(500);
+ Serial.print(".");
+ }
+
+ Serial.println("");
+ Serial.println("WiFi connected");
+ Serial.println("IP address: ");
+ Serial.println(WiFi.localIP());
+}
+
+void reconnect() {
+ // Loop until we're reconnected
+ while (!client.connected()) {
+ Serial.print("Attempting MQTT connection...");
+ // Attempt to connect
+ // If you do not want to use a username and password, change next line to
+ // if (client.connect("ESP8266Client")) {
+ if (client.connect("ESP8266Client", mqtt_user, mqtt_password)) {
+ Serial.println("connected");
+ } else {
+ Serial.print("failed, rc=");
+ Serial.print(client.state());
+ Serial.println(" try again in 5 seconds");
+ // Wait 5 seconds before retrying
+ delay(5000);
+ }
+ }
+}
+
+bool checkBound(float newValue, float prevValue, float maxDiff) {
+ return !isnan(newValue) &&
+ (newValue < prevValue - maxDiff || newValue > prevValue + maxDiff);
+}
+
+long lastMsg = 0;
+float temp = 0.0;
+float hum = 0.0;
+float diff = 1.0;
+
+void loop() {
+ if (!client.connected()) {
+ reconnect();
+ }
+ client.loop();
+
+ long now = millis();
+ if (now - lastMsg > 1000) {
+ lastMsg = now;
+
+ float newTemp = hdc.readTemperature();
+ float newHum = hdc.readHumidity();
+
+ if (checkBound(newTemp, temp, diff)) {
+ temp = newTemp;
+ Serial.print("New temperature:");
+ Serial.println(String(temp).c_str());
+ client.publish(temperature_topic, String(temp).c_str(), true);
+ }
+
+ if (checkBound(newHum, hum, diff)) {
+ hum = newHum;
+ Serial.print("New humidity:");
+ Serial.println(String(hum).c_str());
+ client.publish(humidity_topic, String(hum).c_str(), true);
+ }
+ }
+}
+The last step is to integrate the sensor values into Home Assistant. This can be done by setting up Home Assistant to connect to the MQTT broker and subscribe to the sensor topics.
+ +mqtt:
+ broker: YOUR_MQTT_SERVER_HOST
+ username: your_username
+ password: your_password
+
+sensor:
+ platform: mqtt
+ name: "Temperature"
+ state_topic: "sensor/temperature"
+ qos: 0
+ unit_of_measurement: "ºC"
+
+sensor 2:
+ platform: mqtt
+ name: "Humidity"
+ state_topic: "sensor/humidity"
+ qos: 0
+ unit_of_measurement: "%"
+We discovered two issues annoying enough to warrent the release of 0.7.5:
+ +This release also includes some new platforms (because they keep coming!):
+ +
Also, the media player was extended by @maddox to support the play media command. This has been implemented for the iTunes platform.
+After two weeks of hard work I’m proud to announce the release of Home Assistant v0.7.6. For this release the main focus was bugs, test coverage and documentation. And we exceeded expectations on all three fronts. Bugs have been squashed, test coverage increased to 85% and thanks to the hard work by @fabaff and myself the component section on the website has gotten a complete revamp.
+ +
customize key in configuration.yaml (@balloob)configuration.yaml (@balloob)As part of this release we did some cleanup which introduced backwards incompatible changes:
+ +Heat Control thermostat no longer includes scheduling features. +This feature has been removed completely. Use the automation component instead to control target temperature.
+ +Config changed for calling a service from a script.
+execute_service: has been replaced with service:. See component page for example. The old method will continue working for some time.
Scenes can no longer be turned off. +It is no longer possible to turn a scene off after it has been activated. The way it worked was unpredictable and causes a lot of confusion.
+ +Downloader treats relative paths now relative to the config dir instead of the current working dir. +This makes more sense as most people run Home Assistant as a daemon
+
We have all been hard at work to get this latest release ready. One of the big highlights in this release is the introduction of an extended iconset to be used in the frontend (credits to @happyleavesaoc for idea and prototype). To get started with customizing, pick any icon from MaterialDesignIcons.com, prefix the name with mdi: and stick it into your customize section in configuration.yaml:
homeassistant:
+ customize:
+ switch.ac:
+ icon: 'mdi:air-conditioner'
+
Around a week ago we started with the first survey. Now 30 people have participated. Thank you very much if you did. We think that’s enough time to have some “only partially representative” data. It’s hard to tell how many Home Assistant users are out there. Currently there are 215 members in our Gitter chat room and last week PyPI counted 5063 downloads.
The idea was to anonymously collect some details about the usage of the different parts of Home Assistant and a little bit about the environment its running in.
+ + +Thanks to Python, users are running Home Assistant on the most popular Linux distributions and other operating systems including OS X and Microsoft Windows. One quarter of the operating systems are unknown which leads to the assumption that it is possible to run Home Assistant on most of the available operation systems today. We hope that *BSD users have fun too. The Hardware platform of choice seems to be x86_64 and ARM.
+ +Of course most users are running with the automation component otherwise it would make much sense to use Home Assistant. The sun component is used a lot too. We hope that this is not because this component is enabled by default.
+ +The Alarm control panels and the camera component are both used by around one third of the participants of the survey. It’s safe to say that they cover a niche, but they will gain momentum when people discover how they can build alarm systems with Home Assistant.
+ +Philips Hue is the “winner” in the light category closely followed by MQTT lights. Google Cast and Plex are the top media player platforms. Pushbullet is by far the most-used notification platform. If you followed the recent efforts to improve this platform it’s comprehensible.
+ +It’s interesting to see that most of the sensor, switch, and thermostat platforms are used. A lot of people seem to be interested in the weather data provided by the Forecast sensor. The MQTT sensors and switches are deployed in almost 50% of all Home Assistant setups.
+ +
+
+ Home Assistant releases
+
+ 
+ Operating systems
+
+ 
+ Hardware platforms
+
+ 
+ Components
+
+ 
+ Alarm Control Panels and Cameras
+
+ 
+ Device trackers
+
+ 
+ Lights
+
+ 
+ Media players
+
+ 
+ Notifications
+
+ 
+ Sensors
+
+ 
+ Switches
+
+ 
+ Thermostats
+
The conclusion is that MQTT is popular in almost every section from Alarm Control Panel, presence detection with owntracks, sensors and switches, and now even for lights.
+ +The interpretation of the data is up to you. Again, thanks for participating in this survey.
+From time to time we come along things that are worth sharing with fellow Home Assisters. Here a list of some cool stuff from last week:
+ +First is the public beta of Let’s Encrypt. Let’s Encrypt is a new certificate authority that is free, automated and open. This means that it will now be very easy to secure your connection to Home Assistant while you are away from home. W1ll1am23 has written up a guide how to get started.
+ +The next thing is a show-off of some of the cool stuff people do with Home Assistant. This is miniconfig talking to Home Assistant using the Amazon Echo!
+ +And last but not least, Midwestern Mac did a microSD card performance comparison for the Raspberry Pi. If you’re using a Pi, make sure to check it out!
+It’s been a few weeks but we managed to polish a nice new release of Home Assistant for y’all!
+ +
To update, run pip3 install --upgrade homeassistant.
+
+
+The InfluxDB database is a so-called time series database primarly designed to store sensor data and real-time analytics.
The influxdb component makes it possible to transfer all state changes from Home Assistant to an external InfluxDB database.
The first step is to install the InfluxDB packages. If you are not running Fedora, check the installation section for further details.
+ +$ sudo dnf -y install http://influxdb.s3.amazonaws.com/influxdb-0.9.5.1-1.x86_64.rpm
+Launch the InfluxDB service.
+ +$ sudo systemctl start influxdb
+If everything went well, then the web interface of the database should be accessible at http://localhost:8083/. Create a database home_assistant to use with Home Assistant either with the web interface or the commandline tool influx.
+ 
+ InfluxDB web frontend
+
$ influx
+Visit https://enterprise.influxdata.com to register for updates, InfluxDB server management, and monitoring.
+Connected to http://localhost:8086 version 0.9.5.1
+InfluxDB shell 0.9.5.1
+> CREATE DATABASE home_assistant
+An optional step is to create a user. Keep in mind to adjust the configuration (add username and password) in the next step if you prefer to go this way.
> CREATE USER "home-assistant" WITH PASSWORD 'password'
+To use the influxdb component in your installation, add the following to your configuration.yaml file:
influxdb:
+ host: 127.0.0.1
+After you restart Home Assistant you should see that the InfluxDB database gets filled. The language to query the database is similar to SQL.
+ +$ influx
+[...]
+> USE home_assistant
+Using database home_assistant
+> SELECT * FROM binary_sensor
+name: binary_sensor
+-------------------
+time domain entity_id value
+1449496577000000000 binary_sensor bathroom_door 0
+1449496577000000000 binary_sensor bathroom_window 0
+1449496577000000000 binary_sensor basement_door 0
+1449496577000000000 binary_sensor basement_window 0
+1449496684000000000 binary_sensor bathroom_window 1
+[...]
+Grafana is a dashboard that can create graphs from different sources including InfluxDB. The installation is simple, and there are detailed steps for many different configurations on the Grafana installation page. For a recent system that is running Fedora:
+ +$ sudo dnf -y install https://grafanarel.s3.amazonaws.com/builds/grafana-2.5.0-1.x86_64.rpm
+Start the grafana server.
+ +$ sudo systemctl daemon-reload
+$ sudo systemctl start grafana-server
+$ sudo systemctl status grafana-server
+Login with the username admin and the password admin at http://localhost:3000/login. Now follow the InfluxDB setup instructions.
Now you can start to create dashboards and graphs. You have various options to get the data from the graph. The next image just shows a screenshot of the setting for a temperature sensor.
+ +
+ 
+ Grafana settings
+
If the graph is not showing up in the dashboard you need to adjust the time range in the right upper corner. The graph is created for all state changes recorded by Home Assistant.
+ +
+ 
+ Grafana Temperature graph
+
+In this tutorial I will explain how you can activate Tasker tasks from Home Assistant command line switches. We are going to set up a switch that when toggled will make your Android device say either “On” or “Off”.
You could also do this with the automation component instead so whenever you put your house to sleep mode for example your Android device will open up Google Play Books or the Kindle app ready for you to read as well as dimming your lights, but this tutorial is all about the switches.
+ + + +First things first you should install Tasker and AutoRemote onto your Android device and launch AutoRemote. You should see a URL above the QR code, visit it in your browser and it should bring up a page a bit like this.
+ +
+
+
Now type in SayOn in the Message box and you should see a box appear on the right with a URL in it, this is what we will be using in the Python script later on so save that for later. Do the same thing again but this time replace SayOn with SayOff. Now just click the Send message now! button to test that your commands will get sent to your Android device, if they do you will see a toast message at the bottom of your screen like this one.
+
+
Open up Tasker and make sure you’re in the PROFILES tab, then select the plus icon to create a new profile. Select Event -> Plugin -> AutoRemote -> AutoRemote and then the pencil icon to configure the AutoRemote event. Select Message Filter and enter in SayOn then go back until it asks you for a task. Select New task then just leave the next field blank and select the tick icon.
+This is where we’ll configure our task, so select the plus icon to select an action. Select Alert -> Say to add a Say action. Enter On in the text field and go back to test your task, make sure your media volume is up then select the play icon, you should hear your device say “On”.
+
+
Now you can go back to the main Tasker screen and create another profile but this time replace SayOn with SayOff and On with Off. After you’ve done that go to the main screen again and select the menu button at the top then Exit and Save first to make sure everything is saved properly.
Now it’s time to set it up the script, so create a new Python script and name it On.py then enter this code:
import requests
+requests.get('[URL]')
+Enter in your “On” URL then save it. Create another script but this time call it Off.py and enter your “off” URL instead.
Add a command line switch to your Home Assistant configuration:
+ +switch:
+ platform: command_switch
+ switches:
+ tasker_say:
+ oncmd: python "[LocationOfOnScript]"
+ offcmd: python "[LocationOfOffScript]"
+Now load up Home Assistant and whenever you toggle the switch you created your Android device will respond with either “On” or “Off”. :-)
+Update Dec 16: Great news! Philips has decided to reverse their decision and is working on a software update to allow 3rd party light bulbs again.
+ +
+
+Philips Hue FAQ entries regarding reversing the decision.
+
Original post:
+ + +Philips Hue was one of the first to get smart lights accepted by the mainstream. Their Zigbee-based hub is rock solid, never crashes, great API and worked with other Zigbee light bulbs too. They are a bit expensive but the platform was worth every penny, till now.
+ +Yesterday a thread on /r/homeautomation published that Philips Hue now blocks all but their own bulbs and those of “friends of Hue”. I have been able to confirm this in the Philips Hue FAQ (Update Dec 14: they have removed the entries - mirror here):
+ +
+
+Philips Hue FAQ entries regarding 3rd party light bulbs.
+
This means that after you update your Hue bridge to the latest version:
+ +If you own a Philips Hue hub and are using 3rd party light bulbs, make sure you do not upgrade your hub if you want to be able to pair new 3rd party lightbulbs. But do realize that you are sitting on a ticking time bomb.
+ +I have read, but have been unable to confirm it, that resetting your hub will force a software upgrade. So beware of that too.
+ +I will no longer suggest people to buy into the Philips Hue ecosystem.
+Exposing your Home Assistant instance outside of your network always has been tricky. You have to set up port forwarding on your router and most likely add a dynamic DNS service to work around your ISP changing your IP. After this you would be able to use Home Assistant from anywhere but there is one big red flag: no encryption.
+ +This tutorial will take you through the steps to setup a dynamic DNS for your IP and allow trusted encrypted connection to it - for free using DuckDNS and Let’s Encrypt.
+ +
+
+
Updated 2016-06-18
+ +The DuckDNS part of this tutorial has no requirements but there are a few requirements as of now to run the Let’s Encrypt client.
+ +
The first step is to set up DuckDNS. This is a free dynamic DNS service that you can use to get a DuckDNS.org subdomain to point at your house. A dynamic DNS service works by having your home computer tell DuckDNS.org every 5 minutes what its IP is so that DuckDNS can make sure your domain name is set up correctly.
+ +For this example we will assume our domain is hass-example.duckdns.org.
+ +First step is to acquire and set up our domain name. For this, go to DuckDNS, log in with any of the supported login providers and add a domain. After this check out their installation instructions to finish your installation of DuckDNS. If you’re on a Raspberry Pi, see ‘Pi’ in the category ‘Operating Systems’.
+ +
Let’s Encrypt is a free, automated, and open certificate authority (CA). We will use this to acquire a certificate that can be used to encrypted our connection with Home Assistant.
+ +Let’s Encrypt will give you a free 90-day certificate if you pass their domain validation challenge. Domains are validated by having certain data be accessible on your domain for Let’s Encrypt (they describe it better themselves).
+ +Assuming that your home is behind a router, the first thing to do is to set up port forwarding from your router to your computer that will run Let’s Encrypt. For the Let’s Encrypt set up we need to forward external port 80 to internal port 80 (http connections). This can be set up by accessing your router admin interface (Site with port forwarding instructions per router). This port forward must be active whenever you want to request a new certificate from Let’s Encrypt, typically every three months. If you normally don’t use or have an app that listens to port 80, it should be safe to leave the port open. This will make renewing certificates easier.
Now you’re ready to install and run the client that requests certificates from Let’s Encrypt. The following example will use the platform independent script to install and run the certbot client from Let’s Encrypt. If there is a certbot package for your OS, it’s recommended to install the package instead of the platform independent script. Read the docs for more information. There are also other clients that might offer more customization and options. See the client options page at Let’s Encrypt.
+ +$ mkdir certbot
+$ cd certbot/
+$ wget https://dl.eff.org/certbot-auto
+$ chmod a+x certbot-auto
+$ ./certbot-auto certonly --standalone \
+ --standalone-supported-challenges http-01 \
+ --email your@email.address \
+ -d hass-example.duckdns.org
+If you’re using Docker, run the following command to generate the required keys:
+ +sudo mkdir /etc/letsencrypt /var/lib/letsencrypt
+sudo docker run -it --rm -p 80:80 --name certbot \
+ -v "/etc/letsencrypt:/etc/letsencrypt" \
+ -v "/var/lib/letsencrypt:/var/lib/letsencrypt" \
+ quay.io/letsencrypt/letsencrypt:latest certonly \
+ --standalone --standalone-supported-challenges http-01 \
+ --email your@email.address -d hass-example.duckdns.org
+With either method your certificate will be generated and put in the directory /etc/letsencrypt/live/hass-example.duckdns.org. As the lifetime is only 90 days, you will have to repeat this every 90 days. There’s a special command to simplify renewing certificates:
./certbot-auto renew --quiet --no-self-upgrade --standalone \
+ --standalone-supported-challenges http-01
+
Before updating the Home Assistant configuration, we have to forward port 443 (https connections) to port 8123 on the computer that will run Home Assistant. Do this in your router configuration as previously done for port 80.
The final step is to point Home Assistant at the generated certificates. Before you do this, make sure that the user running Home Assistant has read access to the folder that holds the certificates.
+ +http:
+ api_password: YOUR_SECRET_PASSWORD
+ ssl_certificate: /etc/letsencrypt/live/hass-example.duckdns.org/fullchain.pem
+ ssl_key: /etc/letsencrypt/live/hass-example.duckdns.org/privkey.pem
+You can now navigate to https://hass-example.duckdns.org and enjoy encryption!
+ +Big thanks to Fabian Affolter for his help and feedback on this article.
+Alrighty, it’s time for Home Assistant 0.10. A lot amazing things have changed and sadly we also had to introduce a bunch of backwards incompatible changes. I would like to give a big shoutout to Philip Lundrigan (@philipbl) who put a lot in effort in helping the migration to move towards using templates for a wide variety of platforms.
+ +
This release introduces templates. This will allow you to parse data before it gets processed or create messages for notifications on the fly based on data within Home Assistant. The notification component and the new Alexa/Amazon Echo component are both using the new template functionality to render responses. A template editor has been added to the developer tool section in the app so you can get instant feedback if your templates are working or not.
+ +The temperature at home is {{ states('sensor.temperature') }}.
+More information and examples can be found in the template documentation.
+ +Templates will now be the only way to extract data from ‘raw’ sources like REST, CommandSensor or MQTT. This will replace any specific option that used to do this before. This means that precision, factor, attribute or json_path etc will no longer work.
Affected components and platforms:
+ +First release of 2016 and we are on 🔥! The main repository has passed 2500 ⭐ on GitHub (2596 ⭐ as of now). This release also has a record number of 20 contributors all working on improving and extending Home Assistant. With the continued growth, I am very excited to see what 2016 will bring us 🤘.
+ +
is_state_attr(entity_id, name, value) added (@andythigpen)binary_sensor component.People often ask me about my vision for Home Assistant. Before I can describe where I want to go with Home Assistant, I should first talk about how home automation would look in my ideal world. This will be the aim of this post. I’m not going to focus on protocols, networks or specific hubs. That’s all implementation details. Instead, this post will focus on what is most important: the interaction between the users and their home.
+ +When people start using home automation, they always experience home control first: being able to control devices in new ways using a phone or computer. They believe the future is now and their app will be their remote for their lives. They only focus on what they are getting, not on what they are losing. You install some light bulbs and all of a sudden you are no longer able to use the light switches. You’ll arrive at home at night and have to pull out your phone, open the app, let it connect and finally you’ll be able to turn on the light. All while turning the light on could have been a switch away.
+ +Yes, you can solve this with presence detection. What if your phone runs out of battery? You’ll have to resort to the switch again.
+ +If you find that using your new home devices is cumbersome, the promise of home automation technology has failed you. Your lights should work with both a switch (or button) at the entrance of your room and via presence detection. Honestly, there are hardly any valid use cases for being able to control lights from your phone except for showing off. +
+ +People tend to forget that they are not the only ones in their home. As the developer of your house you’re enthusiastic about the possibilities and are willing to overlook flaws. Chances are very high that the other people in your household have different hobbies and just want to mind their own business.
+ +This means that everything you automate has to work flawlessly. If you successfully manage to cause a response to some stimulus 90% of the time, you’re going to have a disproportionately poor experience 10% of the time. A common automation that fits this pattern is to fade the lights when you start watching a movie or series in the living room. It only works if everyone is watching.
+ +With every automation, you always have to think: what will be the impact if it doesn’t work? Home automation is composed of many different systems by many different vendors that speak many different protocols: things will go wrong. It’s up to you to make sure that they have a limited impact when they fail. Ideally, devices should fall back to a pre-smart home experience. A Philips Hue bulb will act like a standard white light if turned on/off using a normal switch or when not connected to a hub. If things get worse when your system is out of order, your users will revolt. Take for example the Nest thermostat that had a bug in the beginning of January which caused it to stop heating the house, yikes!
+ +Home automation should blend with your current workflow, not replace it. For most devices, there is no faster way to control most devices than how you are already doing it today. Most of the time, the best app is no app. The only interface that can be more convenient, and is accessible for visitors of your home of all ages is a voice interface. The industry has realized this too and there are some major players focussing on voice interaction. Take Apple for example: the only way to control your HomeKit devices is with Siri. Amazon has taken it one step further with the Amazon Echo, providing an always-listening connected speaker/microphone for the living room. I expect a lot more companies to join this segment in 2016.
+ +Voice interfaces are not perfect either. The speed at which you can issue commands is low because you have to wait for a response. There are also issues with the discoverability of commands, recognition of accents and dependency on the cloud for processing your voice. I believe that all but the first one are problems that are going to be solved eventually.
+ +This however doesn’t mean there isn’t a place for apps, there definitely is. They are perfectly well-suited for checking in while you’re away, browsing the state changes of your house or making the lights go all funky when there are kids visiting.
+ +The cloud is a magical thing. Somewhere in the world there are computers collecting the data that your house generates, testing them against your automation rules and sending commands back when needed. The cloud will receive updates and improve itself over time so it is able to serve you better. Until it’s not. There are many reasons why your home might lose its connection to the cloud. The internet can stop working, an update might have gone wrong or the servers running the cloud crash.
+ +When this happens, your house should be able to keep functioning. The cloud should be treated as an extension to your smart home instead of running it. That way you’ll avoid awkward situations like when Amazon AWS was down and the Amazon Echo stopped working.
+ +Good home automation never annoys but is missed when it is not working.
+ +Thanks to Chris LaRose for this feedback and comments.
+Another sprint has come to an end and it seems that we have not slowed down a single bit 🚀. 0.12 is full of new components, platforms and organizational additions.
+ +I would like to give a shout out to Greg Dowling (@pavoni) as every release includes new work from him. He is constantly adding support for new platforms or improving the reliablity of existing components and platforms. Keep up the good work!
+ +This release includes a very frequent requested feature: the ability to organize entities in different tabs in the frontend. See the demo to see this in action and read more in the group documentation how to get started.
+ +
+
+Example of the new views in the frontend. Learn more.
+
/5) (@kennedyshead)homeassistant, switch, light and media_player (@rmkraus)This is a guest post by Home Assistant users Jeremiah Wuenschel and St. John Johnson.
+ +So you own a SmartThings Hub. You probably bought it when you were looking to get into the whole Home Automation hobby because it worked with pretty much everything and offered you the ability to automate anything. After a week of ownership, you realized that building dashboards and automating required writing way more Groovy then you expected. Then one day you were browsing reddit and discovered the amazingness that is Home Assistant! A solution that offered dashboards, graphs, working support for Nest, and REAL EASY automation!
+ +You spent your weekend getting everything set up, showing it off to your significant other, but in the end you got stumped when it came to integrating with all your existing SmartThings toys. What do I do now? Should I buy another hub? Should I just buy a Z-Wave stick?
+ +That’s where we came in. We wanted a solution that can bridge the awesomeness of Home Assistant with the SmartThings hub that works with almost everything.
+ +
+ 
+
This is going to be a pretty detailed tutorial on setting up our SmartThings bridge. However, there are a couple key terms that might be new to you:
+ +Assuming that you already have Home Assistant and Smart Things running, you will first want to get an MQTT broker running. There are a handful of MQTT brokers available in Open Source land. We chose Mosca for its simplicity.
+ +There is very little you need to do to get Mosca running. The easiest approach is to use Docker, and run a command like the following:
+ +$ docker run \
+ -d \
+ --name="mqtt" \
+ -v /opt/mosca:/db \
+ -p 1883:1883 \
+ matteocollina/mosca
+This will start Mosca up inside of a docker container, while keeping persistent storage for Mosca in /opt/mosca. The default configuration is the only thing we need to get things up and running.
If you don’t want to mess with Docker and can get node.js installed without trouble, the standalone instructions are all you need.
+ +This is the small piece of magic that bridges the gap between MQTT and SmartThings. It is a node.js app, and like Mosca it is probably easiest to install with Docker:
+ +$ docker run \
+ -d \
+ --name="mqtt-bridge" \
+ -v /opt/mqtt-bridge:/config \
+ -p 8080:8080 \
+ stjohnjohnson/smartthings-mqtt-bridge
+The code for this bridge is on Github if you want to start it up independently.
+ +The MQTT Bridge only needs to know where your MQTT broker lives. If you are using these docker commands as-is, edit /opt/mqtt-bridge/config.yml to look like this:
---
+mqtt:
+ host: <IP of the host>
+Restart the bridge, and you are ready to go:
+ +$ docker restart mqtt-bridge
+The next step (and possibly the most confusing) is the device type. Go to the Smart Things Device IDE and Create New Device Handler. Choose From Code and paste in the MQTT Bridge Device Code. Click Save, Publish, and then For Me.
Now to install your new Device Handler. Go back to My Devices in the IDE, and click New Device. Enter a name, and pick any random set of characters for the Device Network Id (this will automatically update later). For Type, scroll to the bottom of the list and find your newly created MQTT Bridge. Fill in the other boxes however you like.
Go back to My Devices, and click on your new device in the list. This will bring up a page that allows you to edit your device’s Preferences. Click edit and fill in the 3 pieces of information it asks for.
This will create the link between SmartThings and the MQTT Bridge.
+ +The last step is to setup the SmartApp. After this, any registered devices will start sending their events to MQTT.
+ +Go to the Smart App IDE. Click New SmartApp, followed by From Code. Paste in the MQTT Bridge SmartApp code and click Save. Click Publish and then For Me. In the SmartThings mobile app, add the new SmartApp and configure it with your devices and MQTT Bridge device. Clicking done will subscribe SmartThings to your MQTT broker and begin 2-way propagation of events.
To add SmartThings devices to Home Assistant over MQTT, first enable MQTT in Home Assistant:
+ +mqtt:
+ broker: localhost
+Replace localhost with the location of the running MQTT Broker. Devices from the MQTT Bridge are published to the path smartthings/<Device Name>/<Atribute>
For example, my Dimmer Z-Wave Lamp is called “Fireplace Lights” in SmartThings. The following topics are published:
+ +| Topic | +Description | +
|---|---|
| smartthings/Fireplace Lights/level | +Brightness (0-99) | +
| smartthings/Fireplace Lights/switch | +Switch State (on/off) | +
Here is an example Home Assistant config:
+ +switch:
+ platform: mqtt
+ name: "Fireplace Lights"
+ state_topic: "smartthings/Fireplace Lights/switch"
+ command_topic: "smartthings/Fireplace Lights/switch"
+ brightness_state_topic: "smartthings/Fireplace Lights/level"
+ brightness_command_topic: "smartthings/Fireplace Lights/level"
+ payload_on: "on"
+ payload_off: "off"
+ retain: true
+We recommend retain: true for every MQTT device in order to keep states in sync when things become disconnected.
Start digging through the MQTT Components in Home Assistant to find which components map to the new events being published to MQTT.
+ +Our personal preference for starting the whole suite of software is to use a single Docker-Compose file. Just create a file called docker-compose.yml like this:
mqtt:
+ image: matteocollina/mosca
+ ports:
+ - 1883:1883
+
+mqttbridge:
+ image: stjohnjohnson/smartthings-mqtt-bridge
+ volumes:
+ - ./mqtt-bridge:/config
+ ports:
+ - 8080:8080
+ links:
+ - mqtt
+
+homeassistant:
+ image: homeassistant/home-assistant:latest
+ ports:
+ - 80:80
+ volumes:
+ - ./home-assistant:/config
+ - /etc/localtime:/etc/localtime:ro
+ links:
+ - mqtt
+This will start home-assistant, MQTT, and the Bridge, in dependency order. All config can reference the name of the docker container instead of using IP addresses (e.g. mqtt for the broker host in Home Assistant).
+ +HTTP Endpoint: There are really only 2 ways to communicate with the SmartThings hub that we could find. The easiest approach is to create a RESTful SmartApp authenticated with OAuth that provides state changes via HTTP directly. This approach is pretty straightforward to implement, but it requires communication with the SmartThings cloud service, and can’t be done entirely on your LAN. We hoped to keep all communication internal, and came up with a second approach.
+ +Custom Device Type: SmartThings custom device types allow developers to define handlers for HTTP events received directly over the local network by the SmartThings hub. Messages received are authenticated by MAC address, and can contain arbitrary strings in their payload. Since a Device Type is only ever tied to a single device, we need to add a SmartApp to the mix in order to translate events between individual devices and our special Home Assistant Bridge device. Here is what we have so far:
+ +Z-Wave Switch |
+Zigbee motion sensor |<---> Bridge App <---> Bridge Device Type <---> <Local network>
+Z-Wave light bulb |
+On the Home Assistant side, there is a powerful platform available based on the MQTT lightweight message bus protocol. Everything from lights to switches to temperature sensors can be defined in Home Assistant as an MQTT component, so it makes for a convenient integration point. This requires an MQTT broker for handling the message bus, and one last piece to translate between the HTTP that SmartThings supports and MQTT.
+ +Here is the final sequence of events:
+ +
+
+ 
+
+ SmartThings Bridge Sequence
+
There are a lot of stops along the way for these events, but each piece is a simple translation layer to shuttle the events between systems.
+ +The core of home automation is knowing what’s going on. The faster we know about a state change, the better we can serve the user. If you want to have your lights to turn on when you arrive at home, it doesn’t help if it only knows about it after you’ve already opened the door and manually (!!) turned on the light.
+ +Each smart device consists of the ‘normal’ device and the piece that makes it ‘smart’: the connectivity. The connectivity part of a device can consists of either control, state or both.
+ +State describes what a device is up to right now. For example, a light can be on with a red color and a medium brightness.
+ +Control is about controlling the smart device by sending commands via an API. These commands can vary from configuring how a device works till mimicking how a user would interact with a device. A media player can allow skipping to the next track and a sensor could allow to configure its sensitivity or polling interval.
+ +The Home Assistant APIs are setup to be as convenient as possible. However, a network is always as weak as it’s weakest link. In our case these are the integrations. Take for example controlling a light that does not report state. The only state Home Assistant can report on after sending a command is the assumed state: what do we expect the state of the light to be if the command worked.
+ +We want our users to get the best home automation experience out there and this starts with making sure they have devices that work well with Home Assistant. That’s why we will start applying the following classifiers to our integrations:
+ + +| Classifier | +Description | +|
|---|---|---|
| + | Assumed State | ++ We are unable to get the state of the device. Best we can do is to assume the state based on our last command. + | +
| + | Cloud Polling | ++ Integration of this device happens via the cloud and requires an active internet connection. Polling the state means that an update might be noticed later. + | +
| + | Cloud Push | ++ Integration of this device happens via the cloud and requires an active internet connection. Home Assistant will be notified as soon as a new state is available. + | +
| + | Local Polling | ++ Offers direct communication with device. Polling the state means that an update might be noticed later. + | +
| + | Local Push | ++ Offers direct communication with device. Home Assistant will be notified as soon as a new state is available. + | +
The background to how we got to these classifiers can be read after the break. +
+ +How state is communicated can be broken down into 5 categories. They are not mutually exclusive - a device state can be available both via the cloud and local connectivity.
+ +These are devices that do not have the capabilities to make their state available. They only allow to be controlled. For example, devices with infrared remote controls like TVs and ACs. You can press the turn on button on the remote but can only assume that your command was received and executed successfully. The device might not be powered or something is blocking the infrared receiver.
+ +Home automation will have to approach such devices based on the assumption that it’s commands are received correctly: using optimistic updates. This means that after sending a command it will update the state of the device as if the command was received successfully.
+ +Advantages:
+ +Disadvantages:
+ +These are devices that will only report their state to their own cloud backend. The cloud backend will allow reading the state but will not notify when a new state has arrived. This requires the home automation to check frequently if the state has been updated.
+ +Advantages:
+ +Disadvantages:
+ +All off the previous section applies to this one. On top of that the cloud will now notify the home automation when a new state has arrived. This means that as soon as the cloud knows, the home automation knows.
+ +Advantages:
+ +These devices will offer an API that is locally accessible. The home automation will have to frequently check if the state has been updated.
+ +Advantages:
+ +Disadvantages:
+ +The best of the best. These devices will send out a notice when they get to a new state. These devices usually use a home automation protocol to pass it’s message to a hub that will do the heavy lifting of managing and notifying subscribers
+ +Advantages:
+ +Disadvantages:
+ +Controlling a device can, just like state, be done through cloud and/or local connectivity. But the more important part of control is knowing if your command was a success and the new state of the device.
+ +These devices are not able to be controlled. They will only offer state.
+ +These devices will require the state to be polled after sending a command to see if a command was successfull.
+ +Advantages:
+ +Disadvantages:
+ +These devices will not return a new state as a result of the command but instead will push a new state right away. The downside of this approach is that we have to assume that a state update coming in within a certain period of time after a command is related to the command.
+ +The very best. These devices will answer the command with the new state after executing the command.
+ +Home Assistant tries to offer the best experience possible via its APIs. There are different ways of interacting with Home Assistant but all are local.
+ +The focus of 0.13 was on test coverage, big cheers to @rmkraus for his hard work on this. I’m proud to announce that we’ve hit the 90% test coverage of the core + important components. A big milestone for the project.
+ +
+ 
+ Examples of the new input_select and weblink components.
+
Not only did we gain a lot of test coverage, we also attracted a lot of new developers that contributed a variety of components and platforms:
+ +
Would you like to listen to music in every room in your home, controlled from one source? Then multi-room audio is for you.
+ +Multi-room audio can be achieved by having a computer attached to speakers in every room. On each computer, services run to play and/or control the audio. With this DIY approach, the kind of computer and speakers is very much up to you. It could be your desktop computer with attached powered speakers, your HTPC hooked up to your TV and receiver, a Raspberry Pi with Amp or DAC, or even an Android device.
+ +You’ll need two key software packages, besides Home Assistant. The first is Mopidy, a music server that can play local files, or connect to streaming music services like Spotify. The second is Snapcast, which enables synchronized audio streaming across your network. Both can be integrated into Home Assistant. Each room audio device will run an instance of the Snapcast client, and optionally a Mopidy instance. Your server will run a special instance of Mopidy and the Snapcast server.
+ +Finally, you also need a player to control Mopidy. Any MPD-compatible player will work, and there are several Mopidy-only web-based options available. On Android, Remotedy is particularly nice since you can access multiple Mopidy instances in one place.
+ +Home Assistant will provide device status, and volume control for each room. If you want to play music in all your rooms (on all your clients), access the server instance of Mopidy. If you want to play music only in a specific room, access that specific Mopidy instance. If you’re using a web UI for Mopidy, you can add links to each instance in Home Assistant with the weblink component.
+ +
+ 
+
Mopidy can be run with multiple configuration files, each extending the previous file. This is helpful when we’re running multiple instances with varying functionality.
+ +The core configuration is shared between all instances:
+ +[mpd]
+hostname = ::
+
+[http]
+hostname = ::
+
+[audio]
+output = alsasink
+
+[spotify]
+username = <redacted>
+password = <redacted>
+Add the local configuration on computers that have local media files:
+ +[local]
+media_dir = <your/music/here>
+Finally, the Mopidy instance that connects with Snapcast needs special configuration. Run on a different port to avoid conflicts if you have a second Mopidy instance running on your computer. The audio output is sent to a named pipe - Snapcast will read from there. Note that you may have to adjust the audio output attribute depending on your system and audio sources.
+ +[mpd]
+hostname = ::
+port = 6601
+
+[http]
+hostname = ::
+port = 6681
+
+[audio]
+output = audioresample ! audio/x-raw,rate=48000,channels=2,format=S16LE ! audioconvert ! wavenc ! filesink location=/tmp/snapfifo
+To run a room-specific instance:
+ +$ mopidy --config $CONF_DIR/core.conf
+To run a room-specific instance with local media:
+ +$ mopidy --config $CONF_DIR/core.conf:$CONF_DIR/local.conf
+To run the special Snapcast-connected instance (with local media):
+ +$ mopidy --config $CONF_DIR/core.conf:$CONF_DIR/local.conf:$CONF_DIR/snapcast.conf
+Start the snapserver on the same server running Mopidy with the snapcast configuration.
$ snapserver # or use systemd
+Start the snapclient on computers that will be playing audio.
$ snapclient # or use systemd, add -h <server host> if necessary
+There are a number of snapcast configuration options, but the one relevant to Home Assistant is the client names. You can set them in the snapserver configuration file, by default located at ~/.config/Snapcast/settings.json. Only edit this file while the snapserver is not running. Modify the name JSON value to your liking - this is how the client will be named in Home Assistant.
Use the mpd and snapcast components. Optionally, use weblink to provide easy access to a Mopidy web UI.
+ +media_player:
+- platform: snapcast
+ host: xxxxx
+- platform: mpd
+ server: xxxx
+ location: Multi-Room Controller
+- platform: mpd
+ server: xxx
+ location: Room 1
+
+weblink:
+ entities:
+ - name: Multi-Room Player
+ url: xxxx
+Home Assistant land has been busy and a lot of people have been creating awesome stuff. We’ve added a cookbook section to the website full of examples how you can automate different things. Make sure you take a look and share your own recipes too!
+ +Haaska allows you to control lights, switches, and scenes exposed by your Home Assistant instance using an Amazon Echo. This is different from our own Alexa component because it will teach the Amazon Echo directly about the devices instead of teaching it to talk to Home Assistant. It will not allow you to use custom sentences but it will allow you to skip the ‘Ask Home Assistant’ part when giving commands:
+ +Contributor Maddox has created a plugin for HomeBridge, an open-source HomeKit bridge. This will allow you to control your home using Siri on your Apple devices. HomeBridge has recently restructured so you’ll have to install the plugin separately with the homebridge-homeassistant npm package.
+ +Example config.json entry to load Home Assistant:
+ +"platforms": [
+ {
+ "platform": "HomeAssistant",
+ "name": "HomeAssistant",
+ "host": "http://192.168.1.50:8123",
+ "password": "xxx",
+ "supported_types": ["light", "switch", "media_player", "scene"]
+ }
+]
+HomeBridge on GitHub +HomeBridge Home Assistant Plugin
+ +User thaijames describes in the Home Assistant forums how he has created his own NFC-based alarm system using Home Assistant, DIY components and Garfield dolls.
+ +
+
+Hold your NFC tag against the belly of Garfield to unlock the alarm.
+
It’s been another two weeks which means it’s time for release: 0.14!
+ +
for config parameter to only trigger when a state hasn’t changed for a certain period of time (@pavoni, @stefan-jonasson)
+ 
+ Camera feeds are now directly embedded in the frontend.
+
command_line.Two weeks has past so here is 0.15! We have been focussing a lot on quality. Making sure the system is more stable and reliable. I usually try to highlight one cool thing in the release notes but this release has 4 exciting announcements!
+ +Besides bug fixes, this release also brings:
+ +
# Example using templates for service and data in service call.
+# Works for automation, Alexa, universal media player, template switch.
+automation:
+ - trigger:
+ - platform: state
+ entity_id: switch.bathroom
+ action:
+ service_template: >
+ {% if is_state('switch.bathroom', 'on') %}
+ switch.turn_on
+ {% else %}
+ switch.turn_off
+ {% endif %}
+ data_template:
+ entity_id: switch.{{ states('input_select.is') }}
+media_content_type and media_content_id, to match the corresponding media
+player state attributes. This change affects automations, scripts and scenes.Party people, 0.16 is here! The big thing with this release is that we have completely removed the barrier to get started by MQTT by being able to launch an embedded MQTT server: hbMQTT. Just add mqtt: to your config and a broker is launched and connected with Home Assistant. See the documentation for more info.
Further in this release a bunch of cool new stuff, bug fixes and rewrites for the Vera and Tellstick component (see breaking changes section at bottom for this!).
+ +Rock on.
+ +
Automation: support for old deprecated config has been removed
+Tellstick configuration has changed
+tellstick:
+ signal_repetitions: X
+vera:
+ vera_controller_url: http://192.168.1.161:3480/
+ # Optional to exclude devices - this is a list of vera device ids
+ exclude: [ 13, 14, 16, 20, 23, 72, 73, 74, 75, 76, 77, 78, 88, 89, 99]
+ # Optional to import switches as lights - this is a list of vera device ids
+ lights: [15, 17, 19, 21, 22, 24, 26, 43, 64, 70, 87]
+Today the news spread that Google will be shutting down the Revolv hubs. And shutting down here doesn’t mean they stop selling or supporting them - no, they are sending an update to each hub to turn your perfectly fine home automation hub into a useless piece of plastic. The fact that this seemed like a good idea by Google astonishes me. If anything, they should have gone the same route as ninjasphere: open it all up and let people decide on the fate of their own hub.
+ +I’ve said it before but I’ll repeat it again:
+ +++ +The cloud should be treated as an extension to your smart home instead of running it.
+
Your hub should not be affected when your internet breaks down or the company that sold you your hub goes out of business. It should work locally so that it can continue to work even long after the vendor goes out of business or decides to kill it. Preferably, your hub should also be open so that the community can take over development after the vendor stops caring.
+ +Unless you can afford losing a product here and there, be cautious when buying IoT products that depend on the cloud from companies that are not well established. The chances are high that they go bankrupt or get acquired and closed. This however is easier said than done as Gartner predicts that by 2017, 50 percent of IoT solutions will originate in startups that are less than three years old.
+The frontend of Home Assistant is served with the help of a local web server. If you have customized your installation you already use this functionality. The content of your folder www in your Home Assistant configuration directory (.homeassistant) is available under /local (eg. https://localhost:8123/local).
But there is more you can do! You can not only host images for customization there but HTML files or even web applications including CSS and Javascript.
+ +
+
+
In the past the buzz word “Smart mirror” was used a couple of times in our chatroom and even made it into the issue tracker. The existing solutions (Smart mirror, MagicMirror, and HomeMirror) seems to be overkill if you already have Home Assistant running somewhere in your house or apartment. Why not simple display a web page served by Home Assistant on the tablet? No app and no Raspberry Pi running in the background.
+ +There are plenty of ways to achieve this…RESTful API, Python API, or one of the history components. If it is to be a web page I’m using the MQTT Eventstream component and mqttws31.js.
+ +The HBMQTT broker provides websockets support for MQTT and mqttws31.js included in web page gives you access to the MQTT messages. It’s a matter of minutes. OK, it took a little longer because I’m not a Javascript guy to create the software part that will show details about your environment. The source is available at https://github.com/fabaff/home-assistant-display and the screenshot above shows the result. I guess that every person who is familiar with Javascript would be able to reduce the amount of code and to make it more flexible. Well, it’s a only prototype and showcase to include an image in this blog post.
+ +I hope that this little article could give you an idea of extending Home Assistant in an unconventional way.
+Another awesome release ready to hit your homes. YAML can be hard for beginners and more experienced automators. So to help catch those pesky errors that sneak into your files we’ve been hard at work to introduce config validation! Especially huge thanks to @jaharkes for his hard work on this. Config validation is still in it’s early stages. More common platforms and components have been added but we didn’t do everything yet.
+ +When we encounter an invalid config we will now write a warning to your logs. You can see those in the frontend by clicking on the last developer tool. We’re looking into options to make it more clear - it is a work in progress.
+ +Another big thing is the addition of GTFS support. You probably don’t know it, but GTFS is the standard that public transit companies all over the world use to distribute their schedule. This means that you can now have the time of the next bus/train/etc right in your frontend.
+ +
As of now we are not aware of any breaking changes. However, it might be that Home Assistant will not start for you because of an invalid configuration. A common mistake that people are making is that they are still referring to execute_service in their script configs. This should be service.
One of the main complaints that we receive is something along the lines “I read that X is possible yet I am unable to find it on the website.”. This post is to announce that we have taken the first steps to improve it by revamping the getting started and developers sections. It’s still a work in progress but we now have a solid foundation to build on for the future 👍.
+ +Our documentation has been going through various phases. Initially it was just the README in our GitHub repository. I discovered Jekyll and GitHub pages in December 2014 and created home-assistant.io. I more or less broke the README in 5 pages and called it a website. Back then we had a whopping 11 components.
+ +As Home Assistant grew, so did our documentation. Fabian Affolter does an amazing job in making sure there is at least a documentation stub for each new feature that lands. And that’s quite a feat given our frequent releases! But despite all the efforts, the documentation outgrew our existing documentation organisation.
+ +Today it has been almost 1.5 years since we started the website. We now have 264 components and platforms under our belt and have been honored with 1.5 million page views ✨. And hopefully we now also have documentation that our community deserves.
+ +Finally, if you see some content that could use more clarifcation or is outdated, don’t hesitate to use the ‘Edit in GitHub’ link that is present on each page.
+After 2.5 years I think we can proudly say: Home Assistant is a success. I write we because Home Assistant is no longer a one-person side project. It has become the side project of many people who spend countless hours on making Home Assistant the best home automation software out there. To acknowledge this we migrated the repositories from being under my name to be under our own organisation on GitHub.
+ +On our journey we’ve reached many noteworthy milestones:
+ +All these accomplishments are a nice pat on the back but our journey is far from over. There are a lot of challenges ahead if we want to become the go to solution for home automation for everyone.
+ +Until now the focus has been on making a platform that developers love to use. A platform that is simple but customizable. A platform that is both powerful and reliable. But most important: a platform that is local and open. Home Assistant does a great job at all these things.
+ +There will be some major challenges ahead of us to target groups other than developers. Easy installation and easy configuration being the #1. I’m sure that we’ll be able to eventually achieve these goals. I can’t say yet how or when. As with everything Home Assistant, we’ll take tiny steps, gathering feedback along the way to make sure we’re solving the right problems.
+ +I am confident that we will get there because we are set up for success: we have a robust architecture, high test coverage and an active community of world class developers and users. On top of that, we use Python which allows us to move fast and tackle complex problems in elegant ways. It is so easy to learn that it allows any programmer, experienced or not, to contribute support for devices and services. It’s as simple as filling in the blanks.
+ +I would like to put out a big thank you to all our contributors who make Home Assistant what it is today. It doesn’t matter if it is form of code, documentation or giving support in our chat room or forums. You. all. rock.
+ +Cheers to the future!
+ +Paulus
+It’s time for 0.18. This release cycle is 2 days shorter than usual as I’ll be travelling to Europe. This also means that it can take some more time before you get feedback on PRs.
+ +Since the last release we have moved all Home Assistant source code etc into it’s own organisation on GitHub. We’re growing up! This sadly did cause us to have to move all Docker images. Check the breaking changes section for more info.
+ +
TEMP_CELCIUS is now correctly called TEMP_CELSIUS. Old one is deprecated and will eventually be removed.homeassistant/home-assistant:latest for the latest release and homeassistant/home-assistant:dev for the latest dev version.port: under gateways to device:.This post is by Home Assistant contributor Greg Dowling.
+ +In 2013 Apple introduced iBeacons: a class of Bluetooth low energy (LE) devices that broadcast their identifier to nearby devices, including most smartphones. At first glance it’s hard to imagine why they might be useful. In this two part blog I’ll try and explain why they are useful and how you can use them with Home Assistant.
+ +The reason I started using iBeacons was to improve presence detection (and I think that’s the case with most people) so that’s what I’ll discuss in part 1. In part 2 I’ll talk about using iBeacons to track devices that can’t track themselves.
+ +When you use OwnTracks in standard major move mode (which is kind to your phone battery) it sometimes fails to update when you’d like it to. In my case I found that it would often send a location update as I was on my way home, but then not update when I got home. The result would be that Home Assistant would think I was 500M away from home, and take quite a while to notice I was home. It would also mean that the automation that should turn on my lights when I got home didn’t work very well! There were a few times when my phone location updated at 2am and turned the lights on for me. Fortunately my wife is very patient!
+ +Luckily, OwnTracks supports iBeacons so I could use them to make presence detection more reliable. When OwnTracks sees a beacon it recognises, it will send an update. This means that if you put a beacon at your front door - OwnTracks will see it within a few seconds of you arriving home - and send an update saying it has seen this iBeacon.
+ + + +To do this you first need to set up MQTT and OwnTracks in Home assistant - and make sure that HA can track your phone.
+ +You then have to (A) tell Home Assistant where the beacon is located and (B) tell OwnTracks to recognise the beacon.
+ +You tell HomeAssistant about fixed locations by creating a Zone with the longitude and latitude of your beacon. You should also give the zone a name which you will also use when you set up OwnTracks. An an example this zone specifies the location of my drive way.
+ +Example configuration.yaml entry
+zone:
+ - name: 'Drive'
+ latitude: XXX
+ longitude: YYY
+ radius: 100
+The radius isn’t used by the beacon code, but it is used by the GPS location sensing code. I’ll come back to this a little later. For now just use 50 or 100.
+ +Once you’ve created the zone - you need to restart HA. The next step is:-
+ +Regions menu at the bottom of the screen+ symbol at the top right of the screen-drive ’(start the name with a - see below for the reason)OnCircular Region sectionUUID of your beacon - this may be written on your beacon - or you can copy it from the management app that came with your iBeacon device. It’s a long number – so it’s easier to copy if you can!Minor and Major numbers for your iBeacon - or leave them at 0 which will match all beacons with that UUID
+ 
+
Once you’ve added the iBeacon - you should be able to see it on the OwnTracks region screen. If your phone can see the packets from that beacon, OwnTracks will turn the relevant Region red.
+ +
+ 
+
When OwnTracks sees the beacon (and turns the region red), it also sends an MQTT packet to HA to say that you have entered that region.
+ +The result of the configuration above would be to set the location of device.phone to Drive , (and the GPS location to XXX,YYY) when your phone sees the beacon.
So with the steps above you should be able to improve the reliability of tracking your phone - and send timely updates to HA. I did this for my home - and the lights now turn on before I reach the house on foot. If I arrive by car they turn on within a few seconds of arriving, before I can get to the front door.
+ +I’m also pleased to say I no longer get an arrive home event at 2am that turns the lights on. I hope I’ve convinced you that iBeacons are worth trying!
+ +You will probably use beacons to make entry into your existing GPS zones more reliable. By default either a beacon or a GPS location can cause you to enter a zone - and HA has some logic that should make them two work well together (it ignores GPS updates when you’re in an iBeacon Zone).
+ +However you can also use beacons for situations where GPS doesn’t work well.
+ +This might be because the zones are too close together - or even on top of each other! +For example, my wife works next door - and I couldn’t detect whether she’s at home or in the office via GPS because the accuracy wasn’t high enough. However I can do this by using two beacons.
+ +To make this type of presence detection work you need to turn GPS off for a zone in Home Assistant by making them passive. This is important because otherwise HA will try to decide between two close together zones without enough data. This doesn’t work well.
A passive zone can only be entered via an iBeacon, so a GPS location update will always pick the other zone.
+ +I set up my Home zone to be a standard region, and my office zone to be passive, so the home zone can be entered in the normal way via either GPS or a Beacon.
+ +Example configuration.yaml entry
+zone:
+ - name: 'Office'
+ latitude: XXX
+ longitude: YYY
+ radius: 3
+ passive: true
+You could use this technique to try to detect which room someone is in. This might allow you to notice whether someone is in the living room or the bedroom - even though one is above the other (although beacon packets do pass through walls and floors).
+ +To get this to work you’ll probably need to experiment with the beacon signal strength to try to match the beacon reception area to the location you want to track. Let me know if you get this to work (it doesn’t make sense in my open plan house)
+ +Presence tracking sounds easy - and it’s an important part of Home Automation. Trying it shows how difficult it is to get presence detection right. I’ve found that iBeacons have improved the reliability and timeliness of knowing where I am, and I hope I encouraged you to try them too.
+ +You can find out more about configuring the OwnTracks application and beacons here
+ +There is information about configuring Homeassistant to use beacons here
+ +Owntracks treats a region name with a leading - as a hint that it shouldn’t disconnect after a single missed packet. This improves the ability to keep a connection to a beacon.
However, even when using this feature I’ve noticed that you can still lose connections (although it seems to vary by beacon manufacturer and type - I’ll talk more about this in part 2). This means that it’s best to take into account that you may see false enter/leave events in HA. You may be able to improve this by changing how often the beacons send packets - and by increasing the signal strength (both will drain your beacon batteries more quickly). You can usually change these parameters in the app supplied by the iBeacon maker. You can also find some high power beacons (which have worked well for me).
+ +In automations you can use a for: to avoid triggering during a brief disconnect, or use a script with a delay. Stay tuned for part 2 for an example of this.
iBeacons have a UUID (usually set to the same value for beacons from the same manufacturer), as well as a minor and major number. If you set two beacons to have exactly same details then OwnTracks will think multiple beacons are at the same location.
This means you can have more than one beacon around your home - and a connection to any of them will count as home to OwnTracks and HA. This reduces disconnections.
You can achieve the same effect by using the same the same UUID but different major / minor numbers - and tell OwnTracks not to worry about the minor / major numbers for a particular region by setting them to 0).
Make sure to also check out part II where I talk about how to use iBeacons to track any object.
+At the beginning of April I gave a talk about Home Assistant at the OpenIoT summit in San Diego. I talk about the Home Assistant architecture and explain how to get started integrating your devices. Big thanks to my employer AppFolio (we’re hiring!) for letting me attend. Slides.
+ +This release is big. Until now, our automations and scripts have been very static. Starting today it should all be a bit more dynamic.
+ +Scripts are now available in automations and when responding to Alexa/Amazon Echo. Both of these components will now expose data to be used in script templates (including from_state !). Passing data to script entities is available by passing the data to the script services.
automation:
+ trigger:
+ platform: mqtt
+ topic: some/notify/topic
+ action:
+ service: notify.notify
+ data_template:
+ message:
+
+automation 2:
+ trigger:
+ platform: state
+ entity_id: light.hue
+ action:
+ service: notify.notify
+ data_template:
+ message: is now
+Entity Namespaces allow you to influence the entity ids for a specific platform. For example you can turn light.living_room into light.holiday_home_living_room with the following config:
light:
+ platform: hue
+ entity_namespace: holiday_home
+trigger variable to script templates (@balloob)and and or to combine conditions (@balloob)!env_var (@bah2830)as_timestamp method now available (@srcLurker)/api/discovery_info] with basic instance info (@robbiet480)condition: instead of platform:. For example condition: state.Old RFXtrx config format:
+ + devices:
+ 123efab1:
+ name: My DI.0 light device
+ packetid: 1b2200000890efab1213f60
+New RFXtrx config format:
+ + devices:
+ 1b2200000890efab1213f60:
+ name: My DI.0 light device
+Ben from BRUH Automation authors a lot of great video’s about how he is using Home Assistant and how you can get started with it too. The video below will walk you through how to configure Home Assistant. Enjoy!
+ +Make sure to subscribe to his YouTube channel for more Home Assistant video’s.
+ +I’ve been planning to write this post for a while now as we get questions like this a lot: “Why does Home Assistant use Polymer? Why not React, Redux and what not?”
+ +It’s understandable, Polymer is quite the underdog in the world of web frameworks. A corporate backer does not guarantee popularity or an active community and this shows in the number of projects using Polymer.
+ +Still, we use Polymer and it’s awesome. To explain why, I’ll be referencing the React workflow quite a bit, as they do a lot of things right, and show how it is done in Polymer.
+ +Polymer gives us components for the web, just like React, but based on web standards: web components, CSS variables. These standards don’t have wide browser support yet but it’s being implemented by every major browser: It’s the future. For now they are being polyfilled and that works just fine but in the future the Home Assistant web app will be able to run native in the browsers == fast.
+ + + +Polymer does not have the nice developer experience that one can have with React and the React Dev Tools but that’s a matter of time. The developer tools in every browser have seen a lot of improvements recently and each improvement helps support for web components.
+ +Another major benefit of Polymer for Home Assistant is that we get material design for free. The material design components that come with Polymer have a very high quality. Google is using these components themselves and make sure that performance and accessibility using screen readers/keyboards are great. As an open source project, the more we can outsource, the better - so our contributors can focus on the core product: home automation.
+ +What about Flux, data management and interaction between components? It’s actually pretty similar to React or any other component based framework. Flux-like architectures work with Polymer just like with React: whenever data changes it will update the attributes of a component which will propagate to the children. For Home Assistant we use NuclearJS with our own Polymer bindings. For data moving from child to parent the Polymer pattern is using DOM events instead of callbacks but the end result is the same. It is so similar in fact, that it took me only two hours to make a React Native frontend for on top of our core.
+ +So what about Babel and ES2015? Also this is covered. Each web component exists of a HTML template and a JavaScript class to back it. Think of the HTML template as the render method in React. In Home Assistant we have the HTML templates import one another and have a separate chain for the JavaScript classes backing each component. This allows us to use Babel and NPM modules for the JavaScript part (more info here). This does however come with the downside of other JS based frameworks: the browser blocks any painting while the JavaScript is being parsed instead of upgrading the website incrementally. This, however, is something we take for granted right now and hope that module bundlers will be able to solve this for us eventually. Tree shaking is a very promising improvement in this space.
+ +Most of this blog post has been comparing Polymer to React. In many ways Polymer is similar to React but it is not as far evolved yet. I like React but I do not see it as a technology that will be around forever. Given the trend of previous popular JS frameworks, React will probably get replaced by another framework that works even better. Web components however will be here forever as they are part of the HTML standard. And this gives us peace of mind at the virtual Home Assistant headquarters: we do not have to be afraid of having to rewrite our frontend just to stay relevant or because people don’t want to include another dependency just to run this legacy piece.
+ +So there it is, the reason why we use Polymer.
+
Tons of new supported things in 0.20.
+ +relative_time function to render ie. 7 seconds ago (@robbiet480)!include_dir_merge_list and !include_dir_merge_named (@happyleavesaoc)device_tracker:
+ platform: asuswrt
+ protocol: telnet
+We are always hard at work at the virtual Home Assistant headquarters to make it easier for you to get started with Home Assistant. That’s why @jbags81 recently introduced the all-in-one installer. It allows you to get up and running with a complete Home Assistant setup by entering one line of code into your Raspberry Pi running Raspbian Jessie:
+ +wget -Nnv https://raw.githubusercontent.com/home-assistant/fabric-home-assistant/master/hass_rpi_installer.sh && bash hass_rpi_installer.sh;
+This feature wouldn’t be complete if it wasn’t accompanied by a new video by Ben from BRUH Automation. The video shows how to install Raspbian Jessie on your Raspberry Pi and use the new installation script to get a full Home Assistant system up and running.
+ +This post is by Home Assistant contributor Greg Dowling.
+ +In Part 1 I talked about using iBeacons to improve presence tracking. In part 2 I’ll talk about how to track things like keys that can’t track themselves by using iBeacons.
+ +In the first part I mentioned that iBeacons just send out I’m here packets, and we used this to trigger an update when your phone came close to a fixed beacon.
+ +But beacons don’t have to be fixed.
+ +Your phone knows roughly where it is located (based on mobile phone masts, Wi-Fi networks or GPS). If your phone sees an I’m here message then it knows the beacon is close.
+ +If your phone can remember (or tell a server) where it was when it last saw the iBeacon - then it knows where the beacon was. So the result of this is that you can track where an iBeacon was - even though the iBeacon doesn’t have any tracking technology itself.
+ +So if you put an iBeacon on your keys or in your car - then you can track them.
+ +
+ 
+ Here are my keys - with a Estimote Nearable iBeacon stuck to them. Ugly but effective!
+
It’s easier to set up OwnTracks and HA to track a mobile beacon than the fixed beacon I discussed in Part 1, because you only need to tell OwnTracks about your iBeacon. You don’t need to configure HA at all.
+ +OwnTracks currently only supports mobile beacons on iOS.
+ +You set up the beacon the same way as we discussed in part 1. The only difference is that instead of calling the region the name of a location (eg -drive) you call it the name of the device you want to track (eg -keys). Remember the leading ‘-’ that makes the connection more reliable.
+ +
+
+
Once you’ve added the iBeacon - you should be able to see it on the OwnTracks region screen. If your phone can see the packets from that beacon, OwnTracks will turn the relevant Region red.
+ +Because you turned Share on for the region, when OwnTracks sees the beacon it will send HA a message. HA will use this message to add the beacon as a tracked device if it hasn’t seen it before. So you should see a new device appear in HA called device_tracker.beacon_[name] - and its location will be where your phone thought it was when it last saw the beacon.
+ +
+ 
+
If your phone moves and sends HA a new location while it is still in range of the beacon - HA will update the location of the beacon. So if go for a drive in your car - you will see both your phone and the device_tracker.beacon_car move together.
+ +If you park your car and go shopping - device_tracker.beacon_car will stop moving.
+ +With the basic tracking working - you can use automation to do things like open your gates if your car comes home
+ +automation:
+ - alias: 'Open gate'
+ trigger:
+ - platform: state
+ entity_id: device_tracker.beacon_car
+ from: 'not_home'
+ to: 'home'
+ condition:
+ - condition: state
+ entity_id: switch.gate
+ state: 'off'
+ action:
+ service: switch.turn_on
+ entity_id: switch.gate
+Or warn you if you leave your keys behind
+ +automation:
+ - alias: 'Forgotten keys'
+ trigger:
+ platform: template
+ value_template: '{{ states.device_tracker.greg_gregphone.state != states.device_tracker.beacon_keys.state}}'
+ condition:
+ condition: template
+ value_template: '{{ states.device_tracker.greg_gregphone.state != "home" }}'
+ action:
+ service: script.turn_on
+ entity_id: script.send_key_alert
+
+ - alias: 'Forgotten keys - cancel'
+ trigger:
+ platform: template
+ value_template: '{{ states.device_tracker.greg_gregphone.state == states.device_tracker.beacon_keys.state }}'
+ condition:
+ - condition: state
+ entity_id: script.send_key_alert
+ state: 'on'
+ action:
+ service: script.turn_off
+ entity_id: script.send_key_alert
+script:
+ send_key_alert:
+ sequence:
+ - delay:
+ minutes: 2
+ - service: notify.notify
+ data:
+ message: 'You forgot your keys'
+ target: 'device/gregs_iphone'
+(The delay is needed for two reasons: -
+Of course you can use both fixed and mobile beacons at the same time. I want my gates to open when I arrive home in the car - so I use an iBeacon in the car so that I can track the car, and a iBeacon on my drive so that a location update is triggered when I arrive. I’ve been experimenting with a high power beacon in a waterproof box on my drive which seems to work well to notice when I get home.
+ +
+ 
+
Long range / High power beacon
+ +
+ 
+
Waterproof beacon
+ +This isn’t a buyer’s guide, but I just wanted to mention the iBeacons I’ve been using. I think you should be able to use any iBeacon with HA and OwnTracks. You generally can’t buy beacons in your local electronics shop - so I just wanted to briefly mention the two suppliers I’ve used so far.
+ +I’ve bought quite a few iBeacons from a company called Blue Sense Networks. I work in the tech startup sector in the UK so I partly chose them because they are a local start-up who seemed worth supporting. The products, support and software all seem good. I use a number of their beacons - from a simple USB dongle, to a long range beacon. All their products have batteries that can be changed (or no batteries in the case of the externally powered USB device) - and you can configure all the parameters you’d want to using their software. I had one software issue, support got back to me at a weekend(!) - and the issue was resolved with a software release two days later.
+ +All the beacons seem fine - and the long range unit does work over a longer range than my other beacons.
+ +I bought some other beacons from a US/Polish startup called Estimote, who I think are better known. I bought a developer pack of 10 of their nearables which as well as being iBeacons also send out other data (orientation and motion) using their own protocol. This is interesting if you’re developing your own application, but for OwnTracks and HA they are just regular beacons. They are small and self adhesive - so you can stick them to things (like your keys). You can’t change all the parameters on these devices (UUID/Major/Minor are fixed) - and the batteries can’t be replaced. I also killed one of the estimote beacons (I assume the battery died) after I carried it around for a few months and dropped it many times! On the other hand they are well priced, small and waterproof!
+ +I’ve mainly used these as devices to track rather that location beacons. Estimote also sell some slightly larger iBeacons with replaceable batteries. Estimote support responded quickly and were helpful when I couldn’t work out how to edit their beacon’s parameters (although the answer was you can’t yet).
+ +The larger Blue Sense Network beacons seem to be better at maintaining a connection that the Estimotes - although that might be because I’m reluctant to turn the power to maximum and reduce the gap between sending packets on the Estimotes where I can’t replace the batteries!
+ +As I said in part 1, I’ve found iBeacons to be a good way of improving presence detection. I also used them to track devices like my car and my keys that can’t track themselves.
+ +I’m still experimenting, so I hope I can do more with iBeacons. I hope I’ve encouraged you do so the same. If you do please share your experiences.
+ +Please see the notes at the end of Part 1 for documentation information.
+Our community is amazingly helpful and creative. If you haven’t been there yet, make sure to stop by our chat room and come hang out with us. In this blog post I want to highlight a few recent awesome projects and videos from the community.
+ +SceneGen is a new command line utility developed by Andrew Cockburn that helps with creating scene configurations for Home Assistant. To use it, you put your house in the preferred state, run SceneGen and it will print the scene configuration for your current states.
+ +Nick Touran has been working on integrating IR remotes with Home Assistant. He made it into a component which should be available in the next release which should arrive in a couple of days. In the meanwhile, he wrote up a blog post and has put out a video showing the new integration, very cool!
+ +Ben from BRUH Automation has put out another great video how to get started tracking your location in Home Assistant using MQTT and OwnTracks.
+ +Muhammed Kilic has created a video how to make your Home Assistant instance accessible from the internet using the free dynamic DNS service DuckDNS.
+ +It’s time for release 0.21 and it contains massive core improvements: replacement of our home grown HTTP stack with a standardized WSGI stack. This will improve performance, speed, security and make future development of advanced HTTP features a breeze.
+ +This work was driven by the amazing Josh Wright. His knowledge, high standards and drive for security has helped improve Home Assistant a lot ever since he started helping out. Hip hip hurray for Josh!
+ +Alright, time for the changes:
+ +
frontend: to serve the frontendWe released two hotfixes to address some issues that couldn’t wait till the next release.
+ +It’s been already almost two weeks ago that a few of the Home Assistant developers headed towards Portland for PyCon 2016 - the conference about everything Python. We were there to learn all the nifty tricks to make our code better but most of all, to talk Home Automation.
+ +
+ 
+ Couple of Home Assistant devs. Left to right: Paulus (@balloob), Alex (@infamy), Ryan (@rmkraus).
+
On Monday I (Paulus) gave a presentation about Home Assistant to an audience of over 400 people! It was a bit scary at first but after a couple of minutes it went all great including some great questions afterwards. Slides can be found here and the talk is embedded right below:
+ +One of the things that really impressed me was the amount of people that approached us to tell how they love Home Assistant, how it has replaced their previous solution, how they enjoyed contributing to Home Assistant and how helpful our community is. It makes me proud of Home Assistant and especially our community.
+ + +PyCon has a few great concepts that I haven’t seen at other conferences: open spaces and sprints. Open spaces give anyone the opportunity to get a room and host a session for an hour to talk about any topic. Sprints happen after the conference part of PyCon is over. For four days there are rooms available for participants to get together and hack on their favorite open source projects.
+ +My talk had limited time for Q&A so open spaces offered a great opportunity to get all pending questions answered and connect with the commmunity. There was more interest after the first day so we ended up hosting another open space on the second day.
+ ++ +@anschoen @home_assistant I'm located in Detroit. I could facilitate a workshop. What are we talking (group, potential dates, etc)?
— Jonathan Baginski (@jbags81) June 4, 2016
We’ve had such positive reception on our open spaces that Jonathan Baginski decided to repeat it online. We will be hosting a free online webinar Home Assistant Support 101 - Getting around in Home Assistant later this month. Make sure to RSVP.
+ +After the conference part of PyCon was over we spent one extra day to host a Home Assistant sprint. This allowed us to help people get started with hacking on Home Assistant which lead to some great contributions.
+ +
+ 
+ Home Assistant sprint group photo.
+
I’ve had a really great time at PyCon. It was awesome to meet everyone in person and I hope to see many of you next year!
+It’s time for the 0.22 release. This was a pretty rough release cycle and we had to issue two hot fixes for our core improvements. But it seems now that all is good and a lot of people have reported that their installs are faster than ever and the occasional quirks no longer occur.
+ +We are aware that our new web stack has caused issues installing Home Assistant on ARM-based platforms. This sadly includes the Raspberry Pi and Synology NAS systems. We’re working on getting to a better solution. For Raspberry Pi, the All-in-One installer will take care of everything for you. We’re working on updating our standalone Raspberry Pi installation guide.
+ +There are two cool things that I want to highlight in this release. The first is Pandora support. This is based on the CLI player called pianobar. This means that your machine running Home Assistant can be connected to the speakers and provide your house with tunes.
+ +
+
+
Another cool addition is the local file camera. This seems very basic at first but will allow you to generate a graph with your favorite 3rd party graphing tool and display it on your Home Assistant dashboard. We’re looking forward to see what you can do with this!
+ +
netatmo:
+ api_key: API_KEY
+ secret_key: SECRET_KEY
+ username: username
+ password: password
+
+In the past month I was thinking about ways to integrate USB webcams into Home Assistant again. The main reason was that this would give those devices a second life and enable one to benefit from low-cost video surveillance. There are a couple of options available like pygame or SimpleCV but I never finished something. With the Local File camera platform by Landrash and motion you could integrate a local USB webcam with a few very easy steps.
In this blog post I am using a Fedora 24 (will most likely work on other distributions too) installation with Home Assistant 0.22.1 on a Foxconn nT-330i with an old Logitech QuickCam Orbit AF and a Logitech HD Webcam C270. As a start only the Quickcam is used. No multi-camera setup for now.
+ + + +Check first if the your operating system lists your cameras.
+ +$ lsusb
+[...]
+Bus 002 Device 016: ID 046d:08cc Logitech, Inc. Mic (PTZ)
+[...]
+The camera we are going to use is available at /dev/video1. The C270 is the one on /dev/video0.
$ ls -al /dev/video*
+crw-rw----+ 1 root video 81, 0 Jun 23 08:05 /dev/video0
+crw-rw----+ 1 root video 81, 1 Jun 23 08:36 /dev/video1
+We need an additional software part to handle the cameras. motion is capable of monitoring the video signal from USB and network cameras, do motion detection, and other nifty stuff like saving images, add text, or basic image manipulations. Make sure that you have the RPM Fusion respository enabled.
+ +$ sudo dnf -y install motion
+For our setup we need to modify the file /etc/motion/motion.conf. For now the most important parameters are videodevice, snapshot_interval, and target_dir. The other settings can be left to their defaults. We are going to use the device /dev/video1, use a 30 seconds interval, and set the path to /tmp.
[...]
+###########################################################
+# Capture device options
+############################################################
+
+# Videodevice to be used for capturing (default /dev/video0)
+# for FreeBSD default is /dev/bktr0
+videodevice /dev/video1
+
+[..]
+############################################################
+# Snapshots (Traditional Periodic Webcam File Output)
+############################################################
+
+# Make automated snapshot every N seconds (default: 0 = disabled)
+snapshot_interval 30
+
+[...]
+############################################################
+# Target Directories and filenames For Images And Films
+# For the options snapshot_, picture_, movie_ and timelapse_filename
+# you can use conversion specifiers
+# %Y = year, %m = month, %d = date,
+# %H = hour, %M = minute, %S = second,
+# %v = event, %q = frame number, %t = thread (camera) number,
+# %D = changed pixels, %N = noise level,
+# %i and %J = width and height of motion area,
+# %K and %L = X and Y coordinates of motion center
+# %C = value defined by text_event
+# Quotation marks round string are allowed.
+############################################################
+
+# Target base directory for pictures and films
+# Recommended to use absolute path. (Default: current working directory)
+target_dir /tmp
+
+[...]
+It’s suggested that you adjust at least width and height to get a bigger image from your camera. If you are done, fire up motion.
$ sudo motion
+[0] [NTC] [ALL] conf_load: Processing thread 0 - config file /etc/motion/motion.conf
+[0] [ALR] [ALL] conf_cmdparse: Unknown config option "sdl_threadnr"
+[0] [NTC] [ALL] motion_startup: Motion 3.3.0 Started
+[0] [NTC] [ALL] motion_startup: Logging to file (/var/log/motion.log)
+Your target_dir will start filling up with images from your camera. motion will create a symlink called lastsnap.jpg which always point to the latest snapshot. We will setup the Local File camera platform to use this file.
camera:
+ - platform: local_file
+ name: Cranberry cam
+ file_path: /tmp/lastsnap.jpg
+
+ 
+ The “Cranberry cam” in action
+
The machine with the attached USB camera will become a webcam server as well because motion’s built-in HTTP server is enabled by default. This means that you could connect your USB webcams to a different machine in your network, run motion there, adjust your firewall rules, and use Home Assistant to display the videos. Just check http://[IP of your webcam host]:8081/ to see the stream. This required more powerful hardware than using snapshots, of course.
In a scenario like this needs a Generic MJPEG IP Camera in your configuration.yaml file.
camera:
+ - platform: mjpeg
+ mjpeg_url: http://[IP of your webcam host]:8081
+ name: Cranberry Live cam
+motion is a powerful tool and this blog post only showed two very simple use cases. Take a look at the documentation of motion to unleash its potential.
It’s time for Home Assistant 0.23 and it’s full of goodies. It’s also the release that bumps us over a 1000 tests and to 94% test coverage! Also our install issues on the Raspberry Pi and Synology have been resolved.
+ +This release brings support for two new ecosystems: Envisalink and Homematic. We can now also control your TV via HDMI using HDMI-CEC (which works on the Pi!) and another cool feature is the persistent notifications which allow you to add a notification to the frontend till dismissed.
+ +Wink support has been dramatically improved by migrating to the PubNub API. This allows Wink to push changes from their system to Home Assistant. This change came just in time as somehow our Wink integration was causing a lot of requests to their servers. Thanks to Wink for letting us know so we could solve it instead of blocking us.
+ +On the config side, you can now store your passwords in your OS keyring or just in a standalone file. We also got a new service to reload the core config so no reboots needed anymore after changing customize settings!
+ +
elevation: was introduced to the configuration for weather/sunrise data. For existing configurations add the value shown in the warning [homeassistant.config] Incomplete core config. Auto detected elevation: 665 to your configuration.yaml file.
+Over a year ago I participated in the kickstarter campaign for “CHIP - The World’s First Nine Dollar Computer” by Next Thing Co.. I went for the PocketCHIP because of the idea. Display, built-in storage (thus no need for SD cards), battery-powered, and a keyboard are pretty nice features. Last week a package arrives…
Thanks to Next Thing Co. and their CHIP which is actually 9 USD the space requirement for a single board computer has decreased. No Ethernet and HDMI output helped with that. But I guess that the next development cycle will allow us to put those boards in a matchbox including wired networking and a SATA interface.
+ +
+ 
+ Size comparison of a Cubieboard, OrangePi One, and CHIP.
+
If you start using a PocketCHIP you will definitely look like a Blackberry or a GameBoy user. Typing is done with your thumbs :-)
+ +First a couple of tweaks like setting up sudo, upgrading the existing installation, change passwords, enabling ssh, and removal of the annoying stuff then installation of Home Assistant. There is not much to tell…it’s straight-forward. For the sake of completeness below the notes about what I did.
A Debian installation is available by default. This means that some dependencies for Home Assistant are missing. I haven’t checked if a new build for the PocketCHIP would include them. So, after a $ sudo apt-get update installing those dependencies take a minute or two.
$ sudo apt-get install python3-dev python3-pip python3-venv
+As usual I run Python applications in a venv.
+ +$ pvenv ha
+Let’s activate the created environment.
+ +$ cd ha
+$ source bin/activate
+If you haven’t seen the next two commands already then you should visit our frontsite.
+ +$ pip3 install homeassistant
+$ hass --open-ui
+With surf the browsing experience on the low-resolution display is not that great. Most smartphones, even very cheap ones, have touchscreens with higher resolutions. Nevermind, midori is not better.
+ 
+ PocketCHIP with Home Assistant frontend
+
Well, with PocketCHIP and Home Assistant you could run your home automation on a 49 USD device with a touchscreen, an integrated USP, and a keyboard. With the GPIO available on top of the display you could even connect your PocketCHIP directly to sensors and actuators.
+It’s time for Home Assistant 0.24 and it’s full of new integration for your Home. It contains some structural changes to our history which requires action from your end, so please keep reading.
+ +MapQuest discontinued their free and direct tile access by Monday, July 11, 2016. With CARTO we found a very cool and suitable solution. They allow us to use their tile for the map. Thank you, CARTO.
+ +Roy Hooper did an amazing job migrating the history support from being tied to SQLite to use the ORM SQLAlchemy instead. This means that you can now use any SQL backend for the history. So besides SQLite you can now databases like MySQL or PostgreSQL. However, this does require that you install SQLAlchemy and run a command to migrate your existing history over. We tried to make the process as seamless as possible by introducing a new command line script:
+ +$ pip3 install SQLAlchemy
+$ hass --script db_migrator --config /path/to/config
+You can omit the --config option if you use the default configuration directory. Run the script with --help to get more options.
Quick hot fix after we found a bug in the migrator where it wouldn’t work with a database in a non-standard location. Thanks to @n8henrie and @AlucardZero.
+ +configuration.yaml file.
The history component is tracking everything that is going on within Home Assistant. This means that you have access to all stored information about your home. Our history is not a full-fledged graphical processing and visualization component as you may know from systems and network monitoring tools. The current limitation is that you only can select a day for a visual output of your information and not a period. Also, there is no possibility to drill down on a specific entity.
+ +This blog post will show you ways to export data for reporting, visualization, or further analysis of automation rules.
+ + + +In this blog post I use the temperature of the Aare river close to where I live as a show case. The temperatures were recorded with the Swiss Hydrological Data sensor and the name of the sensor is sensor.aare.
The database is stored at <path to config dir>/.homeassistant/home-assistant_v2.db as SQLite database. In all examples we are going to use the path: /home/ha/.homeassistant/home-assistant_v2.db
If you are just curious what’s stored in your database then you can use the sqlite3 command-line tool or a graphical one like DB Browser for SQLite.
The table that is holding the states is called states. The events tables is responsible for storing the events which occurred. So, we will first check how many entries there are in the states table. sqlite3 needs to know where the databases is located. To work with your database make sure that Home Assistant is not running or create a copy of the existing database. It’s recommended to work with a copy.
$ sqlite3 /home/ha/.homeassistant/home-assistant_v2.db
+SQLite version 3.11.0 2016-02-15 17:29:24
+sqlite> SELECT count(*) FROM states;
+24659
+Let’s have a look at a sample SQL query. This query will show all states in a period for the sensor sensor.aare.
SELECT state, last_changed FROM states
+ WHERE
+ entity_id = 'sensor.aare'
+ AND
+ last_changed BETWEEN
+ '2016-07-05 00:00:00.000000' AND '2016-07-07 00:00:00.000000';
+The SQL statement can be formed that it fits exactly what you need. This means that you can process the data in any way you want for further use. Often it makes sense to eliminate certain entries like Unknown or peaks.
If the above query is executed in DB Browser for SQLite you would be able to save the sensor’s graph as png.
+ +
+ 
+ Visualization with DB Browser for SQLite
+
You may ask: Why not do this with LibreOffice Calc or another spreadsheet application? As most spreadsheet applications are not able to work directly with SQLite database we are going to export the data from the database to CSV.
+ +$ sqlite3 -header -csv /home/ha/.homeassistant/home-assistant_v2.db "SELECT last_changed, state FROM states WHERE entity_id = 'sensor.aare' AND last_changed BETWEEN '2016-07-05 00:00:00.000000' AND '2016-07-07 00:00:00.000000';" > sensor.csv
+The ordering for the SELECT was changed to get the time stamps first and then the state. Now we can import the CSV file into the application of your choice, here it’s LibreOffice Calc.
+ 
+ Import of the CSV file
+
After the import a graph can be created over the existing data.
+ +
+ 
+ Graph in LibreOffice
+
You can also use matplotlib to generate graphs as an alternative to a spreadsheet application. This is a powerful Python 2D plotting library. With the built-in support for SQLite in Python it will only take a couple lines of code to visualize your data.
+ +import sqlite3
+from matplotlib import dates
+import matplotlib.pyplot as plt
+
+import homeassistant.util.dt as dt
+
+values = []
+timestamps = []
+
+conn = sqlite3.connect('/home/ha/.homeassistant/home-assistant_v2.db')
+data = conn.execute("SELECT state, last_changed FROM states WHERE "
+ "entity_id = 'sensor.aare' AND last_changed BETWEEN "
+ "'2016-07-05 00:00:00.000000' AND "
+ "'2016-07-07 00:00:00.000000'")
+
+for x in data:
+ timestamps.append(dates.date2num(dt.parse_datetime(x[1])))
+ values.append(float(x[0]))
+
+plt.plot_date(x=timestamps, y=values, fmt="r-")
+plt.ylabel('Temperature')
+plt.xlabel('Time line')
+
+plt.savefig('sensor.png')
+Creating a connection to the database and executing a query is similar to the ways already seen. The return values from the query are splitted into two lists. The time stamps must be converted in an value which is accepted by matplotlib and then the graph is generated and saved as image.
+ +
+
+ Sensor graph generated by matplotlib
+
Most of the graphs are pretty ugly. So, further beautification will be needed. If you have created a nice report including some amazing graphs then the Home Assistant community would be grateful for sharing them in our forum.
+This is the first blog post by Anton Kireyeu. A new contributor to Home Assistant who will focus on exploring and visualizing Home Assistant data.
+ +As we learned in the recent blog post by Fabian, all operational data of your Home Assistant application is stored locally and is available for exploration. Our first steps were querying data with the DB Browser for SQLite, exporting the data extract as a CSV file and graphing in LibreOffice. But what else can be done with this data and what tools are there available?
+ +This post will help you get set up using a few popular data scientist tools to allow you to locally process your data:
+ +
+
+One of the graphs created with this tutorial.
+
TL; DR: Use this Jupyter Notebook to visualize of your data
+ + + +In order to run the provided Jupyter notebook, please make sure you have the following applications/libraries installed on your computer:
+ +As a Windows user myself, I find the easiest, quickest and most hassle-free way of installing all of these dependencies is to use WinPython. This free open-source portable distribution includes all of the dependencies required for this notebook, as well as a few other essential Python libraries you may require for data exploration in the future.
+ +While all Home Assistant implementations can have varying setup, components and scripts, the underlying data structure is standardized and well-defined. This allows us to write Python code that is environmentally agnostic. Wrapping it in a Jupyter notebook ensures the code, visualizations and directions/explanations are kept digestible and neatly-packaged. One of the amazing features of Jupyter is the ability to change code as you go along, customizing all outputs and visualizations on the fly!
+ +This tutorial is based around a heavily commented Jupyter Notebook that we created. So to get started, you will have to open that:
+ +DB_URL at the beginning of the notebook to point at your Home Assistant databaseThat’s it! The included code will walk you through importing the required libraries, show running raw SQL against your local database, plotting basic data from the states table, and in the end output a few plots of changes for every entity in your system as well as the mean daily value for the past 20 days.
+ +After just those few steps, you will be greeted with beautiful formatted data like this:
+ +
+
+One of the graphs created with this tutorial.
+
Thanks to the magic of Jupyter, all of the code is customizable: want to selectively display your data, only covering a specific entity? Sure thing! Want to change the properties of the plots? No problem!
+ +While you learn and explore your IoT data, we will be working on providing more ready-to-use Jupyter Notebooks. Feel free to ask questions or provide suggestions. Would you like to see a specific visualization? Is there a particular facet of data you’re interested in? Let’s talk about it, let’s dive into the world of data together!
+
+The first release of Micropython for ESP8266 was delivered a couple of weeks ago. The documentation covers a lot of ground. This post is providing only a little summary which should get you started.
Until a couple of weeks ago, the pre-built MicroPython binary for the ESP8266 was only available to backers of the Kickstarter campaign. This has changed now and it is available to the public for download.
+ + + +The easiest way is to use esptool.py for firmware handling tasks. First erase the flash:
+ +$ sudo python esptool.py --port /dev/ttyUSB0 erase_flash
+esptool.py v1.0.2-dev
+Connecting...
+Erasing flash (this may take a while)...
+and then load the firmware. You may adjust the file name of the firmware binary.
+ +$ sudo python esptool.py --port /dev/ttyUSB0 --baud 460800 write_flash --flash_size=8m 0 esp8266-2016-07-10-v1.8.2.bin
+esptool.py v1.2-dev
+Connecting...
+Running Cesanta flasher stub...
+Flash params set to 0x0020
+Writing 540672 @ 0x0... 540672 (100 %)
+Wrote 540672 bytes at 0x0 in 13.1 seconds (330.8 kbit/s)...
+Leaving...
+Now reset the device. You should then be able to use the REPL (Read Evaluate Print Loop). On Linux there is minicom or picocom, on a Mac you can use screen (eg. screen /dev/tty.SLAB_USBtoUART 115200), and on Windows there is Putty to open a serial connection and get the REPL prompt.
The WebREPL work over a wireless connection and allows easy access to a prompt in your browser. An instance of the WebREPL client is hosted at http://micropython.org/webrepl. Alternatively, you can create a local clone of their GitHub repository. This is neccessary if your want to use the command-line tool webrepl_cli.py which is mentionend later in this post.
$ sudo minicom -D /dev/ttyUSB0
+#4 ets_task(4020e374, 29, 3fff70e8, 10)
+WebREPL daemon started on ws://192.168.4.1:8266
+Started webrepl in setup mode
+could not open file 'main.py' for reading
+
+#5 ets_task(4010035c, 3, 3fff6360, 4)
+MicroPython v1.8.2-9-g805c2b9 on 2016-07-10; ESP module with ESP8266
+Type "help()" for more information.
+>>>
++The public build of the firmware may be different than the firmware distributed to the backers of the Kickstarter campaign. Especially in regard of the available modules, turned on debug messages, and alike. Also, the WebREPL may not be started by default. +
+ +Connect a LED to pin 5 (or another pin of your choosing) to check if the ESP8266 is working as expected.
+ +>>> import machine
+>>> pin = machine.Pin(5, machine.Pin.OUT)
+>>> pin.high()
+You can toogle the LED by changing its state with pin.high() and pin.low().
Various ESP8266 development board are shipped with an onboard photocell or a light dependent resistors (LDR) connected to the analog pin of your ESP8266 check if you are able to obtain a value.
+ +>>> import machine
+>>> brightness = machine.ADC(0)
+>>> brightness.read()
+Make sure that you are familiar with REPL and WebREPL because this will be needed soon. Keep in mind the password for the WebREPL access.
+ +Read the instructions about how to setup your wireless connection. Basically you need to upload a boot.py file to the microcontroller and this file is taking care of the connection setup. Below you find a sample which is more or less the same as shown in the documentation.
def do_connect():
+ import network
+
+ SSID = 'SSID'
+ PASSWORD = 'PASSWORD'
+
+ sta_if = network.WLAN(network.STA_IF)
+ ap_if = network.WLAN(network.AP_IF)
+ if ap_if.active():
+ ap_if.active(False)
+ if not sta_if.isconnected():
+ print('connecting to network...')
+ sta_if.active(True)
+ sta_if.connect(SSID, PASSWORD)
+ while not sta_if.isconnected():
+ pass
+ print('Network configuration:', sta_if.ifconfig())
+Upload this file with webrepl_cli.py or the WebREPL:
$ python webrepl_cli.py boot.py 192.168.4.1:/boot.py
+If you reboot, you should see your current IP address in the terminal.
+ +>>> Network configuration: ('192.168.0.10', '255.255.255.0', '192.168.0.1', '192.168.0.1')
+First let’s create a little consumer for Home Assistant sensor’s state. The code to place in main.py is a mixture of code from above and the RESTful API of Home Assistant. If the temperature in the kitchen is higher than 20 °C then the LED connected to pin 5 is switched on.
+If a module is missing then you need to download it from the MicroPython Library overview and upload it to the ESP8266 with webrepl_cli.py manually.
+
# Sample code to request the state of a Home Assistant entity.
+
+API_PASSWORD = 'YOUR_PASSWORD'
+URL = 'http://192.168.0.5:8123/api/states/'
+ENTITY = 'sensor.kitchen_temperature'
+TIMEOUT = 30
+PIN = 5
+
+def get_data():
+ import urequests
+ url = '{}{}'.format(URL, ENTITY)
+ headers = {'x-ha-access': API_PASSWORD,
+ 'content-type': 'application/json'}
+ resp = urequests.get(URL, headers=headers)
+ return resp.json()['state']
+
+def main():
+ import machine
+ import time
+
+ pin = machine.Pin(PIN, machine.Pin.OUT)
+ while True:
+ try:
+ if int(get_data()) >= 20:
+ pin.high()
+ else:
+ pin.low()
+ except TypeError:
+ pass
+ time.sleep(TIMEOUT)
+
+if __name__ == '__main__':
+ print('Get the state of {}'.format(ENTITY))
+ main()
+Upload main.py the same way as boot.py. After a reboot (>>> import machine and >>> machine.reboot()) or power-cycling your physical notifier is ready.
If you run into trouble, press “Ctrl+c” in the REPL to stop the execution of the code, enter >>> import webrepl and >>> webrepl.start(), and upload your fixed file.
When Home Assistant started the focus has always been on making a great developer experience. Allowing anyone to add support for their favorite devices to Home Assistant easily. This focus has been a great success since we now have 339 components and platforms!
+ +Starting with this release, we are extending our extensability to the frontend. Starting this release, any component can add it’s own page to the frontend. Examples of this today are the map, logbook and history. We are looking forward to all the crazy panels you’ll come up with!
+ +We have also seen an exciting trend of people starting to visualize their Internet of Things data using Jupyter Notebooks, which are a great way to create and share documents that contain code, visualizations, and explanatory text. In case you missed it, the blog post by @kireyeu shows an advanced usecase while our Notebooks in the Home Assistant Notebooks repository cover the basics.
+ +This release also includes a bunch of new integrations, among others three new media player platforms. This means that today Home Assistant can talk to 26 different media players!
+ +The brand-new iFrame panel component allows you to add other websites as pages in the Home Assistant frontend. They will show up in the sidebar and can be used the same way as you open the frontend in your browser but all within one view.
+ +I would like to do a shoutout to @fabianhjr. He has started adding typing data (PEP484) to the Home Assistant core. This will help us identify issues before they are released.
+ +
timestamp_local and timestamp_utc) (@fabaff)location extension for Telegram and photo bug fixed (@keatontaylor and @pvizeli)This is a guest post by Home Assistant user and contributor Nolan Gilley.
+ +Today I’ll show you how I used Home Assistant, a NodeMCU (ESP8266), and a couple of accelerometers to automate our laundry room. This is a rewrite of an old post where I did the same thing using a Moteino & Raspberry Pi. This version only requires a NodeMCU.
+ +We have an older washer and dryer which doesn’t have any form of notification when cycles complete. Home Assistant was the obvious solution, I just needed to create sensors for the washer and dryer. I tried using sound sensors but found them unreliable. I ended up using an accelerometer attached to the back of each appliance. I also added magnetic reed switches on the doors of the washer and dryer to detect whether they’re open or closed. I connected the accelerometers and reed switches to an NodeMCU which will relay the data to my MQTT broker.
+ +
+ 
+ Block diagram of schematic
+
After taking some sample data from the accelerometers while each appliance was in operation, I decided to plot the data to help determine the proper thresholds of when the devices were running or off. I had to do this in order to get precise ranges so the dryer sensor wouldn’t get tripped by the washer or vice versa. In the plot below you can see the acceleration in each direction for the accelerometer connected to the dryer. It’s easy to see when the dryer is in operation here. I used the same technique for the washer’s accelerometer.
+ +
+ 
+ Graph showing the accelerometer data
+
Next it was just a matter of integrating everything with Home Assistant. I was able to use the MQTT component to read the washer and dryer states from the Moteino and display it in Home Assistant.
+ +
+ 
+ Status of the dryer and washer in Home Assistant
+
Next I wrote scripts that are run whenever the washer or dryer completes a load. This is triggered by the automation component. When the laundry is complete I have the lights in the house turn red and notify me via Join. Once the door is opened and laundry emptied another script runs that sets the lights back to normal. So far it has been very helpful and very reliable.
+ +
+
+ 
+
+ NodeMCU connected to MPU-6050 accelerometer.
+
Materials used:
+ +Sketch for the NodeMCU is available here.
+ +Home Assistant Configuration:
+ +mqtt:
+ broker: 192.168.1.100
+ port: 1883
+ keepalive: 60
+ qos: 0
+
+sensor:
+ - platform: mqtt
+ name: "Dryer Status"
+ state_topic: "sensor/dryer"
+ unit_of_measurement: ""
+
+ - platform: mqtt
+ name: "Washer Status"
+ state_topic: "sensor/washer"
+ unit_of_measurement: ""
+
+automation:
+ - alias: Washer complete
+ trigger:
+ platform: state
+ entity_id: sensor.washer_status
+ from: 'Running'
+ to: 'Complete'
+ action:
+ service: script.turn_on
+ entity_id: script.washer_complete
+
+ - alias: Washer emptied
+ trigger:
+ platform: state
+ entity_id: sensor.washer_status
+ from: 'Complete'
+ to: 'Empty'
+ action:
+ service: scene.turn_on
+ entity_id: scene.normal
+
+script:
+ washer_complete:
+ alias: Washer Complete
+ sequence:
+ - alias: Join Notification
+ service: notify.join
+ data:
+ message: "The washing machine has finished its cycle, please empty it!"
+ - alias: Living Room Lights Blue
+ service: scene.turn_on
+ data:
+ entity_id: scene.blue
+Resources used:
+ + +This blog post will go into detail about the recent performance optimizations that went into the Home Assistant front end. For people not familiar with the app, check out the demo and the source.
+ +TL; DR: Don’t hack the framework, separate responsibilities, ship less, use service workers, use (future) web standards.
+ +This year at Google I/O I saw Monica from the Polymer team talk about web components and performance. In her talk she mentions a mantra that they use in the Polymer team to make things fast: Do less and be lazy.
+ +Do less and be lazy. It sounds so obvious and it took a while before it started to dawn on me. I think most of the code I write is pretty fast, but I don’t often stop to take a harder look at how and when it runs in practice. When do we need the result, can it be postponed?
+ +And thus started my journey to take a critical look at how the Home Assistant app was working and how to make things faster. Below is the list of the different things that I did to make it fast.
+ +I hope this list can be useful to other people, as a guide for optimizing their own apps or for avoiding pitfalls when building a new one.
+ +The first thing to do is to measure. The Home Assistant front end is a mobile web app, so we shouldn’t measure this on a machine with 8 cores and gigabytes of ram but instead measure on devices you expect a mobile web app to run: phones. Below are two timelines recorded with Home Assistant 0.18.2 (pre-optimizations) and Google Chrome 53. On my Mac the app starts in 1400 miliseconds and on my Nexus 5x in ~6500 miliseconds (~4.5 times slower!).
+ +
+ 
+
Although the app takes 6500 milliseconds to load on my phone, it would perform well afterwards. Still, that initial load is unacceptable. You expect to open an app on your phone and be able to use it, quickly. After I applied all the changes described below, I managed to reduce startup time to 900 miliseconds (-35%) on my Mac and 2400 miliseconds (-63%) on my Nexus 5x. Check out the demo here.
+ +
+ 
+ 
+
The Home Assistant front end consists of two parts. There is Home Assistant JS, which controls all data and interaction between JavaScript and the server. It is a Flux architecture using NuclearJS and ImmutableJS. The UI is implemented by Home Assistant Polymer using Polymer and web components.
+ +I thought to be smart. I split out the JavaScript part of all web components and bundled them separately using Webpack so that I could use ES2015 via BabelJS (architecture). This is not how Polymer components are written and it meant that I was unable to use any of the tooling that is available in the community or easily split up the bundle (more on this later).
+ +So I went ahead and backported all my web components back from shiny beautiful ES6 to ES5. And you know what? It’s not that bad. Yes, not being able to use the concise object notation and arrow functions make your code more verbose. But in the end it is the same code that is running in browsers.
+ +Another benefit of having each web component contain their own script tag is that the browser will process them one by one, allowing the browser to render our loading spinner animation in between.
+ +As you can see in the timelines, we were able to get rid of most of the blocking component loading.
+ +
+ 
+
Whenever you learn a new technology, you feel like you’ve learned a new superpower. Wow, I can do all this with only 2 lines?! I had the same with bundling.
+ +I was initially very focused on shipping just a single file with everything that my app needed. The entry point would be my main component which would require all of its Flux and UI dependencies. Then, just before it all would be rendered, it would check if there is authentication and start the data fetching.
+ +This is a very bad pattern. This means that you will not start any data fetching until your UI is ready to render. Instead, you want your data to be fetched as soon as possible, and while the request is out to the server you want the page to load all your UI components.
+ +To accomplish this I extracted the application core out of the main bundle. In the current optimized version it’s 31.1kb gzip’d. It is loaded before any other scripts so that it can start fetching data as soon as possible.
+ +
+ 
+
When the data does come back before the UI is done loading, we can process it before we start rendering the UI because of all the web components being processed individually. This means that we don’t have to show a loading screen the first time our components render – we can just render the components with the data they require.
+ +The theory behind this one is simple: if we manage to ship less code, the browser has to process less code and it will start faster.
+ +The Home Assistant mobile web application has 10 different panels (pages). Besides that, it also has a dialog for each type of device to show more info. That’s a lot of components and screens of which only a very small set is needed at the start. That means that we are shipping a lot of unnecessary data that the browser has to process before our initial render!
+ +I broke up each panel of the app into a separate bundle that will be loaded on demand. This saved 250 kilobytes (pre-gzip) on just the embedded map alone! This change, however, required some significant changes to our build process.
+ +Breaking up an app in JavaScript is complex because each module explicitly imports their dependencies. This has to continue to work in your browser after breaking it up in multiple files. Web components do not have this problem as it’s part of the platform and thus your browser is the registry! An unregistered web component will be rendered as an empty span element until the element gets registered. Loading order is not important.
+ +// Example of the flexibility of web components.
+var spinner = document.createElement('paper-spinner');
+spinner.active = true;
+document.body.appendChild(spinner);
+Because the browser tracks your web components, creating standalone bundles for parts of the app is easy:
+ +The build script that bundles and minifies the main bundle and panel bundles is <100 lines.
+ +Core.js is still pure JavaScript and requires bundling. In my journey to get a smaller bundle, I went from Webpack to Webpack 2 to Rollup. At each step the bundle got smaller. Rollup is the big winner here because it doesn’t wrap all your modules in function calls but instead concatenates all files with minimal changes to make it work. This not only reduces the file size but also the loading speed. This is because the JavaScript engine will no longer have to invoke a function to resolve each import, it’s doing less work. This might not mean much for a computer but on a phone, everything counts.
+ +If the goal is to ship less, it’s time to take a good look at dependencies. It’s so often that we decide to fall back to yet another NPM package that makes our life a little easier but comes at the cost of size – size usually taken up by functionality that you might never need.
+ +I realized that I only used a few methods of lodash. Lodash (and previously underscore) used to be one of the dependencies that would always be one of the first things that I would add to any project I start. But I could no longer justify it in the case of Home Assistant. Even with dead tree shaking it was not worth including it. Yes, they support a lot of edge cases but those were not relevant to my use case. And standalone lodash packages are still huge. The only thing that I couldn’t replace with a few lines of my own code was debounce. However I found a 40 line replacement.
+ +Moment.js is one of those power libraries. It is able to handle any date problem that you can throw at it. But this obviously comes at the cost of size. Fecha is a date formatting library at ~8% the size of moment.js (only 4.7kb pre-gzip). The only thing that it does not contain is date manipulation, which was something that was not being used.
+ +Using a service worker we’re able to store all app components and core javascript in the browser. This means that after their first visit, the browser will only have to go to the network to fetch the latest data from the server.
+ +Creating a service worker is easy using sw-precache, a service worker generation tool.
+ +When a browser does not support service workers, Home Assistant will serve fingerprinted assets that are aggressively cached. Only when the content changes will the client redownload the asset.
+ +Using fingerprinting with sw-precache required jumping through a few hoops. The final build script can be found here.
+ +This one is more psychological: no one likes staring at a white screen because white screens are ambiguous: are we loading something, is there a crappy connection or maybe even a script error? That’s why it is very important to render something on the screen to show that the rest is being loaded, and as quickly as possible.
+ +The Home Assistant landing page contains just enough CSS and HTML to render the loading screen minus the animations.
+ +Now that the app is fast enough, I might swap out moving from a lite loading screen to drawing an empty toolbar. This makes it look like the UI is almost there.
+ +I left this to the end of the list, mainly because I had no influence on this. Polymer just happened to ship an update while I was optimizing the application which gave a big boost to the loading time.
+ +By using Polymer we have the ability to use tomorrow’s web standards today. This is powered by polyfills. A polyfill will use JavaScript to simulate the behavior that the web standard would have taken care of. As browsers progress, more work can move from the polyfills back to the browsers. This is great because browsers will be able to optimize the work better and thus be faster.
+ +Polymer 1.6 was introduced at the end of June and allowed the app to take advantage of native CSS variables in Chrome and Firefox. It also introduced lazy registration. Both greatly sped up our loading times.
+ +A lot of optimizations have been applied but this journey will never be over. There are still a lot of opportunities to make things even faster. Some ideas that are on my list to explore:
+ +<link rel="preload" …>It’s time for 0.26 and it’s again full of new features and fixes. First I want to highlight that we are now having 500 000 monthly pageviews on the website. A big milestone for us! It’s been an amazing journey. Big thanks to the Home Assistant community for being such a delightful bunch.
+ +This release includes code contributed by 31 different people. The biggest change in this release is a new unit system. Instead of picking Celsius or Fahrenheit you’ll have to pick imperial or metric now. This influences the units for your temperature, distance, and weight. This will simplify any platform or component that needs to know this information. Big thanks to @Teagan42 for her hard work on this!
+ +
# Configuration.yaml example
+homeassistant:
+ # 'metric' for the metric system, 'imperial' for the imperial system
+ unit_system: metric
+I have been working on a new subsystem to complement Home Assistant’s Automation and Scripting components. AppDaemon is a python daemon that consumes events from Home Assistant and feeds them to snippets of python code called “Apps”. An App is a Python class that is instantiated possibly multiple times from AppDaemon and registers callbacks for various system events. It is also able to inspect and set state and call services. The API provides a rich environment suited to home automation tasks that can also leverage all the power of Python.
If you haven’t yet read Paulus’ excellent Blog entry on Perfect Home Automation I would encourage you to take a look. As a veteran of several Home Automation systems with varying degrees success, it was this article more than anything else that convinced me that Home Assistant had the right philosophy behind it and was on the right track. One of the most important points made is that being able to control your lights from your phone, 9 times out of 10 is harder than using a lightswitch - where Home Automation really comes into its own is when you start removing the need to use a phone or the switch - the “Automation” in Home Automation. A surprisingly large number of systems out there miss this essential point and have limited abilities to automate anything which is why a robust and open system such as Home Assistant is such an important part of the equation to bring this all together in the vast and chaotic ecosystem that is the “Internet of Things”.
+ +So given the importance of Automation, what should Automation allow us to do? I am a pragmatist at heart so I judge individual systems by the ease of accomplishing a few basic but representative tasks:
+ +In my opinion, Home Assistant accomplishes the majority of these very well with a combination of Automations, Scripts and Templates, and it’s Restful API.
+ +So why AppDaemon? AppDaemon is not meant to replace Home Assistant Automations and Scripts, rather complement them. For a lot of things, automations work well and can be very succinct. However, there is a class of more complex automations for which they become harder to use, and appdeamon then comes into its own. It brings quite a few things to the table:
AppDaemon Apps are a much more natural fit for this. Recent enhancements to Home Assistant scripts and templates have made huge strides, but for the most complex scenarios, Apps can do things that Automations can’tAppDaemon’s API is full of helper functions that make programming as easy and natural as possible. The functions and their operation are as “Pythonic” as possible, experienced Python programmers should feel right at home.AppDaemon has been designed from the start to enable the user to make changes without requiring a restart of Home Assistant, thanks to it’s loose coupling. However, it is better than that - the user can make changes to code and AppDaemon will automatically reload the code, figure out which Apps were using it and restart them to use the new code without the need to restart AppDaemon itself. It is also possible to change parameters for an individual or multiple apps and have them picked up dynamically, and for a final trick, removing or adding apps is also picked up dynamically. Testing cycles become a lot more efficient as a result.It is in fact a testament to Home Assistant’s open nature that a component like AppDaemon can be integrated so neatly and closely that it acts in all ways like an extension of the system, not a second class citizen. Part of the strength of Home Assistant’s underlying design is that it makes no assumptions whatever about what it is controlling or reacting to, or reporting state on. This is made achievable in part by the great flexibility of Python as a programming environment for Home Assistant, and carrying that forward has enabled me to use the same philosophy for AppDaemon - it took surprisingly little code to be able to respond to basic events and call services in a completely open ended manner - the bulk of the work after that was adding additonal functions to make things that were already possible easier.
The best way to show what AppDaemon does is through a few simple examples.
Lets start with a simple App to turn a light on every night at sunset and off every morning at sunrise. Every App when first started will have its initialize() function called which gives it a chance to register a callback for AppDaemons’s scheduler for a specific time. In this case we are using run_at_sunrise() and run_at_sunset() to register 2 separate callbacks. The argument 0 is the number of seconds offset from sunrise or sunset and can be negative or positive. For complex intervals it can be convenient to use Python’s datetime.timedelta class for calculations. When sunrise or sunset occurs, the appropriate callback function, sunrise_cb() or sunset_cb() is called which then makes a call to Home Assistant to turn the porch light on or off by activating a scene. The variables args["on_scene"] and args["off_scene"] are passed through from the configuration of this particular App, and the same code could be reused to activate completely different scenes in a different version of the App.
import appapi
+
+class OutsideLights(appapi.AppDaemon):
+
+ def initialize(self):
+ self.run_at_sunrise(self.sunrise_cb, 0)
+ self.run_at_sunset(self.sunset_cb, 0)
+
+ def sunrise_cb(self, args, kwargs):
+ self.turn_on(self.args["off_scene"])
+
+ def sunset_cb(self, args, kwargs):
+ self.turn_on(self.args["on_scene"])
+This is also fairly easy to achieve with Home Assistant automations, but we are just getting started.
+ +Our next example is to turn on a light when motion is detected and it is dark, and turn it off after a period of time. This time, the initialize() function registers a callback on a state change (of the motion sensor) rather than a specific time. We tell AppDaemon that we are only interested in state changes where the motion detector comes on by adding an additional parameter to the callback registration - new = "on". When the motion is detected, the callack function motion() is called, and we check whether or not the sun has set using a built-in convenience function: sun_down(). Next, we turn the light on with turn_on(), then set a timer using run_in() to turn the light off after 60 seconds, which is another call to the scheduler to execute in a set time from now, which results in AppDaemon calling light_off() 60 seconds later using the turn_off() call to actually turn the light off. This is still pretty simple in code terms:
import appapi
+
+class MotionLights(appapi.AppDaemon):
+
+ def initialize(self):
+ self.listen_state(self.motion, "binary_sensor.drive", new = "on")
+
+ def motion(self, entity, attribute, old, new, kwargs):
+ if self.sun_down():
+ self.turn_on("light.drive")
+ self.run_in(self.light_off, 60)
+
+ def light_off(self, kwargs):
+ self.turn_off("light.drive")
+This is starting to get a little more complex in Home Assistant automations requiring an Automation rule and two separate scripts.
+ +Now lets extend this with a somewhat artificial example to show something that is simple in AppDaemon but very difficult if not impossible using automations. Lets warn someone inside the house that there has been motion outside by flashing a lamp on and off 10 times. We are reacting to the motion as before by turning on the light and setting a timer to turn it off again, but in addition, we set a 1 second timer to run flash_warning() which when called, toggles the inside light and sets another timer to call itself a second later. To avoid re-triggering forever, it keeps a count of how many times it has been activated and bales out after 10 iterations.
import appapi
+
+class FlashyMotionLights(appapi.AppDaemon):
+
+ def initialize(self):
+ self.listen_state(self.motion, "binary_sensor.drive", new = "on")
+
+ def motion(self, entity, attribute, old, new, kwargs):
+ if self.self.sun_down():
+ self.turn_on("light.drive")
+ self.run_in(self.light_off, 60)
+ self.flashcount = 0
+ self.run_in(self.flash_warning, 1)
+
+ def light_off(self, kwargs):
+ self.turn_off("light.drive")
+
+ def flash_warning(self, kwargs):
+ self.toggle("light.living_room")
+ self.flashcount += 1
+ if self.flashcount < 10:
+ self.run_in(self.flash_warning, 1)
+Of course if I wanted to make this App or its predecessor reusable I would have provided parameters for the sensor, the light to activate on motion, the warning light and even the number of flashes and delay between flashes.
+ +In addition, Apps can write to AppDaemon’s logfiles, and there is a system of constraints that allows yout to control when and under what circumstances Apps and callbacks are active to keep the logic clean and simple.
I have spent the last few weeks moving all of my (fairly complex) automations over to APPDaemon and so far it is working very reliably.
Some people will maybe look at all of this and say “what use is this, I can already do all of this”, and that is fine, as I said this is an alternative not a replacement, but I am hopeful that for some users this will seem a more natural, powerful and nimble way of building potentially very complex automations.
+ +If this has whet your appetite, feel free to give it a try. You can find it, here, including full installation instructions, an API reference, and a number of fully fleshed out examples.
+ +Happy Automating!
+Thanks to Anton Kireyeu we are able to present another awesome Jupyter notebook. I guess that you all know the graph which Github is using to visualize your commits per day over a time-line. It’s a so-called heatmap. If there are more commits, it’s getting hotter. The latest notebook is capable to do the same thing for your devices. To be more precise, for the hours your devices are home.
+ +
+
+Heatmap
+
This week’s blog post could only be possibly described by exactly one hashtag:
+ +or maybe#supersized
+ +Keep reading to see what #Amazing things we have in store for you this week 😄! And make sure you read all the way to the end, because I left a present down there for those committed few among you :)
+ +But first…
+ +Paulus (@balloob) is on vacation in Europe this week, so you will all have to deal with me, Robbie (@robbiet480) for this release blog post. Don’t worry, Paulus will be back to tearing apart your pull requests in no time 😈.
+ +Special thanks to my awesome helpers for this week’s release who are looking over my shoulder to make sure I’m crossing my t’s and dotting my i’s: @Teagan42, @infamy and @fabaff.
+ +For my next trick, let’s hand out some…
+ +I felt that I had to 1-up Paulus (@balloob) somehow with his 500,000 pageviews stat he shared in the 0.26 blog post, so I pushed myself and our development community as a whole super hard the last two weeks to put a lot of love into Home Assistant to bring you not just one, but six #Amazing stats for this release. As of 0.27, we have now surpassed the following milestones:
+ +In addition,
+ +Now that we have that great news out of the way, onto this week’s release which is going to keep the #Amazing gravy train rolling right along and get to the stuff you all really are here for.
+ +While this release is #Amazing, we had to break a few eggs (now you understand the title reference!) to make a beautiful omelette (using home automation obviously) so some platforms and components have needed to introduce breaking changes. Please make sure to read the Breaking Changes section below.
+ +Thanks to @mgbowen we now have the functionality previously provided by @blocke’s ha-local-echo built right into Home Assistant! This means that for those of you with devices that either lack or have a subpar integration with Home Assistant (looking at you Amazon Echo) you can now have a better experience by having your Home Assistant pretend to be a Hue Bridge. Personally, I have used @auchter’s Haaska previously but found that it was slow to respond and sometimes failed entirely. With the new emulated_hue component, you can have local control of entities through Amazon Echo.
We have some excellent upgrades to the notification system coming to you in 0.27, courtesy of me, @robbiet480.
+ +This release adds support for HTML5 push notifications on Chrome/Firefox/Opera on both desktop and Android devices. This means that you can send a notification to your phone even when your Home Assistant is not open in your mobile browser. When using Chrome you can even include 2 action buttons so that you can control your Home Assistant from your phone’s lock screen, allowing you to do things like sound alarms or unlock your front door, all without leaving the notification. Thanks again to me (@robbiet480) and Paulus (@balloob) for all the hard work on this!
+ +
+ 
+
Using the new notify group platform allows you to cut down a lot of duplicate automation logic by combining multiple notification platforms and targets into a single notify service. Check out the docs for more info.
target is no longer needed!For platforms that support it, starting with the new HTML5 platform, any targets that are available will be exposed as individual services, so no more having to remember which targets to use. Please note that the existing services also still exist so you can keep using target if you wish.
Ever restarted Home Assistant to test a configuration change just to find out there is a validation error? Well, not anymore! @kellerza has added a command line script that will validate your configuration as if you started Home Assistant.
+ +$ hass --script check_config
+This release includes a big push on making sure all platforms contain proper configuration validation. This should help in getting your configuration right. Thanks to @fabaff, @pavoni, @pvizeli, @nkgilley for all the hard work on this, you all rock!
+ +
+ 
+
It’s now possible to use FFMpeg to monitor a video stream and detect motion thanks to a new binary sensor platform by @pvizeli.
+ +Due to our wild growth we ended up with a few components that had a lot of overlapping functionality. @turbokongen took on the hard job on merging them. Thermostat and HVAC platforms are now combined under the new Climate component. Rollershutter and Garage Door platforms are now combined under the new Cover component. You can easily upgrade by just swapping out the name. For example replace thermostat with climate. The old components have been deprecated and will be removed in the near future.
fan componentAlong with the new climate component, @Teagan42 and I (@robbiet480) decided we needed something simpler to just control a fan. Currently it has support for controlling Insteon fans. MQTT support will appear in 0.28.0. I tried to get it implemented before 0.27.0 but spent too long writing this blog post 😢.
sensor.forecastio_temperature. Previously they were like sensor.weather_temperature. Apologies for this change, but we needed to make Forecast.io more generic now that we have many weather platforms.type: is no longer required for monitored variables.username instead of user.thermostat and hvac components has been deprecated. Please migrate to the new climate component. (just change the component name, the configurations are compatible)rollershutter and garage_door components have also been deprecated. Please migrate to the new cover component. (just change the component name, the configurations are compatible)Thanks all for sticking with me to the end. I’ll be taking over a lot of Paulus’s (@balloob) work while he is gone, but as I said, don’t worry because he’ll be back well before 0.28.0 comes out. Hopefully you didn’t find this jovial blog post too jarring from our standard style, I just wrote a lot of this at 2am after being awake for almost 20 hours, so I’m a little loopy hahaha 😴.
+ +Also, thanks as always to our developer contributors, documentation contributors, but most of all our users! This would’ve just been a script that Paulus (@balloob) used to control his lights at home if we didn’t have your enthusiasm.
+ +Feel free to let me know what you thought of this blog post and release on Gitter or my Twitter, or even the Home Assistant Twitter. Did I mention we have a brand new Facebook page that you should absolutely Like? There’s a convenient Facebook Like and Twitter follow button right on the sidebar.
+ +I almost forgot about your 🎁 for reading all the way to here: a 🍪! Hope you enjoy it in good health 😄.
+ +Talk to you soon on Gitter and in your pull request comments!
+ +– Robbie
+ +(p.s. To those of you that scrolled directly to the bottom to get your present, just know that you didn’t earn it like the others did. 😄)
+ +
+So, part 1 of ESP8266 and MicroPython was pretty lame, right? Instead of getting information out of Home Assistant we are going a step forward and create our own sensor which is sending details about its state to a Home Assistant instance.
Beside HTTP POST requests, MQTT is the quickest way (from the author’s point of view) to publish information with DIY devices.
+ +You have to make a decision: Do you want to pull or to poll? For slowly changing values like temperature it’s perfectly fine to wait a couple of seconds to retrieve the value. If it’s a motion detector the state change should be available instantly. This means the sensor must take initiative.
+ +An example for pulling is aREST. This is a great way to work with the ESP8266 based units and the Ardunio IDE.
+ +You can find a simple examples for publishing and subscribing with MQTT in the MicroPython library overview in the section for umqtt.
+ +The example below is adopted from the work of @davea as we don’t want to re-invent the wheel. The configuration feature is crafty and simplyfies the code with the usage of a file called /config.json which stores the configuration details. The ESP8266 device will send the value of a pin every 5 seconds.
import machine
+import time
+import ubinascii
+import webrepl
+
+from umqtt.simple import MQTTClient
+
+# These defaults are overwritten with the contents of /config.json by load_config()
+CONFIG = {
+ "broker": "192.168.1.19",
+ "sensor_pin": 0,
+ "client_id": b"esp8266_" + ubinascii.hexlify(machine.unique_id()),
+ "topic": b"home",
+}
+
+client = None
+sensor_pin = None
+
+def setup_pins():
+ global sensor_pin
+ sensor_pin = machine.ADC(CONFIG['sensor_pin'])
+
+def load_config():
+ import ujson as json
+ try:
+ with open("/config.json") as f:
+ config = json.loads(f.read())
+ except (OSError, ValueError):
+ print("Couldn't load /config.json")
+ save_config()
+ else:
+ CONFIG.update(config)
+ print("Loaded config from /config.json")
+
+def save_config():
+ import ujson as json
+ try:
+ with open("/config.json", "w") as f:
+ f.write(json.dumps(CONFIG))
+ except OSError:
+ print("Couldn't save /config.json")
+
+def main():
+ client = MQTTClient(CONFIG['client_id'], CONFIG['broker'])
+ client.connect()
+ print("Connected to {}".format(CONFIG['broker']))
+ while True:
+ data = sensor_pin.read()
+ client.publish('{}/{}'.format(CONFIG['topic'],
+ CONFIG['client_id']),
+ bytes(str(data), 'utf-8'))
+ print('Sensor state: {}'.format(data))
+ time.sleep(5)
+
+if __name__ == '__main__':
+ load_config()
+ setup_pins()
+ main()
+Subscribe to the topic home/# or create a MQTT sensor to check if the sensor values are published.
$ mosquitto_sub -h 192.168.1.19 -v -t "home/#"
+sensor:
+ - platform: mqtt
+ state_topic: "home/esp8266_[last part of the MAC address]"
+ name: "MicroPython"
+@davea created sonoff-mqtt. This code will work on ESP8622 based devices too and shows how to use a button to control a relay.
+It’s already time for 0.28 thanks to our super short release cycles. Now, it’ official…we hit 4000 stars on Github. That’s amazing. Sorry, not as amazing as all the stuff that was going on for 0.27 but still pretty awesome.
+ +This release brings you a huge improvement of the automation and group handling. Both can be reloaded without a Home Assistant restart by calling their new reload services. The automations can be controlled directly from the frontend.
+ +
+ 
+
Singleboard computers are very popular to run Home Assistant. To support this fact, the installation documentation for the Raspberry Pi devices was re-written to get users started as quickly as possible. @Landrash took the lead with on this tasks with help from @kellerza and @MartinHjelmare.
+ +There are countless bugfixes included in this release which will make your experience with the climate and the cover platforms better. Two week ago was the biggest merger of implementations released that ever happened in the history of Home Assistant. Thanks to @turbokongen, @pvizeli, @djbanks, @danielperna84, and others the improvements on the code and the frontend side is continuing…
The Home Assistant API Documentation is a great addition to the already exisiting user documentation. The focus is not end-users but developers who whant to get details about the code without actually browsing the code on Github.
+ +The validation of the configuration is still on-going. Approximatly 80 % is done. This means that we will propably talk about this topic in the next release notes again. To align the configuration of components and platforms we needed to break some. Please refer to the Breaking changes section to check if you need to update your configuration or simple check your log for configuration validation errors. Thanks to @kellerza, @fabaff, @Teagan42, and @pvizeli for your effort!
+ +
known_devices file (@kellerza)link_names for sending Slack message (@salt-lick)data_template (@pvizeli)check_config: Improve yaml fault tolerance and handle border cases (@kellerza)write_registers Modbus service (@persandstrom)sensor.owm_temperature. Previously they were like sensor.weather_temperature. Apologies for this change, but we needed to make OpenWeatherMap more generic now that we have many weather platforms.BaseNotificationService need to be aware that kwargs.get(ATTR_TITLE) will now return None if a title has not been set, and will need to specify kwargs.get(ATTR_TITLE, ATTR_TITLE_DEFAULT) if they always require a title.…don’t hesitate to use our Forum or join us for a little chat.
+Two weeks ago, September 17 marked our 3 year anniversary. In this time Home Assistant managed to grow from a simple script that turned on my lights when the sun set to a kick ass open source project with the best community an open-source project could wish for. This release contains features, bug fixes and performance tweaks by a total of 50 different people! We have also managed to cross the 1000 forks on GitHub. Talking about momentum!
+ +This is a big release as we’ve completely overhauled the internals of Home Assistant. When I initially wrote Home Assistant, still figuring out the ins and outs of Python, I went for an approach that I was familiar with for an application with many moving parts: threads and locks. This approach has served us well over the years but it was slower than it needed to be, especially on limited hardware.
+ +This all changed when @bbangert came around and took on the tough job to migrate the core over to use asynchronous programming. He did an amazing job and I am happy to say that the initial port has been done and is included in this release! On top of that, we have been able to keep our simple and straightforward API at the same time. We are still in the process of migrating more and more components over to the asynchronous API, so expect more speedups and awesome features in the upcoming releases.
+ +There now is support for two new super cool things: Beds and license plates. @technicalpickles created a SleepIQ component that let you monitor the sensor data of your bed. @pvizeli has added license plate recognition based on OpenALPR! This means that you can now be notified about which car is parked on your driveway or in your garage. I also would like to use this opportunity to give a big shoutout to @pvizeli for being such an awesome member of our community. He joined us at the end of June and has helped crush bugs and add awesome features ever since (65 pull requests already!).
+ +On the voluptuous front we have also made great progress. We were able to fully remove the legacy config helpers and have migrated 323 of the 346 components and platforms that needed migrating! This does mean that for some components the configuration has slightly changed, make sure to check out the breaking changes section at the bottom for more info. Thanks everybody for reviewing the Pull requests, testing the changes, and reporting issues.
+ +As you might have noticed, this release has been delayed by 5 days. This was due to a rare, difficult to reproduce problem with the Python interpreter. A huuuuge thanks to all the people that have helped countless hours in researching, debugging and fixing this issue: @bbangert, @turbokongen, @lwis, @kellerza, @technicalpickles, @pvizeli, @persandstrom and @joyrider3774. I am grateful to have all of you as part of the Home Assistant community.
+ +Since 0.28 automation rules can be reloaded directly from the frontend. By default all automation rules are shown. If you want to hide an automation rule, use hide_entity: True.
data_template would incorrectly get cached (@balloob)now and utcnow have been changed from variables to methods. To get the current time replace now with now().yahooweather default name is now yweather. Also min and max temperature are now correctly called Temperature Min and Temperature Max.ffmpeg is now a component for manage some things central. All ffmpeg_bin options have moved to this compoment from platforms.…don’t hesitate to use our Forum or join us for a little chat. The release notes have comments enabled but it’s preferred if you the former communication channels. Thanks.
+Today we’re happy to announce our brand new Raspberry Pi image! It is based on Raspbian Lite combined with HASS so we decided to call it Hassbian.
+ +This image comes pre-installed with everything you need to get started with Home Assistant right away.
+ +To get started, check out the installation instructions in the getting started section or watch the latest video by BRUHAutomation:
+ +It’s based on Raspbian Lite and generated with a fork of the same script that builds the official Raspbian images. For installation of HASS it follows the same install instructions as the Manual installation. Please note that this project has no association with the Raspberry Pi foundation or their projects.
+ +On first boot the latest release of Home Assistant will be installed and can be reached after 3~5 minutes. Pre-installed on this image is the MQTT broker Mosquitto, Bluetooth support and settings for the homeassistant account to use the GPIO pins of the Raspberry Pi. Mosquitto is not activated by default.
As it is today there is no pre-compiled Z-Wave support but it can be installed by following the Getting started instructions for Z-Wave.
+ +Happy Automating!
+Home Assistant will join this year for Hacktoberfest, an event organised by DigitalOcean and GitHub to support and celebrate open source. The idea is that open source projects like Home Assistant will gather a bunch of entry-level bugs, features and documentation enhancements and that you, a current or future contributor, will fix them. If you submit four pull-requests during the month of October you will have earned yourself a limited edition Hacktoberfest T-shirt!
+ +Why contribute to Home Assistant:
+ +Resources to get started:
+ +Are you not a programmer but still want to contribute to Home Assistant? Check out our list of entry-level issues for the Home Assistant website.
+ +
Yes, after only nine days comes 0.30. Don’t worry, we will try to keep our usual release cycle and not start to release every day.
+ +We guess that you already know: The Raspberry Pi image is available now. For Hassbian, @Landrash has combined the most essential parts for a Home Assistant setup in an easy-to-use image for the Raspberry Pi device family. Hassbian is quite young, thus we are looking forward to recieve feedback, issue report, and suggestions to improve it.
+ +A large amount of resources of the development are still focusing on the effort to move Home Assistant further to asynchronous programming. It’s a labor-intensive task, comes with segmentation faults, and unstable instances when certain combinations of sensors are used. The benefit will be more speed in the near future.
+ +To reduce the run-time of your tests, @balloob did a lot of tweaking. For now the RFXtrx tests are excluded which cut the needed time for running on your Pull Request in half.
+ +All configuration sample entries are now minimized. This should help to avoid problem for starters and newbies as they only get what’s needed and not a full sample with all optional entries. If there is an issue with an entry in your configuration.yaml file the error message will provide you an URL that point to the documentation.
+ 
+
As soon as the Hacktoberfest started there were a lot of incoming Pull Requests for the documentation. A huge “Thank you” to all participants. Especially, we would like to give a cookie to @hillaryfraley. She created around a dozen Pull Requests so far and didn’t only fix typos but complete sections. The Hacktoberfest is still on-going and we are looking forward to get more Pull Requests.
+ +With the statistics sensor we would like to introduce a new sensor that is similar to the template sensor or the trend sensor. This sensor is consuming values from another sensor and is doing some statistical analysis of the data. Over a group of samples is the average/mean, the min/max, the total, the standard deviation, and the variance calculated which can be used in your automation rules. If the source is a binary sensor then the state changes are counted.
+ +
+ 
+
As the results are processed on-the-fly you still need to use the data from your database for a in-depth analysis of your stored information. Check the latest notebook for doing statistics with your Home Assistant database.
+ +There was a lot of work done on our implementation which are working with RESTful APIs. @w1ll1am23 extended the aREST platforms to display if an aREST unit is available or not. The aREST implementations are now covered by the configuration check as well. Please check the Breaking changes section for more details.
+ +The REST sensor supports now HTTP authentication (basic and digest) and custom headers. This will allow you to access resources which are protected. This sample sensor will access GitHub and retrieve the latest release number while by-passing the rate limit for non-authenticated requests.
+ +sensor
+ - platform: rest
+ resource: https://api.github.com/repos/home-assistant/home-assistant/releases/latest
+ username: YOUR_GITHUB_USERNAME
+ password: YOUR_GITHUB_ACCESS_TOKEN
+ authentication: basic
+ value_template: '{{ value_json.tag_name }}'
+ headers:
+ Accept: application/vnd.github.v3+json
+ Content-Type: application/json
+ User-Agent: Home Assistant REST sensor
+
known_device.yaml file is now validated (@kellerza)known_devices.yaml validation is now more accepting (@kellerza)notify.html5_unnamed_device_2) the target was not submitted to the platform as a list causing iteration over every character in the string. (@robbiet480)automation have been removed (deprecated since May and have printed warnings to your console):
+ use_trigger_values is gone. You have to copy your triggers to conditions and adjust for the correct config.condition_type is gone. Use condition: or instead.condition: instead of platform:.- platform: forecast with - platform: darksky.…don’t hesitate to use our Forum or join us for a little chat. The release notes have comments enabled but it’s preferred if you the former communication channels. Thanks.
+Hello again friend,
+ +How are you? Having a good day? We sure are. If you aren’t having a good day, this might cheer you up…
+ +Every other weekend around here gets a little hectic leading to a big sigh of relief as we release a new version of Home Assistant to the world. And this time is no different. Our developer community has once again built us a beautiful new release with lots of new features and improvements. We hope you like it.
+ +One last thing before we get going though, I should warn you… @balloob got a bit lazy this week and let me (@robbiet480) step up to the plate again to write the blog post and do the release. I guess I didn’t do such a bad job in 0.27. You’ll never know what surprises I have in store. Now that i’ve got all that stuff out of the way, let’s get started…
+ +Sadly, no big amazing stats to update you with this time, but we did recently pass 7,000 commits! This release featured submissions from 45 contributors. Hopefully with the new updater component we will be able to give you some really good stats in the 0.32 blog post.
+ +
October means Hacktoberfest time and our community has really come through with some excellent improvements and additions. As of this writing, we have 194 merged and 41 open pull requests to the home-assistant repository and 209 merged/28 open pull requests submitted to the home-assistant.github.io repository. If you want to get in on the fun check out our Hacktoberfest blog post or the Hacktoberfest website. You get an awesome t-shirt for free if you have 4 pull requests merged in the month of October! We even have tasks that a non-developer can easily accomplish with a tiny bit of work. Better hurry up though, only 9 days left and most of the easy tasks are gone!
+ +This release includes an update to our updater component. The responsibility of the updater component is to check if a new version is available and notify the user if this is the case.
+ +It used to be that this component would check with PyPi (the Python package manager) to see if a new update was available. This had a couple of problems:
+ +So to work around these problems, we decided to start hosting the version check service ourselves. Since we had to get some infrastructure spun up anyway, we figured we would take it a step further. Which leads me to this bit of the update (the most important part):
+ +Remember how I mentioned that up there in the title that there is some serious business in this release? Well, we also added some basic analytics to the updater component which get sent to the server and stored so that we get a better idea of our user base.
+ +Each Home Assistant instance running the updater component will generate a unique ID (based on UUIDv4) that will be used for the updater to be able to differentiate between instances. This UUID will be stored in your config directory in a file called .uuid.
There are two ways to opt-out. The first way is by using the new opt_out option for the updater. This way the updater will continue to check for updates, but no information about your system will be shared with us.
updater:
+ reporting: no
+You can also disable the updater component entirely by removing updater: from your configuration.yaml although we would not suggest you do this as you would miss any critical updates.
Finally, you can also reset your unique identifier by deleting the .uuid file and restarting Home Assistant.
Here is what my production Home Assistant instance looks like from the server side:
+ +| Name | +Description | +Example | +
|---|---|---|
arch |
+ CPU Architecture | +x86_64 |
+
distribution |
+ Linux Distribution name (only Linux) | +Ubuntu |
+
docker |
+ True if running inside Docker | +false |
+
os_name |
+ Operating system name | +Darwin |
+
os_version |
+ Operating system version | +10.12 |
+
python_version |
+ Python version | +3.5.2 |
+
timezone |
+ Timezone | +America/Los_Angeles |
+
user_agent |
+ User agent used to submit analytics | +python-requests/2.11.1 |
+
uuid |
+ Unique identifier | +10321ee6094d4a2ebb5ed55c675d5f5e |
+
version |
+ Home Assistant version | +0.31.0 |
+
virtualenv |
+ True if running inside virtualenv | +true |
+
In addition to the above collected data, the server will also use your IP address to do a geographic IP address lookup to determine the city that you are from. To be extremely, extremely clear about this bit: The Home Assistant updater does not: store your IP address in a database and also does not submit the location information from your configuration.yaml.
+ 
+ Geo-lookup on my IP resolves to Oakland with latitude/longitude pointing at the geographical center of the city.
+
The server also adds two timestamps to the data: the original date your instance UUID was first seen and the timestamp of the last time we have seen your instance. This gives us the following extra data:
+ +| Name | +Description | +Example | +
|---|---|---|
first_seen_datetime |
+ First time instance ID was submitted | +2016-10-22T19:56:03.542Z |
+
geo_city |
+ GeoIP determined city | +Oakland |
+
geo_country_code |
+ GeoIP determined country code | +US |
+
geo_country_name |
+ GeoIP determined country name | +United States |
+
geo_latitude |
+ GeoIP determined latitude (of the city) | +37.8047 |
+
geo_longitude |
+ GeoIP determined longitude (of the city) | +-122.2124 |
+
geo_metro_code |
+ GeoIP determined metro code | +807 |
+
geo_region_code |
+ GeoIP determined region code | +CA |
+
geo_region_name |
+ GeoIP determined region name | +California |
+
geo_time_zone |
+ GeoIP determined time zone | +America/Los_Angeles |
+
geo_zip_code |
+ GeoIP determined zip code | +94602 |
+
last_seen_datetime |
+ Most recent time instance ID was submitted | +2016-10-22T19:56:03.542Z |
+
This data is held in the highest security. The update system runs in a secured Amazon Web Services account owned by me (@robbiet480). I personally have 5 years of experience with complex AWS deployments and have an extensive security background. I have audited the entire system and made sure to take every step to protect the data, including limiting who has access (just @balloob and myself). While not directly personally identifiable we absolutely understand some users hesistance to giving this information out. Please understand that we are only collecting this information to better understand our user base to provide better long term support and feature development then is currently possible.
+ +We currently have no plans to publicly expose any of this information. If we did do such a thing in the future we would of course notify you in advance. It must also be stated that we will never sell or allow the use of this information for non-Home Assistant purposes.
+ +We thank you for understanding why we are collecting this data and hope that you leave the feature enabled but fully understand if you feel uncomfortable with this.
+ +This section was updated on October 24 to be more clear about geo-lookups being on the city level. See original version.
+ +Now, back to the fun stuff…
+ +Home Assistant got a crazy idea recently that it couldn’t do enough already and wanted to challenge itself even more. I really don’t understand how it came up with this kooky idea, but it now thinks that its newest hobby should be a minor career in journalism.
+ +0.31 adds support for the brand spanking new Alexa Flash Briefing API, allowing you to get updates from Home Assistant anytime you ask Alexa to read your flash briefing. What’s the use case you ask? Well, now when I wake up in the morning and get my flash briefing, Home Assistant adds this to the end of it for me:
+ +++ +Drive time with traffic is 35 minutes. There is an UberPOOL that will cost $11.52, estimated to be 2 minutes away, for a total of 37 minutes. BART is currently estimated to take 29 minutes. You should take BART, as it is estimated to be faster by 8 minutes.
+
Now I know how to best get to my real job (no, Home Assistant is not my real job, it does seem like it sometimes though) every morning. Obviously not the best home automation example, but I think you get the idea. I could see this being used to tell you any major events that happened in your home overnight or reading you your hyperlocal weather report. Thanks to the audio support you could even replace all of the default Alexa Flash Briefing sources with your own news feeds. Home Assistant supports both text and audio content as well as displaying data in the Alexa app. I also want to point out that unlike the existing Skill integration, the Flash Briefing API does not require HTTPS (but you should still be using HTTPS if possible). For more information, check out the new docs.
+ +
+ 
+ You stay classy, San Diego. (It’s funny, because balloob lives in San Diego))
+
A rather nasty Z-Wave issue was discovered recently by @lukas-hetzenecker. There was a somewhat large chance that if you had multiple of the same model Z-Wave device they may both try to use the same entity IDs. To fix the issue the internal Z-Wave index is now appended to the end of all Z-Wave entity IDs.
+ +What this means for all you Z-Wave users is that you will need to update your configurations to reflect the change. I personally have quite a few (17) Z-Wave devices and went through the process this week. Here’s what I had to do:
+ +zwave.customize sectionemulated_hue with Alexa and emulated_hue uses the entity ID as a unique identifier I also had to remove all Z-Wave devices from Alexa and re-add them.Your todo list may be a little different from mine, I just wanted to outline the steps I took to give you an idea of what you need to think about. It’s not a very hard process, especially when using global find and replace in Sublime Text but did take me about 20 minutes to complete.
+ +This is super annoying, I know, especially since we had said in 0.12 that Z-Wave IDs should hopefully never change again, but we are now forced to eat those words. I will state again that Z-Wave IDs shouldn’t change in the future but obviously we see how that went. To sum up on this section… sorry but it had to happen.
+ +approved_ips from string to CIDR validation (@mweinelt)known_devices.yaml reading and writing tweaks and fixes (@kellerza)fail filter added to templates to raise on UndefinedError (@jaharkes)…don’t hesitate to use our Forum or join us for a little chat. The release notes have comments enabled but it’s preferred if you the former communication channels. Thanks.
+ +Thanks for reading all of the above, especially since this week was a pretty long post. We should be back with a new post around November 5th announcing the arrival of 0.32.
+ +– Robbie
+On Saturday, we released Home Assistant 0.31 which includes an improved updater component that checks for new versions using the Home Assistant servers. We wanted to update the community on its rollout and answer some questions that have come up. As part of the update check anonymous information about your operating system and Python version is submitted to Home Assistant servers unless you have opted out.
+ +This change was driven by two important factors.
+ +As a user, you will be able to be notified if you are running a Home Assistant version that includes components that have known security flaws.
+ +Although we hope to not have to use this feature often, it is important for us to be able to reach out to impacted users. We had the need for such a feature once in the past. Due to a bug the forecast.io sensor was making a huge amount of API requests causing some of our users to get charged because they went over the free quota.
+ +Please note that this functionality is not done yet but will be available in a future release.
+ +As developers of Home Assistant, we will be able to see in what kind of environments Home Assistant is running. Here’s a few data points we didn’t have until now:
+ +We store the city so that we can see where our users are from. This information will be used to give us a better insight in where our users are from. This will help us gather data to see if we should for example prioritize internationalization. In addition, we previously had a nasty bug with the sun component in which users above a certain latitude were having crashes multiple times a day. Had the updater component been in place we could have targeted a special priority update notification only to them.
As stated in the release blog post, the location information is not provided by your local Home Assistant installation but is instead gathered by comparing your IP address against the GeoLite2 data created by MaxMind. From their documentation:
+ +++ +IP geolocation is inherently imprecise. Locations are often near the center of the population. Any location provided by a GeoIP database should not be used to identify a particular address or household.
+
We decided to have it enabled by default because we consider the information that is gathered not harmful. We understand that not everyone will agree with us and so we have provided multiple ways to opt out.
+ +It is in our short-term planning to add an option to control this to our frontend.
+ +The source code of our updater AWS Lambda function is now available here.
+Another two weeks have passed and we are pleased to present Home Assistant 0.32.
+ +The Hacktoberfest is over now. Home Assistant made the 2nd and the 3rd place out of almost 30’000 participating repositories with a total of 528 pull requests closed - that’s an average of 17 pull requests a day! Thanks to all the contributors but also to the team of reviewers. This wouldn’t been possible without you 👏 .
+ +This release has improved the reporting when a config validation error occurs. Thanks to @kellerza you will now get a persistent notification added to your UI when this happens.
+ +This release contains the first asynchronous sensor and camera platforms. @pvizeli and @fabaff ported most of the “internal” sensors to async programming. We hope that you will enjoy the new speed.
+ +@balloob and @pvizeli worked a lot on the improvement of the core itself.
+ +For a long time we have had a bunch of weather sensors but it’s getting better: There is now a Weather component. Sorry, not much more to tell right now. The plans are to create a weather UI element and to improve the initial implementation.
+ +
entity_picture (@armills)hass.data to store internal data (@balloob)send_delay feature (@janLo)known_devices (@kellerza)We’ve added a warning to 0.32 to catch platforms accidentally slowing down Home Assistant. Our aim is to fix these quickly when reported, so here is 0.32.1 with all reported platforms fixed.
+ +Our website has now an additional category called “Ecosystem”. This will become the place where tools, apps, and other helper for the Home Assistant ecosystem can store their documentation or guides.
+ + + +garage_door, rollershutter, thermostat, and hvac have been removed.…don’t hesitate to use our Forum or join us for a little chat. The release notes have comments enabled but it’s preferred if you the former communication channels. Thanks.
+@@ -142,7 +142,7 @@ Long range / High power beacon Waterproof beacon -### {% linkable_title Buying Beacons %} +### Buying Beacons This isn’t a buyer's guide, but I just wanted to mention the iBeacons I’ve been using. I think you should be able to use any iBeacon with HA and OwnTracks. You generally can’t buy beacons in your local electronics shop - so I just wanted to briefly mention the two suppliers I’ve used so far. I’ve bought quite a few iBeacons from a company called [Blue Sense Networks](http://bluesensenetworks.com/). I work in the tech startup sector in the UK so I partly chose them because they are a local start-up who seemed worth supporting. The products, support and software all seem good. I use a number of their beacons - from a simple USB dongle, to a long range beacon. All their products have batteries that can be changed (or no batteries in the case of the externally powered USB device) - and you can configure all the parameters you’d want to using their software. I had one software issue, support got back to me at a weekend(!) - and the issue was resolved with a software release two days later. @@ -155,12 +155,12 @@ I’ve mainly used these as *devices to track* rather that *location* beacons. E The larger Blue Sense Network beacons seem to be better at maintaining a connection that the Estimotes - although that might be because I’m reluctant to turn the power to maximum and reduce the gap between sending packets on the Estimotes where I can’t replace the batteries! -### {% linkable_title Conclusion %} +### Conclusion As I said in [part 1](/blog/2016/04/30/ibeacons-part-1-making-presence-detection-work-better), I’ve found iBeacons to be a good way of improving presence detection. I also used them to track devices like my car and my keys that can’t track themselves. I'm still experimenting, so I hope I can do more with iBeacons. I hope I've encouraged you do so the same. If you do please share your experiences. -### {% linkable_title Notes %} +### Notes Please see the [notes at the end of Part 1](/blog/2016/04/30/ibeacons-part-1-making-presence-detection-work-better/#tips) for documentation information. diff --git a/blog/categories/esp8266/atom.xml b/blog/categories/esp8266/atom.xml index 036909c1d2..e6b3dcde97 100644 --- a/blog/categories/esp8266/atom.xml +++ b/blog/categories/esp8266/atom.xml @@ -4,7 +4,7 @@
@@ -142,7 +142,7 @@ Long range / High power beacon Waterproof beacon -### {% linkable_title Buying Beacons %} +### Buying Beacons This isn’t a buyer's guide, but I just wanted to mention the iBeacons I’ve been using. I think you should be able to use any iBeacon with HA and OwnTracks. You generally can’t buy beacons in your local electronics shop - so I just wanted to briefly mention the two suppliers I’ve used so far. I’ve bought quite a few iBeacons from a company called [Blue Sense Networks](http://bluesensenetworks.com/). I work in the tech startup sector in the UK so I partly chose them because they are a local start-up who seemed worth supporting. The products, support and software all seem good. I use a number of their beacons - from a simple USB dongle, to a long range beacon. All their products have batteries that can be changed (or no batteries in the case of the externally powered USB device) - and you can configure all the parameters you’d want to using their software. I had one software issue, support got back to me at a weekend(!) - and the issue was resolved with a software release two days later. @@ -155,12 +155,12 @@ I’ve mainly used these as *devices to track* rather that *location* beacons. E The larger Blue Sense Network beacons seem to be better at maintaining a connection that the Estimotes - although that might be because I’m reluctant to turn the power to maximum and reduce the gap between sending packets on the Estimotes where I can’t replace the batteries! -### {% linkable_title Conclusion %} +### Conclusion As I said in [part 1](/blog/2016/04/30/ibeacons-part-1-making-presence-detection-work-better), I’ve found iBeacons to be a good way of improving presence detection. I also used them to track devices like my car and my keys that can’t track themselves. I'm still experimenting, so I hope I can do more with iBeacons. I hope I've encouraged you do so the same. If you do please share your experiences. -### {% linkable_title Notes %} +### Notes Please see the [notes at the end of Part 1](/blog/2016/04/30/ibeacons-part-1-making-presence-detection-work-better/#tips) for documentation information. @@ -179,7 +179,7 @@ In 2013 Apple introduced iBeacons: a class of Bluetooth low energy (LE) devices The reason I started using iBeacons was to improve presence detection (and I think that’s the case with most people) so that's what I’ll discuss in _part 1_. In _part 2_ I’ll talk about using iBeacons to track devices that can’t track themselves. -### {% linkable_title Using beacons to improve OwnTracks location data %} +### Using beacons to improve OwnTracks location data When you use OwnTracks in standard _major move_ mode (which is kind to your phone battery) it sometimes fails to update when you’d like it to. In my case I found that it would often send a location update as I was on my way home, but then not update when I got home. The result would be that Home Assistant would think I was 500M away from home, and take quite a while to notice I was home. It would also mean that the automation that should turn on my lights when I got home didn’t work very well! There were a few times when my phone location updated at 2am and turned the lights on for me. Fortunately my wife is very patient! @@ -187,7 +187,7 @@ Luckily, OwnTracks supports iBeacons so I could use them to make presence detect -### {% linkable_title Getting Started %} +### Getting Started To do this you first need to set up [MQTT] and [OwnTracks] in Home assistant - and make sure that HA can track your phone. @@ -196,7 +196,7 @@ To do this you first need to set up [MQTT] and [OwnTracks] in Home assistant - a You then have to (A) tell Home Assistant where the beacon is located and (B) tell OwnTracks to recognise the beacon. -#### {% linkable_title A. Tell Home Assistant where your beacon is located %} +#### A. Tell Home Assistant where your beacon is located You tell HomeAssistant about fixed locations by creating a Zone with the longitude and latitude of your beacon. You should also give the zone a name which you will also use when you set up OwnTracks. An an example this zone specifies the location of my drive way. @@ -215,7 +215,7 @@ The radius isn’t used by the beacon code, but it is used by the GPS location s Once you’ve created the zone - you need to restart HA. The next step is:- -#### {% linkable_title B. Tell OwnTracks to track your beacon %} +#### B. Tell OwnTracks to track your beacon 1. Go to the OwnTracks app on your phone 2. Touch the `Regions` menu at the bottom of the screen @@ -244,7 +244,7 @@ So with the steps above you should be able to improve the reliability of trackin I’m also pleased to say I no longer get an _arrive home_ event at 2am that turns the lights on. I hope I’ve convinced you that iBeacons are worth trying! -### {% linkable_title Mixing Beacons and GPS locations %} +### Mixing Beacons and GPS locations You will probably use beacons to make entry into your existing GPS zones more reliable. By default either a beacon or a GPS location can cause you to enter a zone - and HA has some logic that should make them two work well together (it ignores GPS updates when you’re in an iBeacon Zone). @@ -275,17 +275,17 @@ You could use this technique to try to detect which room someone is in. This mig To get this to work you’ll probably need to experiment with the beacon signal strength to try to match the beacon reception area to the location you want to track. Let me know if you get this to work (it doesn’t make sense in my open plan house) -### {% linkable_title Conclusion %} +### Conclusion Presence tracking sounds easy - and it's an important part of Home Automation. Trying it shows how difficult it is to get presence detection right. I've found that iBeacons have improved the reliability and timeliness of knowing where I am, and I hope I encouraged you to try them too. -### {% linkable_title Tips %} +### Tips You can find out more about configuring the OwnTracks application and beacons [here](http://owntracks.org/booklet/features/beacons/) There is information about configuring Homeassistant to use beacons [here](https://home-assistant.io/components/device_tracker.owntracks/) -#### {% linkable_title Connections and disconnecting %} +#### Connections and disconnecting Owntracks treats a region name with a leading `-` as a hint that it shouldn't disconnect after a single missed packet. This improves the ability to keep a connection to a beacon. @@ -293,7 +293,7 @@ However, even when using this feature I’ve noticed that you can still lose con In automations you can use a `for:` to avoid triggering during a brief disconnect, or use a script with a delay. Stay tuned for _part 2_ for an example of this. -#### {% linkable_title Using Multiple beacons for the same Zone %} +#### Using Multiple beacons for the same Zone iBeacons have a `UUID` (usually set to the same value for beacons from the same manufacturer), as well as a `minor` and `major` number. If you set two beacons to have exactly same details then OwnTracks will think multiple beacons are at the same location. This means you can have more than one beacon around your home - and a connection to any of them will count as `home` to OwnTracks and HA. This reduces disconnections. diff --git a/blog/categories/internet-of-things/atom.xml b/blog/categories/internet-of-things/atom.xml index 496c696355..c1dce0a8bf 100644 --- a/blog/categories/internet-of-things/atom.xml +++ b/blog/categories/internet-of-things/atom.xml @@ -4,7 +4,7 @@
-
+
+ src='/images/screenshots/nexus_7_dashboard.png' />
Example of a hub's dashboard. Showing the state of 2 persons, 4 lights and the sun.
-
+
+ src='/images/architecture/home_automation_landscape.png' />
Overview of the home automation landscape.
-
+
The old logo, the new detailed logo and the new simple logo.
@@ -142,7 +142,7 @@ Long range / High power beacon Waterproof beacon -### {% linkable_title Buying Beacons %} +### Buying Beacons This isn’t a buyer's guide, but I just wanted to mention the iBeacons I’ve been using. I think you should be able to use any iBeacon with HA and OwnTracks. You generally can’t buy beacons in your local electronics shop - so I just wanted to briefly mention the two suppliers I’ve used so far. I’ve bought quite a few iBeacons from a company called [Blue Sense Networks](http://bluesensenetworks.com/). I work in the tech startup sector in the UK so I partly chose them because they are a local start-up who seemed worth supporting. The products, support and software all seem good. I use a number of their beacons - from a simple USB dongle, to a long range beacon. All their products have batteries that can be changed (or no batteries in the case of the externally powered USB device) - and you can configure all the parameters you’d want to using their software. I had one software issue, support got back to me at a weekend(!) - and the issue was resolved with a software release two days later. @@ -155,12 +155,12 @@ I’ve mainly used these as *devices to track* rather that *location* beacons. E The larger Blue Sense Network beacons seem to be better at maintaining a connection that the Estimotes - although that might be because I’m reluctant to turn the power to maximum and reduce the gap between sending packets on the Estimotes where I can’t replace the batteries! -### {% linkable_title Conclusion %} +### Conclusion As I said in [part 1](/blog/2016/04/30/ibeacons-part-1-making-presence-detection-work-better), I’ve found iBeacons to be a good way of improving presence detection. I also used them to track devices like my car and my keys that can’t track themselves. I'm still experimenting, so I hope I can do more with iBeacons. I hope I've encouraged you do so the same. If you do please share your experiences. -### {% linkable_title Notes %} +### Notes Please see the [notes at the end of Part 1](/blog/2016/04/30/ibeacons-part-1-making-presence-detection-work-better/#tips) for documentation information. @@ -179,7 +179,7 @@ In 2013 Apple introduced iBeacons: a class of Bluetooth low energy (LE) devices The reason I started using iBeacons was to improve presence detection (and I think that’s the case with most people) so that's what I’ll discuss in _part 1_. In _part 2_ I’ll talk about using iBeacons to track devices that can’t track themselves. -### {% linkable_title Using beacons to improve OwnTracks location data %} +### Using beacons to improve OwnTracks location data When you use OwnTracks in standard _major move_ mode (which is kind to your phone battery) it sometimes fails to update when you’d like it to. In my case I found that it would often send a location update as I was on my way home, but then not update when I got home. The result would be that Home Assistant would think I was 500M away from home, and take quite a while to notice I was home. It would also mean that the automation that should turn on my lights when I got home didn’t work very well! There were a few times when my phone location updated at 2am and turned the lights on for me. Fortunately my wife is very patient! @@ -187,7 +187,7 @@ Luckily, OwnTracks supports iBeacons so I could use them to make presence detect -### {% linkable_title Getting Started %} +### Getting Started To do this you first need to set up [MQTT] and [OwnTracks] in Home assistant - and make sure that HA can track your phone. @@ -196,7 +196,7 @@ To do this you first need to set up [MQTT] and [OwnTracks] in Home assistant - a You then have to (A) tell Home Assistant where the beacon is located and (B) tell OwnTracks to recognise the beacon. -#### {% linkable_title A. Tell Home Assistant where your beacon is located %} +#### A. Tell Home Assistant where your beacon is located You tell HomeAssistant about fixed locations by creating a Zone with the longitude and latitude of your beacon. You should also give the zone a name which you will also use when you set up OwnTracks. An an example this zone specifies the location of my drive way. @@ -215,7 +215,7 @@ The radius isn’t used by the beacon code, but it is used by the GPS location s Once you’ve created the zone - you need to restart HA. The next step is:- -#### {% linkable_title B. Tell OwnTracks to track your beacon %} +#### B. Tell OwnTracks to track your beacon 1. Go to the OwnTracks app on your phone 2. Touch the `Regions` menu at the bottom of the screen @@ -244,7 +244,7 @@ So with the steps above you should be able to improve the reliability of trackin I’m also pleased to say I no longer get an _arrive home_ event at 2am that turns the lights on. I hope I’ve convinced you that iBeacons are worth trying! -### {% linkable_title Mixing Beacons and GPS locations %} +### Mixing Beacons and GPS locations You will probably use beacons to make entry into your existing GPS zones more reliable. By default either a beacon or a GPS location can cause you to enter a zone - and HA has some logic that should make them two work well together (it ignores GPS updates when you’re in an iBeacon Zone). @@ -275,17 +275,17 @@ You could use this technique to try to detect which room someone is in. This mig To get this to work you’ll probably need to experiment with the beacon signal strength to try to match the beacon reception area to the location you want to track. Let me know if you get this to work (it doesn’t make sense in my open plan house) -### {% linkable_title Conclusion %} +### Conclusion Presence tracking sounds easy - and it's an important part of Home Automation. Trying it shows how difficult it is to get presence detection right. I've found that iBeacons have improved the reliability and timeliness of knowing where I am, and I hope I encouraged you to try them too. -### {% linkable_title Tips %} +### Tips You can find out more about configuring the OwnTracks application and beacons [here](http://owntracks.org/booklet/features/beacons/) There is information about configuring Homeassistant to use beacons [here](https://home-assistant.io/components/device_tracker.owntracks/) -#### {% linkable_title Connections and disconnecting %} +#### Connections and disconnecting Owntracks treats a region name with a leading `-` as a hint that it shouldn't disconnect after a single missed packet. This improves the ability to keep a connection to a beacon. @@ -293,7 +293,7 @@ However, even when using this feature I’ve noticed that you can still lose con In automations you can use a `for:` to avoid triggering during a brief disconnect, or use a script with a delay. Stay tuned for _part 2_ for an example of this. -#### {% linkable_title Using Multiple beacons for the same Zone %} +#### Using Multiple beacons for the same Zone iBeacons have a `UUID` (usually set to the same value for beacons from the same manufacturer), as well as a `minor` and `major` number. If you set two beacons to have exactly same details then OwnTracks will think multiple beacons are at the same location. This means you can have more than one beacon around your home - and a connection to any of them will count as `home` to OwnTracks and HA. This reduces disconnections. diff --git a/blog/categories/presence-detection/atom.xml b/blog/categories/presence-detection/atom.xml index dd34b004b5..d9c6aa0dfb 100644 --- a/blog/categories/presence-detection/atom.xml +++ b/blog/categories/presence-detection/atom.xml @@ -4,7 +4,7 @@
@@ -72,7 +72,7 @@ For a long time we have had a bunch of [weather sensors][weather-sensors] but it
- Device tracker: [iCloud][icloud] improvements ([@Bart274])
- Minor features and bug fixes by [@fabaff], [@kellerza], [@robbiet480], [@balloob], [@DavidLP], [@Bart274], [@sdague], [@mtreinish], [@Khabi], [@bbesset], [@bestlibre], [@pvizeli], [@turbokongen], [@devdelay], [@molobrakos], [@postlund], [@wokar], [@armills], [@arsaboo], [@hartmms], [@nsideras], [@tbeckha], and [@kirichkov].
-### {% linkable_title Release 0.32.1 - November 6 %}
+### Release 0.32.1 - November 6
We've added a warning to 0.32 to catch platforms accidentally slowing down Home Assistant. Our aim is to fix these quickly when reported, so here is 0.32.1 with all reported platforms fixed.
@@ -80,14 +80,14 @@ We've added a warning to 0.32 to catch platforms accidentally slowing down Home
- Fix Radiotherm doing I/O inside the event loop ([@balloob])
- Fix camera MJPEG streams when using HTTP 1.0 ([@balloob])
-### {% linkable_title Release 0.32.2 - November 7 %}
+### Release 0.32.2 - November 7
- Move Honeywell I/O out of the event loop ([@balloob])
- Use sequential updates for non-async entities to prevent race conditions ([@pvizeli])
- Fix setting temperature in Celsius on Radiotherm CT50 thermostats ([@andyat])
- Fix PiLight config validation ([@DavidLP])
-### {% linkable_title Release 0.32.3 - November 11 %}
+### Release 0.32.3 - November 11
- Fix OpenWeather weather platform doing I/O in event loop ([@lwis])
- Fix Alarm.com doing I/O in event loop ([@jnewland])
@@ -103,21 +103,21 @@ We've added a warning to 0.32 to catch platforms accidentally slowing down Home
- Light - Flux Led Lights: allow specifying mode if light does not support white mode ([@DanielHiversen])
- Fix Rest switch default template ([@pvizeli])
-### {% linkable_title Misc %}
+### Misc
Our website has now an additional category called "Ecosystem". This will become the place where tools, apps, and other helper for the Home Assistant ecosystem can store their documentation or guides.
- [iOS](https://home-assistant.io/ecosystem/ios/)
- [SceneGen](https://home-assistant.io/ecosystem/scenegen/)
-### {% linkable_title Breaking changes %}
+### Breaking changes
- The [Yahoo Finance][yahoo] platform supports now multiple stock. Please adjust your configuration.
- Deprecated components `garage_door`, `rollershutter`, `thermostat`, and `hvac` have been removed.
- The minimum Python version on Windows has been bumped to Python 3.5.
- The Insteon Hub integration has been disabled due to a [request from Insteon][req-insteon].
-### {% linkable_title If you need help... %}
+### If you need help...
...don't hesitate to use our [Forum](https://community.home-assistant.io/) or join us for a little [chat](https://gitter.im/home-assistant/home-assistant). The release notes have comments enabled but it's preferred if you the former communication channels. Thanks.
@@ -205,16 +205,16 @@ Every other weekend around here gets a little hectic leading to a big sigh of re
One last thing before we get going though, I should warn you... [@balloob] got a bit lazy this week and let me ([@robbiet480]) step up to the plate again to write the blog post and do the release. I guess I didn't do such a bad job in [0.27][zero-two-seven-release]. You'll never know what surprises I have in store. Now that i've got all that stuff out of the way, let's get started...
-## {% linkable_title Stats Update %}
+## Stats Update
Sadly, no big amazing stats to update you with this time, but we did recently pass 7,000 commits! This release featured submissions from 45 contributors. Hopefully with the new updater component we will be able to give you some really good stats in the 0.32 blog post.
-## {% linkable_title Hacktoberfest %}
+## Hacktoberfest
![Hacktoberfest logo][logo]
October means Hacktoberfest time and our community has really come through with some excellent improvements and additions. As of this writing, we have 194 merged and 41 open pull requests to the [home-assistant repository][hacktoberfest-ha-prs] and 209 merged/28 open pull requests submitted to the [home-assistant.github.io repository][hacktoberfest-site-prs]. If you want to get in on the fun check out our [Hacktoberfest][hacktoberfest-blog] blog post or the [Hacktoberfest website][hacktoberfest-website]. You get an awesome t-shirt for free if you have 4 pull requests merged in the month of October! We even have tasks that a non-developer can easily accomplish with a tiny bit of work. Better hurry up though, only 9 days left and most of the easy tasks are gone!
-## {% linkable_title ⚠️ A greatly improved updater component (Please read this!) ⚠️ %}
+## ⚠️ A greatly improved updater component (Please read this!) ⚠️
This release includes an update to our [updater] component. The responsibility of the updater component is to check if a new version is available and notify the user if this is the case.
@@ -226,7 +226,7 @@ It used to be that this component would check with [PyPi] (the Python package ma
So to work around these problems, we decided to start hosting the version check service ourselves. Since we had to get some infrastructure spun up anyway, we figured we would take it a step further. Which leads me to this bit of the update (the most important part):
-### {% linkable_title What you need to know (the important bit!) %}
+### What you need to know (the important bit!)
Remember how I mentioned that up there in the title that there is some serious business in this release? Well, we also added some basic analytics to the updater component which get sent to the server and stored so that we get a better idea of our user base.
@@ -297,7 +297,7 @@ _This section was updated on October 24 to be more clear about geo-lookups being
Now, back to the fun stuff...
-## {% linkable_title Good evening. I'm Ron Burgundy and here's what happening in your world tonight. %}
+## Good evening. I'm Ron Burgundy and here's what happening in your world tonight.
Home Assistant got a crazy idea recently that it couldn't do enough already and wanted to challenge itself even more. I really don't understand how it came up with this kooky idea, but it now thinks that its newest hobby should be a minor career in journalism.
@@ -312,7 +312,7 @@ Now I know how to best get to [my real job][runway] (no, Home Assistant is _not_
You stay classy, San Diego. (It's funny, because balloob lives in San Diego))
-## {% linkable_title Major breaking Z-Wave changes ahead %}
+## Major breaking Z-Wave changes ahead
A rather nasty Z-Wave [issue][z-wave-issue] was discovered recently by [@lukas-hetzenecker]. There was a somewhat large chance that if you had multiple of the same model Z-Wave device they may both try to use the same entity IDs. To fix the issue the internal Z-Wave index is now appended to the end of all Z-Wave entity IDs.
@@ -328,7 +328,7 @@ Your todo list may be a little different from mine, I just wanted to outline the
This is super annoying, I know, especially since we had said in [0.12][zero-one-two-release] that Z-Wave IDs should hopefully never change again, but we are now forced to eat those words. I will state again that Z-Wave IDs shouldn't change in the future but obviously we see how that went. To sum up on this section... sorry but it had to happen.
-## {% linkable_title All changes %}
+## All changes
- [Updater] component ([@infamy], [@robbiet480], [@kellerza])
- Continue to setup other platforms when 1 platform config is invalid ([@kellerza])
@@ -379,24 +379,24 @@ This is super annoying, I know, especially since we had said in [0.12][zero-one-
- iOS support ([@robbiet480])
- Minor features and bug fixes by [@mtl010957], [@molobrakos], [@flyte], [@fabaff], [@phardy], [@sander76], [@T3m3z], [@c-w], [@balloob], [@robbiet480], [@StaticCube], [@vittoriom], [@hartmms], [@kirichkov], [@mezz64], [@ishults], [@Danielhiversen] and [@tchellomello].
-### {% linkable_title Release 0.31.1 - October 24 %}
+### Release 0.31.1 - October 24
- Identify special character encoding error in YAML files ([@kellerza], [@lwis])
- iOS app component bug fixes ([@robbiet480])
- Fix a spelling problem on user-facing error ([@robbiet480])
- YAML includes will ignore dirs/files prefixed with . ([@lwis])
-## {% linkable_title Breaking changes %}
+## Breaking changes
- The [HTTP] component now takes a different format for authenticating IPs
- Configuration format has changed for [Proximity]
- The [Arduino] platform are now covered by the configuration check. Please check the documentation to see how.
- The Z-Wave entity ID change mentioned above
-## {% linkable_title If you need help... %}
+## If you need help...
...don't hesitate to use our [Forum](https://community.home-assistant.io/) or join us for a little [chat](https://gitter.im/home-assistant/home-assistant). The release notes have comments enabled but it's preferred if you the former communication channels. Thanks.
-## {% linkable_title Until next time %}
+## Until next time
Thanks for reading all of the above, especially since this week was a pretty long post. We should be back with a new post around November 5th announcing the arrival of 0.32.
@@ -506,27 +506,27 @@ A large amount of resources of the development are still focusing on the effort
To reduce the run-time of your tests, [@balloob] did a lot of tweaking. For now the RFXtrx tests are excluded which cut the needed time for running on your Pull Request in half.
-### {% linkable_title Documentation %}
+### Documentation
All configuration sample entries are now minimized. This should help to avoid problem for starters and newbies as they only get what's needed and not a full sample with all optional entries. If there is an issue with an entry in your `configuration.yaml` file the error message will provide you an URL that point to the documentation.
- 
+
- 
+
@@ -585,13 +585,13 @@ sensor
- Device Tracker: The `known_device.yaml` file is now validated ([@kellerza])
- Minor features and bug fixes by [@tchellomello], [@pavoni], [@fabaff], [@pvizeli], [@lwis], [@turbokongen], [@Danielhiversen], [@persandstrom], [@balloob], [@robbiet480], [@sam-io], [@bbangert], and you if you are missing here.
-### {% linkable_title Release 0.30.1 - October 8 %}
+### Release 0.30.1 - October 8
- Device Tracker `known_devices.yaml` validation is now more accepting ([@kellerza])
- Handle X10 light numbers greater than 9 ([@mtl010957])
- Fix command line covers without a template ([@roidayan])
-### {% linkable_title Release 0.30.2 - October 12 %}
+### Release 0.30.2 - October 12
- Handle Volvo's with dashes in their name ([@molobrakos])
- Fix some html5 push notification configuration options were discarded after first use ([@T3m3z])
@@ -601,7 +601,7 @@ sensor
- Fix for Slack targets ([@fabaff])
- Fix for Pushover targets ([@Nixon506E])
-### {% linkable_title Breaking changes %}
+### Breaking changes
- All deprecated condition options from `automation` have been removed (deprecated since May and have printed warnings to your console):
- `use_trigger_values` is gone. You have to copy your triggers to conditions and adjust for the correct config.
@@ -610,7 +610,7 @@ sensor
- The [Forecast.io][forecast] was renamed to [Dark Sky][darksky]. Replace your `- platform: forecast` with `- platform: darksky`.
- The [aREST][arest] configuration between the [sensor][arest-sensor] and the [switch][arest-switch] platform was aligned.
-### {% linkable_title If you need help... %}
+### If you need help...
...don't hesitate to use our [Forum](https://community.home-assistant.io/) or join us for a little [chat](https://gitter.im/home-assistant/home-assistant). The release notes have comments enabled but it's preferred if you the former communication channels. Thanks.
[@balloob]: https://github.com/balloob
@@ -684,23 +684,23 @@ This is a big release as we've completely overhauled the internals of Home Assis
This all changed when [@bbangert] came around and took on the tough job to migrate the core over to use asynchronous programming. He did an amazing job and I am happy to say that the initial port has been done and is included in this release! On top of that, we have been able to keep our simple and straightforward API at the same time. We are still in the process of migrating more and more components over to the asynchronous API, so expect more speedups and awesome features in the upcoming releases.
-### {% linkable_title SleepIQ and OpenALPR %}
+### SleepIQ and OpenALPR
There now is support for two new super cool things: Beds and license plates. [@technicalpickles] created a [SleepIQ] component that let you monitor the sensor data of your bed. [@pvizeli] has added license plate recognition based on [OpenALPR]! This means that you can now be notified about which car is parked on your driveway or in your garage. I also would like to use this opportunity to give a big shoutout to [@pvizeli] for being such an awesome member of our community. He joined us at the end of June and has helped crush bugs and add awesome features ever since (65 pull requests already!).
-### {% linkable_title Configuration validation %}
+### Configuration validation
On the voluptuous front we have also made great progress. We were able to fully remove the legacy config helpers and have migrated 323 of the 346 components and platforms that needed migrating! This does mean that for some components the configuration has slightly changed, make sure to check out the breaking changes section at the bottom for more info. Thanks everybody for reviewing the Pull requests, testing the changes, and reporting issues.
-### {% linkable_title Delayed Release %}
+### Delayed Release
As you might have noticed, this release has been delayed by 5 days. This was due to a rare, difficult to reproduce problem with the Python interpreter. A huuuuge thanks to all the people that have helped countless hours in researching, debugging and fixing this issue: [@bbangert], [@turbokongen], [@lwis], [@kellerza], [@technicalpickles], [@pvizeli], [@persandstrom] and [@joyrider3774]. I am grateful to have all of you as part of the Home Assistant community.
-### {% linkable_title Hide automation rules %}
+### Hide automation rules
Since 0.28 [automation rules](/blog/2016/09/10/notify-group-reload-api-pihole/#reload-automation-rules) can be reloaded directly from the frontend. By default all automation rules are shown. If you want to [hide an automation rule](/getting-started/automation-create-first/), use `hide_entity: True`.
-### {% linkable_title All changes %}
+### All changes
@@ -736,39 +736,39 @@ Since 0.28 [automation rules](/blog/2016/09/10/notify-group-reload-api-pihole/#r
- [OpenALPR] support ([@pvizeli])
- Minor features and bug fixes by [@fabaff], [@w1ll1am23], [@turbokongen], [@clach04], [@mKeRix], [@pvizeli], [@DavidLP], [@nvella], [@Teagan42], [@ericwclymer], [@wokar], [@kellerza], [@nkgilley], [@jawilson], [@Danielhiversen], [@ej81], [@danieljkemp], [@balloob], [@philhawthorne], [@LinuxChristian], [@milas], [@simonszu], [@Cinntax], [@irvingwa], [@sytone], [@kk7ds], [@robbiet480].
-### {% linkable_title Hotfix 0.29.1 - September 29 %}
+### Hotfix 0.29.1 - September 29
- Fix typo in Nest climate platform. [We are still experiencing issues with Nest.][nest-issues] ([@tchellomello])
-### {% linkable_title Hotfix 0.29.2 - September 29 %}
+### Hotfix 0.29.2 - September 29
- InfluxDB config fix ([@fabaff], reported by [@lwis])
- Netatmo config fix ([@jabesq])
-### {% linkable_title Hotfix 0.29.3 - September 29 %}
+### Hotfix 0.29.3 - September 29
- Hue config fix ([@pvizeli])
-### {% linkable_title Hotfix 0.29.4 - September 30 %}
+### Hotfix 0.29.4 - September 30
- Alexa config fix ([@balloob], reported by [@lwis])
- Envisalink discovery fix ([@cinntax])
- Acer Projector config fix ([@pvizeli])
-### {% linkable_title Hotfix 0.29.5 - September 30 %}
+### Hotfix 0.29.5 - September 30
- Fix Climate Nest platform ([@tchellomello], [@jawilson])
-### {% linkable_title Hotfix 0.29.6 - October 1 %}
+### Hotfix 0.29.6 - October 1
- Fix segmentation fault ([@bbangert]) 🎉
- Fix nested templates in `data_template` would incorrectly get cached ([@balloob])
-### {% linkable_title Hotfix 0.29.7 - October 5 %}
+### Hotfix 0.29.7 - October 5
- Fix handling SIGTERM and SIGHUP signals (fixes Systemd restart issues) ([@pvizeli])
-### {% linkable_title Breaking changes %}
+### Breaking changes
- The template methods `now` and `utcnow` have been changed from variables to methods. To get the current time replace `now` with `now()`.
- `yahooweather` default name is now `yweather`. Also min and max temperature are now correctly called `Temperature Min` and `Temperature Max`.
@@ -777,7 +777,7 @@ Since 0.28 [automation rules](/blog/2016/09/10/notify-group-reload-api-pihole/#r
- For Wink, make sure your config only contains the access token as in the [docs][Wink].
- Nest sensor 'mode' has been renamed to 'operation_mode'
-### {% linkable_title If you need help... %}
+### If you need help...
...don't hesitate to use our [Forum](https://community.home-assistant.io/) or join us for a little [chat](https://gitter.im/home-assistant/home-assistant). The release notes have comments enabled but it's preferred if you the former communication channels. Thanks.
[nest-issues]: https://github.com/home-assistant/home-assistant/issues/3574
@@ -866,27 +866,27 @@ Since 0.28 [automation rules](/blog/2016/09/10/notify-group-reload-api-pihole/#r
- 
+
@@ -925,14 +925,14 @@ The validation of the configuration is still on-going. Approximatly 80 % is done
- Modbus: New `write_registers` [Modbus] service ([@persandstrom])
- Device tracker: Fix TP-Link Archer C7 long passwords ([@snikch])
-### {% linkable_title Hotfix 0.28.1 - September 12 %}
+### Hotfix 0.28.1 - September 12
- Fix: Simplisafe alarm control panels accept any string for code ([@tchellomello])
- Fix: Z-Wave would sometimes not detect all thermostats ([@turbokongen])
- Fix: Automatic device tracker when 2 or more cars are tracked ([@teagan42])
- Fix: Group ordering is now based on config again ([@balloob], [@kellerza])
-### {% linkable_title Hotfix 0.28.2 - September 13 %}
+### Hotfix 0.28.2 - September 13
- Light - pilight: Fix send RF code ([@DavidLP])
- Recorder: Fix specifying SQLite ([@pvizeli])
@@ -941,7 +941,7 @@ The validation of the configuration is still on-going. Approximatly 80 % is done
- Allow changing covers using scenes ([@nvella])
- Device tracker - Automatic: Fix polling ([@teagan42])
-### {% linkable_title Breaking changes %}
+### Breaking changes
- [OpenweatherMap] entity IDs are now like `sensor.owm_temperature`. Previously they were like `sensor.weather_temperature`. Apologies for this change, but we needed to make OpenWeatherMap more generic now that we have many weather platforms.
- Updates of configuration variables due to configuration check or alignment with other platforms. Please update your configuration entries according to the documentation:
@@ -952,7 +952,7 @@ The validation of the configuration is still on-going. Approximatly 80 % is done
- [switch][command-line-switch] and the [cover][command-line-cover] `command_line` platforms
- Custom components extending `BaseNotificationService` need to be aware that `kwargs.get(ATTR_TITLE)` will now return `None` if a title has not been set, and will need to specify `kwargs.get(ATTR_TITLE, ATTR_TITLE_DEFAULT)` if they always require a title.
-### {% linkable_title If you need help... %}
+### If you need help...
...don't hesitate to use our [Forum](https://community.home-assistant.io/) or join us for a little [chat](https://gitter.im/home-assistant/home-assistant).
diff --git a/blog/categories/survey/atom.xml b/blog/categories/survey/atom.xml
index 5c0fbc104a..43ab86f089 100644
--- a/blog/categories/survey/atom.xml
+++ b/blog/categories/survey/atom.xml
@@ -4,7 +4,7 @@
Another two weeks have passed and we are pleased to present Home Assistant 0.32.
+ +The Hacktoberfest is over now. Home Assistant made the 2nd and the 3rd place out of almost 30’000 participating repositories with a total of 528 pull requests closed - that’s an average of 17 pull requests a day! Thanks to all the contributors but also to the team of reviewers. This wouldn’t been possible without you 👏 .
+ +This release has improved the reporting when a config validation error occurs. Thanks to @kellerza you will now get a persistent notification added to your UI when this happens.
+ +This release contains the first asynchronous sensor and camera platforms. @pvizeli and @fabaff ported most of the “internal” sensors to async programming. We hope that you will enjoy the new speed.
+ +@balloob and @pvizeli worked a lot on the improvement of the core itself.
+ +For a long time we have had a bunch of weather sensors but it’s getting better: There is now a Weather component. Sorry, not much more to tell right now. The plans are to create a weather UI element and to improve the initial implementation.
+ +
entity_picture (@armills)hass.data to store internal data (@balloob)send_delay feature (@janLo)known_devices (@kellerza)We’ve added a warning to 0.32 to catch platforms accidentally slowing down Home Assistant. Our aim is to fix these quickly when reported, so here is 0.32.1 with all reported platforms fixed.
+ +Our website has now an additional category called “Ecosystem”. This will become the place where tools, apps, and other helper for the Home Assistant ecosystem can store their documentation or guides.
+ + + +garage_door, rollershutter, thermostat, and hvac have been removed.…don’t hesitate to use our Forum or join us for a little chat. The release notes have comments enabled but it’s preferred if you the former communication channels. Thanks.
+ + + +On Saturday, we released Home Assistant 0.31 which includes an improved updater component that checks for new versions using the Home Assistant servers. We wanted to update the community on its rollout and answer some questions that have come up. As part of the update check anonymous information about your operating system and Python version is submitted to Home Assistant servers unless you have opted out.
+ +This change was driven by two important factors.
+ +As a user, you will be able to be notified if you are running a Home Assistant version that includes components that have known security flaws.
+ +Although we hope to not have to use this feature often, it is important for us to be able to reach out to impacted users. We had the need for such a feature once in the past. Due to a bug the forecast.io sensor was making a huge amount of API requests causing some of our users to get charged because they went over the free quota.
+ +Please note that this functionality is not done yet but will be available in a future release.
+ +As developers of Home Assistant, we will be able to see in what kind of environments Home Assistant is running. Here’s a few data points we didn’t have until now:
+ +We store the city so that we can see where our users are from. This information will be used to give us a better insight in where our users are from. This will help us gather data to see if we should for example prioritize internationalization. In addition, we previously had a nasty bug with the sun component in which users above a certain latitude were having crashes multiple times a day. Had the updater component been in place we could have targeted a special priority update notification only to them.
As stated in the release blog post, the location information is not provided by your local Home Assistant installation but is instead gathered by comparing your IP address against the GeoLite2 data created by MaxMind. From their documentation:
+ +++ +IP geolocation is inherently imprecise. Locations are often near the center of the population. Any location provided by a GeoIP database should not be used to identify a particular address or household.
+
We decided to have it enabled by default because we consider the information that is gathered not harmful. We understand that not everyone will agree with us and so we have provided multiple ways to opt out.
+ +It is in our short-term planning to add an option to control this to our frontend.
+ +The source code of our updater AWS Lambda function is now available here.
+ + + +Hello again friend,
+ +How are you? Having a good day? We sure are. If you aren’t having a good day, this might cheer you up…
+ +Every other weekend around here gets a little hectic leading to a big sigh of relief as we release a new version of Home Assistant to the world. And this time is no different. Our developer community has once again built us a beautiful new release with lots of new features and improvements. We hope you like it.
+ +One last thing before we get going though, I should warn you… @balloob got a bit lazy this week and let me (@robbiet480) step up to the plate again to write the blog post and do the release. I guess I didn’t do such a bad job in 0.27. You’ll never know what surprises I have in store. Now that i’ve got all that stuff out of the way, let’s get started…
+ +Sadly, no big amazing stats to update you with this time, but we did recently pass 7,000 commits! This release featured submissions from 45 contributors. Hopefully with the new updater component we will be able to give you some really good stats in the 0.32 blog post.
+ +
October means Hacktoberfest time and our community has really come through with some excellent improvements and additions. As of this writing, we have 194 merged and 41 open pull requests to the home-assistant repository and 209 merged/28 open pull requests submitted to the home-assistant.github.io repository. If you want to get in on the fun check out our Hacktoberfest blog post or the Hacktoberfest website. You get an awesome t-shirt for free if you have 4 pull requests merged in the month of October! We even have tasks that a non-developer can easily accomplish with a tiny bit of work. Better hurry up though, only 9 days left and most of the easy tasks are gone!
+ +This release includes an update to our updater component. The responsibility of the updater component is to check if a new version is available and notify the user if this is the case.
+ +It used to be that this component would check with PyPi (the Python package manager) to see if a new update was available. This had a couple of problems:
+ +So to work around these problems, we decided to start hosting the version check service ourselves. Since we had to get some infrastructure spun up anyway, we figured we would take it a step further. Which leads me to this bit of the update (the most important part):
+ +Remember how I mentioned that up there in the title that there is some serious business in this release? Well, we also added some basic analytics to the updater component which get sent to the server and stored so that we get a better idea of our user base.
+ +Each Home Assistant instance running the updater component will generate a unique ID (based on UUIDv4) that will be used for the updater to be able to differentiate between instances. This UUID will be stored in your config directory in a file called .uuid.
There are two ways to opt-out. The first way is by using the new opt_out option for the updater. This way the updater will continue to check for updates, but no information about your system will be shared with us.
updater:
+ reporting: no
+You can also disable the updater component entirely by removing updater: from your configuration.yaml although we would not suggest you do this as you would miss any critical updates.
Finally, you can also reset your unique identifier by deleting the .uuid file and restarting Home Assistant.
Here is what my production Home Assistant instance looks like from the server side:
+ +| Name | +Description | +Example | +
|---|---|---|
arch |
+ CPU Architecture | +x86_64 |
+
distribution |
+ Linux Distribution name (only Linux) | +Ubuntu |
+
docker |
+ True if running inside Docker | +false |
+
os_name |
+ Operating system name | +Darwin |
+
os_version |
+ Operating system version | +10.12 |
+
python_version |
+ Python version | +3.5.2 |
+
timezone |
+ Timezone | +America/Los_Angeles |
+
user_agent |
+ User agent used to submit analytics | +python-requests/2.11.1 |
+
uuid |
+ Unique identifier | +10321ee6094d4a2ebb5ed55c675d5f5e |
+
version |
+ Home Assistant version | +0.31.0 |
+
virtualenv |
+ True if running inside virtualenv | +true |
+
In addition to the above collected data, the server will also use your IP address to do a geographic IP address lookup to determine the city that you are from. To be extremely, extremely clear about this bit: The Home Assistant updater does not: store your IP address in a database and also does not submit the location information from your configuration.yaml.
+
+ Geo-lookup on my IP resolves to Oakland with latitude/longitude pointing at the geographical center of the city.
+
The server also adds two timestamps to the data: the original date your instance UUID was first seen and the timestamp of the last time we have seen your instance. This gives us the following extra data:
+ +| Name | +Description | +Example | +
|---|---|---|
first_seen_datetime |
+ First time instance ID was submitted | +2016-10-22T19:56:03.542Z |
+
geo_city |
+ GeoIP determined city | +Oakland |
+
geo_country_code |
+ GeoIP determined country code | +US |
+
geo_country_name |
+ GeoIP determined country name | +United States |
+
geo_latitude |
+ GeoIP determined latitude (of the city) | +37.8047 |
+
geo_longitude |
+ GeoIP determined longitude (of the city) | +-122.2124 |
+
geo_metro_code |
+ GeoIP determined metro code | +807 |
+
geo_region_code |
+ GeoIP determined region code | +CA |
+
geo_region_name |
+ GeoIP determined region name | +California |
+
geo_time_zone |
+ GeoIP determined time zone | +America/Los_Angeles |
+
geo_zip_code |
+ GeoIP determined zip code | +94602 |
+
last_seen_datetime |
+ Most recent time instance ID was submitted | +2016-10-22T19:56:03.542Z |
+
This data is held in the highest security. The update system runs in a secured Amazon Web Services account owned by me (@robbiet480). I personally have 5 years of experience with complex AWS deployments and have an extensive security background. I have audited the entire system and made sure to take every step to protect the data, including limiting who has access (just @balloob and myself). While not directly personally identifiable we absolutely understand some users hesistance to giving this information out. Please understand that we are only collecting this information to better understand our user base to provide better long term support and feature development then is currently possible.
+ +We currently have no plans to publicly expose any of this information. If we did do such a thing in the future we would of course notify you in advance. It must also be stated that we will never sell or allow the use of this information for non-Home Assistant purposes.
+ +We thank you for understanding why we are collecting this data and hope that you leave the feature enabled but fully understand if you feel uncomfortable with this.
+ +This section was updated on October 24 to be more clear about geo-lookups being on the city level. See original version.
+ +Now, back to the fun stuff…
+ +Home Assistant got a crazy idea recently that it couldn’t do enough already and wanted to challenge itself even more. I really don’t understand how it came up with this kooky idea, but it now thinks that its newest hobby should be a minor career in journalism.
+ +0.31 adds support for the brand spanking new Alexa Flash Briefing API, allowing you to get updates from Home Assistant anytime you ask Alexa to read your flash briefing. What’s the use case you ask? Well, now when I wake up in the morning and get my flash briefing, Home Assistant adds this to the end of it for me:
+ +++ +Drive time with traffic is 35 minutes. There is an UberPOOL that will cost $11.52, estimated to be 2 minutes away, for a total of 37 minutes. BART is currently estimated to take 29 minutes. You should take BART, as it is estimated to be faster by 8 minutes.
+
Now I know how to best get to my real job (no, Home Assistant is not my real job, it does seem like it sometimes though) every morning. Obviously not the best home automation example, but I think you get the idea. I could see this being used to tell you any major events that happened in your home overnight or reading you your hyperlocal weather report. Thanks to the audio support you could even replace all of the default Alexa Flash Briefing sources with your own news feeds. Home Assistant supports both text and audio content as well as displaying data in the Alexa app. I also want to point out that unlike the existing Skill integration, the Flash Briefing API does not require HTTPS (but you should still be using HTTPS if possible). For more information, check out the new docs.
+ +
+
+ You stay classy, San Diego. (It’s funny, because balloob lives in San Diego))
+
A rather nasty Z-Wave issue was discovered recently by @lukas-hetzenecker. There was a somewhat large chance that if you had multiple of the same model Z-Wave device they may both try to use the same entity IDs. To fix the issue the internal Z-Wave index is now appended to the end of all Z-Wave entity IDs.
+ +What this means for all you Z-Wave users is that you will need to update your configurations to reflect the change. I personally have quite a few (17) Z-Wave devices and went through the process this week. Here’s what I had to do:
+ +zwave.customize sectionemulated_hue with Alexa and emulated_hue uses the entity ID as a unique identifier I also had to remove all Z-Wave devices from Alexa and re-add them.Your todo list may be a little different from mine, I just wanted to outline the steps I took to give you an idea of what you need to think about. It’s not a very hard process, especially when using global find and replace in Sublime Text but did take me about 20 minutes to complete.
+ +This is super annoying, I know, especially since we had said in 0.12 that Z-Wave IDs should hopefully never change again, but we are now forced to eat those words. I will state again that Z-Wave IDs shouldn’t change in the future but obviously we see how that went. To sum up on this section… sorry but it had to happen.
+ +approved_ips from string to CIDR validation (@mweinelt)known_devices.yaml reading and writing tweaks and fixes (@kellerza)fail filter added to templates to raise on UndefinedError (@jaharkes)…don’t hesitate to use our Forum or join us for a little chat. The release notes have comments enabled but it’s preferred if you the former communication channels. Thanks.
+ +Thanks for reading all of the above, especially since this week was a pretty long post. We should be back with a new post around November 5th announcing the arrival of 0.32.
+ +– Robbie
+ + + +Yes, after only nine days comes 0.30. Don’t worry, we will try to keep our usual release cycle and not start to release every day.
+ +We guess that you already know: The Raspberry Pi image is available now. For Hassbian, @Landrash has combined the most essential parts for a Home Assistant setup in an easy-to-use image for the Raspberry Pi device family. Hassbian is quite young, thus we are looking forward to recieve feedback, issue report, and suggestions to improve it.
+ +A large amount of resources of the development are still focusing on the effort to move Home Assistant further to asynchronous programming. It’s a labor-intensive task, comes with segmentation faults, and unstable instances when certain combinations of sensors are used. The benefit will be more speed in the near future.
+ +To reduce the run-time of your tests, @balloob did a lot of tweaking. For now the RFXtrx tests are excluded which cut the needed time for running on your Pull Request in half.
+ +All configuration sample entries are now minimized. This should help to avoid problem for starters and newbies as they only get what’s needed and not a full sample with all optional entries. If there is an issue with an entry in your configuration.yaml file the error message will provide you an URL that point to the documentation.
+
+
As soon as the Hacktoberfest started there were a lot of incoming Pull Requests for the documentation. A huge “Thank you” to all participants. Especially, we would like to give a cookie to @hillaryfraley. She created around a dozen Pull Requests so far and didn’t only fix typos but complete sections. The Hacktoberfest is still on-going and we are looking forward to get more Pull Requests.
+ +With the statistics sensor we would like to introduce a new sensor that is similar to the template sensor or the trend sensor. This sensor is consuming values from another sensor and is doing some statistical analysis of the data. Over a group of samples is the average/mean, the min/max, the total, the standard deviation, and the variance calculated which can be used in your automation rules. If the source is a binary sensor then the state changes are counted.
+ +
+
+
As the results are processed on-the-fly you still need to use the data from your database for a in-depth analysis of your stored information. Check the latest notebook for doing statistics with your Home Assistant database.
+ +There was a lot of work done on our implementation which are working with RESTful APIs. @w1ll1am23 extended the aREST platforms to display if an aREST unit is available or not. The aREST implementations are now covered by the configuration check as well. Please check the Breaking changes section for more details.
+ +The REST sensor supports now HTTP authentication (basic and digest) and custom headers. This will allow you to access resources which are protected. This sample sensor will access GitHub and retrieve the latest release number while by-passing the rate limit for non-authenticated requests.
+ +sensor
+ - platform: rest
+ resource: https://api.github.com/repos/home-assistant/home-assistant/releases/latest
+ username: YOUR_GITHUB_USERNAME
+ password: YOUR_GITHUB_ACCESS_TOKEN
+ authentication: basic
+ value_template: '{{ value_json.tag_name }}'
+ headers:
+ Accept: application/vnd.github.v3+json
+ Content-Type: application/json
+ User-Agent: Home Assistant REST sensor
+
known_device.yaml file is now validated (@kellerza)known_devices.yaml validation is now more accepting (@kellerza)notify.html5_unnamed_device_2) the target was not submitted to the platform as a list causing iteration over every character in the string. (@robbiet480)automation have been removed (deprecated since May and have printed warnings to your console):
+ use_trigger_values is gone. You have to copy your triggers to conditions and adjust for the correct config.condition_type is gone. Use condition: or instead.condition: instead of platform:.- platform: forecast with - platform: darksky.…don’t hesitate to use our Forum or join us for a little chat. The release notes have comments enabled but it’s preferred if you the former communication channels. Thanks.
+ + + +Home Assistant will join this year for Hacktoberfest, an event organised by DigitalOcean and GitHub to support and celebrate open source. The idea is that open source projects like Home Assistant will gather a bunch of entry-level bugs, features and documentation enhancements and that you, a current or future contributor, will fix them. If you submit four pull-requests during the month of October you will have earned yourself a limited edition Hacktoberfest T-shirt!
+ +Why contribute to Home Assistant:
+ +Resources to get started:
+ +Are you not a programmer but still want to contribute to Home Assistant? Check out our list of entry-level issues for the Home Assistant website.
+ +
Today we’re happy to announce our brand new Raspberry Pi image! It is based on Raspbian Lite combined with HASS so we decided to call it Hassbian.
+ +This image comes pre-installed with everything you need to get started with Home Assistant right away.
+ +To get started, check out the installation instructions in the getting started section or watch the latest video by BRUHAutomation:
+ +It’s based on Raspbian Lite and generated with a fork of the same script that builds the official Raspbian images. For installation of HASS it follows the same install instructions as the Manual installation. Please note that this project has no association with the Raspberry Pi foundation or their projects.
+ +On first boot the latest release of Home Assistant will be installed and can be reached after 3~5 minutes. Pre-installed on this image is the MQTT broker Mosquitto, Bluetooth support and settings for the homeassistant account to use the GPIO pins of the Raspberry Pi. Mosquitto is not activated by default.
As it is today there is no pre-compiled Z-Wave support but it can be installed by following the Getting started instructions for Z-Wave.
+ +Happy Automating!
+ + + +Two weeks ago, September 17 marked our 3 year anniversary. In this time Home Assistant managed to grow from a simple script that turned on my lights when the sun set to a kick ass open source project with the best community an open-source project could wish for. This release contains features, bug fixes and performance tweaks by a total of 50 different people! We have also managed to cross the 1000 forks on GitHub. Talking about momentum!
+ +This is a big release as we’ve completely overhauled the internals of Home Assistant. When I initially wrote Home Assistant, still figuring out the ins and outs of Python, I went for an approach that I was familiar with for an application with many moving parts: threads and locks. This approach has served us well over the years but it was slower than it needed to be, especially on limited hardware.
+ +This all changed when @bbangert came around and took on the tough job to migrate the core over to use asynchronous programming. He did an amazing job and I am happy to say that the initial port has been done and is included in this release! On top of that, we have been able to keep our simple and straightforward API at the same time. We are still in the process of migrating more and more components over to the asynchronous API, so expect more speedups and awesome features in the upcoming releases.
+ +There now is support for two new super cool things: Beds and license plates. @technicalpickles created a SleepIQ component that let you monitor the sensor data of your bed. @pvizeli has added license plate recognition based on OpenALPR! This means that you can now be notified about which car is parked on your driveway or in your garage. I also would like to use this opportunity to give a big shoutout to @pvizeli for being such an awesome member of our community. He joined us at the end of June and has helped crush bugs and add awesome features ever since (65 pull requests already!).
+ +On the voluptuous front we have also made great progress. We were able to fully remove the legacy config helpers and have migrated 323 of the 346 components and platforms that needed migrating! This does mean that for some components the configuration has slightly changed, make sure to check out the breaking changes section at the bottom for more info. Thanks everybody for reviewing the Pull requests, testing the changes, and reporting issues.
+ +As you might have noticed, this release has been delayed by 5 days. This was due to a rare, difficult to reproduce problem with the Python interpreter. A huuuuge thanks to all the people that have helped countless hours in researching, debugging and fixing this issue: @bbangert, @turbokongen, @lwis, @kellerza, @technicalpickles, @pvizeli, @persandstrom and @joyrider3774. I am grateful to have all of you as part of the Home Assistant community.
+ +Since 0.28 automation rules can be reloaded directly from the frontend. By default all automation rules are shown. If you want to hide an automation rule, use hide_entity: True.
data_template would incorrectly get cached (@balloob)now and utcnow have been changed from variables to methods. To get the current time replace now with now().yahooweather default name is now yweather. Also min and max temperature are now correctly called Temperature Min and Temperature Max.ffmpeg is now a component for manage some things central. All ffmpeg_bin options have moved to this compoment from platforms.…don’t hesitate to use our Forum or join us for a little chat. The release notes have comments enabled but it’s preferred if you the former communication channels. Thanks.
+ + + +It’s already time for 0.28 thanks to our super short release cycles. Now, it’ official…we hit 4000 stars on Github. That’s amazing. Sorry, not as amazing as all the stuff that was going on for 0.27 but still pretty awesome.
+ +This release brings you a huge improvement of the automation and group handling. Both can be reloaded without a Home Assistant restart by calling their new reload services. The automations can be controlled directly from the frontend.
+ +
+
+
Singleboard computers are very popular to run Home Assistant. To support this fact, the installation documentation for the Raspberry Pi devices was re-written to get users started as quickly as possible. @Landrash took the lead with on this tasks with help from @kellerza and @MartinHjelmare.
+ +There are countless bugfixes included in this release which will make your experience with the climate and the cover platforms better. Two week ago was the biggest merger of implementations released that ever happened in the history of Home Assistant. Thanks to @turbokongen, @pvizeli, @djbanks, @danielperna84, and others the improvements on the code and the frontend side is continuing…
The Home Assistant API Documentation is a great addition to the already exisiting user documentation. The focus is not end-users but developers who whant to get details about the code without actually browsing the code on Github.
+ +The validation of the configuration is still on-going. Approximatly 80 % is done. This means that we will propably talk about this topic in the next release notes again. To align the configuration of components and platforms we needed to break some. Please refer to the Breaking changes section to check if you need to update your configuration or simple check your log for configuration validation errors. Thanks to @kellerza, @fabaff, @Teagan42, and @pvizeli for your effort!
+ +
known_devices file (@kellerza)link_names for sending Slack message (@salt-lick)data_template (@pvizeli)check_config: Improve yaml fault tolerance and handle border cases (@kellerza)write_registers Modbus service (@persandstrom)sensor.owm_temperature. Previously they were like sensor.weather_temperature. Apologies for this change, but we needed to make OpenWeatherMap more generic now that we have many weather platforms.BaseNotificationService need to be aware that kwargs.get(ATTR_TITLE) will now return None if a title has not been set, and will need to specify kwargs.get(ATTR_TITLE, ATTR_TITLE_DEFAULT) if they always require a title.…don’t hesitate to use our Forum or join us for a little chat.
+ + + +
+So, part 1 of ESP8266 and MicroPython was pretty lame, right? Instead of getting information out of Home Assistant we are going a step forward and create our own sensor which is sending details about its state to a Home Assistant instance.
This week’s blog post could only be possibly described by exactly one hashtag:
+ +or maybe#supersized
+ +Keep reading to see what #Amazing things we have in store for you this week 😄! And make sure you read all the way to the end, because I left a present down there for those committed few among you :)
+ +But first…
+ +Paulus (@balloob) is on vacation in Europe this week, so you will all have to deal with me, Robbie (@robbiet480) for this release blog post. Don’t worry, Paulus will be back to tearing apart your pull requests in no time 😈.
+ +Special thanks to my awesome helpers for this week’s release who are looking over my shoulder to make sure I’m crossing my t’s and dotting my i’s: @Teagan42, @infamy and @fabaff.
+ +For my next trick, let’s hand out some…
+ +I felt that I had to 1-up Paulus (@balloob) somehow with his 500,000 pageviews stat he shared in the 0.26 blog post, so I pushed myself and our development community as a whole super hard the last two weeks to put a lot of love into Home Assistant to bring you not just one, but six #Amazing stats for this release. As of 0.27, we have now surpassed the following milestones:
+ +In addition,
+ +Now that we have that great news out of the way, onto this week’s release which is going to keep the #Amazing gravy train rolling right along and get to the stuff you all really are here for.
+ +While this release is #Amazing, we had to break a few eggs (now you understand the title reference!) to make a beautiful omelette (using home automation obviously) so some platforms and components have needed to introduce breaking changes. Please make sure to read the Breaking Changes section below.
+ +Thanks to @mgbowen we now have the functionality previously provided by @blocke’s ha-local-echo built right into Home Assistant! This means that for those of you with devices that either lack or have a subpar integration with Home Assistant (looking at you Amazon Echo) you can now have a better experience by having your Home Assistant pretend to be a Hue Bridge. Personally, I have used @auchter’s Haaska previously but found that it was slow to respond and sometimes failed entirely. With the new emulated_hue component, you can have local control of entities through Amazon Echo.
We have some excellent upgrades to the notification system coming to you in 0.27, courtesy of me, @robbiet480.
+ +This release adds support for HTML5 push notifications on Chrome/Firefox/Opera on both desktop and Android devices. This means that you can send a notification to your phone even when your Home Assistant is not open in your mobile browser. When using Chrome you can even include 2 action buttons so that you can control your Home Assistant from your phone’s lock screen, allowing you to do things like sound alarms or unlock your front door, all without leaving the notification. Thanks again to me (@robbiet480) and Paulus (@balloob) for all the hard work on this!
+ +
+
+
Using the new notify group platform allows you to cut down a lot of duplicate automation logic by combining multiple notification platforms and targets into a single notify service. Check out the docs for more info.
target is no longer needed!For platforms that support it, starting with the new HTML5 platform, any targets that are available will be exposed as individual services, so no more having to remember which targets to use. Please note that the existing services also still exist so you can keep using target if you wish.
Ever restarted Home Assistant to test a configuration change just to find out there is a validation error? Well, not anymore! @kellerza has added a command line script that will validate your configuration as if you started Home Assistant.
+ +$ hass --script check_config
+This release includes a big push on making sure all platforms contain proper configuration validation. This should help in getting your configuration right. Thanks to @fabaff, @pavoni, @pvizeli, @nkgilley for all the hard work on this, you all rock!
+ +
+
+
It’s now possible to use FFMpeg to monitor a video stream and detect motion thanks to a new binary sensor platform by @pvizeli.
+ +Due to our wild growth we ended up with a few components that had a lot of overlapping functionality. @turbokongen took on the hard job on merging them. Thermostat and HVAC platforms are now combined under the new Climate component. Rollershutter and Garage Door platforms are now combined under the new Cover component. You can easily upgrade by just swapping out the name. For example replace thermostat with climate. The old components have been deprecated and will be removed in the near future.
fan componentAlong with the new climate component, @Teagan42 and I (@robbiet480) decided we needed something simpler to just control a fan. Currently it has support for controlling Insteon fans. MQTT support will appear in 0.28.0. I tried to get it implemented before 0.27.0 but spent too long writing this blog post 😢.
sensor.forecastio_temperature. Previously they were like sensor.weather_temperature. Apologies for this change, but we needed to make Forecast.io more generic now that we have many weather platforms.type: is no longer required for monitored variables.username instead of user.thermostat and hvac components has been deprecated. Please migrate to the new climate component. (just change the component name, the configurations are compatible)rollershutter and garage_door components have also been deprecated. Please migrate to the new cover component. (just change the component name, the configurations are compatible)Thanks all for sticking with me to the end. I’ll be taking over a lot of Paulus’s (@balloob) work while he is gone, but as I said, don’t worry because he’ll be back well before 0.28.0 comes out. Hopefully you didn’t find this jovial blog post too jarring from our standard style, I just wrote a lot of this at 2am after being awake for almost 20 hours, so I’m a little loopy hahaha 😴.
+ +Also, thanks as always to our developer contributors, documentation contributors, but most of all our users! This would’ve just been a script that Paulus (@balloob) used to control his lights at home if we didn’t have your enthusiasm.
+ +Feel free to let me know what you thought of this blog post and release on Gitter or my Twitter, or even the Home Assistant Twitter. Did I mention we have a brand new Facebook page that you should absolutely Like? There’s a convenient Facebook Like and Twitter follow button right on the sidebar.
+ +I almost forgot about your 🎁 for reading all the way to here: a 🍪! Hope you enjoy it in good health 😄.
+ +Talk to you soon on Gitter and in your pull request comments!
+ +– Robbie
+ +(p.s. To those of you that scrolled directly to the bottom to get your present, just know that you didn’t earn it like the others did. 😄)
+ +Thanks to Anton Kireyeu we are able to present another awesome Jupyter notebook. I guess that you all know the graph which Github is using to visualize your commits per day over a time-line. It’s a so-called heatmap. If there are more commits, it’s getting hotter. The latest notebook is capable to do the same thing for your devices. To be more precise, for the hours your devices are home.
+ +
+
+Heatmap
+
I have been working on a new subsystem to complement Home Assistant’s Automation and Scripting components. AppDaemon is a python daemon that consumes events from Home Assistant and feeds them to snippets of python code called “Apps”. An App is a Python class that is instantiated possibly multiple times from AppDaemon and registers callbacks for various system events. It is also able to inspect and set state and call services. The API provides a rich environment suited to home automation tasks that can also leverage all the power of Python.
It’s time for 0.26 and it’s again full of new features and fixes. First I want to highlight that we are now having 500 000 monthly pageviews on the website. A big milestone for us! It’s been an amazing journey. Big thanks to the Home Assistant community for being such a delightful bunch.
+ +This release includes code contributed by 31 different people. The biggest change in this release is a new unit system. Instead of picking Celsius or Fahrenheit you’ll have to pick imperial or metric now. This influences the units for your temperature, distance, and weight. This will simplify any platform or component that needs to know this information. Big thanks to @Teagan42 for her hard work on this!
+ +
# Configuration.yaml example
+homeassistant:
+ # 'metric' for the metric system, 'imperial' for the imperial system
+ unit_system: metric
+This blog post will go into detail about the recent performance optimizations that went into the Home Assistant front end. For people not familiar with the app, check out the demo and the source.
+ +TL; DR: Don’t hack the framework, separate responsibilities, ship less, use service workers, use (future) web standards.
+ +This year at Google I/O I saw Monica from the Polymer team talk about web components and performance. In her talk she mentions a mantra that they use in the Polymer team to make things fast: Do less and be lazy.
+ +Do less and be lazy. It sounds so obvious and it took a while before it started to dawn on me. I think most of the code I write is pretty fast, but I don’t often stop to take a harder look at how and when it runs in practice. When do we need the result, can it be postponed?
+ +And thus started my journey to take a critical look at how the Home Assistant app was working and how to make things faster. Below is the list of the different things that I did to make it fast.
+ +I hope this list can be useful to other people, as a guide for optimizing their own apps or for avoiding pitfalls when building a new one.
+ +The first thing to do is to measure. The Home Assistant front end is a mobile web app, so we shouldn’t measure this on a machine with 8 cores and gigabytes of ram but instead measure on devices you expect a mobile web app to run: phones. Below are two timelines recorded with Home Assistant 0.18.2 (pre-optimizations) and Google Chrome 53. On my Mac the app starts in 1400 miliseconds and on my Nexus 5x in ~6500 miliseconds (~4.5 times slower!).
+ +
+
+
Although the app takes 6500 milliseconds to load on my phone, it would perform well afterwards. Still, that initial load is unacceptable. You expect to open an app on your phone and be able to use it, quickly. After I applied all the changes described below, I managed to reduce startup time to 900 miliseconds (-35%) on my Mac and 2400 miliseconds (-63%) on my Nexus 5x. Check out the demo here.
+ +
+
+
+
This is a guest post by Home Assistant user and contributor Nolan Gilley.
+ +Today I’ll show you how I used Home Assistant, a NodeMCU (ESP8266), and a couple of accelerometers to automate our laundry room. This is a rewrite of an old post where I did the same thing using a Moteino & Raspberry Pi. This version only requires a NodeMCU.
+ +We have an older washer and dryer which doesn’t have any form of notification when cycles complete. Home Assistant was the obvious solution, I just needed to create sensors for the washer and dryer. I tried using sound sensors but found them unreliable. I ended up using an accelerometer attached to the back of each appliance. I also added magnetic reed switches on the doors of the washer and dryer to detect whether they’re open or closed. I connected the accelerometers and reed switches to an NodeMCU which will relay the data to my MQTT broker.
+ +
+
+ Block diagram of schematic
+
When Home Assistant started the focus has always been on making a great developer experience. Allowing anyone to add support for their favorite devices to Home Assistant easily. This focus has been a great success since we now have 339 components and platforms!
+ +Starting with this release, we are extending our extensability to the frontend. Starting this release, any component can add it’s own page to the frontend. Examples of this today are the map, logbook and history. We are looking forward to all the crazy panels you’ll come up with!
+ +We have also seen an exciting trend of people starting to visualize their Internet of Things data using Jupyter Notebooks, which are a great way to create and share documents that contain code, visualizations, and explanatory text. In case you missed it, the blog post by @kireyeu shows an advanced usecase while our Notebooks in the Home Assistant Notebooks repository cover the basics.
+ +This release also includes a bunch of new integrations, among others three new media player platforms. This means that today Home Assistant can talk to 26 different media players!
+ +The brand-new iFrame panel component allows you to add other websites as pages in the Home Assistant frontend. They will show up in the sidebar and can be used the same way as you open the frontend in your browser but all within one view.
+ +I would like to do a shoutout to @fabianhjr. He has started adding typing data (PEP484) to the Home Assistant core. This will help us identify issues before they are released.
+ +
timestamp_local and timestamp_utc) (@fabaff)location extension for Telegram and photo bug fixed (@keatontaylor and @pvizeli)
+The first release of Micropython for ESP8266 was delivered a couple of weeks ago. The documentation covers a lot of ground. This post is providing only a little summary which should get you started.
Until a couple of weeks ago, the pre-built MicroPython binary for the ESP8266 was only available to backers of the Kickstarter campaign. This has changed now and it is available to the public for download.
+ + + + Read on → + +This is the first blog post by Anton Kireyeu. A new contributor to Home Assistant who will focus on exploring and visualizing Home Assistant data.
+ +As we learned in the recent blog post by Fabian, all operational data of your Home Assistant application is stored locally and is available for exploration. Our first steps were querying data with the DB Browser for SQLite, exporting the data extract as a CSV file and graphing in LibreOffice. But what else can be done with this data and what tools are there available?
+ +This post will help you get set up using a few popular data scientist tools to allow you to locally process your data:
+ +
+
+One of the graphs created with this tutorial.
+
TL; DR: Use this Jupyter Notebook to visualize of your data
+ + + + Read on → + +
The history component is tracking everything that is going on within Home Assistant. This means that you have access to all stored information about your home. Our history is not a full-fledged graphical processing and visualization component as you may know from systems and network monitoring tools. The current limitation is that you only can select a day for a visual output of your information and not a period. Also, there is no possibility to drill down on a specific entity.
+ +This blog post will show you ways to export data for reporting, visualization, or further analysis of automation rules.
+ + + + Read on → + +It’s time for Home Assistant 0.24 and it’s full of new integration for your Home. It contains some structural changes to our history which requires action from your end, so please keep reading.
+ +MapQuest discontinued their free and direct tile access by Monday, July 11, 2016. With CARTO we found a very cool and suitable solution. They allow us to use their tile for the map. Thank you, CARTO.
+ +Roy Hooper did an amazing job migrating the history support from being tied to SQLite to use the ORM SQLAlchemy instead. This means that you can now use any SQL backend for the history. So besides SQLite you can now databases like MySQL or PostgreSQL. However, this does require that you install SQLAlchemy and run a command to migrate your existing history over. We tried to make the process as seamless as possible by introducing a new command line script:
+ +$ pip3 install SQLAlchemy
+$ hass --script db_migrator --config /path/to/config
+You can omit the --config option if you use the default configuration directory. Run the script with --help to get more options.
Quick hot fix after we found a bug in the migrator where it wouldn’t work with a database in a non-standard location. Thanks to @n8henrie and @AlucardZero.
+ +configuration.yaml file.
+Over a year ago I participated in the kickstarter campaign for “CHIP - The World’s First Nine Dollar Computer” by Next Thing Co.. I went for the PocketCHIP because of the idea. Display, built-in storage (thus no need for SD cards), battery-powered, and a keyboard are pretty nice features. Last week a package arrives…
It’s time for Home Assistant 0.23 and it’s full of goodies. It’s also the release that bumps us over a 1000 tests and to 94% test coverage! Also our install issues on the Raspberry Pi and Synology have been resolved.
+ +This release brings support for two new ecosystems: Envisalink and Homematic. We can now also control your TV via HDMI using HDMI-CEC (which works on the Pi!) and another cool feature is the persistent notifications which allow you to add a notification to the frontend till dismissed.
+ +Wink support has been dramatically improved by migrating to the PubNub API. This allows Wink to push changes from their system to Home Assistant. This change came just in time as somehow our Wink integration was causing a lot of requests to their servers. Thanks to Wink for letting us know so we could solve it instead of blocking us.
+ +On the config side, you can now store your passwords in your OS keyring or just in a standalone file. We also got a new service to reload the core config so no reboots needed anymore after changing customize settings!
+ +
elevation: was introduced to the configuration for weather/sunrise data. For existing configurations add the value shown in the warning [homeassistant.config] Incomplete core config. Auto detected elevation: 665 to your configuration.yaml file.
+In the past month I was thinking about ways to integrate USB webcams into Home Assistant again. The main reason was that this would give those devices a second life and enable one to benefit from low-cost video surveillance. There are a couple of options available like pygame or SimpleCV but I never finished something. With the Local File camera platform by Landrash and motion you could integrate a local USB webcam with a few very easy steps.
In this blog post I am using a Fedora 24 (will most likely work on other distributions too) installation with Home Assistant 0.22.1 on a Foxconn nT-330i with an old Logitech QuickCam Orbit AF and a Logitech HD Webcam C270. As a start only the Quickcam is used. No multi-camera setup for now.
+ + + + Read on → + +It’s time for the 0.22 release. This was a pretty rough release cycle and we had to issue two hot fixes for our core improvements. But it seems now that all is good and a lot of people have reported that their installs are faster than ever and the occasional quirks no longer occur.
+ +We are aware that our new web stack has caused issues installing Home Assistant on ARM-based platforms. This sadly includes the Raspberry Pi and Synology NAS systems. We’re working on getting to a better solution. For Raspberry Pi, the All-in-One installer will take care of everything for you. We’re working on updating our standalone Raspberry Pi installation guide.
+ +There are two cool things that I want to highlight in this release. The first is Pandora support. This is based on the CLI player called pianobar. This means that your machine running Home Assistant can be connected to the speakers and provide your house with tunes.
+ +
+
+
Another cool addition is the local file camera. This seems very basic at first but will allow you to generate a graph with your favorite 3rd party graphing tool and display it on your Home Assistant dashboard. We’re looking forward to see what you can do with this!
+ +
netatmo:
+ api_key: API_KEY
+ secret_key: SECRET_KEY
+ username: username
+ password: password
+It’s been already almost two weeks ago that a few of the Home Assistant developers headed towards Portland for PyCon 2016 - the conference about everything Python. We were there to learn all the nifty tricks to make our code better but most of all, to talk Home Automation.
+ +
+
+ Couple of Home Assistant devs. Left to right: Paulus (@balloob), Alex (@infamy), Ryan (@rmkraus).
+
On Monday I (Paulus) gave a presentation about Home Assistant to an audience of over 400 people! It was a bit scary at first but after a couple of minutes it went all great including some great questions afterwards. Slides can be found here and the talk is embedded right below:
+ +One of the things that really impressed me was the amount of people that approached us to tell how they love Home Assistant, how it has replaced their previous solution, how they enjoyed contributing to Home Assistant and how helpful our community is. It makes me proud of Home Assistant and especially our community.
+ + + + Read on → + +It’s time for release 0.21 and it contains massive core improvements: replacement of our home grown HTTP stack with a standardized WSGI stack. This will improve performance, speed, security and make future development of advanced HTTP features a breeze.
+ +This work was driven by the amazing Josh Wright. His knowledge, high standards and drive for security has helped improve Home Assistant a lot ever since he started helping out. Hip hip hurray for Josh!
+ +Alright, time for the changes:
+ +
frontend: to serve the frontendWe released two hotfixes to address some issues that couldn’t wait till the next release.
+ +Our community is amazingly helpful and creative. If you haven’t been there yet, make sure to stop by our chat room and come hang out with us. In this blog post I want to highlight a few recent awesome projects and videos from the community.
+ +SceneGen is a new command line utility developed by Andrew Cockburn that helps with creating scene configurations for Home Assistant. To use it, you put your house in the preferred state, run SceneGen and it will print the scene configuration for your current states.
+ +Nick Touran has been working on integrating IR remotes with Home Assistant. He made it into a component which should be available in the next release which should arrive in a couple of days. In the meanwhile, he wrote up a blog post and has put out a video showing the new integration, very cool!
+ +Ben from BRUH Automation has put out another great video how to get started tracking your location in Home Assistant using MQTT and OwnTracks.
+ +Muhammed Kilic has created a video how to make your Home Assistant instance accessible from the internet using the free dynamic DNS service DuckDNS.
+ +This post is by Home Assistant contributor Greg Dowling.
+ +In Part 1 I talked about using iBeacons to improve presence tracking. In part 2 I’ll talk about how to track things like keys that can’t track themselves by using iBeacons.
+ +In the first part I mentioned that iBeacons just send out I’m here packets, and we used this to trigger an update when your phone came close to a fixed beacon.
+ +But beacons don’t have to be fixed.
+ +Your phone knows roughly where it is located (based on mobile phone masts, Wi-Fi networks or GPS). If your phone sees an I’m here message then it knows the beacon is close.
+ +If your phone can remember (or tell a server) where it was when it last saw the iBeacon - then it knows where the beacon was. So the result of this is that you can track where an iBeacon was - even though the iBeacon doesn’t have any tracking technology itself.
+ +So if you put an iBeacon on your keys or in your car - then you can track them.
+ +
+
+ Here are my keys - with a Estimote Nearable iBeacon stuck to them. Ugly but effective!
+
We are always hard at work at the virtual Home Assistant headquarters to make it easier for you to get started with Home Assistant. That’s why @jbags81 recently introduced the all-in-one installer. It allows you to get up and running with a complete Home Assistant setup by entering one line of code into your Raspberry Pi running Raspbian Jessie:
+ +wget -Nnv https://raw.githubusercontent.com/home-assistant/fabric-home-assistant/master/hass_rpi_installer.sh && bash hass_rpi_installer.sh;
+This feature wouldn’t be complete if it wasn’t accompanied by a new video by Ben from BRUH Automation. The video shows how to install Raspbian Jessie on your Raspberry Pi and use the new installation script to get a full Home Assistant system up and running.
+ +
Tons of new supported things in 0.20.
+ +relative_time function to render ie. 7 seconds ago (@robbiet480)!include_dir_merge_list and !include_dir_merge_named (@happyleavesaoc)device_tracker:
+ platform: asuswrt
+ protocol: telnet
+I’ve been planning to write this post for a while now as we get questions like this a lot: “Why does Home Assistant use Polymer? Why not React, Redux and what not?”
+ +It’s understandable, Polymer is quite the underdog in the world of web frameworks. A corporate backer does not guarantee popularity or an active community and this shows in the number of projects using Polymer.
+ +Still, we use Polymer and it’s awesome. To explain why, I’ll be referencing the React workflow quite a bit, as they do a lot of things right, and show how it is done in Polymer.
+ +Polymer gives us components for the web, just like React, but based on web standards: web components, CSS variables. These standards don’t have wide browser support yet but it’s being implemented by every major browser: It’s the future. For now they are being polyfilled and that works just fine but in the future the Home Assistant web app will be able to run native in the browsers == fast.
+ + + + Read on → + +Ben from BRUH Automation authors a lot of great video’s about how he is using Home Assistant and how you can get started with it too. The video below will walk you through how to configure Home Assistant. Enjoy!
+ +Make sure to subscribe to his YouTube channel for more Home Assistant video’s.
+ +This release is big. Until now, our automations and scripts have been very static. Starting today it should all be a bit more dynamic.
+ +Scripts are now available in automations and when responding to Alexa/Amazon Echo. Both of these components will now expose data to be used in script templates (including from_state !). Passing data to script entities is available by passing the data to the script services.
automation:
+ trigger:
+ platform: mqtt
+ topic: some/notify/topic
+ action:
+ service: notify.notify
+ data_template:
+ message:
+
+automation 2:
+ trigger:
+ platform: state
+ entity_id: light.hue
+ action:
+ service: notify.notify
+ data_template:
+ message: is now
+Entity Namespaces allow you to influence the entity ids for a specific platform. For example you can turn light.living_room into light.holiday_home_living_room with the following config:
light:
+ platform: hue
+ entity_namespace: holiday_home
+trigger variable to script templates (@balloob)and and or to combine conditions (@balloob)!env_var (@bah2830)as_timestamp method now available (@srcLurker)/api/discovery_info] with basic instance info (@robbiet480)condition: instead of platform:. For example condition: state.Old RFXtrx config format:
+ + devices:
+ 123efab1:
+ name: My DI.0 light device
+ packetid: 1b2200000890efab1213f60
+New RFXtrx config format:
+ + devices:
+ 1b2200000890efab1213f60:
+ name: My DI.0 light device
+At the beginning of April I gave a talk about Home Assistant at the OpenIoT summit in San Diego. I talk about the Home Assistant architecture and explain how to get started integrating your devices. Big thanks to my employer AppFolio (we’re hiring!) for letting me attend. Slides.
+ +This post is by Home Assistant contributor Greg Dowling.
+ +In 2013 Apple introduced iBeacons: a class of Bluetooth low energy (LE) devices that broadcast their identifier to nearby devices, including most smartphones. At first glance it’s hard to imagine why they might be useful. In this two part blog I’ll try and explain why they are useful and how you can use them with Home Assistant.
+ +The reason I started using iBeacons was to improve presence detection (and I think that’s the case with most people) so that’s what I’ll discuss in part 1. In part 2 I’ll talk about using iBeacons to track devices that can’t track themselves.
+ +When you use OwnTracks in standard major move mode (which is kind to your phone battery) it sometimes fails to update when you’d like it to. In my case I found that it would often send a location update as I was on my way home, but then not update when I got home. The result would be that Home Assistant would think I was 500M away from home, and take quite a while to notice I was home. It would also mean that the automation that should turn on my lights when I got home didn’t work very well! There were a few times when my phone location updated at 2am and turned the lights on for me. Fortunately my wife is very patient!
+ +Luckily, OwnTracks supports iBeacons so I could use them to make presence detection more reliable. When OwnTracks sees a beacon it recognises, it will send an update. This means that if you put a beacon at your front door - OwnTracks will see it within a few seconds of you arriving home - and send an update saying it has seen this iBeacon.
+ + + + Read on → + +It’s time for 0.18. This release cycle is 2 days shorter than usual as I’ll be travelling to Europe. This also means that it can take some more time before you get feedback on PRs.
+ +Since the last release we have moved all Home Assistant source code etc into it’s own organisation on GitHub. We’re growing up! This sadly did cause us to have to move all Docker images. Check the breaking changes section for more info.
+ +
TEMP_CELCIUS is now correctly called TEMP_CELSIUS. Old one is deprecated and will eventually be removed.homeassistant/home-assistant:latest for the latest release and homeassistant/home-assistant:dev for the latest dev version.port: under gateways to device:.After 2.5 years I think we can proudly say: Home Assistant is a success. I write we because Home Assistant is no longer a one-person side project. It has become the side project of many people who spend countless hours on making Home Assistant the best home automation software out there. To acknowledge this we migrated the repositories from being under my name to be under our own organisation on GitHub.
+ +On our journey we’ve reached many noteworthy milestones:
+ +All these accomplishments are a nice pat on the back but our journey is far from over. There are a lot of challenges ahead if we want to become the go to solution for home automation for everyone.
+ +Until now the focus has been on making a platform that developers love to use. A platform that is simple but customizable. A platform that is both powerful and reliable. But most important: a platform that is local and open. Home Assistant does a great job at all these things.
+ +There will be some major challenges ahead of us to target groups other than developers. Easy installation and easy configuration being the #1. I’m sure that we’ll be able to eventually achieve these goals. I can’t say yet how or when. As with everything Home Assistant, we’ll take tiny steps, gathering feedback along the way to make sure we’re solving the right problems.
+ +I am confident that we will get there because we are set up for success: we have a robust architecture, high test coverage and an active community of world class developers and users. On top of that, we use Python which allows us to move fast and tackle complex problems in elegant ways. It is so easy to learn that it allows any programmer, experienced or not, to contribute support for devices and services. It’s as simple as filling in the blanks.
+ +I would like to put out a big thank you to all our contributors who make Home Assistant what it is today. It doesn’t matter if it is form of code, documentation or giving support in our chat room or forums. You. all. rock.
+ +Cheers to the future!
+ +Paulus
+ + + +One of the main complaints that we receive is something along the lines “I read that X is possible yet I am unable to find it on the website.”. This post is to announce that we have taken the first steps to improve it by revamping the getting started and developers sections. It’s still a work in progress but we now have a solid foundation to build on for the future 👍.
+ +Our documentation has been going through various phases. Initially it was just the README in our GitHub repository. I discovered Jekyll and GitHub pages in December 2014 and created home-assistant.io. I more or less broke the README in 5 pages and called it a website. Back then we had a whopping 11 components.
+ +As Home Assistant grew, so did our documentation. Fabian Affolter does an amazing job in making sure there is at least a documentation stub for each new feature that lands. And that’s quite a feat given our frequent releases! But despite all the efforts, the documentation outgrew our existing documentation organisation.
+ +Today it has been almost 1.5 years since we started the website. We now have 264 components and platforms under our belt and have been honored with 1.5 million page views ✨. And hopefully we now also have documentation that our community deserves.
+ +Finally, if you see some content that could use more clarifcation or is outdated, don’t hesitate to use the ‘Edit in GitHub’ link that is present on each page.
+ + +Another awesome release ready to hit your homes. YAML can be hard for beginners and more experienced automators. So to help catch those pesky errors that sneak into your files we’ve been hard at work to introduce config validation! Especially huge thanks to @jaharkes for his hard work on this. Config validation is still in it’s early stages. More common platforms and components have been added but we didn’t do everything yet.
+ +When we encounter an invalid config we will now write a warning to your logs. You can see those in the frontend by clicking on the last developer tool. We’re looking into options to make it more clear - it is a work in progress.
+ +Another big thing is the addition of GTFS support. You probably don’t know it, but GTFS is the standard that public transit companies all over the world use to distribute their schedule. This means that you can now have the time of the next bus/train/etc right in your frontend.
+ +
As of now we are not aware of any breaking changes. However, it might be that Home Assistant will not start for you because of an invalid configuration. A common mistake that people are making is that they are still referring to execute_service in their script configs. This should be service.
The frontend of Home Assistant is served with the help of a local web server. If you have customized your installation you already use this functionality. The content of your folder www in your Home Assistant configuration directory (.homeassistant) is available under /local (eg. https://localhost:8123/local).
But there is more you can do! You can not only host images for customization there but HTML files or even web applications including CSS and Javascript.
+ +
+
+
Today the news spread that Google will be shutting down the Revolv hubs. And shutting down here doesn’t mean they stop selling or supporting them - no, they are sending an update to each hub to turn your perfectly fine home automation hub into a useless piece of plastic. The fact that this seemed like a good idea by Google astonishes me. If anything, they should have gone the same route as ninjasphere: open it all up and let people decide on the fate of their own hub.
+ +I’ve said it before but I’ll repeat it again:
+ +++ +The cloud should be treated as an extension to your smart home instead of running it.
+
Your hub should not be affected when your internet breaks down or the company that sold you your hub goes out of business. It should work locally so that it can continue to work even long after the vendor goes out of business or decides to kill it. Preferably, your hub should also be open so that the community can take over development after the vendor stops caring.
+ +Unless you can afford losing a product here and there, be cautious when buying IoT products that depend on the cloud from companies that are not well established. The chances are high that they go bankrupt or get acquired and closed. This however is easier said than done as Gartner predicts that by 2017, 50 percent of IoT solutions will originate in startups that are less than three years old.
+ + + +Party people, 0.16 is here! The big thing with this release is that we have completely removed the barrier to get started by MQTT by being able to launch an embedded MQTT server: hbMQTT. Just add mqtt: to your config and a broker is launched and connected with Home Assistant. See the documentation for more info.
Further in this release a bunch of cool new stuff, bug fixes and rewrites for the Vera and Tellstick component (see breaking changes section at bottom for this!).
+ +Rock on.
+ +
Automation: support for old deprecated config has been removed
+Tellstick configuration has changed
+tellstick:
+ signal_repetitions: X
+vera:
+ vera_controller_url: http://192.168.1.161:3480/
+ # Optional to exclude devices - this is a list of vera device ids
+ exclude: [ 13, 14, 16, 20, 23, 72, 73, 74, 75, 76, 77, 78, 88, 89, 99]
+ # Optional to import switches as lights - this is a list of vera device ids
+ lights: [15, 17, 19, 21, 22, 24, 26, 43, 64, 70, 87]
+Two weeks has past so here is 0.15! We have been focussing a lot on quality. Making sure the system is more stable and reliable. I usually try to highlight one cool thing in the release notes but this release has 4 exciting announcements!
+ +Besides bug fixes, this release also brings:
+ +
# Example using templates for service and data in service call.
+# Works for automation, Alexa, universal media player, template switch.
+automation:
+ - trigger:
+ - platform: state
+ entity_id: switch.bathroom
+ action:
+ service_template: >
+ {% if is_state('switch.bathroom', 'on') %}
+ switch.turn_on
+ {% else %}
+ switch.turn_off
+ {% endif %}
+ data_template:
+ entity_id: switch.{{ states('input_select.is') }}
+media_content_type and media_content_id, to match the corresponding media
+player state attributes. This change affects automations, scripts and scenes.It’s been another two weeks which means it’s time for release: 0.14!
+ +
for config parameter to only trigger when a state hasn’t changed for a certain period of time (@pavoni, @stefan-jonasson)
+
+ Camera feeds are now directly embedded in the frontend.
+
command_line.Home Assistant land has been busy and a lot of people have been creating awesome stuff. We’ve added a cookbook section to the website full of examples how you can automate different things. Make sure you take a look and share your own recipes too!
+ +Haaska allows you to control lights, switches, and scenes exposed by your Home Assistant instance using an Amazon Echo. This is different from our own Alexa component because it will teach the Amazon Echo directly about the devices instead of teaching it to talk to Home Assistant. It will not allow you to use custom sentences but it will allow you to skip the ‘Ask Home Assistant’ part when giving commands:
+ +Contributor Maddox has created a plugin for HomeBridge, an open-source HomeKit bridge. This will allow you to control your home using Siri on your Apple devices. HomeBridge has recently restructured so you’ll have to install the plugin separately with the homebridge-homeassistant npm package.
+ +Example config.json entry to load Home Assistant:
+ +"platforms": [
+ {
+ "platform": "HomeAssistant",
+ "name": "HomeAssistant",
+ "host": "http://192.168.1.50:8123",
+ "password": "xxx",
+ "supported_types": ["light", "switch", "media_player", "scene"]
+ }
+]
+HomeBridge on GitHub +HomeBridge Home Assistant Plugin
+ +User thaijames describes in the Home Assistant forums how he has created his own NFC-based alarm system using Home Assistant, DIY components and Garfield dolls.
+ +
+
+Hold your NFC tag against the belly of Garfield to unlock the alarm.
+
Would you like to listen to music in every room in your home, controlled from one source? Then multi-room audio is for you.
+ +Multi-room audio can be achieved by having a computer attached to speakers in every room. On each computer, services run to play and/or control the audio. With this DIY approach, the kind of computer and speakers is very much up to you. It could be your desktop computer with attached powered speakers, your HTPC hooked up to your TV and receiver, a Raspberry Pi with Amp or DAC, or even an Android device.
+ +You’ll need two key software packages, besides Home Assistant. The first is Mopidy, a music server that can play local files, or connect to streaming music services like Spotify. The second is Snapcast, which enables synchronized audio streaming across your network. Both can be integrated into Home Assistant. Each room audio device will run an instance of the Snapcast client, and optionally a Mopidy instance. Your server will run a special instance of Mopidy and the Snapcast server.
+ +Finally, you also need a player to control Mopidy. Any MPD-compatible player will work, and there are several Mopidy-only web-based options available. On Android, Remotedy is particularly nice since you can access multiple Mopidy instances in one place.
+ +Home Assistant will provide device status, and volume control for each room. If you want to play music in all your rooms (on all your clients), access the server instance of Mopidy. If you want to play music only in a specific room, access that specific Mopidy instance. If you’re using a web UI for Mopidy, you can add links to each instance in Home Assistant with the weblink component.
+ +
+
+
The focus of 0.13 was on test coverage, big cheers to @rmkraus for his hard work on this. I’m proud to announce that we’ve hit the 90% test coverage of the core + important components. A big milestone for the project.
+ +
+
+ Examples of the new input_select and weblink components.
+
Not only did we gain a lot of test coverage, we also attracted a lot of new developers that contributed a variety of components and platforms:
+ +
The core of home automation is knowing what’s going on. The faster we know about a state change, the better we can serve the user. If you want to have your lights to turn on when you arrive at home, it doesn’t help if it only knows about it after you’ve already opened the door and manually (!!) turned on the light.
+ +Each smart device consists of the ‘normal’ device and the piece that makes it ‘smart’: the connectivity. The connectivity part of a device can consists of either control, state or both.
+ +State describes what a device is up to right now. For example, a light can be on with a red color and a medium brightness.
+ +Control is about controlling the smart device by sending commands via an API. These commands can vary from configuring how a device works till mimicking how a user would interact with a device. A media player can allow skipping to the next track and a sensor could allow to configure its sensitivity or polling interval.
+ +The Home Assistant APIs are setup to be as convenient as possible. However, a network is always as weak as it’s weakest link. In our case these are the integrations. Take for example controlling a light that does not report state. The only state Home Assistant can report on after sending a command is the assumed state: what do we expect the state of the light to be if the command worked.
+ +We want our users to get the best home automation experience out there and this starts with making sure they have devices that work well with Home Assistant. That’s why we will start applying the following classifiers to our integrations:
+ + +| Classifier | +Description | +|
|---|---|---|
| + | Assumed State | ++ We are unable to get the state of the device. Best we can do is to assume the state based on our last command. + | +
| + | Cloud Polling | ++ Integration of this device happens via the cloud and requires an active internet connection. Polling the state means that an update might be noticed later. + | +
| + | Cloud Push | ++ Integration of this device happens via the cloud and requires an active internet connection. Home Assistant will be notified as soon as a new state is available. + | +
| + | Local Polling | ++ Offers direct communication with device. Polling the state means that an update might be noticed later. + | +
| + | Local Push | ++ Offers direct communication with device. Home Assistant will be notified as soon as a new state is available. + | +
The background to how we got to these classifiers can be read after the break.
+ + + + Read on → + +This is a guest post by Home Assistant users Jeremiah Wuenschel and St. John Johnson.
+ +So you own a SmartThings Hub. You probably bought it when you were looking to get into the whole Home Automation hobby because it worked with pretty much everything and offered you the ability to automate anything. After a week of ownership, you realized that building dashboards and automating required writing way more Groovy then you expected. Then one day you were browsing reddit and discovered the amazingness that is Home Assistant! A solution that offered dashboards, graphs, working support for Nest, and REAL EASY automation!
+ +You spent your weekend getting everything set up, showing it off to your significant other, but in the end you got stumped when it came to integrating with all your existing SmartThings toys. What do I do now? Should I buy another hub? Should I just buy a Z-Wave stick?
+ +That’s where we came in. We wanted a solution that can bridge the awesomeness of Home Assistant with the SmartThings hub that works with almost everything.
+ +
+
+
Another sprint has come to an end and it seems that we have not slowed down a single bit 🚀. 0.12 is full of new components, platforms and organizational additions.
+ +I would like to give a shout out to Greg Dowling (@pavoni) as every release includes new work from him. He is constantly adding support for new platforms or improving the reliablity of existing components and platforms. Keep up the good work!
+ +This release includes a very frequent requested feature: the ability to organize entities in different tabs in the frontend. See the demo to see this in action and read more in the group documentation how to get started.
+ +
+
+Example of the new views in the frontend. Learn more.
+
/5) (@kennedyshead)homeassistant, switch, light and media_player (@rmkraus)People often ask me about my vision for Home Assistant. Before I can describe where I want to go with Home Assistant, I should first talk about how home automation would look in my ideal world. This will be the aim of this post. I’m not going to focus on protocols, networks or specific hubs. That’s all implementation details. Instead, this post will focus on what is most important: the interaction between the users and their home.
+ +When people start using home automation, they always experience home control first: being able to control devices in new ways using a phone or computer. They believe the future is now and their app will be their remote for their lives. They only focus on what they are getting, not on what they are losing. You install some light bulbs and all of a sudden you are no longer able to use the light switches. You’ll arrive at home at night and have to pull out your phone, open the app, let it connect and finally you’ll be able to turn on the light. All while turning the light on could have been a switch away.
+ +Yes, you can solve this with presence detection. What if your phone runs out of battery? You’ll have to resort to the switch again.
+ +If you find that using your new home devices is cumbersome, the promise of home automation technology has failed you. Your lights should work with both a switch (or button) at the entrance of your room and via presence detection. Honestly, there are hardly any valid use cases for being able to control lights from your phone except for showing off.
+ + + + Read on → + +First release of 2016 and we are on 🔥! The main repository has passed 2500 ⭐ on GitHub (2596 ⭐ as of now). This release also has a record number of 20 contributors all working on improving and extending Home Assistant. With the continued growth, I am very excited to see what 2016 will bring us 🤘.
+ +
is_state_attr(entity_id, name, value) added (@andythigpen)binary_sensor component.Alrighty, it’s time for Home Assistant 0.10. A lot amazing things have changed and sadly we also had to introduce a bunch of backwards incompatible changes. I would like to give a big shoutout to Philip Lundrigan (@philipbl) who put a lot in effort in helping the migration to move towards using templates for a wide variety of platforms.
+ +
Exposing your Home Assistant instance outside of your network always has been tricky. You have to set up port forwarding on your router and most likely add a dynamic DNS service to work around your ISP changing your IP. After this you would be able to use Home Assistant from anywhere but there is one big red flag: no encryption.
+ +This tutorial will take you through the steps to setup a dynamic DNS for your IP and allow trusted encrypted connection to it - for free using DuckDNS and Let’s Encrypt.
+ +
+
+
Update Dec 16: Great news! Philips has decided to reverse their decision and is working on a software update to allow 3rd party light bulbs again.
+ +
+
+Philips Hue FAQ entries regarding reversing the decision.
+
Original post:
+ + + + Read on → + +
+In this tutorial I will explain how you can activate Tasker tasks from Home Assistant command line switches. We are going to set up a switch that when toggled will make your Android device say either “On” or “Off”.
You could also do this with the automation component instead so whenever you put your house to sleep mode for example your Android device will open up Google Play Books or the Kindle app ready for you to read as well as dimming your lights, but this tutorial is all about the switches.
+ + + + Read on → + +It’s been a few weeks but we managed to polish a nice new release of Home Assistant for y’all!
+ +
To update, run pip3 install --upgrade homeassistant.
+
+
From time to time we come along things that are worth sharing with fellow Home Assisters. Here a list of some cool stuff from last week:
+ +First is the public beta of Let’s Encrypt. Let’s Encrypt is a new certificate authority that is free, automated and open. This means that it will now be very easy to secure your connection to Home Assistant while you are away from home. W1ll1am23 has written up a guide how to get started.
+ +The next thing is a show-off of some of the cool stuff people do with Home Assistant. This is miniconfig talking to Home Assistant using the Amazon Echo!
+ +And last but not least, Midwestern Mac did a microSD card performance comparison for the Raspberry Pi. If you’re using a Pi, make sure to check it out!
+ + +Around a week ago we started with the first survey. Now 30 people have participated. Thank you very much if you did. We think that’s enough time to have some “only partially representative” data. It’s hard to tell how many Home Assistant users are out there. Currently there are 215 members in our Gitter chat room and last week PyPI counted 5063 downloads.
The idea was to anonymously collect some details about the usage of the different parts of Home Assistant and a little bit about the environment its running in.
+ + + + Read on → + +We have all been hard at work to get this latest release ready. One of the big highlights in this release is the introduction of an extended iconset to be used in the frontend (credits to @happyleavesaoc for idea and prototype). To get started with customizing, pick any icon from MaterialDesignIcons.com, prefix the name with mdi: and stick it into your customize section in configuration.yaml:
homeassistant:
+ customize:
+ switch.ac:
+ icon: 'mdi:air-conditioner'
+
After two weeks of hard work I’m proud to announce the release of Home Assistant v0.7.6. For this release the main focus was bugs, test coverage and documentation. And we exceeded expectations on all three fronts. Bugs have been squashed, test coverage increased to 85% and thanks to the hard work by @fabaff and myself the component section on the website has gotten a complete revamp.
+ +
customize key in configuration.yaml (@balloob)configuration.yaml (@balloob)I recently learned about the ESP8266, a $5 chip that includes WiFi and is Arduino compatible. This means that all your DIY projects can now be done for a fraction of the price.
+ +For this tutorial, I’ll walk through how to get going with ESP8266, get the temperature and humidity and report it to MQTT where Home Asssistant can pick it up.
+ +
+
+Picture of the final setup (+ 2 LED for decoration)
+
+
+Home Assistant will keep track of historical values and allow you to integrate it into automation.
+
We discovered two issues annoying enough to warrent the release of 0.7.5:
+ +This release also includes some new platforms (because they keep coming!):
+ +
Also, the media player was extended by @maddox to support the play media command. This has been implemented for the iTunes platform.
+ + +A few weeks have past and it is time again for another release: version 0.7.4. This time we’re very glad to be able to introduce brand new integration with OwnTracks to allow tracking of people on a map. The geo support consists of three different parts:
+ +We have added a new getting started section to get up and running.
+ +
+
+Map in Home Assistant showing two people and three zones (home, school, work)
+
Ofcourse more things happened in the last three weeks. I’m moving away from my usual long post to a short summary of highlights:
+ + + +It’s like someone opened a can of rock solid developers and emptied it above our chat channel because it exploded with great conversations and solid contributions. Featured in release 0.7.3: Sonos, iTunes, Alarm component and Automation upgrade.
+ +See GitHub for more detailed release notes.
+ +Migration note: the scheduler component has been removed in favor of the automation component.
Sonos
+ Sonos support has been added by @rhooper and @SEJeff. Home Assistant is now able to automatically detect Sonos devices in your network and set them up for you. It will allow you to control music playing on your Sonos and change the volume.
iTunes and airplay speakers
+ @maddox has contributed support for controlling iTunes and airplay speakers. For this to work you will have to run itunes-api on your Mac as middleware.
# Example configuration.yaml entry
+media_player:
+ platform: itunes
+ name: iTunes
+ host: http://192.168.1.50
+ port: 8181
+
+Inspried by a feature requests I started looking into the available options to do monitoring of remote hosts. The feature request is about displaying system information in a similar way than the systemmonitor sensor does it for the local system. After a while I started to think that it would be a nice addition for a small home network where no full-blown system monitoring setup is present.
Today we announce the release of Home Assistant v0.7.2 which includes brand new support by @sfam to integrate with IFTTT. IFTTT stands for If This, Then That and is a webservice that integrates with almost every possible webservice out there. Adding Home Assistant to this mix means Home Assistant can connect with all via IFTTT.
+ +It is now possible to disable your irregation system if it is going to be cloudy tomorrow or tweet if your smoke alarm goes off.
+ +
+
+
Head over to the setup instructions to get started with IFTTT. Click the read more button for some example recipes.
+ + + + Read on → + + MQTT support was added to Home Assistant recently. The MQTT component will enable you to do all sort of things. Most likely you will use it to communicate with your devices. But Home Assistant doesn’t care where the data is coming from or is limited to real hardware as long as there is MQTT support. This means that it doesn’t matter if the data is coming from a human, a web service, or a device.
A great example is shown in a Laundry Automation post in this blog.
+ +This post will give you a small overview of some other possibilities on how to use MQTT with Home Assistant.
+ + + + Read on → + +As Home Assistant is gaining more and more users we started to feel the pain from not having a proper release mechanism. We had no version numbering and required users to checkout the source using Git to get started. On top of that, as the number of devices that we support keeps raising, so did the number of dependencies that are used. That’s why we decided to change the way we roll. From now on:
+ +hass.config in the current working directory to ~/.homeassistant (%APPDATA%/.homeassistant on Windows).<config-dir>/lib.A huge shout out to Ryan Kraus for making this all possible. Please make sure you read the full blog post for details on how to migrate your existing setup.
+ +And while Ryan was fixing distribution, I have been hard at work in giving Home Assistant a face lift. We already looked pretty good but lacked proper form of organization for users with many devices. The new UI moves away from a card per entity and has cards per group and domain instead. The demo has been updated so give it a spin.
+ +
+
+
+
+ Screenshots of the new UI
+
This is a guest post by Home Assistant user and contributor Nolan Gilley.
+ +In our house, laundry has been a struggle for quite some time. Our washer and dryer both lack a buzzer which leads to forgotten laundry, and stinky mess that needs to be rewashed. I decided to create a solution by monitoring the washer and dryer myself with some cheap electronics.
+ +As an avid user of Home Assistant, I decided it would be the perfect application to manage the UI and notification system. Now all I needed was a way to monitor the washer and dryer. I tried using sound sensors but found them unreliable. I ended up opting for an accelerometer attached to the back of each appliance. I also added magnetic reed switches on the doors of the washer and dryer to detect if the doors are open or closed. I connected the accelerometers and reed switches to a Moteino, an arduino clone with an RF transceiver. The Moteino can perform the logic to figure out which state the appliances are in and wirelessly communicate that data with another Moteino that is connected via serial to my Raspberry Pi. The Raspberry Pi reads the serial data and repeats it over MQTT for Home Assistant to use. This is great because I don’t have to run Home Assistant on the Raspberry Pi. I can run it on a faster machine and point the MQTT component to my Raspberry Pi.
+ +After taking some sample data from the accelerometers while each appliance was in operation, I decided to plot the data to help determine the proper thresholds of when the devices were running or off. I had to do this in order to get precise ranges so the dryer sensor wouldn’t get tripped by the washer or vice versa. In the plot below you can see the acceleration in the x direction for the accelerometer connected to the washing machine. It’s easy to see when the washing machine is in operation here. I used the same technique for the dryer’s accelerometer.
+ +
+
+
+
+ Graph showing the accelerometer data
+
A minor bug fix release to fix some issues that have come up since the last release. Please upgrade as soon as possible by running git pull from the Home Assistant directory.
This release is a major milestone in our test coverage as we’ve crossed into the 80s! It has to be noted that this covers mainly the core and automation components. Platforms that communicate with IoT devices have been excluded.
+ +As we didn’t want to just push out bug fixes, this release includes a few additions:
+ +Verisure Support
+ Home Assistant support to integrate your Verisure alarms, hygrometers, sensors and thermometers has been contributed by @persandstrom.
# Example configuration.yaml entry
+verisure:
+ username: user@example.com
+ password: password
+ alarm: 1
+ hygrometers: 0
+ smartplugs: 1
+ thermometers: 0
+It’s time for the August release and there is some serious good stuff this time. The core of Home Assistant has gone some serious clean up and a bump in test coverage thanks to @balloob. If you’re a developer, make sure you read up on the deprecation notices. @fabaff did another great round of documentating all the various components.
+ +MQTT Support
+ The big new addition in this release is the support for the MQTT protocol by @fabaff with some help from @balloob. It will now be possible to integrate any IoT device that talks via MQTT. For the initial release we support connecting Home Assistant to a broker (no TLS yet). Components can now subscribe and publish to MQTT topics (see the example) and also support for the automation component has been added. For more information, see the MQTT component page.
# Example configuration.yaml entry
+mqtt:
+ broker: IP_ADDRESS_BROKER
+ # All the other options are optional:
+ port: 1883
+ keepalive: 60
+ qos: 0
+ username: your_username
+ password: your_secret_password
+Another month has passed and some great new features have landed in Home Assistant. This month release has been made possible by balloob, ettisan, fabaff, gyran, jamespcole, michaelarnauts, miniconfig and rmkraus.
+ +This release includes some architectural changes by me. The first is that the frontend is now based on a NuclearJS JavaScript backend. This has greatly helped to organize and optimize the frontend code. Another change is that Home Assistant will now install dependencies on-demand instead of installing dependencies for all supported devices.
+ +IP Camera Support +James has worked very hard to add support for IP cameras to Home Assistant which is included in this release. The initial release focusses on providing generic IP camera support. This means that any webcam that can exposes a JPEG image via a url can be integrated.
+ +Home Assistant will route the requests to your camera via the server allowing you to expose IP camera’s inside your network via the Home Assistant app.
+ +# Example configuration.yaml entry
+camera:
+ platform: generic
+ name: my sample camera
+ username: MY_USERNAME
+ password: MY_PASSWORD
+ still_image_url: http://194.218.96.92/jpg/image.jpg
+
+To update to the latest version, run scripts/update. Please report any issues on GitHub.
+
Wow, almost a month has gone by since the last release and this release is packed. The biggest part of this release is probably one that you won’t notice: the frontend has been upgraded from Polymer 0.5 to the brand new released Polymer 1.0. Polymer has been declared stable by the Google overlords which will allow us to expand functionality that was waiting for this moment to arrive.
+ +This release sets a record for the amount of people involved: 8! Andythigpen, Jamespcole, Azelphur, Fabaff, Dutchy-, Fbradyirl, wind-rider and ettisan, thanks a lot for your contributions!
+ +A big improvement has been brought this release by wind-rider. He took the time to revive the Chromecast support and started improving the media player integration. This triggered other people to join in resulting in a revamped media player experience and support for the Music Player Daemon.
+ +
+ Example of the new media player cards
+
+To update to the latest version, run scripts/update. Please report any issues on GitHub.
+
Almost three busy weeks have past since the last release. We used this time to finally make the overhaul to use UTC as the internal date time format. We added a bunch of test coverage in the process to make sure the transition went smoothly. Pleas see the blog post about the UTC refactor for backwards incompatible changes.
+ +This release includes a significant startup boost for the frontend and a fix for Wemo discovery after their latest firmware upgrade.
+ +I would like to give a big shout out to our newest contributor fabaff for taking the time to improve the documentation.
+ +
+To update to the latest version, run scripts/update. Please report any issues on GitHub.
+
I have recently merged code to refactor Home Assistant to use only UTC times internally. A much needed refactor. I’ve added some extra test coverage to time sensitive parts to ensure stability. The code has been live in the dev branch for the last 9 days and will be soon released to the master branch.
+ +From now on all internal communication will be done in UTC: time changed events, datetime attributes of states, etc. To get the current time in UTC you can call homeassistant.util.dt.utcnow(). This is a timezone aware UTC datetime object. homeassistant.util.dt is a new util package with date helpers.
There is also such a thing as local time. Local time is based on the time zone that you have setup in your configuration.yaml. Local times should only be used for user facing information: logs, frontend and automation settings in configuration.yaml.
Setting up a time zone happens in configuration.yaml. If you have no time zone setup, it will be auto detected using the existing detection code using freegeoip.net. You can find a list of compatible time zones on Wikipedia.
homeassistant:
+ time_zone: America/Los_Angeles
+The changes to the code are mostly backwards compatible. The old hass.track_time_change and hass.track_point_in_time use now internally two new methods: hass.track_utc_time_change and hass.track_point_in_utc_time. The usage of the old methods have not changed and should be backwards compatible.
This refactor adds a new migration for the database adding a utc_offset column to events and states. This information is currently not used but can prove useful in the future when we start analyzing the historical data.
All built-in components have been upgraded. The following list is only for people that run custom components:
+ +hass.track_time_change and hass.track_point_in_time will now return a time zone aware datetime object. Python does not allow comparing a naive with an aware datetime object.sun.next_rising(hass) and sun.next_setting(hass) are backwards compatible, just be careful if you used to read the raw attributes.It’s been a month since the latest update and a lot has happened again. Here a quick overview of the new things.
+ +Line Charts +James has upgraded the history in the frontend to support line graphs. Line graphs will be shown for any entity that has a unit of measurement. The line graphs will also be shown in the more info card of an entity. See the demo for a live example.
+ +
+
+
ISY994 hub support
+ Ryan has contributed support to integrate the ISY994 hub by Universal Devices. This allows you to integrate your X10/Insteon sensors, switches and lights.
He has created an extensive getting started guide which can be found on the ISY994 component page.
+ +# Example configuration.yaml entry
+isy994:
+Logbook
+ I (Paulus) have added a logbook component. The logbook component provides a different perspective on the history of your house by showing all the changes that happened to your house in chronological order. See the demo for a live example.
+
# Example configuration.yaml entry
+logbook:
+A new version of Home Assistant has just been pushed out. It contains bugfixes contributed by jamespcole, andythigpen, trainman419 and me. It also adds a bunch of great new features:
+ +Script
+Andythigpen has contributed a script component. This allows users to create a sequence of service calls and delays. Scripts can be started using the service script/turn_on and interrupted using the service script/turn_off. A separate page has been added to the frontend to see the status of your scripts.
# Example configuration.yaml entry
+script:
+ # Turns on the bedroom lights and then the living room lights 1 minute later
+ wakeup:
+ alias: Wake Up
+ sequence:
+ - alias: Bedroom lights on
+ execute_service: light.turn_on
+ service_data:
+ entity_id: group.bedroom
+ - delay:
+ # supports seconds, milliseconds, minutes, hours, etc.
+ minutes: 1
+ - alias: Living room lights on
+ execute_service: light.turn_on
+ service_data:
+ entity_id: group.living_room
+It has only been a little over a week since Theodor introduced YAML support for Home Assistant but so much has already happened that it is time for a summary of recent changes. Before mentioning the highlights I want to thank andythigpen, jamespcole and theolind for numerous bug fixes, enhancements and new contributions. Thanks!
+ +Monitor local resources.
+Theodor has contributed a new sensor platform to allow you to monitor disk usage, memory usage, CPU usage and running processes. This platform has superseded the process component which is now considered deprecated.
# Example configuration.yaml entry
+sensor:
+ - platform: systemmonitor
+ resources:
+ - type: disk_use_percent
+ arg: /home
+ - type: memory_free
+ - type: process
+ arg: kodi
+Experimental Z-Wave support
+There is now experimental support for connecting Z-Wave networks using a Z-Wave USB stick. Right now it only integrates Z-Wave sensors into Home Assistant. Our goal is to get this tested by more people before adding support for other Z-Wave devices.
The new component is built on top of python-openzwave. This package is currently not distributed on PyPi so we’ve added a script scripts/build_python_openzwave to install it on your machine. Alternatively you can use the Docker image which is ready to go.
The development was done using an AEON Z-Wave USB stick and an AEON Z-Wave MultiSensor.
+ +# Example configuration.yaml entry
+zwave:
+ usb_path: /dev/ttyUSB0
+Voice control
+An initial version of voice control for Home Assistant has landed. The current implementation consists of two parts.
The first part is a component called conversation that exposes the service conversation/process. This service is capable of processing text and translating them into commands for devices. For now it will only support commands in the format of Turn <Friendly Name> <on/off>.
The second part is an upgrade to the frontend to use the speech-to-text in Chrome to allow users to speak commands. If you’re using Chrome, you can test this out in the demo.
+ +# Example configuration.yaml entry
+conversation:
+It is well known that you are either a good programmer or a good designer. It’s rare you’ll meet someone that is both. That’s why it wasn’t surprising to anyone that the logo that I made was mediocre — at best. Luckily, Jeremy Geltman has come to the rescue and contributed a brand new logo for Home Assistant.
+ +The new logo follows Googles material design spec. It uses the blue color that Home Assistant uses in the interface and it comes in two versions: a high detailed version (for homescreen icon etc) and a simple version (for favicon etc).
+ +
+
+The old logo, the new detailed logo and the new simple logo.
+
Home Assistant is now using YAML for it’s configuration file. YAML allows the use of lists, which should make the configuration file a bit more flexible and useful. The new configuration file format is backwards compatible with existing components. Because of this, there is no need for component developers to update their components.
+ +The new file is named configuration.yaml and if it can’t be found in your config directory, Home Assistant will instead try to find the old configuration file, home-assistant.conf.
+ +The home-assistant.conf.example has been replaced with an updated configuration.yaml.example.
+ +Users of Home Assistant should migrate as the old configuration format is deprecated.
+ + +Home Assistant has learned a new trick to get the latest information from the server: streaming updates. No longer will the frontend poll every 30 seconds for updates but instead it will keep a connection open and get the latest changes pushed as soon as they happen.
+ +A new toggle has been added ot the sidebar to turn streaming updates on and off. This preference will be saved on a per-browser basis using local storage. The toggle will also indicate when there is an error setting up a stream after which it will fall back to use polling.
+ +
Ever since the launch of Home Assistant you have been able to track the state of your house. But the view has always been limited to what the current state is. Not what it was. Today we are going to change that by introducing two brand new components:
+ +By adding this view into the past, we are adding an extra dimension into the state of your house. This brings great new possibilities for future features. The focus of todays release is on getting the recording component to you to start recording and getting some data. To show what is being recorded a view has been added that shows the last 24 hours of your house. Expect more extensive tools to explore your history in the future.
+ +Adding history to the UI was a challenge on itself because the old UI did not support easy navigation. So to add to the awesomeness of this release, Home Assistant also got a face lift.
+ +The history component will be enabled for new users by default. For current users, run scripts/update to upgrade to the latest version and add [history] to your home-assistant.conf file.
+
+
+
+
+Events are saved in a local database. Google Graphs is used to draw the graph. Drawing is happening 100% in your browser - no data is transfered to anyone at any time. +
+ + + + Read on → + +I have just merged the latest version of the development branch into master. Here are some of the highlights of this release:
+ +Configuration via the frontend
+Phliips Hue will now be auto discovered and uses the new configurator component to interact with the user to finish the setup process.
Wink Hub support
+Thanks to the work done by John McLaughlin and Geoff Norton we now support the lights, switches and sensors that are connected to the Wink hub.
The getting started guide and component page have been reorganized
+The getting started instructions have been split into separate pages per component and a general overview page. The goal is to have a page per component that describes:
More reasonable errors
+Home Assistant should now throw better errors and offer solutions if you do not have the right version of Python 3, forgot to clone the git submodules or install the dependencies.
Streamlined first launch
+Home Assistant now supports --open-ui and --demo-mode command line properties to open the browser automatically and have something to show. Home Assistant now supports to be run without a password, allowing the interface to login automatically on launch.
For thet majority of its existence, Home Assistant primary focus was on presence detection, lights and switches. But not anymore as we’re expanding the supported devices. Today, we’re proud to introduce Nest Thermostat integration for Home Assistant contributed by Stefano Fiorini!
+ +
+
+
The new integration exists out of two parts: a generic thermostat component and a Nest platform implementation. The initial version implements provides a read-only card and services to control it. The plan is in the future to add temperature and away mode controls from the thermostat card and more info dialog. Internally, we are using the Python package python-nest by jkoelker to talk to the Nest.
+ +If you own a Nest thermostat, add the following lines to your home-assistant.conf:
[thermostat]
+platform=nest
+username=YOUR_USERNAME
+password=YOUR_PASSWORD
+Most people do not like configuring things. Things just have to work, out of the box. Reaching this scenario is the goal of what we are about to introduce: our new discovery component.
+ +The discovery component will scan the WiFi network from time to time for connected zeroconf/mDNS and uPnP devices. The intial introduction is mainly focussed on getting the right architecture in place and discovers Belkin WeMo switches and Google Chromecasts connected to your network. When found, it will load and notify the appropritate component and it will be ready to use within seconds.
+ +Most devices still require some sort of interaction from the user after being discovered - be it a button being pressed or some sort of authentication. This is a challenge that will be solved in the future.
+ +To enable the discovery component, add the following to your home-assistant.conf:
[discovery]
+A new discovery section has been added to the Adding a new platform page with instructions how to make your platform discoverable.
+ + +One of the things that was missing in Home Assistant for a while was a way to communicate with users. Wouldn’t it be nice to get a message when important events happen like the lights being turned on while no one is home? Since the Home Assistant frontend runs as a web application on the phone, we have no way to bring ourselves to the front. This is where the new notify component comes in, powered by PushBullet.
+ +The new notify component will take in messages and tells them to the user. For now this will be powered by the very awesome PushBullet but any other messaging platform can be easily added.
+ +
+
+ A message triggered by the simple_alarm component is shown by PushBullet on the Moto360.
+
Read on to learn how to enable the notify component and integrate it with other components.
+ + + + Read on → + +The internet has been buzzing over the last year about home automation. A lot of different terms fly around like the internet of things, home automation and the smart home. +This article will try to explain how they all relate.
+ +The first thing to introduce is the Internet of Things (IoT). This refers to a new generation of devices that cannot only be controlled by humans via buttons or remotes but also provide an interface to communicate with other devices and applications. For example, an IoT-capable coffee machine could receive commands to create different types of coffee and be able to broadcast the amount of water left in its resevoir.
+ +There is no widely adopted open standard for smart device communication. This prevents a lot of devices to communicate with one another. And even if they could, most devices are not designed to manage other devices. To solve this we need a device to be able to communicate with and manage all these connected devices. This device is called a hub.
+ +As a bare minimum a hub has to keep track of the state of each device and should be able to control them if possible. For example, it has to know which lights are on or off and offer a way to control the lights. For a sensor it only has to know the value. A hub with these capabilities offers home control.
+ +
+
+
+
+ Example of a hub’s dashboard. Showing the state of 2 persons, 4 lights and the sun.
+
I finally took the time to setup a simple website to help people getting started with Home Assistant. The process was super smooth thanks to the great tools Jekyll and Octopress and the great services GitHub Pages and CloudFlare.
+ + +The alarmdotcom platform is consuming the information provided by a Alarm.com.
To enable this, add the following lines to your configuration.yaml:
# Example configuration.yaml entry
+alarm_control_panel:
+ platform: alarmdotcom
+ username: YOUR_USERNAME
+ password: YOUR_PASSWORD
+Configuration variables:
+ +The concord232 platform provides integration with GE, Interlogix (and other brands) alarm panels that support the RS-232 Automation Control Panel interface module (or have it built in). Supported panels include Concord 4.
To enable this, add the following lines to your configuration.yaml:
# Example configuration.yaml entry
+alarm_control_panel:
+ - platform: concord232
+Configuration variables:
+ +The envisalink alarm control panel platform allows you to control your Envisalink alarms.
The requirement is that you have setup your Envisalink hub.
+ + + +This platform enables you to set manual alarms in Home Assistant.
+ +# Example configuration.yaml entry
+alarm_control_panel:
+ platform: manual
+Configuration variables:
+ +In this section you find some real life examples of how to use this panel.
+ +Using sensors to trigger the alarm.
+ +automation:
+- alias: 'Trigger alarm while armed away'
+ trigger:
+ - platform: state
+ entity_id: sensor.pir1
+ state: 'active'
+ - platform: state
+ entity_id: sensor.pir2
+ state: 'active'
+ - platform: state
+ entity_id: sensor.door
+ state: 'open'
+ - platform: state
+ entity_id: sensor.window
+ state: 'open'
+ condition:
+ - platform: state
+ entity_id: alarm_control_panel.ha_alarm
+ state: armed_away
+ action:
+ service: alarm_control_panel.alarm_trigger
+ entity_id: alarm_control_panel.ha_alarm
+The mqtt alarm panel platform enables the possibility to control MQTT capable alarm panels. The Alarm icon will change state after receiving a new state from state_topic. If these messages are published with RETAIN flag, the MQTT alarm panel will receive an instant state update after subscription and will start with the correct state. Otherwise, the initial state will be unknown.
The component will accept the following states from your Alarm Panel (in lower case):
+ +The component is able to control your Alarm Panel by publishing to the command_topic when a user interacts with the Home Assistant frontend.
To enable this platform, add the following lines to your configuration.yaml:
# Example configuration.yaml entry
+alarm_control_panel:
+ platform: mqtt
+ state_topic: "home/alarm"
+ command_topic: "home/alarm/set"
+Configuration variables:
+ +The nx584 platform provides integration with GE, Caddx, Interlogix (and other brands) alarm panels that support the NX584 interface module (or have it built in). Supported panels include NX4/6/8/8E. Actual integration is done through pynx584 which is required for this to work.
To enable this, add the following lines to your configuration.yaml:
# Example configuration.yaml entry
+alarm_control_panel:
+ - platform: nx584
+Configuration variables:
+ +localhost.5007.The simplisafe platform enables the ability to control a SimpliSafe control panel. simplisafe.com.
To enable this, add the following lines to your configuration.yaml:
# Example configuration.yaml entry
+alarm_control_panel:
+ platform: simplisafe
+ username: YOUR_USERNAME
+ password: YOUR_PASSWORD
+Configuration variables:
+ +The Verisure alarm control panel platform allows you to control your Verisure Alarms.
+ +The requirement is that you have setup your Verisure hub.
+ +The changed_by attribute enables one to be able to take different actions depending on who armed/disarmed the alarm in automation.
automation:
+ - alias: Alarm status changed
+ trigger:
+ - platform: state
+ entity_id: alarm_control_panel.alarm_1
+ action:
+ - service: notify.notify
+ data_template:
+ message: >
+ Alarm changed from {{ trigger.from_state.state }}
+ to {{ trigger.to_state.state }}
+ by {{ trigger.to_state.attributes.changed_by }}
+There are a few ways that you can use Amazon Echo and Home Assistant together.
+ + + +No matter which method(s) you decide to use, please remember that Amazon Echo requires an active Internet connection to function. If your Internet is down or experiencing issues (or Amazon’s infrastructure is having issues), none of these methods will work.
+ +Amazon has released Echosim, a website that simulates the Alexa service in your browser. That way it is easy to test your skills without having access to a physical Amazon Echo.
+ +If you just want to be able to turn anything with a switch (like lights, switches, media players, etc) on and off, you should enable the Emulated Hue component. It makes your Home Assistant appear as if it were a Phillips Hue bridge, which Echo works with natively.
+ +Enabling the Emulated Hue component means you can turn things on and off by simply saying
+ +++ +Alexa, turn the living room lights on.
+
or
+ +++ +Alexa, set the living room lights to twenty percent.
+
instead of
+ +++ +Alexa, tell Home Assistant to turn the living room lights on.
+
or
+ +++ +Alexa, tell Home Assistant to set the living room lights to twenty percent.
+
In addition, you would need to build custom intents for each device and on/off combination using the below method, whereas everything just works without any extra work by using Emulated Hue.
+ +Please note that you can use Emulated Hue and the built-in Alexa component side-by-side without issue if you wish.
+ +The built-in Alexa component allows you to integrate Home Assistant into Alexa/Amazon Echo. This component will allow you to query information and call services within Home Assistant by using your voice. Home Assistant offers no built-in sentences but offers a framework for you to define your own.
+ +Amazon requires the endpoint of a skill to be hosted via SSL. Self-signed certificates are ok because our skills will only run in development mode. Read more on our blog about how to set up encryption for Home Assistant. If you are unable to get HTTPS up and running, consider using this AWS Lambda proxy for Alexa skills.
+ +To get started with Alexa skills:
+ +You can use this specially sized Home Assistant logo as the large icon and this one as the small one.
+ +Alexa works based on intents. Each intent has a name and variable slots. For example, a LocateIntent with a slot that contains a User. Example intent schema:
{
+ "intents": [
+ {
+ "intent": "LocateIntent",
+ "slots": [
+ {
+ "name": "User",
+ "type": "AMAZON.US_FIRST_NAME"
+ }]
+ },
+ {
+ "intent": "WhereAreWeIntent",
+ "slots": []
+ }
+ ]
+}
+To bind these intents to sentences said by users you define utterances. Example utterances can look like this:
+ +LocateIntent Where is {User}
+LocateIntent Where's {User}
+LocateIntent Where {User} is
+LocateIntent Where did {User} go
+
+WhereAreWeIntent where we are
+This means that we can now ask Alexa things like:
+ +Out of the box, the component will do nothing. You have to teach it about all intents you want it to answer to. The way it works is that the answer for each intent is based on templates that you define. Each template will have access to the existing states via the states variable but will also have access to all variables defined in the intent.
You can use templates for the values of speech/text, card/title and card/content.
Actions are using the Home Assistant Script Syntax and also have access to the variables from the intent.
+ +Configuring the Alexa component for the above intents would look like this:
+ +# Example configuration.yaml entry
+alexa:
+ intents:
+ WhereAreWeIntent:
+ speech:
+ type: plaintext
+ text: >
+ {%- if is_state('device_tracker.paulus', 'home') and
+ is_state('device_tracker.anne_therese', 'home') -%}
+ You are both home, you silly
+ {%- else -%}
+ Anne Therese is at {{ states("device_tracker.anne_therese") }}
+ and Paulus is at {{ states("device_tracker.paulus") }}
+ {% endif %}
+
+ LocateIntent:
+ action:
+ service: notify.notify
+ data_template:
+ message: The location of {{ User }} has been queried via Alexa.
+ speech:
+ type: plaintext
+ text: >
+ {%- for state in states.device_tracker -%}
+ {%- if state.name.lower() == User.lower() -%}
+ {{ state.name }} is at {{ state.state }}
+ {%- endif -%}
+ {%- else -%}
+ I am sorry, I do not know where {{ User }} is.
+ {%- endfor -%}
+ card:
+ type: simple
+ title: Sample title
+ content: Some more content
+One of the most useful applications of Alexa integrations is to call scenes directly. This is easily achieved with some simple setup on the Home Assistant side and by letting Alexa know which scenes you want to run.
+ +First we will configure Alexa. In the Amazon Interaction module add this to the intent schema:
+ +{
+ "intent": "ActivateSceneIntent",
+ "slots":
+ [
+ {
+ "name" : "Scene",
+ "type" : "Scenes"
+ }
+ ]
+}
+Then create a custom slot type called Scenes listing every scene you want to control:
+
+Custom slot type for scene support.
+
The names must exactly match the scene names (minus underscores - amazon discards them anyway and we later map them back in with the template).
+ +Add a sample utterance:
+ +ActivateSceneIntent activate {Scene}
+Then add the intent to your Alexa Section in your HA config file:
+ + ActivateSceneIntent:
+ action:
+ service: scene.turn_on
+ data_template:
+ entity_id: scene.{{ Scene | replace(" ", "_") }}
+ speech:
+ type: plaintext
+ text: OK
+Here we are using templates to take the name we gave to Alexa e.g. downstairs on and replace the space with an underscore so it becomes downstairs_on as Home Assistant expects.
Now say Alexa ask homeassistant to activate <some scene> and Alexa will activate that scene for you.
We can easily extend the above idea to work with scripts as well. As before, add an intent for scripts:
+ +{
+ "intent": "RunScriptIntent",
+ "slots":
+ [
+ {
+ "name" : "Script",
+ "type" : "Scripts"
+ }
+ ]
+}
+Create a custom slot type called Scripts listing every script you want to run:
+
+Custom slot type for script support.
+
Add a sample utterance:
+ +RunScriptIntent run {Script}
+Then add the intent to your Alexa Section in your HA config file:
+ + RunScriptIntent:
+ action:
+ service: script.turn_on
+ data_template:
+ entity_id: script.{{ Script | replace(" ", "_") }}
+ speech:
+ type: plaintext
+ text: OK
+Now say Alexa ask homeassistant to run <some script> and Alexa will run that script for you.
In the examples above, we told Alexa to say OK when she successfully completed the task. This is effective but a little dull! We can again use templates to spice things up a little.
First create a file called alexa_confirm.yaml with something like the following in it (go on, be creative!):
>
+ {{ [
+ "OK",
+ "Sure",
+ "If you insist",
+ "Done",
+ "No worries",
+ "I can do that",
+ "Leave it to me",
+ "Consider it done",
+ "As you wish",
+ "By your command",
+ "Affirmative",
+ "Yes oh revered one",
+ "I will",
+ "As you decree, so shall it be",
+ "No Problem"
+ ] | random }}
+Then, wherever you would but some simple text for a response likeOK, replace it with a reference to the file so that:
text: OK
+becomes:
+ +text: !include alexa_confirm.yaml
+Alexa will now respond with a random phrase each time. You can use the include for as many different intents as you like so you only need to create the list once.
+ +As of version 0.31 Home Assistant supports the new Alexa Flash Briefing Skills API. A Flash Briefing Skill adds a new Flash Briefing source that is generated by Home Assistant.
+ +You can use templates for the title, audio, text and display_url configuration parameters.
Here’s an example configuration of a Flash briefing skill that will tell you who is at home:
+ +# Example configuration.yaml entry
+alexa:
+ flash_briefings:
+ whoishome:
+ - title: Who's at home?
+ text: >
+ {%- if is_state('device_tracker.paulus', 'home') and
+ is_state('device_tracker.anne_therese', 'home') -%}
+ You are both home, you silly
+ {%- else -%}
+ Anne Therese is at {{ states("device_tracker.anne_therese") }}
+ and Paulus is at {{ states("device_tracker.paulus") }}
+ {% endif %}
+You can add multiple items for a feed if you want. The Amazon required uid and timestamp will be randomly generated at startup and change at every restart of Home Assistant.
+ +Please refer to the Amazon documentation for more information about allowed configuration parameters and formats.
+ +https://YOUR_HOST/api/alexa/flash_briefings/BRIEFING_ID?api_password=YOUR_API_PASSWORD where BRIEFING_ID is the key you entered in your configuration (such as whoishome in the above example). NOTE: Do not use a non-standard http or https port, AWS will not connect to it.| To invoke your flash briefing, open the Alexa app on your phone or go to [Alexa | +http://alexa.amazon.com/], open the “Skills” configuration section, select “Your Skills”, scroll to the bottom, tap on the Flash Briefing Skill you just created, enable it, then manage Flash Briefing and adjust ordering as necessary. Finally ask your Echo for your “news”,”flash briefing”, or “briefing”. | +
APCUPSd status information can be integrated into Home Assistant when the Network Information Server (NIS) is configured is enabled on the APC device.
+ +To enable this sensor, add the following lines to your configuration.yaml:
# Example configuration.yaml entry
+apcupsd:
+Configuration variables:
+ +localhost.3551.The Arduino device family are microcontroller boards that are often based on the ATmega328 chip. They come with digital input/output pins (some can be used as PWM outputs), analog inputs, and a USB connection. The equipment depends on the type of board. The most common ones are the Arduino Uno and the Arduino Leonardo with 14 digital input/output pins and 6 analog input pins.
+ +There are a lot of extensions (so called shields) available. Those shields can be plugged-in into the existing connectors and stacked on top of each other. This makes it possible to expand the capabilities of the Arduino boards.
+ +The arduino component is designed to let you use a directly attached board to your Home Assistant host over USB.
You need to have the Firmata firmware on your board. Please upload the StandardFirmata sketch to your board, please refer to the Arduino documentation for further information.
To integrate an Arduino boards with Home Assistant, add the following section to your configuration.yaml file:
# Example configuration.yaml entry
+arduino:
+ port: /dev/ttyACM0
+Configuration variables:
+ +ttyACM* otherwise ttyUSB*.The exact number can be determined with the command shown below.
+ +$ ls /dev/ttyACM*
+If that’s not working, check your dmesg or journalctl -f output. Keep in mind that Arduino clones are often using a different name for the port (eg. /dev/ttyUSB*).
+A word of caution: The Arduino boards are not storing states. This means that with every initialization the pins are set to off/low. +
+ +Add the user who is used to run Home Assistant to the groups to allow access to the serial port.
+ +sudo usermod -a -G dialout,lock $USER
+Please see the getting started section for in-depth documentation on how to use the automation component.
+ +Starting with 0.28 your automation rules can be controlled with the frontend.
+ +
+
+
This allows one to reload the automation without restarting Home Assistant itself. If you don’t want to see the automation rule in your frontend use hide_entity: True to hide it.
automation:
+ - alias: Door alarm
+ hide_entity: True
+ trigger:
+ - platform: state
+ ...
+In addition to the APCUPSd Sensor devices, you may also create a device which is simply “on” when the UPS status is online and “off” at all other times.
+ +To enable this sensor, you first have to set up apcupsd, and add the following lines to your configuration.yaml file:
# Example configuration.yaml entry
+binary_sensor:
+ - platform: apcupsd
+Configuration variables:
+ +The arest binary sensor platform allows you to get all data from your devices (like Arduinos with a ethernet/wifi connection, the ESP8266, and the Raspberry Pi) running the aREST RESTful framework.
To use your aREST binary sensor in your installation, add the following to your configuration.yaml file:
# Example configuration.yaml entry
+binary_sensor:
+ - platform: arest
+ resource: http://IP_ADDRESS
+ pin: 8
+Configuration variables:
+ +Accessing the URL http://IP_ADDRESS/digital/PIN_NUMBER should give you the state of the pin inside a JSON response as return_value.
$ curl -X GET http://192.168.0.5/digital/9
+{"return_value": 0, "id": "office1", "name": "Office", "connected": true}
+An example for Pin 9 inspired by the command above could look like this:
+ +# Example configuration.yaml entry
+binary_sensor:
+ - platform: arest
+ resource: http://192.168.0.5/digital/9
+ pin: 9
+ name: Office
++This sensor is not suitable for fast state changes because there is a high possibility that the change took place between two update cycle. +
+ + +The bloomsky binary sensor platform allows you to get data from your BloomSky device.
To get your BloomSky binary sensors working with Home Assistant, follow the instructions for the BloomSky component first.
+ +To use your BloomSky binary sensor in your installation, add the following to your configuration.yaml file:
# Example configuration.yaml entry
+binary_sensor:
+ - platform: bloomsky
+ monitored_conditions:
+ - Night
+ - Rain
+Configuration variables:
+ +The command_line binary sensor platform issues specific commands to get data.
To use your Command binary sensor in your installation, add the following to your configuration.yaml file:
# Example configuration.yaml entry
+binary_sensor:
+ - platform: command_line
+ command: cat /proc/sys/net/ipv4/ip_forward
+Configuration variables:
+ +In this section you find some real life examples of how to use this sensor.
+ +Check the state of an SickRage instance.
+ +# Example configuration.yaml entry
+binary_sensor:
+ - platform: command_line
+ command: netstat -na | find "33322" | find /c "LISTENING" > nul && (echo "Running") || (echo "Not running")
+ name: 'sickragerunning'
+ sensor_class: moving
+ payload_on: "Running"
+ payload_off: "Not running"
+Check if RasPlex is online.
binary_sensor:
+ - platform: command_line
+ command: 'ping -c 1 rasplex.local | grep "1 received" | wc -l'
+ name: 'is_rasplex_online'
+ sensor_class: connectivity
+ payload_on: 1
+ payload_off: 0
+An alternative solution could look like this:
+ +binary_sensor:
+ platform: command_line
+ name: Printer
+ command: ping -c 1 192.168.1.10 &> /dev/null && echo success || echo fail
+ sensor_class: connectivity
+ payload_on: "success"
+ payload_off: "fail"
+The concord232 platform provides integration with GE, Interlogix (and other brands) alarm panels that support the RS-232 Automation Control Panel interface module (or have it built in). Supported panels include Concord 4.
To enable this, add the following lines to your configuration.yaml:
# Example configuration.yaml entry
+binary_sensor:
+ - platform: concord232
+Configuration variables:
+ +localhost.The digital_ocean binary sensor platform allows you to monitor your Digital Ocean droplets.
To use your Digital Ocean droplets, you first have to set up your Digital Ocean hub and then add the following to your configuration.yaml file:
# Example configuration.yaml entry
+binary_sensor:
+ - platform: digital_ocean
+ droplets:
+ - 'fedora-512mb-nyc3-01'
+ - 'coreos-512mb-nyc3-01'
+Configuration variables:
+ +To get your Ecobee binary sensors working with Home Assistant, follow the instructions for the general Ecobee component.
+ + +This can typically be one of those batteryless wall switches. Currently only one type has been tested: Eltako FT55. Other devices will most likely not work without changing the Home Asisstant code.
+ +To use your EnOcean device, you first have to set up your EnOcean hub and then add the following to your configuration.yaml file:
# Example configuration.yaml entry
+binary_sensor:
+ - platform: enocean
+ id: [0x01,0x90,0x84,0x3C]
+Configuration variables:
+ +The envisalink platform allows you to get data from your Envisalink binary sensors from within Home Assistant.
Check the type/class list for a possible visualization of your zone.
+ +The requirement is that you have setup your Envisalink hub.
+ + +The ffmpeg platform allows you to use any video or audio feed with FFmpeg for various sensors in Home Assistant. Available are: noise, motion.
+If the ffmpeg process is broken, the sensor will be unavailable. To restart it, use the service binary_sensor.ffmpeg_restart.
+
To add FFmpeg with noise detection to your installation, add the following to your configuration.yaml file:
# Example configuration.yaml entry
+binary_sensor:
+ - platform: ffmpeg
+ tool: noise
+Configuration variables:
+ +noise.ffmpeg, like audio frequency filtering.To experiment with values:
+ +$ ffmpeg -i YOUR_INPUT -vn -filter:a silencedetect=n=-30dB:d=1 -f null -
+FFmpeg doesn’t have a motion detection filter, but can use a scene filter to detect a new scene/motion. You can set how much needs to change in order to detect motion with the option ‘changes’, the percent value of change between frames. If you want a really small value for ‘changes’, you can also add a denoise filter.
+ +To add FFmpeg with motion detection to your installation, add the following to your configuration.yaml file:
# Example configuration.yaml entry
+binary_sensor:
+ - platform: ffmpeg
+ tool: motion
+ input: FFMPEG_SUPPORTED_INPUT
+Configuration variables:
+ +motion.To experiment with values (changes/100 is the scene value in FFmpeg):
+ +$ ffmpeg -i YOUR_INPUT -an -filter:v select=gt(scene\,0.1) -f framemd5 -
+If you are running into trouble with this sensor, please refer to the troubleshooting section.
+ +extra_arguments: -filter:v "crop=100:100:12:34"The homematic binary sensor platform lets you observe the state changes of binary Homematic sensors through Home Assistant.
Devices will be configured automatically. Please refer to the component configuration on how to setup Homematic.
+ + +The URL for a binary sensor looks like the example below:
+ +http://IP_ADDRESS:8123/api/states/binary_sensor.DEVICE_NAME
++You should choose a unique device name (DEVICE_NAME) to avoid clashes with other devices. +
+ +The JSON payload must contain the new state and can have a friendly name. The friendly name is used in the frontend to name the sensor.
+ +{"state": "on", "attributes": {"friendly_name": "Radio"}}
+For a quick test curl can be useful to “simulate” a device.
$ curl -X POST -H "x-ha-access: YOUR_PASSWORD" \
+ -H "Content-Type: application/json" \
+ -d '{"state": "off", "attributes": {"friendly_name": "Radio"}}' \
+ http://localhost:8123/api/states/binary_sensor.radio
+To check if the sensor is working, use again curl to retrieve the current state.
$ curl -X GET -H "x-ha-access: YOUR_PASSWORD" \
+ -H "Content-Type: application/json" \
+ http://localhost:8123/api/states/binary_sensor.radio
+{
+ "attributes": {
+ "friendly_name": "Radio"
+ },
+ "entity_id": "binary_sensor.radio",
+ "last_changed": "16:45:51 05-02-2016",
+ "last_updated": "16:45:51 05-02-2016",
+ "state": "off"
+}
+In this section you find some real life examples of how to use this sensor. Beside curl.
As already shown on the API page, it’s very simple to use Python and the Requests module for the interaction with Home Assistant.
+ +response = requests.post(
+ 'http://localhost:8123/api/states/binary_sensor.radio',
+ headers={'x-ha-access': 'YOUR_PASSWORD', 'content-type': 'application/json'},
+ data=json.dumps({'state': 'on', 'attributes': {'friendly_name': 'Radio'}}))
+print(response.text)
+httpiehttpie is a user-friendly CLI HTTP client.
$ http -v POST http://localhost:8123/api/states/binary_sensor.radio \
+ x-ha-access:YOUR_PASSWORD content-type:application/json state=off \
+ attributes:='{"friendly_name": "Radio"}'
+The isy994 platform allows you to get data from your ISY994 binary sensors from within Home Assistant.
They will be automatically discovered if the isy994 component is loaded.
+ + +To get your KNX binary sensors working with Home Assistant, follow the instructions for the KNX component.
+ + +The modbus binary sensor allows you to gather data from Modbus coils.
To use your Modbus binary sensors in your installation, add the following to your configuration.yaml file:
# Example configuration.yml entry
+binary_sensor:
+ - platform: modbus
+ coils:
+ - name: Sensor1
+ slave: 1
+ coil: 100
+ - name: Sensor2
+ slave: 1
+ coil: 110
+Configuration variables:
+ +The mqtt binary sensor platform uses the MQTT message payload as the sensor value. If messages in this state_topic are published with RETAIN flag, the sensor will receive an instant update with the last known value. Otherwise, the initial state will be off.
To use your MQTT binary sensor in your installation, add the following to your configuration.yaml file:
# Example configuration.yml entry
+binary_sensor:
+ - platform: mqtt
+ state_topic: "home-assistant/window/contact"
+Configuration variables:
+ +For a quick check you can use the commandline tools shipped with mosquitto to send MQTT messages. Set the state of a sensor manually:
$ mosquitto_pub -h 127.0.0.1 -t home-assistant/window/contact -m "OFF"
+An extended configuration for the same sensor could look like this if you want/need to be more specific.
+ +# Example configuration.yml entry
+binary_sensor:
+ platform: mqtt
+ state_topic: "home-assistant/window/contact"
+ name: "Windows contact"
+ qos: 0
+ payload_on: "1"
+ payload_off: "0"
+ sensor_class: opening
+ value_template: '{{ value.x }}'
+Integrates MySensors binary sensors into Home Assistant. See the main component for configuration instructions.
+ +The following sensor types are supported:
+ +| S_TYPE | +V_TYPE | +
|---|---|
| S_DOOR | +V_TRIPPED | +
| S_MOTION | +V_TRIPPED | +
| S_SMOKE | +V_TRIPPED | +
| S_TYPE | +V_TYPE | +
|---|---|
| S_SPRINKLER | +V_TRIPPED | +
| S_WATER_LEAK | +V_TRIPPED | +
| S_SOUND | +V_TRIPPED | +
| S_VIBRATION | +V_TRIPPED | +
| S_MOISTURE | +V_TRIPPED | +
For more information, visit the serial api of MySensors.
+ +/**
+ * Documentation: http://www.mysensors.org
+ * Support Forum: http://forum.mysensors.org
+ *
+ * http://www.mysensors.org/build/binary
+ */
+
+
+#include <MySensor.h>
+#include <SPI.h>
+#include <Bounce2.h>
+
+#define SN "BinarySensor"
+#define SV "1.0"
+#define CHILD_ID 1
+#define BUTTON_PIN 3 // Arduino Digital I/O pin for button/reed switch.
+
+MySensor gw;
+Bounce debouncer = Bounce();
+MyMessage msg(CHILD_ID, V_TRIPPED);
+
+void setup()
+{
+ gw.begin();
+ gw.sendSketchInfo(SN, SV);
+ // Setup the button.
+ pinMode(BUTTON_PIN, INPUT_PULLUP);
+ // After setting up the button, setup debouncer.
+ debouncer.attach(BUTTON_PIN);
+ debouncer.interval(5);
+ gw.present(CHILD_ID, S_DOOR);
+ gw.send(msg.set(0));
+}
+
+void loop()
+{
+ if (debouncer.update()) {
+ // Get the update value.
+ int value = debouncer.read();
+ // Send in the new value.
+ gw.send(msg.set(value == LOW ? 1 : 0));
+ }
+}
+The nest binary sensor platform let you monitor various states of a thermostat from Nest.
+You must have the Nest component configured to use this sensors. +
+ +To set it up, add the following information to your configuration.yaml file:
binary_sensor:
+ - platform: nest
+ monitored_conditions:
+ - 'fan'
+ - 'hvac_ac_state'
+ - 'hvac_heater_state'
+ - 'hvac_aux_heater_state'
+ - 'hvac_heat_x2_state'
+ - 'hvac_heat_x3_state'
+ - 'hvac_alt_heat_state'
+ - 'hvac_alt_heat_x2_state'
+ - 'hvac_emer_heat_state'
+ - 'online'
+Configuration variables:
+ +The netatmo binary sensor platform is consuming the information provided by a Netatmo Welcome camera. This component allows you to get the latest event seen by the camera.
To enable the Netatmo binary sensor, you have to set up netatmo, this will use discovery to add your binary sensor.
+ +If you want to select a specific sensor, set discovery to False for netatmo and add the following lines to your configuration.yaml:
# Example configuration.yaml entry
+binary_sensor:
+ platform: netatmo
+ home: home_name
+ cameras:
+ - camera_name1
+ monitored_conditions:
+ - Someone known
+ - Someone unknown
+ - Motion
+Configuration variables:
+ +If home and cameras is not provided, all cameras will be used. If multiple cameras are available then each monitored conditions will create a specific sensor for each camera
+ ++Welcome tags are not yet supported, but will be in a next update. +
+ + +The nx584 platform provides integration with GE, Caddx, Interlogix (and other brands) alarm panels that support the NX584 interface module (or have it built in). Supported panels include NX4/6/8/8E. Actual integration is done through pynx584 which is required for this to work.
Enabling this sensor platform exposes all of your zones as binary sensors, which provides visibility through the UI as well as the ability to trigger automation actions instantly when something happens like a door opening, or a motion sensor trigger.
+ +To enable this feature, add the following lines to your configuration.yaml:
# Example configuration.yaml entry
+binary_sensor:
+ platform: nx584
+Configuration variables:
+ +localhost, which will work if the server process is running on the same system as Home Assistant.5007.opening, motion, gas, smoke, moisture, safety.An extended configuration entry could look like this:
+ +```yaml
+binary_sensor: + platform: nx584 + host: 192.168.1.10 + port: 5007 + exclude_zones: + - 3 + - 5 + zone_types: + 1: opening + 2: opening + 4: motion + 6: moisture
+ + +The octoprint binary sensor platform let you monitor if your 3D printer is printing or if there was a printing error.
+You must have the OctoPrint component configured to use this sensor. +
+ +To set it up, add the following information to your configuration.yaml file:
binary_sensor:
+ - platform: octoprint
+ monitored_conditions:
+ - Printing
+ - Printing Error
+Configuration variables:
+ +The rest binary sensor platform is consuming a given endpoint which is exposed by a RESTful API of a device, an application, or a web service. The binary sensor has support for GET and POST requests.
The JSON messages can contain different values like 1, "1", TRUE, true, on, or open. If the value is nested then use a template.
{
+ "name": "Binary sensor",
+ "state": {
+ "open": "true",
+ "timestamp": "2016-06-20 15:42:52.926733"
+ }
+}
+To enable this sensor, add the following lines to your configuration.yaml file for a GET request:
# Example configuration.yaml entry
+binary_sensor:
+ - platform: rest
+ resource: http://IP_ADDRESS/ENDPOINT
+or for a POST request:
+ +# Example configuration.yaml entry
+binary_sensor:
+ - platform: rest
+ resource: http://IP_ADDRESS/ENDPOINT
+ method: POST
+Configuration variables:
+ +basic or digest.+Make sure that the URL exactly matches your endpoint or resource. +
+ +In this section you find some real life examples of how to use this sensor.
+ +Instead of using an aREST binary sensor, you could retrieve the value of a device supporting aREST directly with a REST binary sensor.
+ +binary_sensor:
+ - platform: rest
+ resource: http://192.168.0.5/digital/9
+ method: GET
+ name: Light
+ sensor_class: light
+ value_template: '{{ value_json.return_value }}'
+The REST sensor supports HTTP authentication and customized headers.
+ +binary_sensor:
+ - platform: rest
+ resource: http://IP_ADDRESS:5000/binary_sensor
+ username: ha1
+ password: test1
+ authentication: basic
+ headers:
+ User-Agent: Home Assistant
+ Content-Type: application/json
+The headers will contain all relevant details. This will also give you the ability to access endpoints that are protected by tokens.
+ +```bash +Content-Length: 1024 +Host: IP_ADDRESS1:5000 +Authorization: Basic aGExOnRlc3Qx +Accept-Encoding: identity +Content-Type: application/json +User-Agent: Home Assistant
+ + +The rpi_gpio binary sensor platform allows you to read sensor values of the GPIOs of your Raspberry Pi.
To use your Raspberry Pi’s GPIO in your installation, add the following to your configuration.yaml file:
# Example configuration.yaml entry
+binary_sensor:
+ - platform: rpi_gpio
+ ports:
+ 11: PIR Office
+ 12: PIR Bedroom
+Configuration variables:
+ +For more details about the GPIO layout, visit the Wikipedia article about the Raspberry Pi.
+ + + +To get your SleepIQ binary sensors working with Home Assistant, follow the instructions for the general SleepIQ component.
+ + +The TCP Binary Sensor is a type of TCP Sensor which is either “off” or “on”. In order to use this sensor type, in addition to the configuration for the TCP Sensor, you must supply a value_on value to represent what is returned when the device is turned on.
To enable this sensor, add the following lines to your configuration.yaml:
binary_sensor:
+# Example configuration.yaml entry
+ platform: tcp
+ name: TCP Binary Sensor
+ host: IP_ADDRESS
+ port: PORT
+ payload: "r State\n"
+ value_on: 1
+ timeout: 5
+Configuration options for the a TCP Sensor:
+ +The template platform supports sensors which breaks out the state and state_attributes from other entities.
To enable Template binary sensors in your installation, add the following to your configuration.yaml file:
# Example configuration.yaml entry
+binary_sensor:
+ - platform: template
+ sensors:
+ sun_up:
+ value_template: '{{ states.sun.sun.attributes.elevation > 0}}'
+ friendly_name: 'Sun is up'
+Configuration variables:
+ +In this section you find some real life examples of how to use this sensor.
+ +This example indicates true if a sensor is above a given threshold. Assuming a sensor of furnace that provides a current reading for the fan motor, we can determine if the furnace is running by checking that it is over some threshold:
sensor:
+ - platform: template
+ sensors:
+ furnace_on:
+ value_template: {{ states.sensor.furnace.state > 2.5 }}
+ friendly_name: 'Furnace Running
+ sensor_class: heat
+Some movement sensors and door/window sensors will appear as a switch. By using a template binary sensor, the switch can be displayed as a binary sensors. The original switch can then be hidden by customizing.
+ +binary_sensor:
+ - platform: template
+ sensors:
+ movement:
+ value_template: "{{ states.switch.movement.state == 'on' }}"
+ sensor_class: motion
+ door:
+ value_template: "{{ states.switch.door.state == 'on' }}"
+ sensor_class: opening
+This example combines multiple CO sensors into a single overall status. It also shows how to use entity_id
binary_sensor:
+ - platform: template
+ sensors:
+ co:
+ friendly_name: 'CO'
+ sensor_class: 'gas'
+ value_template: >-
+ {%- if is_state("sensor.bedroom_co_status", "Ok")
+ and is_state("sensor.kitchen_co_status", "Ok")
+ and is_state("sensor.wardrobe_co_status", "Ok") -%}
+ Off
+ {%- else -%}
+ On
+ {%- endif %}
+ entity_id:
+ - sensor.bedroom_co_status
+ - sensor.kitchen_co_status
+ - sensor.wardrobe_co_status
+The trend platform allows you to create sensors which show the trend of numeric state orstate_attributes from other entities. This sensor requires two updates of the underlying sensor to establish a trend. Thus it can take some time to show an accurate state. It can be useful as part of automations, where you want to base an action on a trend.
To enable Trend binary sensors in your installation, add the following to your configuration.yaml file:
# Example configuration.yaml entry
+binary_sensor:
+ - platform: trend
+ sensors:
+ solar_angle:
+ entity_id: sun.sun
+Configuration variables:
+ +true means decending rather than ascending)In this section you find some real life examples of how to use this sensor.
+ +This example indicates true if the temperature is rising:
binary_sensor:
+ - platform: trend
+ sensors:
+ temperature_up:
+ friendly_name: 'Temp increasing'
+ entity_id: sensor.skylight_temperature
+ sensor_class: heat
+And this one indicates true if the temperature is falling:
binary_sensor:
+ - platform: trend
+ sensors:
+ temperature_down:
+ friendly_name: 'Temp decreasing'
+ entity_id: sensor.skylight_temperature
+ sensor_class: cold
+ invert: Yes
+The vera platform allows you to get data from your Vera binary sensors from within Home Assistant.
They will be automatically discovered if the vera component is loaded.
+ + +A zigbee binary sensor in this context is a device connected to one of the digital input pins on a ZigBee module. The states reported by such a device are limited to on or off. By default, a binary sensor is considered on when the ZigBee device’s digital input pin is held ‘high’ and considered off when it is held low. This behaviour can be inverted by setting the on_state configuration variable to low.
To enable a digital input pin as binary sensor in your installation, add the following lines to your configuration.yaml:
# Example configuration.yaml entry
+binary_sensor:
+ - platform: zigbee
+ name: Hallway PIR Sensor
+ pin: 0
+Configuration variables:
+ +high (default) or low, depicting whether the binary sensor is considered on when the pin is high or low.To get your Z-Wave binary sensors working with Home Assistant, follow the instructions for the general Z-Wave component.
+ + +Binary sensors are gathering information about state of switches, contacts, pins, and alike. The return value of those sensors is usually digital (1/0). This means that those sensors knows only two states: 0/off/low/open/false and 1/on/high/closed/true.
+ +Knowing that there are only two states allows Home Assistant to represent the sensor better in the frontend.
+ +Most binary sensors support the sensor_class: which let you specify the type of your sensor. The following types are supported:
For analog sensors please check the component overview.
+ + +The bloomsky component allows you to access your BloomSky weather station’s sensors, binary sensors, and camera from Home Assistant.
Obtain your API key from your BloomSky dashboard. Click developers in the bottom left of the screen.
To integrate your BloomSky hub with Home Assistant, add the following section to your configuration.yaml file:
# Example configuration.yaml entry
+bloomsky:
+ api_key: YOUR_API_KEY
+Configuration variables:
+ +The browser component provides a service to open URLs in the default browser on the host machine.
To load this component, add the following lines to your configuration.yaml:
# Example configuration.yaml entry
+browser:
+browser/browse_url| Service data attribute | +Optional | +Description | +
|---|---|---|
url |
+ no | +The url to open | +
To use this service, choose Call Service from the Developer Tools. Choose the service browser/browse_url from the list of Available services: and enter the URL into the Service Data field and hit CALL SERVICE.
+ +{"url": "http://www.google.com"}
+This will open the given URL on the host machine.
+ + +The bloomsky camera component allows you to view the current photo created by the camera in the BloomSky weather station. This can work in concert with BloomSky sensors.
To enable this camera in your installation, set up the BloomSky component with your API key and add the following to your configuration.yaml file:
# Example configuration.yaml entry
+camera:
+ platform: bloomsky
+The ffmpeg platform allows you to use any video feed as a camera in Home Assistant via FFmpeg. This video source must support multiple simultaenous reads, because for every concurrent Home Assistant user, a connection will be made to the source every 10 seconds. Normally this should not be a problem.
To enable your FFmpeg feed in your installation, add the following to your configuration.yaml file:
# Example configuration.yaml entry
+camera:
+ - platform: ffmpeg
+ input: FFMPEG_SUPPORTED_INPUT
+Configuration variables:
+ +ffmpeg, e.g. image quality or video filter options.You can control the image quality with extra_arguments -q:v 2-32 or with lossless option -pred 1.
If you are running into trouble with this sensor, please refer to the Troubleshooting section.
+ + +The foscam platform allows you to watch the live stream of your Foscam IP camera in Home Assistant.
To enable your Foscam IP camera in your installation, add the following to your configuration.yaml file:
# Example configuration.yaml entry
+camera:
+ platform: foscam
+ ip: IP_ADDRESS
+ username: USERNAME
+ password: PASSWORD
+Configuration variables:
+ ++There seems to be some issues within Foscam with lengthy passwords and passwords containing certain symbols. Be sure to check your camera’s documentation. +
+ +Foscam Webcams which support CGI Commands can be controlled by Home Assistant (Source). For an example of how this can be done, see the Foscam IP Camera Pan, Tilt, Zoom Control Cookbook entry.
+ + +The generic camera platform allows you to integrate any IP camera or other url into Home Assistant. Templates can be used to generate the urls on the fly.
Home Assistant will serve the images via its server, making it possible to view your IP camera’s while outside of your network. The endpoint is /api/camera_proxy/camera.[name].
To enable this camera in your installation, add the following to your configuration.yaml file:
# Example configuration.yaml entry
+camera:
+ - platform: generic
+ still_image_url: http://194.218.96.92/jpg/image.jpg
+Configuration variables:
+ +basic (default) or digest auth for requests.
+
+ 
+ Example showing the Generic camera platform pointing at a dynamic Google Map image.
+
+
The local_file camera platform allows you to integrate any readable image file from disk into Home Assistant as a camera. If the image is updated on the file system the image displayed in Home Assistant will also be updated.
This can for example be used with various camera platforms that save a temporary images locally. It can also be used to display a graph that you render periodically and will then be displayed in Home Assistant.
+ +To enable this camera in your installation, add the following to your configuration.yaml file:
# Example configuration.yaml entry
+camera:
+ - platform: local_file
+ file_path: /tmp/image.jpg
+Configuration variables:
+ +
+The given file_path must be an existing file because the camera platform setup make a readable check on it.
+
The mjpeg camera platform allows you to integrate IP cameras which are capable to stream their video with MJPEG into Home Assistant.
Home Assistant will serve the images via its server, making it possible to view your IP camera’s while outside of your network. The endpoint is /api/camera_proxy/camera.[name]?time=[timestamp].
To enable this camera in your installation, add the following to your configuration.yaml file:
# Example configuration.yaml entry
+camera:
+ - platform: mjpeg
+ mjpeg_url: http://192.168.1.92/mjpeg
+Configuration variables:
+ +basic (default) or digest auth for requests.
+There is a known issue in urllib3 that you will get error messages in your logs like [StartBoundaryNotFoundDefect(), MultipartInvariantViolationDefect()], unparsed data: '' but the component still works fine. You can ignore the messages.
+
The netatmo camera platform is consuming the information provided by a Netatmo Welcome camera. This component allows you to view the current photo created by the Camera.
To enable the Netatmo camera, you have to set up netatmo, this will use discovery to add your camera.
+ +If you want to select a specific camera, set discovery to False for netatmo and add the following lines to your configuration.yaml:
# Example configuration.yaml entry
+camera:
+ platform: netatmo
+Configuration variables:
+ +If home and cameras are not provided, all cameras will be displayed. For more control over your cameras check the configuration sample below.
+ +# Example configuration.yaml entry
+camera:
+ platform: netatmo
+ home: home_name
+ cameras:
+ - camera_name1
+ - camera_name2
+The rpi_camera platform allows you to integrate the Raspberry Pi camera into Home Assistant. This component uses the application raspistill to store the image from camera.
To enable this camera in your installation, add the following to your configuration.yaml file:
# Example configuration.yaml entry
+camera:
+ - platform: rpi_camera
+Configuration variables:
+ +The given file_path must be an existing file because the camera platform setup make a writeable check on it.
+ + + +
+The synology platform allows you to watch the live streams of your Synology Surveillance Station based IP cameras in Home Assistant.
To enable your Surveillance Station cameras in your installation, add the following to your configuration.yaml file:
# Minimum configuration.yaml entry
+camera:
+ - platform: synology
+ url: SYNOLOGY_URL
+ username: USERNAME
+ password: PASSWORD
+Configuration variables:
+ +True.A full sample configuration for the synology platform is shown below:
# Example configuration.yaml entry
+camera:
+ - platform: synology
+ url: https://192.168.1.120:5001
+ username: USERNAME
+ password: PASSWORD
+ verify_ssl: False
+
+Most users will need to set valid_ssl to false unless they have installed a valid SSL certificate in place of the built in self-signed certificate.
+
The uvc component allows you to integrate UniFi Video Camera (UVC) into Home Assistant.
To enable a UVC camera in your installation, add the following to your configuration.yaml file:
# Example configuration.yaml entry
+camera:
+ - platform: uvc
+ nvr: IP_ADDRESS
+ key: API_KEY
+Configuration variables:
+ +The verisure camera platform allows you to control your Verisure cameras.
The requirement is that you have setup your Verisure hub.
+ + + +The camera component allows you to use IP cameras with Home Assistant. With a little additional work you could use USB cameras as well.
+ + + +To get your Ecobee thermostats working with Home Assistant, follow the instructions for the general Ecobee component.
+ + +The eq3btsmart climate platform allows you to integrate EQ3 Bluetooth Smart Thermostats.
The only functionality is to set the temperature, there doesn’t seem to be any way to query the temperature sensor or battery level (read more).
+ +Setup is a bit more cumbersome than for most other thermostats. It has to be paired first:
+ +bluetoothctl
+scan on
+<Wait for the thermostat to be found, which looks like this: [NEW] Device 00:11:22:33:44:55 CC-RT-BLE>
+scan off
+<Set the thermostat to pairing mode.>
+pair <MAC>
+trust <MAC>
+disconnect <MAC>
+exit
+Then check with gatttool if the connection works as expected:
+ +gatttool -b 00:11:22:33:44:55 -I
+[00:11:22:33:44:55][LE]> connect
+Attempting to connect to 00:11:22:33:44:55
+Connection successful
+[00:11:22:33:44:55][LE]> char-write-req 0x0411 03
+Characteristic value was written successfully
+Notification handle = 0x0421 value: 02 01 09 14 04 2d
+[00:11:22:33:44:55][LE]> disconnect
+[00:11:22:33:44:55][LE]> exit
+Important: For gatttool or homeassistant to work, the thermostat needs to be disconnected from bluetoothd, so I found it best to modify the hass-daemon startscript by adding:
+ +/usr/bin/bt-device -d CC-RT-BLE
+to the start function of /etc/init.d/hass-daemon.
+ +# Example configuration.yaml entry
+climate:
+ - platform: eq3btsmart
+ devices:
+ room1:
+ mac: '00:11:22:33:44:55'
+Configuration variables:
+ +The generic_thermostat climate platform is a thermostat implemented in Home Assistant. It uses a sensor and a switch connected to a heater under the hood. If the measured temperature is cooler then the target temperature, the heater will be turned on and turned off when required temperature is reached.
# Example configuration.yaml entry
+climate:
+ - platform: generic_thermostat
+ name: Study
+ heater: switch.study_heater
+ target_sensor: sensor.study_temperature
+Configuration variables:
+ +entity_id for heater switch, must be a toggle device.entity_id for a temperature sensor, target_sensor.state must be temperature.A full configuration example looks like the one below. min_cycle_duration must contains at least one of the following entries: days:, hours:, minutes:, seconds: or milliseconds:.
# Full example configuration.yaml entry
+climate:
+ - platform: generic_thermostat
+ name: Study
+ heater: switch.study_heater
+ target_sensor: sensor.study_temperature
+ min_temp: 15
+ max_temp: 21
+ target_temp: 17
+ min_cycle_duration:
+ seconds: 5
+The heatmiser climate platform let you control Heatmiser DT/DT-E/PRT/PRT-E thermostats from Heatmiser. The module itself is currently setup to work over a RS232 -> RS485 converter, therefore it connects over IP.
Further work would be required to get this setup to connect over Wifi, but the HeatmiserV3 python module being used is a full implementation of the V3 protocol. If you would like to contribute to making this work over wifi, please contact @andylockran on github.
+ +To set it up, add the following information to your configuration.yaml file:
climate:
+ platform: heatmiser
+ ipaddress: YOUR_IPADDRESS
+ port: YOUR_PORT
+ tstats:
+ - 1:
+ id: THERMOSTAT_ID
+ name: THERMOSTAT_NAME
+A single interface can handle up to 32 connected devices.
+ +Configuration variables:
+ +The honeywell climate platform let you control Honeywell Connected thermostats from Home Assistant.
To set it up, add the following information to your configuration.yaml file:
climate:
+ platform: honeywell
+ username: YOUR_USERNAME
+Configuration variables:
+ +The knx climate platform is used as in interface with KNX thermostats.
KNX thermostats use at least 2 group addresses: one for the current temperature and one for the target temperature (named set-point in KNX terms).
+ +To use your KNX thermostats in your installation, add the following to your configuration.yaml file:
# Example configuration.yaml entry
+climate:
+ - platform: knx
+ address : KNX_ADDRESS
+ temperature_address: 0/1/1
+ setpoint_address: 0/1/0
+With the current version of the module, no advanced KNX thermostat functionalities (e.g. HVAC mode) are supported.
+ + +Integrates MySensors HVAC into Home Assistant. See the main component for configuration instructions.
+ +The following actuator types are supported:
+ +| S_TYPE | +V_TYPE | +
|---|---|
| S_HVAC | +V_HVAC_FLOW_STATE*, V_HVAC_SETPOINT_HEAT, V_HVAC_SETPOINT_COOL, V_HVAC_SPEED | +
V_HVAC_FLOW_STATE is mapped to the state of the Climate component in HA as follows:
+ +| Home Assistant State | +MySensors State | +
|---|---|
| STATE_COOL | +CoolOn | +
| STATE_HEAT | +HeatOn | +
| STATE_AUTO | +Off | +
| STATE_OFF | +AutoChangeOver | +
Currently humidity, away_mode, aux_heat, swing_mode is not supported. This will be included in later versions as feasible.
+ +Set the target temperature using V_HVAC_SETPOINT_HEAT in Heat mode, and V_HVAC_SETPOINT_COOL in Cool Mode. In case of any Auto Change Over mode you can use V_HVAC_SETPOINT_HEAT as well as V_HVAC_SETPOINT_COOL to set the both the low bound and the high bound temperature of the device.
+ +You can use V_HVAC_SPEED to control the Speed setting of the Fan in the HVAC.
+ +For more information, visit the serial api of MySensors.
+ +/*
+* Documentation: http://www.mysensors.org
+* Support Forum: http://forum.mysensors.org
+*/
+
+#include <MySensor.h>
+/*
+* Include all the other Necessary code here.
+* The example code is limited to message exchange for mysensors
+* with the controller (ha).
+*/
+
+#define CHILD_ID_HVAC 0 // childId
+MyMessage msgHVACSetPointC(CHILD_ID_HVAC, V_HVAC_SETPOINT_COOL);
+MyMessage msgHVACSpeed(CHILD_ID_HVAC, V_HVAC_SPEED);
+MyMessage msgHVACFlowState(CHILD_ID_HVAC, V_HVAC_FLOW_STATE);
+
+/*
+* Include all the other Necessary code here.
+* The example code is limited to message exchange for mysensors
+* with the controller (ha).
+*/
+
+void setup()
+{
+ // Startup and initialize MySensors library.
+ // Set callback for incoming messages.
+ gw.begin(incomingMessage);
+
+ // Send the sketch version information to the gateway and Controller
+ gw.sendSketchInfo("HVAC", "0.1");
+
+ gw.present(CHILD_ID_HVAC, S_HVAC, "Thermostat");
+ gw.send(msgHVACFlowState.set("Off"));
+ gw.send(msgHVACSetPointC.set(target_temp));
+ gw.send(msgHVACSpeed.set("Max"));
+}
+
+void loop() {
+ // Process incoming messages (like config from server)
+ gw.process();
+}
+
+void incomingMessage(const MyMessage &message) {
+ String recvData = message.data;
+ recvData.trim();
+ switch (message.type) {
+ case V_HVAC_SPEED:
+ if(recvData.equalsIgnoreCase("auto")) fan_speed = 0;
+ else if(recvData.equalsIgnoreCase("min")) fan_speed = 1;
+ else if(recvData.equalsIgnoreCase("normal")) fan_speed = 2;
+ else if(recvData.equalsIgnoreCase("max")) fan_speed = 3;
+ processHVAC();
+ break;
+ case V_HVAC_SETPOINT_COOL:
+ target_temp = message.getFloat();
+ processHVAC();
+ break;
+ case V_HVAC_FLOW_STATE:
+ if(recvData.equalsIgnoreCase("coolon") && (!Present_Power_On )){
+ togglePower();
+ }
+ else if(recvData.equalsIgnoreCase("off") && Present_Power_On ){
+ togglePower();
+ }
+ break;
+ }
+}
+The nest climate platform let you control a thermostat from Nest.
+You must have the Nest component configured to use those thermostats. +
+ +To set it up, add the following information to your configuration.yaml file:
climate:
+ platform: nest
+
+
+
The netatmo thermostat platform is consuming the information provided by a Netatmo Smart Thermostat thermostat. This component allows you to view the current temperature and setpoint.
To enable the Netatmo thermostat, you first have to set up netatmo, this will use discovery to add your thermostat.
+ +If you want to select a specific thermostat, set discovery to False for netatmo and add the following lines to your configuration.yaml:
# Example configuration.yaml entry
+climate:
+ - platform: netatmo
+Configuration variables:
+ +If relay and thermostat are not provided, all thermostats will be displayed.
+ +# Example configuration.yaml entry
+climate:
+ platform: netatmo
+ relay: relay_name
+ thermostat:
+ - thermostat_name
+The proliphix climate platform let you control Proliphix thermostat from Home Assistant.
Currently supported and tested thermostats:
+ +To set it up, add the following information to your configuration.yaml file:
climate:
+ platform: proliphix
+ host: IP_ADDRESS
+ username: YOUR_USERNAME
+ password: YOUR_PASSWORD
+Configuration variables:
+ +The Proliphix NT Thermostat series are ethernet connected thermostats. They have a local HTTP interface that is based on get/set +of OID values. A complete collection of the API is available in this API documentation.
+ + + +The radiotherm climate platform let you control a thermostat from Radio Thermostat.
The underlaying library supports:
+ +To set it up, add the following information to your configuration.yaml file:
# Example configuration.yaml entry
+climate:
+ platform: radiotherm
+Configuration variables:
+ +True) or are temporary (False). Defaults to False.Temperature settings from Home Assistant will be sent to thermostat and then hold at that temperature. Set to False if you set a thermostat schedule on the thermostat itself and just want Home Assistant to send temporary temperature changes.
Multiple thermostats could be assigned by using host: if auto-detetion is not used.
climate:
+ platform: radiotherm
+ host:
+ - 192.168.99.137
+ - 192.168.99.202
+The vera climate platform allows you to control your Vera thermostats from within Home Assistant.
They will be automatically discovered if the vera component is loaded.
+ +For more configuration information see the Vera component documentation.
+ + +To get your Z-Wave thermostat or HVAC unit working with Home Assistant, follow the instructions for the general Z-Wave component.
+ +
+Thermostats with support for fan modes or different operating modes, will be handled like a HVAC device and will also be detected as one.
+
+If the thermostat support different operating modes, you will get one thermostat entity for each mode. These can be hidden with settings using the customize setting in the configuration.yaml file.
+
To enable the climate component for your Z-Wave network, add the following to your configuration.yaml file.
climate:
+ platform: zwave
+Once enabled, any Z-Wave climate devices will be available to Home Assistant. Multiple entities may be created. The following entities are created for a Remotec ZXT-120.
+ +The following examples will instruct a Remotec ZXT-120 to turn the attached device mode to Heating, and set the temperature at 24 degrees after 8pm. Add it to automation.yaml.
automation:
+ - alias: Turn on Heater at 8pm
+ trigger:
+ - platform: time
+ after: "20:00:00"
+ action:
+ - service: climate.set_operation_mode
+ entity_id: climate.remotec_zxt120_heating_1_id
+ data:
+ operation_mode: Heat
+ - service: climate.set_temperature
+ entity_id: climate.remotec_zxt120_heating_1_39
+ data:
+ temperature: 24
+Generally in Home Assistant you can use the homeassistant/turn_off service to turn devices off. For the Remotec ZXT-120, you must instead make a service call like the following.
automation:
+ - alias: Turn off Heater at 9pm
+ trigger:
+ - platform: time
+ after: "21:00:00"
+ action:
+ - service: climate.set_operation_mode
+ entity_id: climate.remotec_zxt120_heating_1_id
+ data:
+ operation_mode: 'Off'
+Note: In the example above, the word Off is encased in single quotes to be valid YAML.
A simple way to test if your Z-Wave climate device is working is to use 
Services from the Developer Tools. Choose the applicable Climate service from the list of Available services: and enter something like the sample below into the Service Data field and then press CALL SERVICE.
{
+ "entity_id": "climate.remotec_zxt120_heating_1_id",
+ "operation_mode": "Heat"
+}
+The climate component is built for the controlling and monitoring of HVAC (heating, ventilating, and air conditioning) and thermostat devices.
To enable this component, pick one of the platforms, and add it to your configuration.yaml:
# Example configuration.yaml entry
+climate:
+ platform: demo
+Available services: climate.set_aux_heat, climate.set_away_mode, climate.set_temperature, climate.set_humidity, climate.set_fan_mode, climate.set_operation_mode, climate.set_swing_mode
+Not all climate services may be available for your platform. Be sure to check the available services Home Assistant has enabled by checking Services.
+
climate.set_aux_heatTurn auxiliary heater on/off for climate device
+ +| Service data attribute | +Optional | +Description | +
|---|---|---|
entity_id |
+ yes | +String or list of strings that point at entity_id’s of climate devices to control. Else targets all. |
+
aux_heat |
+ no | +New value of auxiliary heater. | +
automation:
+ trigger:
+ platform: time
+ after: "07:15:00"
+ action:
+ - service: climate.set_aux_heat
+ data:
+ entity_id: climate.kitchen
+ aux_heat: true
+climate.set_away_modeTurn away mode on/off for climate device
+ +| Service data attribute | +Optional | +Description | +
|---|---|---|
entity_id |
+ yes | +String or list of strings that point at entity_id’s of climate devices to control. Else targets all. |
+
away_mode |
+ no | +New value of away mode. | +
automation:
+ trigger:
+ platform: time
+ after: "07:15:00"
+ action:
+ - service: climate.set_away_mode
+ data:
+ entity_id: climate.kitchen
+ away_mode: true
+climate.set_temperatureSet target temperature of climate device
+ +| Service data attribute | +Optional | +Description | +
|---|---|---|
entity_id |
+ yes | +String or list of strings that point at entity_id’s of climate devices to control. Else targets all. |
+
temperature |
+ no | +New target temperature for hvac | +
target_temp_high |
+ yes | +New target high temperature for hvac | +
target_temp_low |
+ yes | +New target low temperature for hvac | +
operation_mode |
+ yes | +Operation mode to set temperature to. This defaults to current_operation mode if not set, or set incorrectly. | +
automation:
+ trigger:
+ platform: time
+ after: "07:15:00"
+ action:
+ - service: climate.set_temperature
+ data:
+ entity_id: climate.kitchen
+ temperature: 24
+ operation_mode: Heat
+climate.set_humiditySet target humidity of climate device
+ +| Service data attribute | +Optional | +Description | +
|---|---|---|
entity_id |
+ yes | +String or list of strings that point at entity_id’s of climate devices to control. Else targets all. |
+
humidity |
+ no | +New target humidity for climate device | +
automation:
+ trigger:
+ platform: time
+ after: "07:15:00"
+ action:
+ - service: climate.set_humidity
+ data:
+ entity_id: climate.kitchen
+ humidity: 60
+climate.set_fan_modeSet fan operation for climate device
+ +| Service data attribute | +Optional | +Description | +
|---|---|---|
entity_id |
+ yes | +String or list of strings that point at entity_id’s of climate devices to control. Else targets all. |
+
fan_mode |
+ no | +New value of fan mode | +
automation:
+ trigger:
+ platform: time
+ after: "07:15:00"
+ action:
+ - service: climate.set_fan_mode
+ data:
+ entity_id: climate.kitchen
+ fan_mode: 'On Low'
+climate.set_operation_modeSet operation mode for climate device
+ +| Service data attribute | +Optional | +Description | +
|---|---|---|
entity_id |
+ yes | +String or list of strings that point at entity_id’s of climate devices to control. Else targets all. |
+
operation_mode |
+ no | +New value of operation mode | +
automation:
+ trigger:
+ platform: time
+ after: "07:15:00"
+ action:
+ - service: climate.set_operation_mode
+ data:
+ entity_id: climate.kitchen
+ operation_mode: Heat
+climate.set_swing_modeSet operation mode for climate device
+ +| Service data attribute | +Optional | +Description | +
|---|---|---|
entity_id |
+ yes | +String or list of strings that point at entity_id’s of climate devices to control. Else targets all. |
+
swing_mode |
+ no | +New value of swing mode | +
automation:
+ trigger:
+ platform: time
+ after: "07:15:00"
+ action:
+ - service: climate.set_swing_mode
+ data:
+ entity_id: climate.kitchen
+ swing_mode: 1
++This component is intended for developers. +
+ +The configurator component allows components to request information from the user. It is currently implemented as the minimum viable product:
+ +The Hue component in the demo and Plex are implemented using the configurator. See the source of the demo component for a simple example.
+ +See the source for more details on how to use the configurator component.
+ + +The conversation component can process sentences into commands for Home Assistant. It is currently limited to parsing commands in the format turn <Friendly Name> <on/off>.
To enable the conversion option in your installation, add the following to your configuration.yaml file:
# Example configuration.yaml entry
+conversation:
+When this component is active and you are using a supported browser voice commands will be activated in the frontend. Browse to the demo using Chrome or Chromium to see it in action.
+ +
+ 
+
+ Apple iPhones do not support this feature in any browser. +
+ + +A command_linecover platform that issues specific commands when it is moved up, down and stopped. It allows anyone to integrate any type of cover into Home Assistant that can be controlled from the command line.
To enable a command line cover in your installation, add the following to your configuration.yaml file:
# Example configuration.yaml entry
+cover:
+- platform: command_line
+ covers:
+ garage_door:
+ command_open: move_command up garage
+ command_close: move_command down garage
+ command_stop: move_command stop garage
+Configuration variables:
+ +0 the indicates the cover is fully closed, whereas a 100 indicates the cover is fully open.command_state will ignore the result code of the command but the template evaluating will indicate the position of the cover. For example, if your command_state returns a string “open”, using value_template as in the example config above will allow you to translate that into the valid state 100.In this section you find some real life examples of how to use this sensor.
+ +# Example configuration.yaml entry
+cover:
+- platform: command_line
+ covers:
+ garage_door:
+ command_open: move_command up garage
+ command_close: move_command down garage
+ command_stop: move_command stop garage
+ command_state: state_command garage
+ value_template: >
+ {% if value == 'open' %}
+ 100
+ {% elif value == 'closed' %}
+ 0
+ {% endif %}
+
+The garadget cover platform lets you control Garadget garage door futurizers through Home Assistant.
To enable Garadget Covers in your installation, add the following to your configuration.yaml file:
# Example configuration.yaml entry
+cover:
+ platform: garadget
+ covers:
+ 190028001947343412342341:
+ username: UseYourLogin@garadget.com
+ password: abc123
+ name: Left Garage Door
+ 4c003f001151353432134214:
+ access_token: df4cc785ff818f2b01396c44142342fccdef
+Configuration variables:
+ +If provided, the access_token will be used, otherwise the username and password will be used to automatically generate an access token at start time.
+ + +The isy994 platform allows you to get data from your ISY994 cover from within Home Assistant.
They will be automatically discovered if the isy994 component is loaded.
+ + +The mqtt cover platform enables the possibility to control an MQTT cover. The device state will be updated only after receiving the a new
+state from state_topic. If these messages are published with RETAIN flag, the MQTT device will receive an instant state update after subscription and will start with correct state. Otherwise, the initial state will be unknown.
There is a state attribute that stores the relative position of the device, where 0 means the device is closed and all other intermediate positions means the device is open.
When a state topic is not available, the cover will work in optimistic mode. In this mode, the cover will immediately change state after every command. Otherwise, the cover will wait for state confirmation from device (message from state_topic).
Optimistic mode can be forced, even if state_topic is available. Try to enable it, if experiencing incorrect cover operation.
To use your MQTT cover in your installation, add the following to your configuration.yaml file:
# Example configuration.yml entry
+cover:
+ - platform: mqtt
+ name: "MQTT Cover"
+ state_topic: "home-assistant/cover"
+ command_topic: "home-assistant/cover/set"
+Configuration variables:
+ +MQTT Cover.OPEN.CLOSE.STOP.open.closed.true if no state topic defined, else false.0. Will also be used when publishing messages.false.In this section you find some real life examples of how to use this sensor.
+ +The example below shows a full configuration for a cover.
+ +# Example configuration.yml entry
+cover:
+ - platform: mqtt
+ state_topic: "home-assistant/cover"
+ command_topic: "home-assistant/cover/set"
+ name: "MQTT Cover"
+ qos: 0
+ retain: true
+ payload_open: "OPEN"
+ payload_close: "CLOSE"
+ payload_stop: "STOP"
+ state_open: "OPEN"
+ state_closed: "STATE"
+ optimistic: false
+ value_template: '{{ value.x }}'
+For a check you can use the command line tools mosquitto_pub shipped with mosquitto to send MQTT messages. This allows you to operate your cover manually:
$ mosquitto_pub -h 127.0.0.1 -t home-assistant/cover/set -m "CLOSE"
+Integrates MySensors covers into Home Assistant. See the main component for configuration instructions.
+ +The following actuator types are supported:
+ +| S_TYPE | +V_TYPE | +
|---|---|
| S_COVER | +V_UP, V_DOWN, V_STOP, [V_DIMMER or V_LIGHT] | +
| S_TYPE | +V_TYPE | +
|---|---|
| S_COVER | +V_UP, V_DOWN, V_STOP, [V_PERCENTAGE or V_STATUS] | +
All V_TYPES above are required. Use V_PERCENTAGE (or V_DIMMER) if you know the exact position of the cover in percent, use V_STATUS (or V_LIGHT) if you don’t.
+ +For more information, visit the serial api of MySensors.
+ +/*
+ * Documentation: http://www.mysensors.org
+ * Support Forum: http://forum.mysensors.org
+ */
+
+// Enable debug prints to serial monitor
+#define MY_DEBUG
+#define MY_RADIO_NRF24
+
+#include <MySensors.h>
+#define SN "Cover"
+#define SV "1.1"
+
+// Actuators for moving the cover up and down respectively.
+#define COVER_UP_ACTUATOR_PIN 2
+#define COVER_DOWN_ACTUATOR_PIN 3
+// Sensors for finding out when the cover has reached its up/down position.
+// These could be simple buttons or linear hall sensors.
+#define COVER_UP_SENSOR_PIN 4
+#define COVER_DOWN_SENSOR_PIN 5
+
+#define CHILD_ID 0
+
+// Internal representation of the cover state.
+enum State {
+ IDLE,
+ UP, // Window covering. Up.
+ DOWN, // Window covering. Down.
+};
+
+static int state = IDLE;
+static int status = 0; // 0=cover is down, 1=cover is up
+static bool initial_state_sent = false;
+MyMessage upMessage(CHILD_ID, V_UP);
+MyMessage downMessage(CHILD_ID, V_DOWN);
+MyMessage stopMessage(CHILD_ID, V_STOP);
+MyMessage statusMessage(CHILD_ID, V_STATUS);
+
+void sendState() {
+ // Send current state and status to gateway.
+ send(upMessage.set(state == UP));
+ send(downMessage.set(state == DOWN));
+ send(stopMessage.set(state == IDLE));
+ send(statusMessage.set(status));
+}
+
+void setup() {
+ pinMode(COVER_UP_SENSOR_PIN, INPUT);
+ pinMode(COVER_DOWN_SENSOR_PIN, INPUT);
+}
+
+void presentation() {
+ sendSketchInfo(SN, SV);
+
+ present(CHILD_ID, S_COVER);
+}
+
+void loop() {
+ if (!initial_state_sent) {
+ sendState();
+ initial_state_sent = true;
+ }
+
+ if (state == IDLE) {
+ digitalWrite(COVER_UP_ACTUATOR_PIN, LOW);
+ digitalWrite(COVER_DOWN_ACTUATOR_PIN, LOW);
+ }
+
+ if (state == UP && digitalRead(COVER_UP_SENSOR_PIN) == HIGH) {
+ Serial.println("Cover is up.");
+ // Update status and state; send it to the gateway.
+ status = 1;
+ state = IDLE;
+ sendState();
+ // Actuators will be disabled in next loop() iteration.
+ }
+
+ if (state == DOWN && digitalRead(COVER_DOWN_SENSOR_PIN) == HIGH) {
+ Serial.println("Cover is down.");
+ // Update status and state; send it to the gateway.
+ status = 0;
+ state = IDLE;
+ sendState();
+ // Actuators will be disabled in next loop() iteration.
+ }
+}
+
+void receive(const MyMessage &message) {
+ if (message.type == V_UP) {
+ // Set state to covering up and send it back to the gateway.
+ state = UP;
+ sendState();
+ Serial.println("Moving cover up.");
+
+ // Activate actuator until the sensor returns HIGH in loop().
+ digitalWrite(COVER_UP_ACTUATOR_PIN, HIGH);
+ }
+
+ if (message.type == V_DOWN) {
+ // Set state to covering up and send it back to the gateway.
+ state = DOWN;
+ sendState();
+ Serial.println("Moving cover down.");
+ // Activate actuator until the sensor returns HIGH in loop().
+ digitalWrite(COVER_DOWN_ACTUATOR_PIN, HIGH);
+ }
+
+ if (message.type == V_STOP) {
+ // Set state to idle and send it back to the gateway.
+ state = IDLE;
+ sendState();
+ Serial.println("Stopping cover.");
+
+ // Actuators will be switched off in loop().
+ }
+}
+The rfxtrx platform supports Siemens/LightwaveRF and RFY roller shutters that communicate in the frequency range of 433.92 MHz.
First you have to set up your rfxtrx hub.
+ +The easiest way to find your roller shutters is to add this to your configuration.yaml:
cover:
+ platform: rfxtrx
+ automatic_add: True
+Launch your homeassistant and go the website (e.g http://localhost:8123). Push your remote and your device should be added.
+ +Once added it will show an ID (e.g 0b11000102ef9f210010f70) and you can verify that it works from the frontend. Then you should update your configuration to:
cover:
+ platform: rfxtrx
+ devices:
+ 0b11000102ef9f210010f70:
+ name: device_name
+The RFXtrx433e is required for RFY support, however it does not support receive for the RFY protocol - as such devices cannot be automatically added. Instead, configure the device in the rfxmngr tool. Make a note of the assigned ID and Unit Code and then add a device to the configuration with the following id 071a0000[id][unit_code]. Eg, if the id was 0a 00 01, and the unit code was 01 then the fully qualified id would be 071a00000a000101.
Example configuration:
+ +# Example configuration.yaml entry
+cover:
+ platform: rfxtrx
+ automatic_add: False
+ signal_repetitions: 2
+ devices:
+ 0b1100ce3213c7f210010f70: # Siemens/LightwaveRF
+ name: Bedroom Shutter
+ 070a00000a000101: # RFY
+ name: Bathroom Shutter
+Configuration variables:
+ +The rpi_gpio cover platform allows you to use a Raspberry Pi to control your cover such as Garage doors.
It uses two pins on the Raspberry Pi.
+ +state_pin will detect if the cover is closed, andrelay_pin will trigger the cover to open or close.Although you do not need Andrews Hilliday’s software controller when you run Home Assistant, he has written clear instructions on how to hook your garage door and sensors up to your Raspberry Pi, which can be found here.
+ +To enable Raspberry Pi Covers in your installation, add the following to your configuration.yaml file:
# Example configuration.yaml entry
+cover:
+ platform: rpi_gpio
+ covers:
+ - relay_pin: 10
+ state_pin: 11
+ - relay_pin: 12
+ state_pin: 13
+ name: 'Right door'
+Configuration variables:
+ +The SCSGate devices can control motorized covers connected to the BTicino MyHome system.
+ +To enable SCSGate covers in your installation, add the following to your configuration.yaml file:
# Example configuration.yaml entry
+cover:
+ platform: scsgate
+ devices:
+ living_room:
+ name: Living Room
+ scs_id: XXXXX
+Configuration variables:
+ ++Known limitation: It is not possible to know the current state of the cover. +
+ + + +The vera cover platform allows you to control your Vera covers from within Home Assistant.
They will be automatically discovered if the Vera component is loaded.
+ +For more configuration information see the Vera component documentation.
+ + +Wink cover/garage door functionality depends on the product you’re using. With GoControl/Linear Home Assistant can open, close, and view state. Chamberlain is currently limited to view only. Meaning Home Assistant will only show the current state of the door and control has been disabled (by Chamberlain). If you have a Chamberlain garage door, and would like to control it via Home Assistant, please contact Chamberlain and request that they re-enabled third-party control.
+ +The following quote is from Wink.
+ +++ +As part of our agreement with Chamberlain, third-party access to control Chamberlain garage doors has been restricted. Please contact Chamberlain directly to inquire about permissions.
+
The requirement is that you have setup your Wink hub.
+ + +Z-Wave garage doors, blinds, and roller shutters are supported as cover in Home Assistant.
+ +To get your Z-Wave covers working with Home Assistant, follow the instructions for the general Z-Wave component.
+ + +Home Assistant can give you an interface to control covers such as rollershutters, blinds, and garage doors.
+ +Available services: cover.open_cover, cover.close_cover, cover.stop_cover, cover.open_cover_tilt, cover.close_cover_tilt, cover.stop_cover_tilt
| Service data attribute | +Optional | +Description | +
|---|---|---|
entity_id |
+ yes | +String or list of strings that point at entity_id’s of covers. Else targets all. |
+
cover.set_cover_positionSet cover position of one or multiple covers.
+ +| Service data attribute | +Optional | +Description | +
|---|---|---|
entity_id |
+ yes | +String or list of strings that point at entity_id’s of covers. Else targets all. |
+
position |
+ no | +Integer between 0 and 100. | +
automation:
+ trigger:
+ platform: time
+ after: "07:15:00"
+ action:
+ - service: cover.set_cover_position
+ data:
+ entity_id: cover.demo
+ position: 50
+cover.set_cover_tilt_positionSet cover tilt position of one or multiple covers.
+ +| Service data attribute | +Optional | +Description | +
|---|---|---|
entity_id |
+ yes | +String or list of strings that point at entity_id’s of covers. Else targets all. |
+
position |
+ no | +Integer between 0 and 100. | +
automation:
+ trigger:
+ platform: time
+ after: "07:15:00"
+ action:
+ - service: cover.set_cover_tilt_position
+ data:
+ entity_id: cover.demo
+ position: 50
+The demo platform allows you to use components which are providing a demo of their implementation. The demo entities are dummies but show you how the acutal platform looks like. This way you can run own demonstration instance like the online Home Assistant demo or hass --demo-mode but combined with your own real/functional platforms.
Available demo platforms:
+ +alarm_control_panel)binary_sensor)camera)climate)cover)fan)light)lock)notify)sensor)switch)weather)To integrate a demo platform in Home Assistant, add the following section to your configuration.yaml file:
# Example configuration.yaml entry
+[component]:
+ - platform: demo
+Configuration variables:
+ +Home Assistant has a built-in component called device_sun_light_trigger to help you automate your lights. The component will:
This component requires the components sun, device_tracker and light to be enabled.
+ +To enable this component, add the following lines to your configuration.yaml file:
# Example configuration.yaml entry
+device_sun_light_trigger:
+Configuration variables:
+ +A full configuration example could look like this:
+ +# Example configuration.yaml entry
+device_sun_light_trigger:
+ light_group: group.living_room
+ light_profile: relax
+ device_group: group.my_devices
+ disable_turn_off: 1
+This platform allows you to detect presence by looking at connected devices to an Actiontec device.
+ +Supported devices (tested):
+ ++This device tracker needs telnet to be enabled on the router. +
+ +To use this device tracker in your installation, add the following to your configuration.yaml file:
# Example configuration.yaml entry
+device_tracker:
+ - platform: actiontec
+ host: YOUR_ROUTER_IP
+ username: YOUR_ADMIN_USERNAME
+ password: YOUR_ADMIN_PASSWORD
+Configuration variables:
+ +192.168.1.1.admin.See the device tracker component page for instructions how to configure the people to be tracked.
+ + + +This platform allows you to detect presence by looking at connected devices to an Aruba Instant device.
+ +Supported devices (tested):
+ ++This device tracker needs telnet to be enabled on the router. +
+ +To use this device tracker in your installation, add the following to your configuration.yaml file:
# Example configuration.yaml entry
+device_tracker:
+ - platform: aruba
+ host: YOUR_ROUTER_IP
+ username: YOUR_ADMIN_USERNAME
+ password: YOUR_ADMIN_PASSWORD
+Configuration variables:
+ +192.168.1.1.admin.See the device tracker component page for instructions how to configure the people to be tracked.
+ + + +The asuswrt platform offers presence detection by looking at connected devices to a ASUSWRT based router.
+This platform is NOT available for Microsoft Windows installations. +
+ +To use an ASUSWRT router in your installation, add the following to your configuration.yaml file:
# Example configuration.yaml entry
+device_tracker:
+ - platform: asuswrt
+ host: YOUR_ROUTER_IP
+ username: YOUR_ADMIN_USERNAME
+Configuration variables:
+ +192.168.1.1.admin.ssh or telnet) to use. Defaults to ssh.router or ap). Defaults to router.
+You need to enable telnet on your router if you choose to use protocol: telnet.
+
See the device tracker component page for instructions how to configure the people to be tracked.
+ + +The automatic platform offers presence detection by retrieving your car’s information from the Automatic cloud service.
To use an Automatic ODB reader in your installation, add the following to your configuration.yaml file:
# Example configuration.yaml entry
+device_tracker:
+ - platform: automatic
+ client_id: 1234567
+ secret: 0987654321
+ username: your@email.com
+ password: your_password
+ devices:
+ - 2007 Honda Element
+ - 2004 Subaru Impreza
+Configuration variables:
+ +See the device tracker component page for instructions how to configure the cars to be tracked.
+ + +The bbox platform offers presence detection by looking at connected devices to a Bbox based router from Bouygues, which is one of the main Internet provider in France.
+Bbox is a generic name for different hardware routers. The platform has only been tested on a Sagem F@st 5330b because it’s the only model the developer owns. +
+ +To use an Bbox router in your installation, add the following to your configuration.yaml file:
# Example configuration.yaml entry
+device_tracker:
+ - platform: bbox
++For now and due to third party limitation, the Bbox must be on the same local network as the Home Assistant installation. And with the default IP configuration (IP of the router must be 192.168.1.254). +
+ +See the device tracker component page for instructions how to configure the people to be tracked.
+ + + +This tracker discovers new devices on boot and in regular intervals and tracks bluetooth low-energy devices periodically based on interval_seconds value. It is not required to pair the devices with each other!
+Devices discovered are stored with ‘BLE_’ as the prefix for device mac addresses in known_devices.yaml.
+Requires PyBluez. If you are on Raspbian, make sure you first install bluetooth and libbluetooth-dev by running sudo apt install bluetooth libbluetooth-dev
+
+Requires gattlib, which is not compatible with windows. This tracker won’t work on windows! +
+ +To use the Bluetooth tracker in your installation, add the following to your configuration.yaml file:
# Example configuration.yaml entry
+device_tracker:
+ - platform: bluetooth_le_tracker
+As some BT LE devices change their MAC address regularly, a new device is only discovered when it has been seen 5 times. +Some BTLE devices (e.g. fitness trackers) are only visible to the devices that they are paired with. In this case, the BTLE tracker won’t see this device.
+ +BTLE tracking requires root privileges.
+ +For running Home Assistant as non root user we can give python3 the missing capabilities to access the bluetooth stack. Quite like setting the setuid bit (see Stack Exchange for more information).
+ +$ sudo apt-get install libcap2-bin
+$ sudo setcap 'cap_net_raw,cap_net_admin+eip' `readlink -f \`which python3\``
+A restart of Home Assistant is required.
+ +For additional configuration variables check the Device tracker page.
+ + +This tracker discovers new devices on boot and tracks bluetooth devices periodically based on interval_seconds value. It is not required to pair the devices with each other! Devices discovered are stored with ‘bt_’ as the prefix for device mac addresses in known_devices.yaml.
To use the Bluetooth tracker in your installation, add the following to your configuration.yaml file:
# Example configuration.yaml entry
+device_tracker:
+ - platform: bluetooth_tracker
+In some cases it can be that your device is not discovered. In that case let your phone scan for BT devices while you restart Home Assistant. Just hit Scan on your phone all the time until Home Assisstant is fully restarted and the device should appear in known_devices.yaml.
For additional configuration variables check the Device tracker page.
+ + +This platform offers presence detection by looking at connected devices to a BT Home Hub 5 based router.
+ +To use a BT Home Hub 5 router in your installation, add the following to your configuration.yaml file:
# Example configuration.yaml entry
+device_tracker:
+ - platform: bt_home_hub_5
+ host: 192.168.1.254
+Configuration variables:
+ +See the device tracker component page for instructions how to configure the people to be tracked.
+ + +This platform offers presence detection by looking at connected devices to a DD-WRT based router.
+ +To use a DD-WRT router in your installation, add the following to your configuration.yaml file:
# Example configuration.yaml entry
+device_tracker:
+ - platform: ddwrt
+ host: ROUTER_IP_ADDRESS
+ username: YOUR_ADMIN_USERNAME
+ password: YOUR_ADMIN_PASSWORD
+Configuration variables:
+ +192.168.1.1.admin.See the device tracker component page for instructions how to configure the people to be tracked.
+ + +The fritz platform offers presence detection by looking at connected devices to a AVM Fritz!Box based router.
+It might be necessary to install additional packages: $ sudo apt-get install libxslt-dev libxml2-dev python3-lxml
+
To use an Fritz!Box router in your installation, add the following to your configuration.yaml file:
# Example configuration.yaml entry
+device_tracker:
+ - platform: fritz
+Configuration variables:
+ +192.168.1.1. It is optional since every fritzbox is also reachable by using the IP address 169.254.1.1.admin.+It seems that it is not necessary to use it in current generation Fritz!Box routers because the necessary data can be retrieved anonymously. +
+ +See the device tracker component page for instructions how to configure the people to be tracked.
+ + + +The icloud platform allows you to detect presence using the iCloud service. iCloud allows users to track their location on iOS devices.
It does require that your device is registered with “Find My iPhone”.
+ +To integrate iCloud in Home Assistant, add the following section to your configuration.yaml file:
# Example configuration.yaml entry
+device_tracker:
+ - platform: icloud
+ username: USERNAME
+ password: PASSWORD
+ account_name: accountname
+Configuration variables:
+ +@ in the email address).+This may cause battery drainage as it wakes up your device to get the current location. +
+ ++You may receive an email from Apple stating that someone has logged into your account. +
+ +To disable the drainage of the battery, a dynamic interval is being used for each individual device instead of a fixed interval for all devices linked to one account. The dynamic interval is based on the current zone of a device, the distance towards home and the battery level of the device.
+ +2 Steps Authentication is enabled for iCloud. The component will ask which device you want to use as Trusted Device and then you can enter the code that has been sent to that device. The duration of this authentication is determined by Apple, but is now at 2 months, so you will only need to verify your account each two months, even after restarting Home Assistant. +2 Factor Authentication is the improved version of 2 Steps Authentication, this is still not supported by the pyicloud library. Therefore it’s not possible to use it with the device_tracker yet.
+ +4 services are available for this component:
+account_name and device_name are optional.account_name and device_name are optional.account_name and device_name are optional. If interval is used in the service_data, the iDevice will be updated with that new interval. That interval will be fixed until the iDevice changes zone or if this service is called again. If interval isn’t used in the service_data, the interval for that iDevice will revert back to it’s default dynamic interval based on it’s current zone, it’s distance towards home and it’s battery level.account_name is optional.This platform allows you to detect presence using Locative. Locative is an open source app for iOS and Android that allows users to set up a GET or POST request when a geofence is entered or exited. This can be configured with Home Assistant to update your location.
To integrate Locative in Home Assistant, add the following section to your configuration.yaml file:
# Example configuration.yaml entry
+device_tracker:
+ - platform: locative
+Install on your smartphone:
+ + + +To configure Locative, you must set up the app to send a GET request to your Home Assistant server at http://<ha_server>/api/locative. Make sure to include the API password if you have configured a password in Home Assistant (add ?api_password=<password> to the end of the URL). When you enter or exit a geofence, Locative will send a GET request to that URL, updating Home Assistant. You are not able to specify a device name in Locative. Instead, you will need to look in your known_devices.yaml file for a new device that Locative will have created on it’s first GET. If you had been or are using Owntracks as well, you will need to update the device name used in the Owntracks setup with the name that Locative generated.
+ 
+
When you enter a geofence, your location name in Home Assistant will be set to the name of the geofence in Locative. When you exit a geofence, your location name in Home Assistant will be set to “not home”.
+ +To use Locative in combination with another device tracker, such as nmap or Netgear, fill in the mac field to the Locative entry in known_devices.yaml with the MAC address of the device you want to track. The state of the device will be determined by the source that reported last.
This is one of the two ways we support OpenWRT. If you encounter problems, try ubus.
+ +This is a presence detection scanner for OpenWRT using luci.
+ +Before this scanner can be used you have to install the luci RPC package on OpenWRT:
+ +# opkg install luci-mod-rpc
+To use this device tracker in your installation, add the following to your configuration.yaml file:
# Example configuration.yaml entry
+device_tracker:
+ - platform: luci
+ host: ROUTER_IP_ADDRESS
+ username: YOUR_ADMIN_USERNAME
+ password: YOUR_ADMIN_PASSWORD
+Configuration variables:
+ +192.168.1.1.admin.See the device tracker component page for instructions how to configure the people to be tracked.
+ ++Some installations have a small bug. The timeout for luci RPC calls is not set and this makes the call fail. +
+ + + +The mqtt device tracker platform allows you to detect presence by monitoring an MQTT topic for new locations. To use this platform, you specify a unique topic for each device.
To use this device tracker in your installation, add the following to your configuration.yaml file:
# Example configuration.yaml entry
+device_tracker:
+ - platform: mqtt
+ devices:
+ paulus_oneplus: /location/paulus
+ annetherese_n4: /location/annetherese
+Configuration variables:
+ +Example JSON you can publish to the topic (e.g. via mqtt.publish service):
+ +{
+ "topic": "/location/paulus",
+ "payload": "home"
+}
+This platform allows you to detect presence by looking at connected devices to a Netgear device.
+ +To use this device tracker in your installation, add the following to your configuration.yaml file:
# Example configuration.yaml entry
+device_tracker:
+ - platform: netgear
+ host: YOUR_ROUTER_IP
+ username: YOUR_ADMIN_USERNAME
+ password: YOUR_ADMIN_PASSWORD
+Configuration variables:
+ +192.168.1.1.admin.See the device tracker component page for instructions how to configure the people to be tracked.
+ + +As an alternative to the router-based device tracking, it is possible to directly scan the network for devices by using Nmap. The IP addresses to scan can be specified in any format that Nmap understands, including the network-prefix notation (192.168.1.1/24) and the range notation (192.168.1.1-255).
If you’re on Debian or Ubuntu, you might have to install the packages for arp and nmap. Do so by running $ sudo apt-get install net-tools nmap. On a Fedora host run $ sudo dnf -y install nmap.
Host detection is done via Nmap’s “fast scan” (-F) of the most frequently used 100 ports, with a host timeout of 5 seconds.
To use this device tracker in your installation, add the following to your configuration.yaml file:
# Example configuration.yaml entry
+device_tracker:
+ - platform: nmap_tracker
+ hosts: 192.168.1.1/24
+Configuration variables:
+ +A full example for the nmap tracker could look like the following sample:
# Example configuration.yaml entry for nmap
+# One whole subnet, and skipping two specific IPs.
+device_tracker:
+ - platform: nmap_tracker
+ hosts: 192.168.1.1/24
+ home_interval: 10
+ exclude:
+ - 192.168.1.12
+ - 192.168.1.13
+# Example configuration.yaml for nmap
+# One subnet, and two specific IPs in another subnet.
+device_tracker:
+ - platform: nmap_tracker
+ hosts:
+ - 192.168.1.1/24
+ - 10.0.0.2
+ - 10.0.0.15
+See the device tracker component page for instructions how to configure the people to be tracked.
+ + +This platform allows you to detect presence using Owntracks. OwnTracks allows users to track their location on Android and iOS phones and publish it to an MQTT broker. This platform will connect to the broker and monitor for new locations.
+ +This component requires the MQTT component to be set up and works very well together with the zone component.
+ +To integrate Owntracks in Home Assistant, add the following section to your configuration.yaml file:
# Example configuration.yaml entry
+device_tracker:
+ - platform: owntracks
+Configuration variables:
+ +True, the Owntracks users who are in waypoint_whitelist can export waypoints from the device and Home Assistant will import them as zone definitions. Defaults to True.A full sample configuration for the owntracks plaftfrom is shown below:
# Example configuration.yaml entry
+device_tracker:
+ - platform: owntracks
+ max_gps_accuracy: 200
+ waypoints: True
+ waypoint_whitelist:
+ - jon
+ - ram
+Owntracks can also be used with other device trackers, such as Nmap or Netgear. To do this, fill in the mac field to the Owntracks entry in known_devices.yaml with the MAC address of the device you want to track. This way the state of the device will be determined by the source that reported last. The naming convention for known device list is <username>_<device-id> and could be set in app configuration. More details about this config can found in device tracker.
Owntracks can track regions, and send region entry and exit information to Home Assistant (HA). You set up a region in the Owntracks app which you should name the same as your HA Zone, and then make sure to turn on the share option for the region in the owntracks app. Please see the owntracks documentation.
Home Assistant will use the enter and leave messages to set your zone location. Your location will be set to the center of zone when you enter. Location updates from OwnTracks will be ignored while you are inside a zone.
+ +When you exit a zone, Home Assistant will start using location updates to track you again. To make sure that Home Assistant correctly exits a zone (which it calculates based on your GPS co-ordinates), you may want to set your Zone radius in HA to be slightly smaller that the Owntracks region radius.
+ +When run in the usual significant changes mode (which is kind to your phone battery), Owntracks sometimes doesn’t update your location as quickly as you’d like when you arrive at a zone. This can be annoying if you want to trigger an automation when you get home. You can improve the situation using iBeacons.
+ +iBeacons are simple bluetooth devices that send out an “I’m here” message. They are supported by IOS and some Android devices. Owntracks explain more here.
+ +When you enter an iBeacon region, Owntracks will send a region enter message to HA as described above. So if you want to have an event triggered when you arrive home, you can put an iBeacon outside your front door. If you set up an OwnTracks iBeacon region called home then getting close to the beacon will trigger an update to HA that will set your zone to be home.
When you exit an iBeacon region HA will switch back to using GPS to determine your location. Depending on the size of your zone, and the accuracy of your GPS location this may change your HA zone.
+ +Sometimes Owntracks will lose connection with an iBeacon for a few seconds. If you name your beacon starting with - Owntracks will wait longer before deciding it has exited the beacon zone. HA will ignore the - when it matches the Owntracks region with Zones. So if you call your Owntracks region -home then HA will recognise it as home, but you will have a more stable iBeacon connection.
iBeacons don’t need to be stationary. You could put one on your key ring, or in your car.
+ +When your phone sees a mobile iBeacon that it knows about, it will tell HA the location of that iBeacon. If your phone moves while you are connected to the iBeacon, HA will update the location of the iBeacon. But when your phone loses the connection, HA will stop updating the iBeacon location.
+ +To use mobile iBeacons with HA, you just set up a region that doesn’t match your Zone names. If HA sees an entry event for a iBeacon region that doesn’t match a Zone name (say keys) - it will start tracking it, calling the device device_tracker.beacon_keys).
This allows you to write zone automations for devices that can’t track themselves (for example alert me if I leave the house and my keys are still at home). Another example would be open the gates if my car arrives home.
+ +You can use iBeacons of both types together, so if you have a Zone drive with an iBeacon region called -drive and you arrive home with a mobile iBeacon called -car, then device_tracker.beacon_car will be set to a state of drive.
By default, any Owntracks user connected to Home Assistant can export their waypoint definitions (from the Export - Export to Endpoint menu item) which will then be translated to zone definitions in Home Assistant. The zones will be named <user>-<device> - <waypoint name>. This functionality can be controlled in 2 ways:
waypoints can be set to False which will disable importing waypoints for all users.waypoint_whitelist can contain a list of users who are allowed to import waypoints.A lot WiFi access points and WiFi routers support the Simple Network Management Protocol (SNMP). This is a standardized method for monitoring/manageing network connected devices. SNMP uses a tree-like hierarchy where each node is an object. Many of these objects contain (live) lists of insances and metrics, like network interfaces, disks, and wifi registrations.
+ ++This device tracker needs SNMP to be enabled on the router. +
+ +OID examples:
+ +1.3.6.1.4.1.14988.1.1.1.2.1.1 (confirmed, unknown RouterOS version/model)1.3.6.1.2.1.4.22.1.2 (confirmed, RouterOS 6.x on RB2011)1.3.6.1.4.1.14823.2.3.3.1.2.4.1.2 (untested)1.3.6.1.2.1.17.7.1.2.2.1.1 (confirmed on firmware 2.32e)1.3.6.1.2.1.4.22.1.2 (tested on Chaos Calmer 15.05 firmware, need to install snmpd package)1.3.6.1.2.1.4.22.1.2 (tested on 2.2.4-RELEASE, need to enable SNMP service)1.3.6.1.2.1.3.1.1.2.19.1 (Archer VR2600v, need to enable SNMP service)To use the SNMP version 1 platform in your installation, add the following to your configuration.yaml file:
# Example configuration.yaml entry for SNMP version 1
+device_tracker:
+ - platform: snmp
+ host: 192.168.1.1
+ community: public
+ baseoid: 1.3.6.1.4.1.14988.1.1.1.2.1.1
+If you want to use encryption, you must enable SNMP version 3 by adding authkey and privkey variables and enabling SNMP version 3 on your router. Currently only SHA1 is supported for authentication and AES for encryption. Example of SNMPv3 configuration:
# Example configuration.yaml entry for SNMP version 3
+device_tracker:
+ - platform: snmp
+ host: 192.168.1.1
+ community: username
+ authkey: authpass
+ privkey: privpass
+ baseoid: 1.3.6.1.4.1.14988.1.1.1.2.1.1
+Configuration variables:
+ +public with read-only permission (which is sufficient).See the device tracker component page for instructions how to configure the people to be tracked.
+ + +Thomson produced networking equipment (under the brand name SpeedTouch) till 2010 and was then renamed to Technicolor.
+ +This platform allows you to detect presence by looking at connected devices to a Thomson device.
+ +To use this device tracker in your installation, add the following to your configuration.yaml file:
# Example configuration.yaml entry
+device_tracker:
+ - platform: thomson
+ host: YOUR_ROUTER_IP
+ username: YOUR_ADMIN_USERNAME
+ password: YOUR_ADMIN_PASSWORD
+Configuration variables:
+ +See the device tracker component page for instructions how to configure the people to be tracked.
+ + +The tomato platform requires an extra config variable called http_id. The value can be obtained by logging in to the Tomato admin interface and search for http_id in the page source code.
Because of a limitation in Tomato’s API, this platform will only track wireless devices. If tracking wired devices like a Philips Hue Hub is necessary, it is possible to use another platform like NMAP.
+ +To use this device tracker in your installation, add the following to your configuration.yaml file:
# Example configuration.yaml entry
+device_tracker:
+ - platform: tomato
+ host: YOUR_ROUTER_IP_ADDRESS
+ username: YOUR_ADMIN_USERNAME
+ password: YOUR_ADMIN_PASSWORD
+ http_id: YOUR_HTTP_ID
+Configuration variables:
+ +http_id in the page source code.See the device tracker component page for instructions how to configure the people to be tracked.
+ +A description of the API s available in this Tomato API blog post.
+ + + +The tplink platform allows you to detect presence by looking at connected devices to a TP-Link device. This includes the ArcherC9 line.
+TP-Link devices typically only allow one login at a time to the admin console. This component will count torwards your one allowed login. Depending on how aggressively you configure device_tracker you may not be able to access the admin console of your TP-Link device without first stopping Home Assistant (and waiting a few minutes for the session to timeout) before you’ll be able to login. +
+ +# Example configuration.yaml entry
+device_tracker:
+ - platform: tplink
+ host: YOUR_ROUTER_IP
+ username: YOUR_ADMIN_USERNAME
+ password: YOUR_ADMIN_PASSWORD
+Configuration variables:
+ +For Archer C9 models running firmware version 150811 or later please use the encrypted password you can retrieve like this:
+ +document.getElementById("login-password").value;.See the device tracker component page for instructions how to configure the people to be tracked.
+ + +This is one of the two ways we support OpenWRT. If you encounter problems, try luci.
+ +This is a presence detection scanner for OpenWRT using ubus.
+ +Before this scanner can be used you have to install the ubus RPC package on OpenWRT:
+ +opkg install rpcd-mod-file
+And create a read-only user to be used by setting up the ACL file /usr/share/rpcd/acl.d/user.json.
{
+ "user": {
+ "description": "Read only user access role",
+ "read": {
+ "ubus": {
+ "*": [ "*" ]
+ },
+ "uci": [ "*" ]
+ },
+ "write": {}
+ }
+}
+Restart the services.
+ +# /etc/init.d/rpcd restart && /etc/init.d/uhttpd restart
+Check if the file namespaces is registered with the RPC server.
# ubus list | grep file
+file
+After this is done, add the following to your configuration.yaml file:
# Example configuration.yaml entry
+device_tracker:
+ - platform: ubus
+ host: ROUTER_IP_ADDRESS
+ username: YOUR_ADMIN_USERNAME
+ password: YOUR_ADMIN_PASSWORD
+Configuration variables:
+ +See the device tracker component page for instructions how to configure the people to be tracked.
+ + +This platform allows you to detect presence by looking at devices connected to a Ubiquiti Unifi controller.
+ +To use this device tracker in your installation, add the following to your configuration.yaml file:
# Example configuration.yaml entry
+device_tracker:
+ - platform: unifi
+ username: YOUR_ADMIN_USERNAME
+ password: YOUR_ADMIN_PASSWORD
+Configuration variables:
+ +localhost.8443.admin.site_id for device tracking. Defaults to default. Found in the URL of the controller (i.e. https://CONTROLLER:PORT/manage/site/SITE_ID/dashboard)See the device tracker component page for instructions how to configure the people to be tracked.
+ + +The volvooncall platform offers presence detection by retrieving your car’s information from the Volvo On Call cloud service.
To use Volvo On Call in your installation, add the following to your configuration.yaml file:
# Example configuration.yaml entry
+device_tracker:
+ - platform: volvooncall
+ username: username
+ password: password
+Configuration variables:
+ +See the device tracker component page for instructions how to configure the cars to be tracked.
+ + +Home Assistant can get information from your wireless router or third party services like iCloud or OwnTracks to track which devices are connected and considered “in home”. Please check the sidebar for a list of brands of supported wireless routers and services.
+ +There are also trackers available which use different technologies like MQTT or Nmap to scan the network for devices.
+ +An event (device_tracker_new_device) will be fired when a device is discovered for the first time.
device_tracker platformTo get started add the following lines to your configuration.yaml (example for Netgear):
# Example configuration.yaml entry for Netgear device
+device_tracker:
+ - platform: netgear
+ host: 192.168.1.1
+ username: admin
+ password: YOUR_PASSWORD
+The following optional parameters can be used with any platform. However device tracker will only look for global settings under the configuration of the first configured platform:
+ +| Parameter | +Default | +Description | +
|---|---|---|
track_new_devices |
+ True | +If new discovered devices are tracked by default | +
interval_seconds |
+ 12 | +Seconds between each scan for new devices | +
consider_home |
+ 180 | +Seconds to wait till marking someone as not home after not being seen. This parameter is most useful for households with Apple iOS devices that go into sleep mode while still at home to conserve battery life. iPhones will occasionally drop off the network and then re-appear. consider_home helps prevent false alarms in presence detection when using IP scanners such as Nmap. consider_home accepts various time representations, (E.g. the following all represents 3 minutes: 180, 0:03, 0:03:00) |
+
The extended example from above would look like the following sample:
+ +# Example configuration.yaml entry for Netgear device
+device_tracker:
+ - platform: netgear
+ host: 192.168.1.1
+ username: admin
+ interval_seconds: 10
+ consider_home: 180
+ track_new_devices: yes
+Multiple device trackers can be used in parallel, such as Owntracks and Nmap. The state of the device will be determined by the source that reported last.
+ +known_devices.yamlOnce device_tracker is enabled, a file will be created in your config dir named known_devices.yaml. Edit this file to adjust which devices to be tracked.
Here’s an example configuration for a single device:
+ +devicename:
+ name: Friendly Name
+ mac: EA:AA:55:E7:C6:94
+ icon: mdi:face-profile
+ picture: https://home-assistant.io/images/favicon-192x192.png
+ gravatar: test@example.com
+ track: yes
+ hide_if_away: no
+| Parameter | +Default | +Description | +
|---|---|---|
name |
+ Host name or “Unnamed Device” | +The friendly name of the device | +
mac |
+ None | +The MAC address of the device. Add this if you are using a network device tracker like Nmap or SNMP | +
icon |
+ None | +A name of an MDI Icon. | +
picture |
+ None | +A picture that you can use to easily identify the person or device. You can also save the image file in a folder “www” in the same location (can be obtained from developer tools) where you have your configuration.yaml file and just use picture: /local/favicon-192x192.png. |
+
gravatar |
+ None | +An email address for the device’s owner. If provided, it will override picture |
+
track |
+ False | +If yes/on/true then the device will be tracked. Otherwise its location and state will not update |
+
hide_if_away |
+ False | +If yes/on/true then the device will be hidden if it is not at home |
+
consider_home |
+ [uses platform setting] | +Allows you to override the global consider_home setting from the platform configuration on a per device level |
+
The digital_ocean component allows you to access the information about your Digital Ocean droplets from Home Assistant.
Obtain your API key from your Digital Ocean dashboard.
+ +To integrate your Digital Ocean droplets with Home Assistant, add the following section to your configuration.yaml file:
# Example configuration.yaml entry
+digital_ocean:
+ access_token: YOUR_API_KEY
+Configuration variables:
+ +The Home Assistant discovery protocol is a lightweight feature that introduces support for Home Assistant servers to be discoverable. This will allow Home Assistant instances running with MicroPython to get started without any required configuration (Example from the MicroPython Home Assistant documentation):
+ +from homeassistant.discovery import get_instance()
+
+hass = get_instance()
+
+for state in hass.states():
+ print(state)
+To enable discovery in your installation, add the following to your configuration.yaml file:
# Example configuration.yml entry
+discoverable:
+ expose_password: yes
+Configuration variables:
+ +get_instance('my password')).Home Assistant can discover and automatically configure zeroconf/mDNS and uPnP devices on your network. Currently the discovery component can detect:
It will be able to add Google Chromecasts and Belkin WeMo switches automatically, for Philips Hue it will require some configuration from the user.
+ +To load this component, add the following lines to your configuration.yaml:
# Example configuration.yaml entry
+discovery:
+
+Home Assistant must be on the same network as the devices for uPnP discovery to work.
+If running Home Assistant in a Docker container use switch --net=host to put it on the host’s network.
+
If you are developing a new platform, please read how to make your platform discoverable.
+ ++There is currently a known issue with running this platform on a 64-bit version of Python and Windows. +
+ ++If you are on Windows and you’re using Python 3.5, download the Netifaces dependency here. +
+ +
+If you see Not initializing discovery because could not install dependency netdisco==0.6.1 in the logs, you will need to install the python3-dev or python3-devel package on your system manually (eg. sudo apt-get install python3-dev or sudo dnf -y install python3-devel). On the next restart of home-assistant, discovery should work. If you still get an error, check if you have a compiler (gcc) available on your system.
+
The downloader component provides a service to download files. It will raise an error and not continue to set itself up when the download directory does not exist. The directory needs to be writable for the user that is running Home Assistant.
To enable it, add the following lines to your configuration.yaml file:
# Example configuration.yaml entry
+downloader:
+ download_dir: downloads
+Configuration variables:
+ +.homeassistant/downloads).Go the the “Developer Tools”, then to “Call Service”, and choose downloader/download_file from the list of available services. Fill the “Service Data” field as shown in the example below and hit “CALL SERVICE”.
{"url":"http://domain.tld/path/to/file"}
+This will download the file from the given URL.
+ +| Service data attribute | +Optional | +Description | +
|---|---|---|
url |
+ no | +The url of the file to download. | +
The dweet component makes it possible to transfer details collected with Home Assistant to Dweet.io and visualize them with freeboard.io. Keep in mind that your information will be public!
+ 
+
+ The publishing interval is limited to 1 second. This means that it’s possible to missing fast changes. +
+ +To use the deweet component in your installation, add the following to your configuration.yaml file:
# Example configuration.yaml entry
+dweet:
+ name: HAExport
+ whitelist:
+ - input_slider.brightness
+ - input_boolean.notify_home
+ - sensor.weather_temperature
+ - sensor.cpu
+Configuration variables:
+ +The ecobee component lets you control a thermostats and view sensor data from ecobee thermostats.
You will need to obtain an API key from ecobee’s developer site to use this component. To get the key, first you need to register your thermostat which should be done as part of the ecobee installation. Once you have done that perform the following steps.
+ +Now login to the regular consumer portal, and in the hamburger menu there will be a new option Developer. Now we can create the Application to hook up to Home Assistant.
+ +Now under the Name and Summary Section you will have an API key. Copy this key and use it in you configuration section below. Click the X to close the Developer section.
+ +The first time you run Home Assistant with this component it will give you a PIN code that you need to authorize in the ecobee consumer portal. You can do this by clicking Add Application in the My Apps section in the sidebar.
+ +The PIN can be found from the Home Assistant portal on the Ecobee card or from the configurator.ecobee entity in states in the portal.
+ +default_view that don’t show the card. To get around this you can temporarily comment out the default_view section or add the configurator.ecobee component to your default_view and restart Home Assistant.Once you enter the PIN on the ecobee site, wait approximately 5 minutes and then click on the I have authorized the app link at the bottom of the ecobee popup window. If everything worked correctly, you should now be able to restart Home Assistant again to see the full ecobee card with all of the sensors populated or see the list of sensors in the developer tools. Now you can re-enable your default_view (if you had to disable it) and add the ecobee sensors to a group and/or view.
To set it up, add the following information to your configuration.yaml file:
# Example configuration.yaml entry
+ecobee:
+ api_key: asdfghjklqwertyuiopzxcvbnm
+Configuration variables:
+ +.homeassistant configuration path.False.
+ 
+ 
+
The emoncms_history component makes it possible to transfer details collected with Home Assistant to Emoncms.org or your local running Emoncms instance. It will send the data to a specific input node on Emoncms with the entity IDs as a key. Afterwards you can create feeds and dashboards in Emoncms with the collected data.
To use the emoncms_history component in your installation, add the following to your configuration.yaml file:
# Example configuration.yaml entry
+emoncms_history:
+ api_key: put your emoncms WRITE api key here
+ url: https://emoncms.org
+ inputnode: 19
+ whitelist:
+ - sensor.owm_temperature
+ - sensor.owm_wind_speed
+Configuration variables:
+ +The emulated_hue component provides a virtual Philips Hue bridge, written entirely in software, that allows services that work with the Hue API to interact with Home Assistant
+entities. The driving use case behind this functionality is to allow Home Assistant to work with an Amazon Echo with no set up cost outside of configuration changes.
+ It is recommended to assign a static IP address to the computer running Home Assistant. This is because the Amazon Echo discovers devices by IP addresss, and if the IP changes, the Echo won’t be able to control it. This is easiest done from your router, see your router’s manual for details. +
+ +To enable the emulated Hue bridge, add the following to your configuration.yaml file:
# Example configuration.yaml entry
+emulated_hue:
+Configuration variables:
+ +off_maps_to_on_domains (Optional): The domains that maps an “off” command to an “on” command.
+ +For example, if script is included in the list, and you ask Alexa to “turn off the water plants script,” the command will be handled as if you asked her to turn on the script.
If not specified, this defaults to the following list:
+ +scriptsceneexpose_by_default (Optional): Whether or not entities should be exposed via the bridge by default instead of explicitly (see the ‘emulated_hue’ customization below). If not specified, this defaults to true. Warning: If you have a lot of devices (more than 49 total across all exposed domains), you should be careful with this opton. Exposing more devices than Alexa supports can result in it not seeing any of them. If you are having trouble getting any devices to show up, try disabling this, and explicitly exposing just a few devices at a time to see if that fixes it.
+expose_by_default is set to true. If not specified, this defaults to the following list:
+ switchlightgroupinput_booleanmedia_playerA full configuration sample looks like the one below.
+ +# Example configuration.yaml entry
+emulated_hue:
+ host_ip: 192.168.1.186
+ listen_port: 8300
+ off_maps_to_on_domains:
+ - script
+ - scene
+ expose_by_default: true
+ exposed_domains:
+ - light
+With additional customization you will be able to specify the behaviour of the existing entities.
+ +# Example customization
+homeassistant:
+ customize:
+ light.bedroom_light:
+ # Don't allow light.bedroom_light to be controlled by the emulated Hue bridge
+ emulated_hue: false
+ light.office_light:
+ # Address light.office_light as "back office light"
+ emulated_hue_name: "back office light"
+The following are attributes that can be applied in the customize section:
expose_by_default option.You can verify that the emulated_hue component has been loaded and is responding by pointing a local browser to the following URL:
+http://<HA IP Address>:8300/description.xml - This URL should return a descriptor file in the form of an XML file.
+http://<HA IP Address>:8300/api/pi/lights - This will return a list of devices, lights, scenes, groups, etc.. that emulated_hue is exposing to Alexa.
Much of this code is based on work done by Bruce Locke on his ha-local-echo project, originally released under the MIT License. The license is located here.
+ + +The EnOcean standard is supported by many different vendors. There are switches and sensors of many different kinds, and typically they employ energy harvesting to get power such that no batteries are unnecessary.
+ +The enocean component adds support for some of these devices. You will need a controller like the USB300 in order for it to work.
There is currently support for the following device types within Home Assistant:
+ +However, only a few devices have been confirmed to work. These are:
+ +Other devices will most likely need some changes in the Home Assistant code in order to work. Support for teaching of devices is also missing at this time.
+ +To integrate an EnOcean controller with Home Assistant, add the following section to your configuration.yaml file:
# Example configuration.yaml entry
+enocean:
+ device: /dev/ttyUSB0
+Configuration variables:
+ +The envisalink component will allow Home Assistant users who own either a DSC or Honeywell alarm panel to leverage their alarm system and it’s sensors to provide Home Assistant with rich information about their homes. Connectivity between Home Assistant and the alarm panel is accomplished through a device produced by Eyez On, known as the Envisalink. The Envisalink evl3 and evl4 boards provide a TCP/IP interface to the alarm panel, where it emulates an alarm keypad. This board also exposes a raw TCP/IP based API, upon which this component is built. Currently, the Envisalink version 4 is the latest model. This component supports both the evl3 and the evl4.
Please visit the eyezon website for further information about the evl3 and evl4 boards.
+ +There is currently support for the following device types within Home Assistant:
+ +This is a fully event-based component. Any event sent by the Envisalink device will be immediately reflected within Home Assistant.
+ +As of 0.29, the alarm_trigger service is supported. It is possible to fire off an envisalink-based alarm directly from Home Assistant. For example, a newer zwave/zigbee sensor can now be integrated into a legacy alarm system using a Home Assistant automation.
+ +An envisalink section must be present in the configuration.yaml file and contain the following options as required:
# Example configuration.yaml entry
+envisalink:
+ host: <envisalink IP address>
+ panel_type: HONEYWELL or DSC
+ user_name: YOUR_USERNAME
+ password: YOUR_PASSWORD
+ code: '1234'
+ port: 4025
+ evl_version: 3
+ keepalive_interval: 60
+ zonedump_interval: 30
+ panic_type: Police
+ zones:
+ 11:
+ name: 'Back Door'
+ type: 'opening'
+ 21:
+ name: 'First Floor Motion'
+ type: 'motion'
+ partitions:
+ 1:
+ name: 'Home Alarm'
+Configuration variables:
+ +HONEYWELL or DSC, depending upon which alarm system you have.4025360 seconds.30The isy994 platform allows you to get data from your ISY994 fan from within Home Assistant.
They will be automatically discovered if the isy994 component is loaded.
+ + +The mqtt fan platform let you control your MQTT enabled fans.
In an ideal scenario, the MQTT device will have a state_topic to publish state changes. If these messages are published with RETAIN flag, the MQTT fan will receive an instant state update after subscription and will start with correct state. Otherwise, the initial state of the fan will be false.
When a state_topic is not available, the fan will work in optimistic mode. In this mode, the fan will immediately change state after every command. Otherwise, the fan will wait for state confirmation from the device (message from state_topic).
Optimistic mode can be forced even if a state_topic is available. Try to enable it if you are experiencing incorrect fan operation.
To enable MQTT fans in your installation, add the following to your configuration.yaml file:
# Example configuration.yml entry
+fan:
+ - platform: mqtt
+ command_topic: "bedroom_fan/on/set"
+Configuration variables:
+ +true if no state topic defined, else false.off, low, med, and high.
+Make sure that your topic is an exact match. some-topic/ and some-topic are different topics.
+
In this section you find some real life examples of how to use this fan.
+ +The example below shows a full configuration for a MQTT fan.
+ +# Example configuration.yml entry
+fan:
+ - platform: mqtt
+ name: "Bedroom Fan"
+ state_topic: "bedroom_fan/on/state"
+ command_topic: "bedroom_fan/on/set"
+ oscillation_state_topic: "bedroom_fan/oscillation/state"
+ oscillation_command_topic: "bedroom_fan/oscillation/set"
+ speed_state_topic: "bedroom_fan/speed/state"
+ speed_command_topic: "bedroom_fan/speed/set"
+ qos: 0
+ payload_on: "true"
+ payload_off: "false"
+ payload_oscillation_on: "true"
+ payload_oscillation_off: "false"
+ payload_low_speed: "low"
+ payload_medium_speed: "medium"
+ payload_high_speed: "high"
+ speeds:
+ - low
+ - medium
+ - high
+The nest fan platform let you control a fan from Nest.
+You must have the Nest component configured to use those thermostats. +
+ +To set it up, add the following information to your configuration.yaml file:
fan:
+ platform: nest
+The fan component is built for the controlling of fan devices. It can be called the little brother of the climate component.
To enable this component, pick one of the platforms, and add it to your configuration.yaml:
# Example configuration.yaml entry
+climate:
+ platform: fan
+Add an RSS/Atom feed reader that polls feeds every hour and sends new entries into the event bus.
+ +To use RSS feeds in your installation, add the following to your configuration.yaml file:
# Example configuration.yaml entry
+feedreader:
+ urls:
+ - https://home-assistant.io/atom.xml
+ - https://github.com/blog.atom
+Configuration variables:
+ +Feedreader events can be used out of the box to trigger automation actions, e.g.:
+ +automation:
+ - alias: Trigger action when new element(s) in RSS feed
+ trigger:
+ platform: event
+ event_type: feedreader
+ action:
+ service: script.turn_on
+ entity_id: script.my_action
+For more advanced use cases, a custom component registering to the feedreader event type could be used instead:
EVENT_FEEDREADER = "feedreader"
+hass.bus.listen(EVENT_FEEDREADER, event_listener)
+To get started developing custom components, please refer to the developers documentation
+ + +The FFmpeg component allows other Home Assistant components to process video and audio streams. This component supports all FFmpeg versions since 3.0.0; if you have a older version, please update.
+ +
+You need the ffmpeg binary in your system path. On Debian 8 or Raspbian (Jessie) you can install it from debian-backports. If you want hardware acceleration support on a Raspberry Pi, you will need to build from source by yourself. Windows binaries are avilable on the FFmpeg website.
+
To set it up, add the following information to your configuration.yaml file:
ffmpeg:
+Configuration variables:
+ +ffmpeg binary.input is usable by ffmpeg.To get the binary on Raspbian Debian Jessie Lite on a RPi you need to perform the following:
+$ sudo apt-get install libav-tools
+This will get a forked version of ffmpeg called avconv, once this is installed you need to use the following in the configuration:
+ +ffmpeg:
+ ffmpeg_bin: /usr/bin/avconv
+In most cases, ffmpeg automatically detects all needed options to read a video or audio stream or file. But it is possible in rare cases that you will need to set options to help ffmpeg out.
First check that your stream is playable by ffmpeg outside of Home Assistant with (use option -an or -vn to disable video or audio stream):
$ ffmpeg -i INPUT -an -f null -
+Now you should be able to see what is going wrong. The following list contains some common problems and solutions:
+ +[rtsp @ ...] UDP timeout, retrying with TCP: You need to set an RTSP transport in the configuration with: input: -rtsp_transport tcp -i INPUT[rtsp @ ...] Could not find codec parameters for stream 0 (Video: ..., none): unspecified size: FFmpeg needs more data or time for autodetection (the default is 5 seconds). You can set the analyzeduration and/or probesize options to experiment with giving FFmpeg more leeway. If you find the needed value, you can set it with: input: -analyzeduration xy -probesize xy -i INPUT. More information about this can be found here.The foursquare component accepts pushes from the Foursquare Real-Time API and a service to check users in on Swarm.
# Example configuration.yaml entry
+foursquare:
+ access_token: "<foursquare access token>"
+ push_secret: "<foursquare push secret>"
+Configuration variables:
+ +The component accepts pushes from Foursquare at /api/foursquare. The route does not require authentication.
Foursquare checkin events can be used out of the box to trigger automation actions, e.g.:
+ +automation:
+ - alias: Trigger action when you check into a venue.
+ trigger:
+ platform: event
+ event_type: foursquare.push
+ action:
+ service: script.turn_on
+ entity_id: script.my_action
+To check a user in, use the foursquare/checkin service.
Parameters:
+ +The graphite component records all events and state changes and feeds the data to a graphite instance.
To enable this component, add the following lines to your configuration.yaml:
# Example configuration.yaml entry
+graphite:
+Configuration variables:
+ +localhostha.Groups allow the user to combine multiple entities into one. A group can be promoted to a view by setting the view option to yes. This will make the group available as a new tab in the frontend.
Check the Set State 
page from the Developer Tools and browse the Current entities: listing for all available entities.
By default, every group appears in the HOME tab. If you name a group default_view it will REPLACE the contents of the HOME tab so you can customize it as you wish.
# Example configuration.yaml entry
+group:
+ default_view:
+ view: yes
+ entities:
+ - group.awesome_people
+ - group.climate
+ kitchen:
+ name: Kitchen
+ entities:
+ - switch.kitchen_pin_3
+ upstairs:
+ name: Kids
+ icon: mdi:account-multiple
+ view: yes
+ entities:
+ - input_boolean.notify_home
+ - camera.demo_camera
+ - device_tracker.demo_paulus
+ - group.garden
+Configuration variables:
+ +
+
+Example of groups shown as views in the frontend.
+
If all entities in a group are switches or lights then Home Assistant adds a switch at the top of the card that turns them all on/off at once.
+ +You can create views (tabs) that contain other groups.
+Notice in the example below that in order to refer to the group “Living Room”, you use group.living_room (lowercase and spaces replaced with underscores).
# Example configuration.yaml entry that shows two groups, referred to in a view group (tab)
+ Living Room:
+ entities:
+ - light.light_family_1
+ - binary_sensor.motion_living
+
+ Bedroom: light.light_bedroom, switch.sleeping
+
+ Rooms:
+ view: yes
+ name: Rooms
+ entities:
+ - group.living_room
+ - group.bedroom
+The CEC component provides services that allow selecting the active device, powering on all devices, and setting all devices to standby. Devices are defined in the configuration file by associating HDMI port number and a device name. Connected devices that provide further HDMI ports, such as Soundbars and AVRs are also supported. Devices are listed from the perspective of the CEC-enabled Home Assistant device. Any connected device can be listed, regardless of whether it supports CEC. Ideally the HDMI port number on your device will map correctly the CEC physical address. If it does not, use cec-client (part of the libcec package) to listen to traffic on the CEC bus and discover the correct numbers.
The computer running Home Assistant must support CEC, and of course be connected via HDMI to a device also supporting CEC. You can purchase a USB CEC adapter to add support if necessary. Note that all Raspberry Pi models support CEC natively.
+ +libcec must be installed for this component to work. Follow the installation instructions for your environment, provided at the link. libcec installs Python 3 bindings by default as a system Python module. If you are running Home Assistant in a Python virtual environment, make sure it can access the system module, by either symlinking it or using the --system-site-packages flag.
Create a symlink to the cec installation.
$ ln -s /usr/local/lib/python3.4/dist-packages/cec /path/to/your/venv/lib/python3.4/site-packages
+For the default virtual environment of a Raspberry Pi AIO the command would be as follows.
+ +$ ln -s /usr/local/lib/python3.4/dist-packages/cec /srv/hass/hass_venv/lib/python3.4/site-packages
+If after symlinking and adding hdmi_cec: to your configuration you are getting the following error in your logs,
+* failed to open vchiq instance you will also need to add the user account Home Asssistant runs under, to the video group. To add the Home Assisitant’s user account to the video group, run the following command. $ usermod -a -G video <hass_user_account>
+
ssh pi@your_raspberry_pi_ipecho scan | cec-client -s -d 1opening a connection to the CEC adapter...
+requesting CEC bus information ...
+CEC bus information
+===================
+device #4: Playback 1
+address: 3.0.0.0
+active source: no
+vendor: Sony
+osd string: BD
+CEC version: 1.4
+power status: on
+language: ???
+Note the address: line above this will be used to configure HA, this address is represented below as 3: BlueRay player
+ +In the following example, a Pi Zero running Home Assistant is on a TV’s HDMI port 1. HDMI port 2 is attached to a AV receiver. Three devices are attached to the AV receiver on HDMI ports 1 through 3.
+ +hdmi_cec:
+ devices:
+ 1: Pi Zero
+ 2:
+ 1: Fire TV Stick
+ 2: Chromecast
+ 3: Another Device
+ 3: BlueRay player
+Call the hdmi_cec/select_device service with the name of the device to select, for example:
{
+ "device": "Chromecast"
+}
+So an Automation action using the example above would look something like this.
+ +action:
+ service: hdmi_cec.select_device
+ data:
+ device: Chromecast
+Call the hdmi_cec/power_on service (no arguments) to power on any devices that support this function.
Call the hdmi_cec/standby service (no arguments) to place in standby any devices that support this function.
The history component will track everything that is going on within Home Assistant and allows the user to browse through it.
To enable the history option in your installation, add the following to your configuration.yaml file:
# Basic configuration.yaml entry
+history:
+
+
+
+
+
+Events are saved in a local database. Google Graphs is used to draw the graph. Drawing is happening 100% in your browser. No data is transferred to anyone at any time. +
+ +Configuration variables:
+ +Without any include or exclude configuration the history displays graphs for every entity (well that’s not exactly true - for instance hidden entities or scenes are never shown) on a given date. If you are only interested in some of the entities you several options:
Define domains and entities to exclude (aka. blacklist). This is convenient when you are basically happy with the information displayed, but just want to remove some entities or domains. Usually these are entities/domains which do not change (like weblink) or rarely change (updater or automation).
# Example configuration.yaml entry with exclude
+history:
+ exclude:
+ domains:
+ - automation
+ - weblink
+ - updater
+ entities:
+ - sensor.last_boot
+ - sensor.date
+Define domains and entities to display by using the include configuration (aka. whitelist). If you have a lot of entities in your system and your exclude lists possibly get very large, it might be better just to define the entities or domains to display.
# Example configuration.yaml entry with include
+history:
+ include:
+ domains:
+ - sensor
+ - switch
+ - media_player
+Use the include list to define the domains/entities to display, and exclude some of them with in the exclude list. This makes sense if you for instance include the sensor domain, but want to exclude some specific sensors. Instead of adding every sensor entity to the include entities list just include the sensor domain and exclude the sensor entities you are not interested in.
# Example configuration.yaml entry with include and exclude
+history:
+ include:
+ domains:
+ - sensor
+ - switch
+ - media_player
+ exclude:
+ entities:
+ - sensor.last_boot
+ - sensor.date
+The history is stored in a SQLite database home-assistant_v2.db within your configuration directory.
time_changed that happened while recorder component was running.new_state values of state_changed events.entity_id: the entity_id of the entitystate: the state of the entityattributes: JSON of the state attributeslast_changed: timestamp last time the state has changed. A state_changed event can happen when just attributes change.last_updated: timestamp anything has changed (state, attributes)created: timestamp this entry was inserted into the databaseWhen the history component queries the states table it only selects states where the state has changed: WHERE last_changed=last_updated
SQLite databases do not support native dates. That’s why all the dates are saved in seconds since the UNIX epoch. Convert them manually using this site or in Python:
+ +from datetime import datetime
+datetime.fromtimestamp(1422830502)
+The history information are also available through the RESTful API.
+ + +The Homematic component provides bi-directional communication of Homematic platforms with their real world counterparts. This implementation does in no way modify your existing setup. Instead it queries your setup for its devices and subscribes to them to send and receive events.
+ +Device support is currently available for most of:
+ +If you want to see if a specific device you have is supported, head over to the pyhomematic repository and browse through the sourcecode. A dictionary with the device identifiers (e.g. HM-Sec-SC-2) can be found within the relevant modules near the bottom.
+ +We automatically detect all devices we currently support and try to generate useful names. If you enable name-resolving, we try to fetch names from Metadata (Homegear), via JSON-RPC or the XML-API you may have installed on your CCU. Since this may fail this is disabled by default. +You can manually override the created entities be using Home Assistants Customizing feature. With it you are able to hide entities you don’t need to see within the UI.
+ +To set up the component, add the following information to your configuration.yaml file:
homematic:
+ local_ip: 127.0.0.1
+Configuration variables:
+ +False if not specified.To further explain the resolvenames option:
+We use three approaches to fetch the names of devices. Each assumes you have properly named your devices in your existing Homematic setup. As a general advice: Use ASCII for your devices names. Home Assistant won’t include non-ASCII characters in entity-names.
Resolving names can take some time. So when you start Home Assistant you won’t see you devices at first. For a setup with 20+ devices it can take up to a minute until all devices show up in the UI.
+ +Devices with buttons
+ +Devices with buttons (e.g. HM-Sen-MDIR-WM55, remote controls) may not be fully visible in the UI. This is intended, as buttons don’t serve any value here and all they do is trigger events. +As an example: +The HM-Sen-MDIR-WM55 motion detector will be displayed as 2 entities. A motion sensor and a brightness sensor. On top of that we have 2 sets (one set per button) of 4 events: PRESS_SHORT, PRESS_LONG, PRESS_CONT, PRESS_LONG_RELEASE. Be aware, that there are devices which don’t provide all of these events. But in general: if you can press it, it at least has PRESS_SHORT. +Here’s an example of how to use these events for automations:
+ +automation:
+ trigger:
+ platform: event
+ event_type: homematic.keypress
+ event_data:
+ name: Kitchen Switch
+ channel: 1
+ param: PRESS_SHORT
+ action:
+ service: switch.turn_on
+ entity_id: switch.Kitchen_Ambience
+
+The channel parameter is equal to the channel of the button you are configuring the automation for. You can view the available channels in the UI you use to pair your devices. +The name depends on if you chose to resolve names or not. If not, it will be the device ID (e.g. LEQ1234657). If you chose to resolve names (and that is successful), it will be the name you have set in your CCU or in the metadata (e.g. “Kitchen Switch”).
+ +Other events
+ +homematic.keypress: See above.
+ +homematic.impulse: For impulse sensors with event_data ‘name’ and ‘channel’.
+ +Service
+ +homematic/virtualkey: Simulate a keypress on CCU/Homegear with device or virtual keys.
+ +...
+
+action:
+ service: homematic.virtualkey
+ data:
+ address: BidCoS-RF
+ channel: 1
+ param: PRESS_LONG
+homematic/set_value: Set the value of a system variable.
+ +...
+
+action:
+ service: homematic.set_value
+ data:
+ entity_id: homematic.varname_bool
+ value: true
+The http component serves all files and data required for the Home Assistant frontend. You only need to add this to your configuration file if you want to change any of the default settings.
+It’s HIGHLY recommended that you set the api_password, especially if you are planning to expose your installation to the internet.
+
# Example configuration.yaml entry
+http:
+ api_password: YOUR_PASSWORD
+Configuration variables:
+ +Access-Control-Allow-Origin header to the Origin header if it is found in the list, and the Access-Control-Allow-Headers header to Origin, Accept, X-Requested-With, Content-type, X-HA-access. You must provide the exact Origin, i.e. https://home-assistant.io will allow requests from https://home-assistant.io but not http://home-assistant.io.The sample below shows a configuration entry with possible values:
+ +# Example configuration.yaml entry
+http:
+ api_password: YOUR_PASSWORD
+ server_port: 12345
+ ssl_certificate: /etc/letsencrypt/live/hass.example.com/fullchain.pem
+ ssl_key: /etc/letsencrypt/live/hass.example.com/privkey.pem
+ cors_allowed_origins:
+ - https://google.com
+ - https://home-assistant.io
+ trusted_networks:
+ - 127.0.0.1
+ - ::1
+ - 192.168.0.0/24
+ - 2001:DB8:ABCD::/48
+The Set up encryption using Let’s Encrypt blog post gives you details about the encryption of your traffic using free certificates from Let’s Encrypt.
+ +On top of the http component is a REST API and a Python API available. There is also support for Server-sent events available.
The http platforms are not real platforms within the meaning of the terminology used around Home Assistant. Home Assistant’s REST API sends and receives messages over HTTP.
To use those kind of sensors or binary sensors in your installation no configuration in Home Assistant is needed. All configuration is done on the devices themselves. This means that you must be able to edit the target URL or endpoint and the payload. The entity will be created after the first message has arrived.
+ +All requests need to be sent to the endpoint of the device and must be POST.
+ +If you want to use Home Assistant to host or serve static files then create a directory called www under the .homeassistant configuration path. The static files in .homeassistant/www/ can be accessed by the following URL http://your.domain:8123/local/.
Manything is a smart app that turns your iPhone, iPod, or iPad into a wifi camera for monitoring your home, your pets, anything! Comes with live streaming, motion activated alerts, cloud video recording, and more.
+ +To get manything support, HA will use IFTTT’s Maker Channel and the ManyThing Channel. Use the IFTTT Setup instructions to activate the IFTTT Platform.
+ +After setting up IFTTT, Maker Channel and ManyThing Channel, you can use the following examples to configure Home Assistant.
+ +# Example configuration.yaml entry
+automation:
+- alias: 'ManyThing Recording ON'
+ # This calls an IFTTT recipe to turn on recording of the ManyThing Camera
+ # if we leave the house during the day.
+ trigger:
+ - platform: state
+ entity_id: group.all_devices
+ state: 'not_home'
+
+ condition:
+ - platform: state
+ entity_id: sun.sun
+ state: 'above_horizon'
+
+ action:
+ service: ifttt.trigger
+ data: {"event":"manything_on"}
+
+- alias: 'ManyThing Recording OFF'
+ # This calls an IFTTT recipe to turn off recording of the ManyThing Camera
+ # when we are home unless it's nighttime.
+ trigger:
+ - platform: state
+ entity_id: group.all_devices
+ state: 'home'
+ - platform: state
+ entity_id: sun.sun
+ state: 'above_horizon'
+
+ condition: use_trigger_values
+
+ action:
+ service: ifttt.trigger
+ data: {"event":"manything_off"}
+
+
+You need to setup a unique trigger for each event you sent to IFTTT.
+For ManyThing support, you need to set up an on and off event.
+
You can use the developer tools to test your Maker Channel trigger. To do this, open the Home Assistant UI, open the sidebar, click on the first icon in the developer tools. This should get you to the ‘Call Service’ screen. Fill in the following values:
+ +| Field | +Value | +
|---|---|
| domain | +ifttt |
+
| service | +trigger |
+
| Service Data | +{"event": "manything_on"} |
+
IFTTT is a web service that allows users to create chains of simple conditional statements, so called “recipes”. With the IFTTT component you can trigger recipes through the “maker” channel. See the announcement blog post for examples how to use it.
+ +# Example configuration.yaml entry
+ifttt:
+ key: xxxxx-x-xxxxxxxxxxxxx
+Key is your API key which can be obtained by viewing the properties of the Maker Channel.
+ +
+
+Property screen of the Maker Channel
+
Once you have added your key to configuration.yaml, restart your Home Assistant server. This will load up the IFTTT component and make a service available to trigger events in IFTTT.
+After restarting the server, be sure to watch the console for any logging errors that show up in red, white or yellow. +
+ +You can use the developer tools to test your Maker Channel trigger. To do this, open the Home Assistant UI, open the sidebar, click on the first icon in the developer tools. This should get you to the ‘Call Service’ screen. Fill in the following values:
+ +| Field | +Value | +
|---|---|
| domain | +ifttt |
+
| service | +trigger |
+
| Service Data | +{"event": "EventName", "value1": "Hello World"} |
+
+
+When your screen looks like this, click the ‘call service’ button.
+
+
+You need to setup a unique trigger for each event you sent to IFTTT.
+
# Example configuration.yaml Automation entry
+automation:
+ alias: Startup Notification
+ trigger:
+ platform: event
+ event_type: homeassistant_start
+ action:
+ service: ifttt.trigger
+ data: {"event":"TestHA_Trigger", "value1":"Hello World!"}
+To be able to receive events from IFTTT, your Home Assistant instance needs to be accessible from the web. This can be achieved by forwarding port 8123 from your router to the device running Home Assistant. If your ISP is giving you a new IP address from time to time, consider using DuckDNS.
+ +In the URL field, you can then put an API URL. You probably want to use a POST action, so select POST as method. After your request line, you need to add your Home Assistant password, which you defined in the http section of your config, in the form off ?api_password=<your_password>. For the message body, refer to the API page linked above.
+
+
Additional examples of using IFTTT channels can be found below.
+ +| Channel | +Description | +
|---|---|
| Manything | +Automates turning recording ON and OFF based on Home Assistant AWAY and HOME values. | +
+Support for these components is provided by the Home Assistant community. +
+
+
+
+
+ 
+
+
+
+
+
+ 
+
+ 
+
+
+
+
+
+
+
+ 
+
+ 
+
+ 
+
+ 
+
+
+
+ 
+
+
+
+ 
+
+ 
+
+
+
+ The influxdb component makes it possible to transfer all state changes to an external InfluxDB database. For more details, see the blog post on InfluxDB.
The default InfluxDB configuration doesn’t enforce authentication. If you have installed InfluxDB on the same host where Home Assistant is running and haven’t made any configuration changes, add the following to your configuration.yaml file:
+
+ 
+
+ 
+
+ 
+
+ 
+
+ 
+
+ 
+
+ 
+
+ 
+
+ 
+
+ 
+
+ 
+
+ 
+
+ 
+
+ 
+
+ 
+
+ 
+
+ 
+
+ 
+
+ 
+
+ 
+
+ 
+
+ 
+
+ 
+
+ 
+
+ 
+
+ 
+
+ 
+
+ 
+
+ 
+
+ 
+
+ 
+
+ 
+
+ 
+
+ 
+
+ 
+
+ 
+
+ 
+
+ 
+
+ 
+
+ 
+
+ 
+
+ 
+
+ 
+
+ 
+
+ 
+
+ 
+
+ 
+
+ 
+
+ 
+
+ 
+
+ 
+
+ 
+
+ 
+
+ 
+
+ 
+
+ 
+
+ 
+
+ 
+
+ 
+
+ 
+
+ 
+
+ 
+
+ 
+
+ 
+
+ 
+
+ 
+
+ 
+
+ 
+
+ 
+
+ 
+
+ 
+
+ 
+
+ 
+
+ 
+
+ 
+
+ 
+
+ 
+
+ 
+
+ 
+
+ 
+
+ 
+
+ 
+
+ 
+
+ 
+
+ 
+
+ 
+
+ 
+
+ 
+
+ 
+
+ # Example configuration.yaml entry
+influxdb:
+You will still need to create a database named home_assistant via InfluxDB’s web interface or command line. For instructions how to create a database check the InfluxDB documentation relevant to the version you have installed.
Configuration variables:
+ +localhost.home_assistant. The database must already exist.influxdb:
+ host: 192.168.1.190
+ port: 20000
+ database: DB_TO_STORE_EVENTS
+ username: MY_USERNAME
+ password: MY_PASSWORD
+ ssl: true
+ verify_ssl: true
+ blacklist:
+ - entity.id1
+ - entity.id2
+ whitelist:
+ - entity.id3
+ - entity.id4
+ tags:
+ instance: prod
+ source: hass
+The input_boolean component allows the user to define boolean values that can be controlled via the frontend and can be used within conditions of automation. This can for example be used to disable or enable certain automations.
# Example configuration.yaml entry
+input_boolean:
+ notify_home:
+ name: Notify when someone arrives home
+ initial: off
+ icon: mdi:car
+Configuration variables:
+ +Pick an icon that you can find on materialdesignicons.com to use for your input and prefix the name with mdi:. For example mdi:car, mdi:ambulance, or mdi:motorbike.
Here’s an example of an automation using the above input_boolean. This action will only occur if the switch is on.
+ +automation:
+ alias: Arriving home
+ trigger:
+ platform: state
+ entity_id: binary_sensor.motion_garage
+ to: 'on'
+ condition:
+ platform: state
+ entity_id: input_boolean.notify_home
+ state: 'on'
+ action:
+ service: notify.pushbullet
+ data:
+ title: ""
+ message: "Honey, I'm home!"
+The input_select component allows the user to define a list of values that can be selected via the frontend and can be used within conditions of automation. When a user selectes a new item, a state transition event is generated. This state event can be used in an automation trigger.
To enable this platform, add the following lines to your configuration.yaml:
# Example configuration.yaml entry
+input_select:
+ who_cooks:
+ name: Who cooks today
+ options:
+ - Paulus
+ - Anne Therese
+ initial: Anne Therese
+ icon: mdi:panda
+ living_room_preset:
+ options:
+ - Visitors
+ - Visitors with kids
+ - Home Alone
+Configuration variables:
+ +Pick an icon that you can find on materialdesignicons.com to use for your input and prefix the name with mdi:. For example mdi:car, mdi:ambulance, or mdi:motorbike.
The input_slider component allows the user to define values that can be controlled via the frontend and can be used within conditions of automation. Changes to the slider generate state events. These state events can be utilized as automation triggers as well.
# Example configuration.yaml entry
+input_slider:
+ slider1:
+ name: Slider 1
+ initial: 30
+ min: -20
+ max: 35
+ step: 1
+Configuration variables:
+ +Here’s an example of input_slider being used as a trigger in an automation.
+# Example configuration.yaml entry using 'input_slider' as a trigger in an automation
+
+# Define input_slider
+input_slider:
+ bedroom_brightness:
+ name: Brightness
+ initial: 254
+ min: 0
+ max: 254
+ step: 1
+
+# Automation.
+automation:
+ - alias: Bedroom Light - Adjust Brightness
+ trigger:
+ platform: state
+ entity_id: input_slider.bedroom_brightness
+ action:
+ - service: light.turn_on
+# Note the use of 'data_template:' below rather than the normal 'data:' if you weren't using an input variable
+ data_template:
+ entity_id: light.bedroom
+ brightness: '{{ trigger.to_state.state | int }}'
+
+Another code example using input_slider, this time being used in an action in an automation.
+# Example configuration.yaml entry using 'input_slider' in an action in an automation
+
+# Define 'input_select'
+input_select:
+ scene_bedroom:
+ name: Scene
+ options:
+ - Select
+ - Concentrate
+ - Energize
+ - Reading
+ - Relax
+ - 'OFF'
+ initial: 'Select'
+
+# Define input_slider
+input_slider:
+ bedroom_brightness:
+ name: Brightness
+ initial: 254
+ min: 0
+ max: 254
+ step: 1
+
+# Automation.
+automation:
+ - alias: Bedroom Light - Custom
+ trigger:
+ platform: state
+ entity_id: input_select.scene_bedroom
+ to: CUSTOM
+ action:
+ - service: light.turn_on
+# Again, note the use of 'data_template:' rather than the normal 'data:' if you weren't using an input variable.
+ data_template:
+ entity_id: light.bedroom
+ brightness: '{{ states.input_slider.bedroom_brightness.state | int }}'
+
++This component has been disabled due to a complaint by Insteon. It will be enabled again once this issue has been resolved. +
+ +The insteon component lets you use your Insteon Hub with Home Assistant.
You will need to obtain an Insteon REST API key from the Insteon Developer program to use this component.
+ +To integrate your Insteon Hub with Home Assistant, add the following section to your configuration.yaml file:
# Example configuration.yaml entry
+insteon_hub:
+ username: YOUR_USERNAME
+ password: YOUR_PASSWORD
+ api_key: YOUR_API_KEY
+Configuration variables:
+ +The introduction component will show a card in the UI with steps on how to get started. It will also print the same message to the console when starting up.
+ +The introduction component is loaded by default on a new Home Assistant instance.
+ +# Example configuration.yaml entry
+introduction:
+To disable this component, remove the introduction: entry from your configuration.yaml file.
The ISY994 is a home automation controller that is capable of controlling Insteon and X10 devices. Some models of the ISY994 can even control Z-Wave devices. +The ISY994 controller is manufactured by Universal Devices.
+ +Home Assistant is capable of communicating with any binary sensor, cover, fan, light, lock, sensor and switch that is configured on the controller. Using the programs on the controller, custom binary sensors, cover, fan, lock, and switches can also be created.
+ +To integrate your ISY994 controller with Home Assistant, add the following section to your configuration.yaml file:
# Example configuration.yaml entry
+isy994:
+ host: ISY_ADDRESS
+ username: ISY_USERNAME
+ password: ISY_PASSWORD
+Configuration variables:
+ +Once the ISY controller is configured, it will automatically import any binary sensors, covers, fans, lights, locks, sensors and switches it can locate.
+ +Using the Programs tab in the controller’s Administrative Console, custom devices can be created that will appear natively inside of Home Assistant. Home Assistant will scan the following folders and build the device to the associated domains:
+ +My Programs
+├── HA.binary_sensor
+| ├── Movement In House
+| | └── status
+| └── Garage Open
+| | └── status
+├── HA.cover
+| ├── Left Garage Door
+| | ├── actions
+| | └── status
+| ├── Living Room Blinds
+| | ├── actions
+| | └── status
+├── HA.fan
+| ├── Desk Fan
+| | ├── actions
+| | └── status
+| ├── Living Room Fan
+| | ├── actions
+| | └── status
+├── HA.lock
+| ├── Front Door
+| | ├── actions
+| | └── status
+| ├── Back Door
+| | ├── actions
+| | └── status
+├── HA.switch
+| ├── Dining Lights
+| | ├── actions
+| | └── status
+| ├── Sleep Mode
+| | ├── actions
+| | └── status
+A device is created by creating a directory, with the name for the device, under any of the following root directories:
+A program, named status, is required under the program device directory. A program, named actions, is required for all program devices except for binary_sensor. Any other programs in these device directories will be ignored.
+ +
+ 
+
The status program in this directory is what indicates the state of the device:
+
+ 
+
The actions program indicates what should be performed for the following device services:
+
+ 
+
The example program above shows how to control a legacy X10 device from Home Assistant using an ISY controller.
+ + +The Join platform exposes services from Join. In Home Assistant, the Join features are divided up in two locations, the Join component, and the Join notify platform. The notify platform allows us to send messages to Join devices, the the component allows us to access the other special features that Join offers.
+ +In the configuration.yaml file you need to provide the device id of the target device. If you want to send to a group of devices, you need to provide an api key. You can find you device id and api key here.
To set it up, add the following information to your configuration.yaml file:
notify:
+ - platform: joaoapps_join
+ device_id: d5asdfasdf54645h45h368761dfe5gt8a
+ name: droid *optional
+ api_key: asd97823jb628a34fwsdfwefd5384345tf2d *optional
+
+joaoapps_join:
+ - name: android
+ device_id: group.android
+ api_key: asd97823jb628a34fwsdfwefd5384345tf2d
+Configuration variables:
+ +The notify service has a few optional parameters such as icon and small icon. You can use them like so:
+ +{"message":"Hello!","title":"From Hass","data":{"icon":"https://goo.gl/KVqcYi","smallicon":"http://goo.gl/AU4Wf1"}}
+The services exposed in the joaoapps_join component can be used with the service data described below:
+ +| Service | +Data | +
| —————————— | +—————————————————————— | +
| joaoapps_join/ring | ++ |
| joaoapps_join/send_sms | +{“number”:”5553334444”, “message”:”Hello!”} | +
| joaoapps_join/send_tasker | +{“command”:”test”} | +
| joaoapps_join/send_url | +{“url”:”http://google.com”} | +
| joaoapps_join/send_wallpaper | +{“url”:”http://www.planwallpaper.com/static/images/ZhGEqAP.jpg”} | +
| joaoapps_join/send_file | +{“url”:”http://download.thinkbroadband.com/5MB.zip”} | +
The keyboard component simulates key presses on the host machine. It currently offers the following Buttons as a Service (BaaS):
keyboard/volume_upkeyboard/volume_downkeyboard/volume_mutekeyboard/media_play_pausekeyboard/media_next_trackkeyboard/media_prev_trackTo load this component, add the following lines to your configuration.yaml:
keyboard:
+You may need to install platform-specific dependencies for PyUserInput in order to use the keyboard component. In most cases this can be done by running:
+ +$ pip3 install [package name]
+x64 Windows users may have trouble installing pywin through pip. Using an executable installer should work around this issue.
+ +Similar installers (unofficial) for pyhook have been ported to python 3.4 and should help with x64 pip issues with pyhook.
+ + +Receive signals from a keyboard and use it as a remote control.
+ +This component allows you to use a keyboard as remote control. It will fire keyboard_remote_command_received events which can then be used in automation rules.
The evdev package is used to interface with the keyboard and thus this is Linux only. It also means you can’t use your normal keyboard for this because evdev will block it.
# Example configuration.yaml entry
+keyboard_remote:
+ device_descriptor: '/dev/input/by-id/foo'
+ key_value: 'key_up'
+Configuration variables:
+ +key_up, key_down, and key_hold. Be careful, key_hold will fire a lot of events.And an automation rule to breathe life into it:
+ +automation:
+ alias: Keyboard all lights on
+ trigger:
+ platform: event
+ event_type: keyboard_remote_command_received
+ event_data:
+ key_code: 107 # inspect log to obtain desired keycode
+ action:
+ service: light.turn_on
+ entity_id: light.all
+KNX/EIB integration for Home Assistant allows you to connect to a KNX bus. The component requires a local KNX/IP interface like the Weinzierl 730. Through this it will send and receive commands to and from other devices to the KNX bus.
+ +There is currently support for the following device types within Home Assistant:
+ +A knx section must be present in the configuration.yaml file and contain the following options as required:
# Example configuration.yaml entry
+knx:
+0.0.0.0 which will start discovery for your KNX/IP gateway.3671.The blinkstick platform lets you control your Blinkstick lights from within Home Assistant.
To add blinkstick to your installation, add the following to your configuration.yaml file:
# Example configuration.yaml entry
+light:
+ platform: blinksticklight
+ serial: BS000795-1.1
+ name: Living Room
+Configuration variables:
+ +An EnOcean light can take many forms. Currently only one type has been tested: Eltako FUD61 dimmer.
+ +To use your EnOcean device, you first have to set up your EnOcean hub and then add the following to your configuration.yaml file:
# Example configuration.yaml entry
+light:
+ - platform: enocean
+ id: [0x01,0x90,0x84,0x3C]
+ sender_id: [0xFF,0xC6,0xEA,0x04]
+Configuration variables:
+ +The flux_led support is integrated into Home Assistant as a light platform. Several brands use the same protocol and they have the HF-LPB100 chipset in common.
Example of bulbs:
+ +The chances are high that your bulb or controller (eg. WiFi LED CONTROLLER) will work if you can control the device with the MagicHome app.
+ +To enable those lights, add the following lines to your configuration.yaml file:
# Example configuration.yaml entry
+light:
+ - platform: flux_led
+Configuration variables:
+ +Will automatically search and add all lights on start up:
+ +# Example configuration.yaml entry
+light:
+ - platform: flux_led
+ automatic_add: True
+Will add two lights with given name and create an automation rule to randomly set color each 45 seconds:
+ +light:
+# Example configuration.yaml entry
+ - platform: flux_led
+ devices:
+ 192.168.0.106:
+ name: flux_lamppost
+ 192.168.0.109:
+ name: flux_living_room_lamp
+
+automation:
+ random_flux_living_room_lamp:
+ trigger:
+ platform: time
+ seconds: '/45'
+ action:
+ service: light.turn_on
+ data:
+ entity_id: light.flux_living_room_lamp
+ effect: random
+Philips Hue support is integrated into Home Assistant as a light platform. The preferred way to setup the Philips Hue platform is by enabling the discovery component.
+ +Once discovered, if you have a custom default view, locate configurator.philips_hue in the entities list ( < > ) and add it to a group in configuration.yaml. Restart Home Assistant so that the configurator is visible in the Home Assistant dashboard. Once Home Assistant is restarted, locate and click on configurator.philips_hue to bring up the initiation dialog. This will prompt you to press the Hue button to register the Hue hub in home assistant. Once complete, the configurator entity isn’t needed anymore and can be removed from any visible group in configuration.yaml.
Restarting Home Assistant once more should result in the Hue lights listed as “light” entities. Add these light entities to configuration.yaml and restart home assistant once more to complete the installation.
+ +If you want to enable the component without relying on the discovery component, add the following lines to your configuration.yaml:
# Example configuration.yaml entry
+light:
+ platform: hue
+ host: DEVICE_IP_ADDRESS
+Configuration variables:
+ +This platform allows you to integrate your Hyperion into Home Assistant.
+ +Hyperion is an opensource Ambilight implementation which runs on many platforms.
+ +# Example configuration.yaml entry
+light:
+ - platform: hyperion
+Configuration variables:
+ +The insteon_hub light component lets you control your lights connected to an Insteon Hub with Home Assistant.
To get your Insteon Hub fan working with Home Assistant, follow the instructions for the general Insteon Hub component.
+ + +The isy994 platform allows you to get data from your ISY994 light from within Home Assistant.
They will be automatically discovered if the isy994 component is loaded.
+ + +The lifx platform allows you to integrate your LIFX into Home Assistant.
# Example configuration.yaml entry
+light:
+ - platform: lifx
+Configuration variables:
+ +limitlessled can control your LimitlessLED lights from within Home Assistant. The lights are also known as EasyBulb, AppLight, AppLamp, MiLight, LEDme, dekolight, or iLight.
Before configuring Home Assistant, make sure you can control your bulbs or LEDs with the MiLight mobile application. Discover your bridge(s) IP address. You can do this via your router or a mobile application like Fing (android or itunes). Keep in mind that LimitlessLED bulbs are controlled via groups. You can not control an individual bulb via the bridge, unless it is in a group by itself. Note that you can assign an rgbw and white group to the same group number, effectively allowing 8 groups (4 rgbw and 4 white) per bridge.
To add limitlessled to your installation, add the following to your configuration.yaml file:
# Example configuration.yaml entry
+light:
+ platform: limitlessled
+ bridges:
+ - host: 192.168.1.10
+ groups:
+ - number: 1
+ name: Bedroom
+ - number: 2
+ type: rgbw
+ name: Bathroom
+ - host: 192.168.1.11
+ groups:
+ - number: 1
+ name: Living Room & Hall
+Configuration variables:
+ +192.168.1.325). Don’t use if you aren’t sure.1-4). Corresponds to the group number on the remote.rgbw or white. rgbw is the default if you don’t specify this entry.Refer to the light documentation for general property usage, but keep in mind the following notes specific to LimitlessLED.
+ +When starting Home Assistant, your LimitlessLED bulbs will be set to known default values. This ensures a consistent user interface and uninterrupted turning on/off. If you control your LimitlessLED lights via the MiLight mobile application or other means while Home Assistant is running, Home Assistant can not track those changes and you may observe unexpected behavior. This is due to a LimitlessLED limitation.
+ + +To get your LiteJet lights working with Home Assistant, follow the instructions for the general LiteJet component.
+ + +The mqtt light platform let you control your MQTT enabled light.
In an ideal scenario, the MQTT device will have a state topic to publish state changes. If these messages are published with RETAIN flag, the MQTT switch will receive an instant state update after subscription and will start with correct state. Otherwise, the initial state of the switch will be false/off.
+ +When a state topic is not available, the light will work in optimistic mode. In this mode, the light will immediately change state after every command. Otherwise, the light will wait for state confirmation from device (message from state_topic).
Optimistic mode can be forced, even if state topic is available. Try to enable it, if experiencing incorrect light operation.
+ +# Example configuration.yml entry
+light:
+ - platform: mqtt
+ command_topic: "office/rgb1/light/switch"
+Configuration variables:
+ +
+ Make sure that your topics match exact. some-topic/ and some-topic are different topics.
+
In this section you find some real life examples of how to use this sensor.
+ +To enable a light with brightness and RGB support in your installation, add the following to your configuration.yaml file:
# Example configuration.yml entry
+light:
+ - platform: mqtt
+ name: "Office Light RGB"
+ state_topic: "office/rgb1/light/status"
+ command_topic: "office/rgb1/light/switch"
+ brightness_state_topic: "office/rgb1/brightness/status"
+ brightness_command_topic: "office/rgb1/brightness/set"
+ rgb_state_topic: "office/rgb1/rgb/status"
+ rgb_command_topic: "office/rgb1/rgb/set"
+ state_value_template: "{{ value_json.state }}"
+ brightness_value_template: "{{ value_json.brightness }}"
+ rgb_value_template: "{{ value_json.rgb | join(',') }}"
+ qos: 0
+ payload_on: "ON"
+ payload_off: "OFF"
+ optimistic: false
+To enable a light with brightness (no RGB version) in your installation, add the following to your configuration.yaml file:
# Example configuration.yml entry
+light:
+ platform: mqtt
+ name: "Office light"
+ state_topic: "office/rgb1/light/status"
+ command_topic: "office/rgb1/light/switch"
+ brightness_state_topic: 'office/rgb1/light/brightness'
+ brightness_command_topic: 'office/rgb1/light/brightness/set'
+ qos: 0
+ payload_on: "ON"
+ payload_off: "OFF"
+ optimistic: false
+A basic example using a nodeMCU board (ESP8266) to control its built-in led (on/off) can be found here. Here is another example to control a RGB led (on/off, brightness and colors).
+ + +The mqtt_json light platform lets you control a MQTT-enabled light that can receive JSON messages.
This platform supports on/off, brightness, RGB colors, transitions, and short/long flashing. The messages sent to/from the lights look similar to this, omitting fields when they aren’t needed:
+ +{
+ "brightness": 255,
+ "color": {
+ "g": 255,
+ "b": 255,
+ "r": 255
+ },
+ "transition": 2,
+ "state": "ON"
+}
+In an ideal scenario, the MQTT device will have a state topic to publish state changes. If these messages are published with the RETAIN flag, the MQTT light will receive an instant state update after subscription and will start with the correct state. Otherwise, the initial state of the light will be off.
+ +When a state topic is not available, the light will work in optimistic mode. In this mode, the light will immediately change state after every command. Otherwise, the light will wait for state confirmation from the device (message from state_topic).
Optimistic mode can be forced, even if state topic is available. Try enabling it if the light is operating incorrectly.
+ +# Example configuration.yaml entry
+light:
+ - platform: mqtt_json
+ command_topic: "home/rgb1/set"
+Configuration variables:
+ +
+ Make sure that your topics match exact. some-topic/ and some-topic are different topics.
+
In this section you find some real life examples of how to use this sensor.
+ +To enable a light with brightness and RGB support in your installation, add the following to your configuration.yaml file:
# Example configuration.yaml entry
+light:
+ - platform: mqtt_json
+ name: mqtt_json_light_1
+ state_topic: "home/rgb1"
+ command_topic: "home/rgb1/set"
+ brightness: true
+ rgb: true
+To enable a light with brightness (but no color support) in your installation, add the following to your configuration.yaml file:
# Example configuration.yaml entry
+light:
+ - platform: mqtt_json
+ name: mqtt_json_light_1
+ state_topic: "home/rgb1"
+ command_topic: "home/rgb1/set"
+ brightness: true
+A full example of custom lighting using this platform and an ESP8266 microcontroller can be found here. It supports on/off, brightness, transitions, RGB colors, and flashing.
+ + +Integrates MySensors lights into Home Assistant. See the main component for configuration instructions.
+ +The following actuator types are supported:
+ +| S_TYPE | +V_TYPE | +
|---|---|
| S_DIMMER | +V_DIMMER*, V_LIGHT* | +
| S_TYPE | +V_TYPE | +
|---|---|
| S_DIMMER | +[V_DIMMER* or V_PERCENTAGE*], [V_LIGHT* or V_STATUS*] | +
| S_RGB_LIGHT | +V_RGB*, [V_LIGHT* or V_STATUS*], [V_DIMMER or V_PERCENTAGE] | +
V_TYPES with a star (*) denotes required V_TYPES. Use either V_LIGHT or V_STATUS and either V_DIMMER or V_PERCENTAGE for an applicable actuator.
+ +For more information, visit the serial api of MySensors.
+ +/*
+ * Documentation: http://www.mysensors.org
+ * Support Forum: http://forum.mysensors.org
+ *
+ * http://www.mysensors.org/build/dimmer
+ */
+
+#include <MySensor.h>
+#include <SPI.h>
+
+#define SN "DimmableRGBLED"
+#define SV "1.0"
+#define CHILD_ID 1
+#define LED_PIN 5
+
+MySensor gw;
+
+char rgb[7] = "ffffff"; // RGB value.
+int currentLevel = 0; // Current dimmer level.
+MyMessage dimmerMsg(CHILD_ID, V_PERCENTAGE);
+MyMessage lightMsg(CHILD_ID, V_STATUS);
+MyMessage rgbMsg(CHILD_ID, V_RGB);
+
+void setup()
+{
+ gw.begin(incomingMessage);
+ gw.sendSketchInfo(SN, SV);
+ gw.present(CHILD_ID, S_RGB_LIGHT);
+ // Send initial values.
+ gw.send(lightMsg.set(currentLevel > 0 ? 1 : 0));
+ gw.send(dimmerMsg.set(currentLevel));
+ gw.send(rgbMsg.set(rgb));
+}
+
+void loop()
+{
+ gw.process();
+}
+
+void incomingMessage(const MyMessage &message) {
+ if (message.type == V_RGB) {
+ // Retrieve the RGB value from the incoming message.
+ // RGB LED not implemented, just a dummy print.
+ String hexstring = message.getString();
+ hexstring.toCharArray(rgb, sizeof(rgb));
+ Serial.print("Changing color to ");
+ Serial.println(rgb);
+ gw.send(rgbMsg.set(rgb));
+ }
+
+ if (message.type == V_STATUS || message.type == V_PERCENTAGE) {
+ // Retrieve the light status or dimmer level from the incoming message.
+ int requestedLevel = atoi(message.data);
+
+ // Adjust incoming level if this is a V_LIGHT update [0 == off, 1 == on].
+ requestedLevel *= (message.type == V_STATUS ? 100 : 1);
+
+ // Clip incoming level to valid range of 0 to 100
+ requestedLevel = requestedLevel > 100 ? 100 : requestedLevel;
+ requestedLevel = requestedLevel < 0 ? 0 : requestedLevel;
+
+ // Change level value of LED pin.
+ analogWrite(LED_PIN, (int)(requestedLevel / 100. * 255));
+ currentLevel = requestedLevel;
+
+ // Update the gateway with the current V_STATUS and V_PERCENTAGE.
+ gw.send(lightMsg.set(currentLevel > 0 ? 1 : 0));
+ gw.send(dimmerMsg.set(currentLevel));
+ }
+}
+The osramlightify platform allows you to integrate your Osram Lightify into Home Assistant.
# Example configuration.yaml entry
+light:
+ - platform: osramlightify
+ host: 192.168.0.50
+Configuration variables:
+ +192.168.1.50.The qwikswitch light platform allows you to control your QwikSwitch relays and dimmers as lights from within Home Assistant.
The platform is configured through the QwikSwitch component.
+ + +The rfxtrx platform support lights that communicate in the frequency range of 433.92 MHz.
First you have to set up your rfxtrx hub.
+ +The easiest way to find your lights is to add this to your configuration.yaml:
light:
+ - platform: rfxtrx
+ automatic_add: True
+Launch your Home Assistant and go the website. Push your remote and your device should be added:
+ +
+
+
Here the name is 0b11000102ef9f210010f70 and you can verify that it works from the frontend. Then you should update your configuration to:
light:
+ platform: rfxtrx
+ devices:
+ 0b11000102ef9f210010f70:
+ name: device_name
+Example configuration:
+ +# Example configuration.yaml entry
+light:
+ platform: rfxtrx
+ devices:
+ 0b11000f10e9e5660b010f70:
+ name: Light1
+ 0b1100100f29e5660c010f70:
+ name: Light_TV
+Configuration variables:
+ +The SCSGate device can control lights of the BTicino MyHome system.
+ +To enable SCSGate lights in your installation, add the following to your configuration.yaml file:
# Example configuration.yaml entry
+light:
+ platform: scsgate
+ devices:
+ living_room:
+ name: Living Room
+ scs_id: XXXXX
+Configuration variables:
+ +This tellstick light platform allows you to control your TellStick dimmers.
To use your TellStick device, you first have to set up your Tellstick hub and then add the following to your configuration.yaml file:
# Example configuration.yaml entry
+light:
+ platform: tellstick
+The vera platform allows you to control your Vera lights from within Home Assistant.
They will be automatically discovered if the vera component is loaded.
+ +For more configuration information see the Vera component documentation.
+ + + +The wemo platform allows you to control your Belkin WeMo LED lights from within Home Assistant.
They will be automatically discovered if the discovery component is enabled.
+ +For more configuration information see the WeMo component documentation.
+ + + +The x10 light platform allows you to control your X10 based lights with Home Assistant.
Requires Heyu x10 interface.
+ +To enable those lights, add the following lines to your configuration.yaml file:
# Example configuration.yaml entry
+light:
+ - platform: x10
+ devices:
+ - id: a2
+ - id: a3
+ name: Bedroom Lamp
+Configuration variables:
+ +The yeelight light platform allows you to control your Yeelight Wifi bulbs with Home Assistant.
To enable those lights, add the following lines to your configuration.yaml file:
# Example configuration.yaml entry
+ - platform: yeelight
+ devices:
+ 192.168.1.25:
+ name: palier
+Configuration variables:
+ ++Before trying to control your light through Home Assistant, you have to setup your bulb using Yeelight app. ( Android, IOS ). +In the bulb property, you have to enable “Developer Mode” +Determine your bulb ip (using router, software, ping …) +
+ ++Tests are only made with a YLDP03YL model. Because it’s the only hardware developer owns. If you have bugs with another kind of model, you could open an issue on Home Assitant Github +
+ + + +A ZigBee light in this context is a light connected to one of the digital output pins on a ZigBee module. It can simply be switched on and off. By default, a light is considered on when the ZigBee device’s digital output is held high and considered off when it is held low. This behaviour can be inverted by setting the on_state configuration variable to low.
To configure a digital output pin as light, add the following to your configuration.yaml file:
light:
+ - name: Desk Lamp
+ platform: zigbee
+ pin: 0
+Configuration variables:
+ +high (default) or low, depicting whether the digital output pin is pulled high or low when the light is turned on.To get your Z-Wave lights working with Home Assistant, follow the instructions for the general Z-Wave component.
+ + +This component allows you to track and control various light bulbs.
+ +It has 4 built-in light profiles which you’re able to extend by putting a light_profiles.csv file in your config dir.
Preferred way to setup the Philips Hue platform is through the the discovery component. For the Wink light platform enable the wink component.
+ +If you want to enable the light component directly, add the following lines to your configuration.yaml:
light:
+ platform: hue
+
+The light component supports multiple entries in configuration.yaml by appending a sequential number to the section: light 2:, light 3: etc.
+
light.turn_onTurns one light on or multiple lights on using groups.
+ +| Service data attribute | +Optional | +Description | +
|---|---|---|
entity_id |
+ no | +String or list of strings that point at entity_ids of lights. Else targets all. |
+
transition |
+ yes | +Integer that represents the time the light should take to transition to the new state in seconds. *not supported by Wink | +
profile |
+ yes | +String with the name of one of the built-in profiles (relax, energize, concentrate, reading) or one of the custom profiles defined in light_profiles.csv in the current working directory. Light profiles define a xy color and a brightness. If a profile is given and a brightness or xy color then the profile values will be overwritten. |
+
xy_color |
+ yes | +A list containing two floats representing the xy color you want the light to be. Two comma seperated floats that represent the color in XY. | +
rgb_color |
+ yes | +A list containing three integers representing the rgb color you want the light to be. Three comma seperated integers that represent the color in RGB. You can find a great chart here: Hue Color Chart | +
color_temp |
+ yes | +An INT in mireds representing the color temperature you want the light to be. | +
color_name |
+ yes | +A human readable string of a color name, such as blue or goldenrod or chucknorris. If your browser can display it, so can Home Assistant. |
+
brightness |
+ yes | +Integer between 0 and 255 for how bright the color should be. | +
flash |
+ yes | +Tell light to flash, can be either value short or long. *not supported by Wink |
+
effect |
+ yes | +Applies an effect such as colorloop or random. |
+
light.turn_offTurns one or multiple lights off.
+ +| Service data attribute | +Optional | +Description | +
|---|---|---|
entity_id |
+ no | +String or list of strings that point at entity_ids of lights. Else targets all. |
+
transition |
+ yes | +Integer that represents the time the light should take to transition to the new state in seconds. | +
light.toggleToggles the state of one or multiple lights using groups.
+ +Note: If light.toggle is used for a group of lights, it will toggle the individual state of each light.
| Service data attribute | +Optional | +Description | +
|---|---|---|
entity_id |
+ no | +String or list of strings that point at entity_ids of lights. Else targets all. |
+
transition |
+ yes | +Integer that represents the time the light should take to transition to the new state in seconds. | +
LIRC integration for Home Assistant allows you to receive signals from an infrared remote control and control actions based on the buttons you press. You can use them to set scenes or trigger any other automation.
+ +Sending IR commands is not supported in this component (yet), but can be accomplished using the shell_command component in conjunction with the irsend command.
To allow Home Assistant to talk to your IR receiver, you need to first make sure you have the correct dependencies installed:
+ +$ sudo apt-get install lirc liblircclient-dev
++If you are configuring on a Raspberry Pi, there are excellent instructions with GPIO schematics and driver configurations here. Consider following these. +
+ +Now teach LIRC about your particular remote control by preparing a lircd configuration file (/etc/lirc/lircd.conf). Search the LIRC remote database for your model. If you can’t find it, then you can always use the irrecord program to learn your remote. This will create a valid configuration file. Add as many remotes as you want by pasting them into the file. If irrecord doesn’t work (e.g. for some air conditioner remotes), then the mode2 program is capable of reading the codes in raw mode, followed by irrecord -a to extract hex codes.
Next, you have to make a ~/.lircrc file that maps keypresses to system actions. The configuration is a bit tedious but it must be done. Use the prog = home-assistant for all keys you want to be recognized by Home Assistant. The values you set for button must be the same as in the lircd.conf file and the values you put for config entry will be the sensor value in Home Assistant when you press the button. An example may look like this:
begin
+ remote = SONY
+ button = KEY_1
+ prog = home-assistant
+ config = KEY_1
+end
+begin
+ remote = SONY
+ button = KEY_2
+ prog = home-assistant
+ config = KEY_2
+end
+begin
+ remote = SONY
+ button = KEY_3
+ prog = home-assistant
+ config = KEY_3
+end
+Test your LIRC installation before proceeding by running:
+ +$ ircat home-assistant
+and pressing some buttons on the remote. You should see them register on the screen if LIRC is properly configured.
+ +# Example configuration.yaml entry
+lirc:
+The LIRC component fires ir_command_received events on the bus. You can capture the events and respond to them in automation scripts like this:
# Example configuration.yaml automation entry
+automation:
+ - alias: Off on Remote
+ trigger:
+ platform: event
+ event_type: ir_command_received
+ event_data:
+ button_name: KEY_0
+ action:
+ service: homeassistant.turn_off
+ entity_id: group.a_lights
+The button_name data values (e.g. KEY_0) are set by you in the .lircrc file.
LiteJet is a centralized lighting system that predates most home automation technology. All lights and wall switches are wired to a central panel. This central panel has a serial port interface that allows a computer to control the system via LiteJet’s third party protocol.
+ +Home Assistant integrates the LiteJet 3rd party protocol and allows you to get the status and control the connected lights.
+ +After connecting the LiteJet’s RS232-2 port to your computer, add the following to your configuration.yaml:
litejet:
+ port: /dev/serial/by-id/THE-PATH-OF-YOUR-SERIAL-PORT
+Your LiteJet MCP should be configured for 19.2 K baud, 8 data bits, 1 stop bit, no parity, and to transmit a ‘CR’ after each response. These settings can be configured using the LiteJet programming software.
+ +You can also configure the Home Assistant to ignore lights, scenes, and switches via their name. This is highly recommended since LiteJet has a fixed number of each of these and with most systems many will be unused.
+ +litejet:
+Configuration variables:
+ +false. This can be useful when debugging your lighting as you can press/release switches remotely.litejet:
+ exclude_names:
+ - 'Button #'
+ - 'Scene #'
+ - 'Timed Scene #'
+ - 'Timed Scene#'
+ - 'LV Rel #'
+ - 'Fan #'
+The isy994 platform allows you to get data from your ISY994 lock from within Home Assistant.
They will be automatically discovered if the isy994 component is loaded.
+ + +The mqtt lock platform let you control your MQTT enabled locks.
In an ideal scenario, the MQTT device will have a state_topic to publish state changes. If these messages are published with RETAIN flag, the MQTT lock will receive an instant state update after subscription and will start with correct state. Otherwise, the initial state of the lock will be false/unlocked.
When a state_topic is not available, the lock will work in optimistic mode. In this mode, the lock will immediately change state after every command. Otherwise, the lock will wait for state confirmation from the device (message from state_topic).
Optimistic mode can be forced, even if state topic is available. Try to enable it, if experiencing incorrect lock operation.
+ +To enable MQTT locks in your installation, add the following to your configuration.yaml file:
# Example configuration.yml entry
+lock:
+ - platform: mqtt
+ command_topic: "home/frontdoor/set"
+Configuration variables:
+ +true if no state_topic defined, else false.
+Make sure that your topic match exact. some-topic/ and some-topic are different topics.
+
In this section you find some real life examples of how to use this lock.
+ +The example below shows a full configuration for a MQTT lock.
+ +# Example configuration.yml entry
+lock:
+ platform: mqtt
+ name: Frontdoor
+ state_topic: "home-assistant/frontdoor/"
+ command_topic: "home-assistant/frontdoor/set"
+ payload_lock: "LOCK"
+ payload_unlock: "UNLOCK"
+ optimistic: false
+ qos: 1
+ retain: true
+ value_template: '{{ value.x }}'
+Keep an eye on ratining messages to keep the state as you don’t want to unlock your door by accident when you restart something.
+ +For a check you can use the command line tools mosquitto_pub shipped with mosquitto to send MQTT messages. This allows you to operate your cover manually:
$ mosquitto_pub -h 127.0.0.1 -t home-assistant/frontdoor/set -m "LOCK"
+The vera platform allows you to control your Vera locks from within Home Assistant.
They will be automatically discovered if the vera component is loaded.
+ +For more configuration information see the Vera component documentation.
+ + +The Verisure lock platform allows you to control your Verisure locks.
+ +The requirement is that you have setup your Verisure hub.
+ + + +To get your Z-Wave locks working with Home Assistant, follow the instructions for the general Z-Wave component.
+ + +Keeps track which locks are in your environment, their state and allows you to control them.
+ +all_locks.lock/lock and lock/unlock to control locks.Go the the Developer Tools, then to Call Service in the frontend, and choose lock/lock or lock/unlock from the list of available services (Available services: on the left). Enter something like the sample below into the Service Data field and hit CALL SERVICE.
{"entity_id":"lock.front_door"}
+| Service data attribute | +Optional | +Description | +
|---|---|---|
entity_id |
+ yes | +Only act on specific lock. Else targets all. | +
The logbook component provides a different perspective on the history of your house by showing all the changes that happened to your house in reverse chronological order. See the demo for a live example.
To enable the logbook in your installation, add the following to your configuration.yaml file:
# Example configuration.yaml entry
+logbook:
+Configuration variables:
+ +If you want to exclude messages of some entities or domains from the logbook just add the exclude parameter like:
# Example of excluding domains and entities from the logbook
+logbook:
+ exclude:
+ entities:
+ - sensor.last_boot
+ - sensor.date
+ domains:
+ - sun
+ - weblink
+In case you just want to see messages from some specific entities or domains use the include configuration:
# Example to show how to include only the listed domains and entities in the logbook
+logbook:
+ include:
+ domains:
+ - sensor
+ - switch
+ - media_player
+You can also use the include list and filter out some entities or domains with an exclude list. Usually this makes sense if you define domains on the include side and filter out some specific entities.
# Example of combining include and exclude configurations
+logbook:
+ include:
+ domains:
+ - sensor
+ - switch
+ - media_player
+ exclude:
+ entities:
+ - sensor.last_boot
+ - sensor.date
+Entities customized as hidden are excluded from the logbook by default, but sometimes you want to show the entity in the UI and not in the logbook. For instance you use the sensor.dateto show the current date in the UI, but you do not want an logbook entry for that sensor every day.
+To exclude these entities just add them to the exclude > entities list in the configuration of the logbook.
To exclude all events from a whole domain add it to the exclude > domain list. For instance you use the sun domain only to trigger automations on the `azimuth attribute, then you possible are not interested in the logbook entries for sun rise and sun set.
It is possible to add custom entries to the logbook by using the script component to fire an event.
+ +# Example configuration.yaml entry
+script:
+ add_logbook_entry:
+ alias: Add Logbook
+ sequence:
+ - event: LOGBOOK_ENTRY
+ event_data:
+ name: Kitchen
+ message: is being used
+ # Optional
+ entity_id: light.kitchen
+ domain: light
+The logentries component makes it possible to log all state changes to your Logentries account using Logentries Webhook endpoint and a token based log
To use the logentries component in your installation, add the following to your configuration.yaml file:
# Example configuration.yaml entry
+logentries:
+ token: TOKEN
+Configuration variables:
+ +The logger component lets you define the level of logging activities in Home Assistant.
+ +To enable the logger in your installation, add the following to your configuration.yaml file:
By default log all messages and ignore events lower than critical for specified components.
+ +# Example configuration.yaml entry
+logger:
+ default: info
+ logs:
+ homeassistant.components.device_tracker: critical
+ homeassistant.components.camera: critical
+By default ignore all messages lower than critical and log event for specified components.
+ +# Example configuration.yaml entry
+logger:
+ default: critical
+ logs:
+ homeassistant.components: info
+ homeassistant.components.rfxtrx: debug
+ homeassistant.components.device_tracker: critical
+ homeassistant.components.camera: critical
+Possible log severities are:
+ +The braviatv platform allows you to control a Sony Bravia TV.
Almost all Sony Bravia TV 2013 and newer are supported.
+ +You will need to configure your TV to allow the Home Assistant for remote usage. To do that, ensure that your TV is turned on. Open the configuration popup on Home Assistant and enter a random PIN (for example 0000). After that, the TV will show you a PIN and Home Assistant will allow you to re-enter that PIN. Enter the PIN shown on your TV and Home Assistant will be able to control your Sony Bravia TV.
+ +To add a TV to your installation, add the following to your configuration.yaml file:
# Example configuration.yaml entry
+media_player:
+ - platform: braviatv
+ host: 192.168.0.10
+Configuration variables:
+ +You are also able to configure the TV manually by placing a bravia.conf file in your .homeassistant config directory with the following information - please update the details to match your setup:
{"192.168.0.10": {"pin": "7745", "mac": "ac:1e:0a:e1:0c:01"}}
+Google Cast devices like Android TVs and Chromecasts will be automatically discovered if you enable the discovery component. There is a issue where Chromecasts can only be discovered if your device is connected to the same subnet as your Chromecast.
+ +Chromecast platform can also be forced to load by adding the following lines to your configuration.yaml:
# Example configuration.yaml entry
+media_player:
+ - platform: cast
+Configuration variables:
+ +The cmus platform allows you to control a cmus music player on a remote or local machine from Home Assistant.
To add cmus to your installation, add the following to your configuration.yaml file if running locally it will look like:
# Example configuration.yaml entry
+media_player:
+ - platform: cmus
+if cmus is running on a remote server:
+ +# Example configuration.yaml entry
+media_player:
+ - platform: cmus
+ host: IP_ADDRESS
+ password: PASSWORD
+Configuration variables:
+ +The denon platform allows you to control a Denon Network Receivers from Home Assistant.
Supported devices:
+ +To add a Denon Network Receiver to your installation, add the following to your configuration.yaml file:
# Example configuration.yaml entry
+media_player:
+ - platform: denon
+ host: IP_ADDRESS
+Configuration variables:
+ +A few notes:
+ +The DirecTV receivers will be automatically discovered if you enable the discovery component.
+ +The directv media player platform can also be forced to load by adding the following lines to your configuration.yaml:
# Example configuration.yaml entry
+media_player:
+ - platform: directv
+Configuration variables:
+ +8080.The emby platform allows you to control a Emby multimedia system from Home Assistant.
To add Emby to your installation, add the following to your configuration.yaml file:
# Example configuration.yaml entry
+media_player:
+ - platform: emby
+ host: 192.168.11.5
+ api_key: "emby_api_key"
+Configuration variables:
+ +The firetv platform allows you to control a Amazon Fire TV/stick.
The python-firetv Python 2.x module with its helper script that exposes a HTTP server to fetch state and perform actions is used.
+ +Steps to configure your Amazon Fire TV stick with Home Assistant:
+ +apt-get install swig libssl-dev python-dev libusb-1.0-0pip install flaskpip install https://pypi.python.org/packages/source/M/M2Crypto/M2Crypto-0.24.0.tar.gzpip install firetv[firetv-server]firetv-server -d <fire tv device IP>:5555, background the process{
+"devices": {
+"default": {
+ "host": "192.168.1.153:5555",
+ "state": "play"
+}
+}
+}
+"default" above is the device name you will need to use for your configuration.yamlTo add FireTV to your installation, Note your device name, and add the following to your configuration.yaml file:
# Example configuration.yaml entry
+media_player:
+ - platform: firetv
+Configuration variables:
+ +firetv-server is running. Default is localhost.firetv-server is running. Default is 5556.default.
+Note that python-firetv has support for multiple Amazon Fire TV devices. If you have more than one configured, be sure to specify the device ID in device. Run firetv-server -h and/or view the source for complete capabilities.
+
The gpmdp media player platform allows you to control a GPMDP instance running on a computer from Home Assistant.
You will have first have to check “Enable playback API” in GPMDP’s settings and then add an inbound rule to the firewall to allow access to port 5672 on the computer running GPMDP.
+ +Then just add the following to your configuration.yaml file:
# Example configuration.yaml entry
+media_player:
+ - platform: gpmdp
+ host: IP_ADDRESS
+Configuration variables:
+ +The iTunes platform allows you to control iTunes from Home Assistant. It uses a 3rd party server that you run on your Mac called itunes-api. Play, pause, or skip songs remotely on iTunes running on your Mac.
+ +In addition to controlling iTunes, your available AirPlay endpoints will be added as media players as well. You can then individually address them append turn them on, turn them off, or adjust their volume.
+ +To add iTunes to your installation, add the following to your configuration.yaml file:
# Example configuration.yaml entry
+media_player:
+ - platform: itunes
+ host: http://192.168.1.50
+Configuration variables:
+ +The kodi platform allows you to control a Kodi multimedia system from Home Assistant.
To add Kodi to your installation, add the following to your configuration.yaml file:
# Example configuration.yaml entry
+media_player:
+ - platform: kodi
+ host: http://192.168.0.123
+Configuration variables:
+ +none, quit, hibernate, suspend, reboot, or shutdown. Default none.The lg_netcast platform allows you to control a LG Smart TV running NetCast 3.0 (LG Smart TV models released in 2012) and NetCast 4.0 (LG Smart TV models released in 2013). For the new LG WebOS TV’s use the webostv platform.
To add a LG TV to your installation, add the following to your configuration.yaml file:
# Example configuration.yaml entry
+media_player:
+ - platform: lg_netcast
+ host: 192.168.0.20
+Configuration variables:
+ +To get the access token for your TV configure the lg_netcast platform in Home Assistant without the access_token.
+After starting Home Assistant the TV will display the access token on screen.
+Just add the token to your configuration and restart Home Assistant and the media player component for your LG TV will show up.
+The access token will not change until you factory reset your TV. +
+ + + +The mpchc platform allows you to connect a Media Player Classic Home Cinema to Home Assistant. It will allow you to see the current playing item, and respond to changes in the player’s state.
For this component to function, you will need to enable the Web Interface in the MPC-HC options dialog.
+ +
+ 
+
If the server running Home Assistant is not the same device that is running MPC-HC, you will need to ensure that the allow access from localhost only option is not set.
+ ++The MPC-HC web interface is highly insecure, and allows remote clients full player control file-system access without authentication. Never allow access to the Web UI from outside of your trusted network, and if possible use a proxy script to restrict control or redact sensitive information. +
+ +To add MPC-HC to your installation, add the following to your configuration.yaml file:
# Example configuration.yaml entry
+media_player:
+ - platform: mpchc
+ host: http://192.168.0.123
+Configuration variables:
+ +The mpd platform allows you to control a Music Player Daemon from Home Assistant. Unfortunatly you will not be able to manipulate the playlist (add or delete songs) or add transitions between the songs.
Even though no playlist manipulation is possible, it is possible to use the play_media service to load an existing saved playlist as part of an automation or scene.
+ +To add MPD to your installation, add the following to your configuration.yaml file:
# Example configuration.yaml entry
+media_player:
+ - platform: mpd
+ host: IP_ADDRESS
+Configuration variables:
+ +Example script to load a saved playlist called “DeckMusic” and set the volume:
+ +relaxdeck:
+ sequence:
+ - service: media_player.play_media
+ data:
+ entity_id: media_player.main
+ media_content_type: playlist
+ media_content_id: DeckMusic
+
+ - service: media_player.volume_set
+ data:
+ entity_id: media_player.main
+ volume_level: 0.60
+This platform works with Music Player Daemon and mopidy with Mopidy-MPD as used by Pi MusicBox.
+ + + +The onkyo platform allows you to control a Onkyo receiver from Home Assistant.
To add an Onkyo receiver to your installation, add the following to your configuration.yaml file:
# Example configuration.yaml entry
+media_player:
+ - platform: onkyo
+ host: 192.168.1.2
+ name: receiver
+ sources:
+ pc: 'HTPC'
+Configuration variables:
+ +192.168.1.2. If not specified, the platform will load any discovered receivers.List of source names:
+ +The panasonic_viera platform allows you to control a Panasonic Viera TV.
Currently known supported models:
+ +If your model is not on the list then give it a test, if everything works correctly then add it to the list on GitHub.
+ +To add a TV to your installation, add the following to your configuration.yaml file:
# Example configuration.yaml entry
+media_player:
+ - platform: panasonic_viera
+ host: 192.168.0.10
+Configuration variables:
+ +192.168.0.10.55000.If you have a Pandora account, you can control it from Home Assistant with this media player.
+ +This media player uses the Pianobar command-line Pandora client, which you have to install separately. This can be done on a Raspberry Pi 2 with Raspbian Jesse as follows . (Note: Other platforms may have different installation processes)
+ +Install the following dependencies:
+ +$ sudo apt-get install git libao-dev libgcrypt11-dev libfaad-dev libmad0-dev libjson0-dev make pkg-config libav-tools libavcodec-extra libavcodec-dev libcurl4-openssl-dev libavfilter-dev libavformat-dev
+Now clone the Pianobar repo and build pianobar:
+ +$ git clone https://github.com/PromyLOPh/pianobar.git
+$ cd pianobar
+$ make clean && make
+$ sudo make install
+Configure Pianobar to auto-login and start playing a station (optional, see man pianobar) by creating and editing the ~/.config/pianobar/config file:
password = Password
+user = you@youraccount.com
+Test it out by running pianobar in the command line. You should be able to listen to your Pandora stations.
The Pandora player can be loaded by adding the following lines to your configuration.yaml:
# Example configuration.yaml entry
+media_player:
+ - platform: pandora
+That’s it! Now you will find a media player. If you click it you will find all your stations listed as different sources. If you switch to one, the station will begin playing.
+ +
+
+
The philips_js platform allows you to control Philips TVs which expose the jointSPACE API. Instructions on how to activate the API and if your model is supported can be found here.
To add your TV to your installation, add the following to your configuration.yaml file:
# Example configuration.yaml entry
+media_player:
+- name: NAME
+ platform: philips_js
+ host: 192.168.1.99
+Configuration variables:
+ +The pioneer platform allows you to control Pioneer Network Receivers.
To add a Pioneer receiver to your installation, add the following to your configuration.yaml file:
# Example configuration.yaml entry
+media_player:
+ - platform: pioneer
+ host: 192.168.0.10
+Configuration variables:
+ +192.168.0.1023 (default) or 8102Notes:
+ +timeout is a socket level option and should only be configured if you know what you are doing.The plex platform allows you to connect a Plex Media Server to Home Assistant. It will allow you to control media playback and see the current playing item. The preferred way to setup the Plex platform is by enabling the the the discovery component and requires GDM to be enabled.
If local authentication is enabled or multiple users are defined, Home Assistant requires an authentication token to be entered in the frontend. Press “CONFIGURE” to do it.
+ +
+ 
+
If you don’t know your token, see Finding your account token / X-Plex-Token.
+ +
+ 
+
If you want to enable the plex platform directly, add the following lines to your configuration.yaml:
# Example configuration.yaml entry
+media_player:
+ - platform: plex
+In case discovery does not work (GDM disabled or non-local plex server), you can create ~/.homeassistant/plex.conf manually.
{"IP_ADDRESS:PORT": {"token": "TOKEN"}}
+null (without quotes) otherwise.At this moment, the Plex platform only supports one Plex Media Server.
+ +It is possible to get errors that look like the following.
+ +ERROR:plexapi:http://192.168.1.10:32400: ('Connection aborted.', BadStatusLine("''",))
+INFO:homeassistant.components.media_player.plex:No server found at: http://192.168.1.10:32400
+If this occurs, try changing the setting Secure connections in your Plex Media Server to Preferred (instead of Required). The Plex component does not currently support HTTPS.
The Roku media players will be automatically discovered if you enable the discovery component.
+ +The roku media player platform can also be forced to load by adding the following lines to your configuration.yaml:
# Example configuration.yaml entry
+media_player:
+ - platform: roku
+Configuration variables:
+ +The russound_rnet platform allows you to control Russound devices that make use of the RNET protocol.
This has initially been tested against a Russound CAV6.6 unit with six zones and six sources.
+ +Connecting to the Russound device is only possible by TCP, you can make use of a TCP to Serial gateway such as tcp_serial_redirect
+ +To add a device to your installation, add the following to your configuration.yaml file:
# Example configuration.yaml entry
+media_player:
+ - platform: russound_rnet
+ host: 192.168.1.10
+ port: 1337
+ name: Russound
+ zones:
+ 1:
+ name: Main Bedroom
+ 2:
+ name: Living Room
+ 3:
+ name: Kitchen
+ 4:
+ name: Bathroom
+ 5:
+ name: Dining Room
+ 6:
+ name: Guest Bedroom
+ sources:
+ - name: Sonos
+ - name: Sky+
+Configuration variables:
+ +The samsungtv platform allows you to control a Samsung Smart TV.
When the TV is first connected, you will need to accept Home Assistant on the TV to allow communication.
+ +To add a TV to your installation, add the following to your configuration.yaml file:
# Example configuration.yaml entry
+media_player:
+ - platform: samsungtv
+ host: 192.168.0.10
+Configuration variables:
+ +Currently known supported models:
+ +Currently tested but not working models:
+ +If your model is not on the list then give it a test, if everything works correctly then add it to the list on GitHub. +The first letter (U, P, L, H & K) represent the screen type, e.g. LED or Plasma. The second letter represents the region, E is Europe, N is North America and A is Asia & Australia. The two numbers following that represent the screen size. +If you add your model remember to remove these before adding them to the list.
+ +There’s currently a known issue with some TV’s receiving a Key press UP that can interrupt certain applications.
+ + +The snapcast platform allows you to control Snapcast from Home Assistant.
To add Snapcast to your installation, add the following to your configuration.yaml file:
# Example configuration.yaml entry
+media_player:
+ - platform: snapcast
+ host: xxx.xxx.xxx.xxx
+Configuration variables:
+ +192.168.0.10.The sonos platform allows you to control your Sonos HiFi wireless speakers and audio components from Home Assistant. By default it supports auto-discovery provided by Home Assistant, and you don’t need to add anything to your configuration.yaml. Alternatively, there are some manual configuration options, listed as follows:
To add your Sonos components to your installation, add the following to your configuration.yaml file. It will perform Sonos auto-discovery of your connected speakers.
# Example configuration.yaml entry using Sonos discovery
+media_player:
+ - platform: sonos
+If you have multiple network devices, you can provide the IP address of the device that should be used for Sonos auto-discovery.
+ +# Example configuration.yaml entry using Sonos discovery on a specific interface
+media_player:
+ - platform: sonos
+ interface_addr: 192.0.2.1
+You can also specify one or more hosts to connect to if they cannot be found with Sonos auto-discovery.
+ +# Example configuration.yaml entry with manually specified addresses
+media_player:
+ - platform: sonos
+ hosts: 192.0.2.25
+or, for multiple hosts:
+ +# Example configuration.yaml entry with manually specified addresses
+media_player:
+ - platform: sonos
+ hosts:
+ - 192.0.2.25
+ - 192.0.2.26
+ - 192.0.2.27
+sonos_snapshotTake a snapshot of what is currently playing on one or more speakers. This service, and the following one, are useful if you want to play a doorbell or notification sound and resume playback afterwards. If no entity_id is provided, all speakers are snapshotted.
| Service data attribute | +Optional | +Description | +
|---|---|---|
entity_id |
+ no | +String or list of strings that point at entity_ids of coordinator speakers. |
+
sonos_restoreRestore a previosly taken snapshot of one or more speakers. If no entity_id is provided, all speakers are restored.
| Service data attribute | +Optional | +Description | +
|---|---|---|
entity_id |
+ no | +String or list of strings that point at entity_ids of coordinator speakers. |
+
sonos_group_playersGroup all players together under a single coordinator.
+ +| Service data attribute | +Optional | +Description | +
|---|---|---|
entity_id |
+ no | +String or list of a single entity_id that will become the coordinator speaker. |
+
sonos_unjoinRemove one or more speakers from a group of speakers. If no entity_id is provided, all speakers are unjoined.
| Service data attribute | +Optional | +Description | +
|---|---|---|
entity_id |
+ no | +String or list of entity_ids that will be separated from their coordinator speaker. |
+
sonos_set_sleep_timerSets a timer that will turn off a speaker by tapering the volume down to 0 after a certain amount of time. Protip: If you set the sleep_time value to 0, then the speaker will immediately start tapering the volume down.
+ +| Service data attribute | +Optional | +Description | +
|---|---|---|
entity_id |
+ no | +String or list of entity_ids that will have their timers set. Must be a coordinator speaker. |
+
sleep_time |
+ no | +Integer number of seconds that the speaker should wait until it starts tapering. Cannot exceed 86399 (one day). | +
sonos_clear_sleep_timerClear the sleep timer on a speaker, if one is set.
+ +| Service data attribute | +Optional | +Description | +
|---|---|---|
entity_id |
+ no | +String or list of entity_ids that will have their timers cleared. Must be a coordinator speaker. |
+
The squeezebox platform allows you to control a Logitech Squeezebox music player from Home Assistant. This lets you control Squeezebox hardware like the Classic, Transporter, Duet, Boom, Radio and Touch and of software players like SoftSqueeze, SqueezePlayer and SqueezeSlave.
To add your Squeezebox player to your installation, add the following to your configuration.yaml file:
# Example configuration.yaml entry
+media_player:
+ - platform: squeezebox
+ host: IP_ADDRESS
+Configuration variables:
+ +Universal Media Players combine multiple existing entities in Home Assistant into one media player entity. This is used for creating a single entity that controls an entire media center.
+ +Multiple Media Player entities can be controlled from a Universal Media Player. Additionally, the Universal Media Player allows volume and power commands to be re-routed to other entities in Home Assistant. This allows the power and volume to control external devices like a television or audio receiver.
+ +A Universal Media Player is created in configuration.yaml as follows.
# Example configuration.yaml entry
+media_player:
+ - platform: universal
+ name: MEDIA_PLAYER_NAME
+ children:
+ - media_player.CHILD_1_ID
+ - media_player.CHILD_2_ID
+ commands:
+ turn_on:
+ service: SERVICE
+ data: SERVICE_DATA
+ turn_off:
+ service: SERVICE
+ data: SERVICE_DATA
+ volume_up:
+ service: SERVICE
+ data: SERVICE_DATA
+ volume_down:
+ service: SERVICE
+ data: SERVICE_DATA
+ volume_mute:
+ service: SERVICE
+ data: SERVICE_DATA
+ attributes:
+ is_volume_muted: ENTITY_ID|ATTRIBUTE
+ state: ENTITY_ID|ATTRIBUTE
+Configuration variables:
+ +The universal media player will primarily imitate one of its children. The first child in the list that is active (not idle/off) will be controlled the universal media player. The universal media player will also inherit its state from the first active child. Entities in the children list must be media players.
+ +It is recommended that the command turn_on, the command turn_off, and the attribute state all be provided together. The state attribute indicates if the Media Player is on or off. If state indicates the media player is off, this status will take precedent over the states of the children. If all the children are idle/off and state is on, the universal media player’s state will be on.
+ +It is also recomended that the command volume_up, the command volume_down, the command volume_mute, and the attribute is_volume_muted all be provided together. The attribute is_volume_muted should return either True or the on state when the volume is muted. The volume_mute service should toggle the mute setting.
+ +Below is an example configuration.
+ +media_player:
+ platform: universal
+ name: Test Universal
+ children:
+ - media_player.living_room_cast
+ - media_player.living_room_kodi
+ commands:
+ turn_on:
+ service: switch.turn_on
+ data:
+ entity_id: switch.living_room_tv
+ turn_off:
+ service: switch.turn_off
+ data:
+ entity_id: switch.living_room_tv
+ volume_up:
+ service: switch.turn_on
+ data:
+ entity_id: switch.living_room_volume_up
+ volume_down:
+ service: switch.turn_on
+ data:
+ entity_id: switch.living_room_volume_down
+ volume_mute:
+ service: switch.turn_on
+ data:
+ entity_id: switch.living_room_mute
+ attributes:
+ state: switch.living_room_tv
+ is_volume_muted: switch.living_room_mute
+In this example, a switch is available to control the power of the television. Switches are also available to turn the volume up, turn the volume down, and mute the audio. These could be command line switches or any other entity in Home Assistant. The turn_on and turn_off commands will be redirected to the television and the volume commands will be redirected to an audio receiver.
+ +The children are a Chromecast and a Kodi player. If the Chromecast is playing, the Universal Media Player will reflect its status. If the Chromecast is idle and Kodi is playing, the Universal Media player will change to reflect its status.
+ + +The webostv platform allows you to control a LG WebOS Smart TV.
When the TV is first connected, you will need to accept Home Assistant on the TV to allow communication.
+ +To add a TV to your installation, add the following to your configuration.yaml file:
# Example configuration.yaml entry
+media_player:
+ - platform: webostv
+Configuration variables:
+ +If you do not provide a host name, all LG WebOS Smart TV’s within your network will be auto-discovered if your TV network name is set to [LG] webOS TV.
A full configuration example will look like the sample below:
+ +# Example configuration.yaml entry
+media_player:
+ - platform: webostv
+ host: 192.168.0.10
+ name: Living Room TV
+ customize:
+ sources:
+ - livetv
+ - youtube
+ - makotv
+The yamaha platform allows you to control Yamaha Network Receivers from Home Assistant.
Supported devices:
+ +To add a Yamaha Network Receiver to your installation, add the following to your configuration.yaml file:
# Example configuration.yaml entry
+media_player:
+ - platform: yamaha
+Configuration variables:
+ +HDMI1 to ChromeCastA few notes:
+ +A full configuration example will look like the sample below:
+# Example configuration.yaml entry
+media_player:
+ - platform: yamaha
+ host: 192.168.0.10
+ source_ignore:
+ - "AUX"
+ - "HDMI6"
+ source_names:
+ HDMI1: "ChromeCast"
+ AV4: "Vinyl"
+Interacts with media players on your network. Please check the sidebar for a full list of supported devices.
+ +Available services: turn_on, turn_off, toggle, volume_up, volume_down, media_play_pause, media_play, media_pause, media_stop, media_next_track, media_previous_track, clear_playlist
| Service data attribute | +Optional | +Description | +
|---|---|---|
entity_id |
+ yes | +Target a specific media player. Defaults to all. | +
media_player/volume_mute| Service data attribute | +Optional | +Description | +
|---|---|---|
entity_id |
+ yes | +Target a specific media player. Defaults to all. | +
is_volume_muted |
+ no | +True/false for mute/unmute | +
media_player/volume_set| Service data attribute | +Optional | +Description | +
|---|---|---|
entity_id |
+ yes | +Target a specific media player. Defaults to all. | +
volume_level |
+ no | +Integer for volume level | +
media_player/media_seek| Service data attribute | +Optional | +Description | +
|---|---|---|
entity_id |
+ yes | +Target a specific media player. Defaults to all. | +
seek_position |
+ no | +Position to seek to. The format is platform dependent. | +
media_player/play_media| Service data attribute | +Optional | +Description | +
|---|---|---|
entity_id |
+ yes | +Target a specific media player. Defaults to all. | +
media_content_id |
+ no | +A media identifier. The format of this is component dependent. For example, you can provide URLs to Sonos and Cast but only a playlist ID to iTunes. | +
media_content_type |
+ no | +A media type. Must be one of MUSIC, TVSHOW, VIDEO, EPISODE, CHANNEL or PLAYLIST. For example, to play music you would set media_content_type to MUSIC. |
+
The mochad component is the main component to integrate all X10 platforms being controlled by mochad. Besides this component you will have to setup your X10 devices separately.
To integrate your Mochad units with Home Assistant, add the following section to your configuration.yaml file:
# Example configuration.yaml entry
+mochad:
+Configuration variables:
+ +localhost.1099.A full configuration sample could look like the one below:
+ +# Example configuration.yaml entry
+mochad:
+ host: localhost
+ port: 1099
+Modbus is a serial communication protocol to control PLCs (Programmable logic controller). It currently supports sensors and switches which can be controlled over serial, TCP, and UDP connections.
+ +To add modbus to your installation, add the following to your configuration.yaml file:
For a network connection:
+ +# Example configuration.yaml entry for a TCP connection
+modbus:
+ type: tcp
+ host: IP_ADDRESS
+ port: 2020
+Configuration variables:
+ +For a serial connection:
+ +# Example configuration.yaml entry for a serial connection
+modbus:
+ type: serial
+ method: rtu
+ port: /dev/ttyUSB0
+ baudrate: 9600
+ stopbits: 1
+ bytesize: 8
+ parity: N
+Configuration variables:
+ +| Service | +Description | +
|---|---|
| write_register | +Write register. Requires unit, address and value fields. value can be either single value or an array |
+
MQTT (aka MQ Telemetry Transport) is a machine-to-machine or “Internet of Things” connectivity protocol on top of TCP/IP. It allows extremely lightweight publish/subscribe messaging transport.
+ +To integrate MQTT into Home Assistant, add the following section to your configuration.yaml file:
# Example configuration.yaml entry
+mqtt:
+ broker: IP_ADDRESS_BROKER
+ port: 1883
+ client_id: home-assistant-1
+ keepalive: 60
+ username: USERNAME
+ password: PASSWORD
+ certificate: /home/paulus/dev/addtrustexternalcaroot.crt
+ protocol: 3.1
+Configuration variables:
+ +/home/user/identrust-root.pem/home/user/owntracks/cookie.key)/home/user/owntracks/cookie.crt)The MQTT component needs you to run an MQTT broker for Home Assistant to connect to. There are four options, each with various degrees of ease of setup and privacy.
+ +Home Assistant contains an embedded MQTT broker. If no broker configuration is given, the HBMQTT broker is started and Home Assistant connects to it. Embedded broker default configuration:
+ +| Setting | +Value | +
|---|---|
| Host | +localhost | +
| Port | +1883 | +
| Protocol | +3.1.1 | +
| User | +homeassistant | +
| Password | +Your API password | +
| Websocket port | +8080 | +
# Example configuration.yaml entry
+mqtt:
++This broker does not currently work with OwnTracks because of a protocol version issue. +
+ +If you want to customize the settings of the embedded broker, use embedded: and the values shown in the HBMQTT Broker configuration. This will replace the default configuration.
# Example configuration.yaml entry
+mqtt:
+ embedded:
+ # Your HBMQTT config here. Example at:
+ # http://hbmqtt.readthedocs.org/en/latest/references/broker.html#broker-configuration
+This is the most private option but requires a bit more work. There are two free and open-source brokers to pick from: Mosquitto and Mosca.
+ +# Example configuration.yaml entry
+mqtt:
+ broker: 192.168.1.100
+ port: 1883
+ client_id: home-assistant-1
+ keepalive: 60
+ username: USERNAME
+ password: PASSWORD
+
+There is an issue with the Mosquitto package included in Ubuntu 14.04 LTS. Specify protocol: 3.1 in your MQTT configuration to work around this issue.
+
The Mosquitto project runs a public broker. This is the easiest to set up, but there is no privacy as all messages are public. Use this only for testing purposes and not for real tracking of your devices.
+ +mqtt:
+ broker: test.mosquitto.org
+ port: 1883
+
+ # Optional, replace port 1883 with following if you want encryption
+ # (doesn't really matter because broker is public)
+ port: 8883
+ # Download certificate from http://test.mosquitto.org/ssl/mosquitto.org.crt
+ certificate: /home/paulus/downloads/mosquitto.org.crt
+CloudMQTT is a hosted private MQTT instance that is free for up to 10 connected devices. This is enough to get started with for example OwnTracks and give you a taste of what is possible.
+ ++Home Assistant is not affiliated with CloudMQTT nor will receive any kickbacks. +
+ +#, check ‘read access’ and ‘write access’mqtt:
+ broker: <Server>
+ port: <SSL Port>
+ username: <User>
+ password: <Password>
++Home Assistant will automatically load the correct certificate if you connect to an encrypted channel of CloudMQTT (port range 20 000 - 30 000). +
+ +The MQTT component will register the service publish which allows publishing messages to MQTT topics. There are two ways of specifying your payload. You can either use payload to hard-code a payload or use payload_template to specify a template that will be rendered to generate the payload.
{
+ "topic": "home-assistant/light/1/command",
+ "payload": "on"
+}
+{
+ "topic": "home-assistant/light/1/state",
+ "payload_template": "{{ states('device_tracker.paulus') }}"
+}
+The logger component allow the logging of received MQTT messages.
+ +# Example configuration.yaml entry
+logger:
+ default: warning
+ logs:
+ homeassistant.components.device_tracker.mqtt: debug
+The mosquitto broker package ships commandline tools to send and recieve MQTT messages. As an alternative have a look at hbmqtt_pub and hbmqtt_sub which are provied by HBMQTT. For sending test messages to a broker running on localhost check the example below:
$ mosquitto_pub -h 127.0.0.1 -t home-assistant/switch/1/on -m "Switch is ON"
+If you are using the embedded MQTT broker, the command looks a little different because you need to add the MQTT protocol version.
+ +$ mosquitto_pub -V mqttv311 -t "hello" -m world
+or if you are using a API password:
+ +$ mosquitto_pub -V mqttv311 -u homeassistant -P <your api password> -t "hello" -m world
+Another way to send MQTT messages by hand is to use the “Developer Tools” in the Frontend. Choose “Call Service” and then mqtt/mqtt_send under “Available Services”. Enter something similar to the example below into the “Service Data” field.
{
+ "topic":"home-assistant/switch/1/on",
+ "payload":"Switch is ON"
+}
+The message should appear on the bus:
+ +... [homeassistant] Bus:Handling <Event MQTT_MESSAGE_RECEIVED[L]: topic=home-assistant/switch/1/on, qos=0, payload=Switch is ON>
+For reading all messages sent on the topic home-assistant to a broker running on localhost:
$ mosquitto_sub -h 127.0.0.1 -v -t "home-assistant/#"
+For the embedded MQTT broker the command looks like:
+ +$ mosquitto_sub -v -V mqttv311 -t "#"
+Add the username homeassistant and your API password if needed.
The MQTT switch and sensor platforms support processing JSON over MQTT messages and parsing them using JSONPath. JSONPath allows you to specify where in the JSON the value resides that you want to use. The following examples will always return the value 100.
| JSONPath query | +JSON | +
|---|---|
somekey |
+ { 'somekey': 100 } |
+
somekey[0] |
+ { 'somekey': [100] } |
+
somekey[0].value |
+ { 'somekey': [ { value: 100 } ] } |
+
To use this, add the following key to your configuration.yaml:
switch:
+ platform: mqtt
+ state_format: 'json:somekey[0].value'
+More information about the full JSONPath syntax can be found here.
+ + + +The mqtt_eventstream components connects two Home Assistant instances via MQTT.
To integrate MQTT Eventstream into Home Assistant, add the following section to your configuration.yaml file:
# Example configuration.yaml entry
+mqtt_eventstream:
+ publish_topic: MyServerName
+ subscribe_topic: OtherHaServerName
+Configuration variables:
+ +The MySensors project combines Arduino boards with NRF24L01 radio boards to build sensor networks. The component will automatically add all available devices to Home Assistant, after presentation is done.
+ +Integrate your Serial, Ethernet or MQTT Client MySensors Gateway by adding the following to your configuration.yaml file:
# Example configuration.yaml entry
+mysensors:
+ gateways:
+ - device: '/dev/ttyUSB0'
+ persistence_file: 'path/mysensors.json'
+ baud_rate: 38400
+ - device: '/dev/ttyACM0'
+ persistence_file: 'path/mysensors2.json'
+ baud_rate: 115200
+ - device: '192.168.1.18'
+ persistence_file: 'path/mysensors3.json'
+ tcp_port: 5003
+ - device: mqtt
+ persistence_file: 'path/mysensors4.json'
+ topic_in_prefix: 'mygateway1-out'
+ topic_out_prefix: 'mygateway1-in'
+ debug: true
+ optimistic: false
+ persistence: true
+ retain: true
+ version: 2.0
+Configuration variables:
+ +mqtt to setup the MQTT gateway. Resolving DNS addresses is theoretically supported but not tested.+Not all features of MySensors 2.0 are yet supported by Home Assistant. As more features are added, they will be described here in the documentation. Go to the MySensors platform pages under “related components” to see what message types are currently supported. +
+ +If you are using an original Arduino as a serial gateway, the port will be named ttyACM*. The exact number can be determined with the command shown below.
$ ls /dev/ttyACM*
+If using the MQTT gateway, you also need to have the MQTT component configured in Home Assistant. See below for a minimum MQTT configuration:
+ +mqtt:
+ client_id: home-assistant-1
++The MQTT gateway requires MySensors version 2.0 and only the MQTT client gateway is supported. +
+ +Present a MySensors sensor or actuator, by following these steps:
+ +configuration.yaml./*
+ * Documentation: http://www.mysensors.org
+ * Support Forum: http://forum.mysensors.org
+ *
+ * http://www.mysensors.org/build/relay
+ */
+
+#define MY_DEBUG
+#define MY_RADIO_NRF24
+#define MY_REPEATER_FEATURE
+#define MY_NODE_ID 1
+#include <SPI.h>
+#include <MySensors.h>
+#include <Bounce2.h>
+
+#define RELAY_PIN 5
+#define BUTTON_PIN 3
+#define CHILD_ID 1
+#define RELAY_ON 1
+#define RELAY_OFF 0
+
+Bounce debouncer = Bounce();
+bool state = false;
+bool initialValueSent = false;
+
+MyMessage msg(CHILD_ID, V_STATUS);
+
+void setup()
+{
+ pinMode(BUTTON_PIN, INPUT_PULLUP);
+ debouncer.attach(BUTTON_PIN);
+ debouncer.interval(10);
+
+ // Make sure relays are off when starting up
+ digitalWrite(RELAY_PIN, RELAY_OFF);
+ pinMode(RELAY_PIN, OUTPUT);
+}
+
+void presentation() {
+ sendSketchInfo("Relay+button", "1.0");
+ present(CHILD_ID, S_BINARY);
+}
+
+void loop()
+{
+ if (!initialValueSent) {
+ Serial.println("Sending initial value");
+ send(msg.set(state?RELAY_ON:RELAY_OFF));
+ Serial.println("Requesting initial value from controller");
+ request(CHILD_ID, V_STATUS);
+ wait(2000, C_SET, V_STATUS);
+ }
+ if (debouncer.update()) {
+ if (debouncer.read()==LOW) {
+ state = !state;
+ // Send new state and request ack back
+ send(msg.set(state?RELAY_ON:RELAY_OFF), true);
+ }
+ }
+}
+
+void receive(const MyMessage &message) {
+ if (message.isAck()) {
+ Serial.println("This is an ack from gateway");
+ }
+
+ if (message.type == V_STATUS) {
+ if (!initialValueSent) {
+ Serial.println("Receiving initial value from controller");
+ initialValueSent = true;
+ }
+ // Change relay state
+ state = (bool)message.getInt();
+ digitalWrite(RELAY_PIN, state?RELAY_ON:RELAY_OFF);
+ send(msg.set(state?RELAY_ON:RELAY_OFF));
+ }
+}
+Visit the library api of MySensors for more information.
+ + + +The Nest component is the main component to integrate all Nest related platforms. Besides this component you will have to setup your thermostat and any connected sensors separately.
+ +# Example configuration.yaml entry
+nest:
+ username: USERNAME
+ password: PASSWORD
+
+climate:
+ platform: nest
+# Example configuration.yaml entry to show only devices at your vacation home
+nest:
+ username: USERNAME
+ password: PASSWORD
+ structure: Vacation
+
+climate:
+ platform: nest
+# Example configuration.yaml entry to show only devices at your vacation and primary homes
+nest:
+ username: USERNAME
+ password: PASSWORD
+ structure:
+ - Vacation
+ - Primary
+
+climate:
+ platform: nest
+Configuration variables:
+ +The netatmo component platform is the main component to integrate all Netatmo related platforms.
To enable the Netatmo component, add the following lines to your configuration.yaml:
# Example configuration.yaml entry
+netatmo:
+ api_key: YOUR_API_KEY
+ secret_key: YOUR_SECRET_KEY
+ username: YOUR_USERNAME
+ password: YOUR_PASSWORD
+Configuration variables:
+ +To get your API credentials, you have to declare a new application in the NetAtmo Developer Page. Sign in using your username and password from your regular NetAtmo account. +Click on ‘Create an App’ at the top of the page.
+ +
+
+
You have to fill the form, but only two fields are required : Name and Description. It doesn’t really matter what you put into those. Just write something that make sense to you. To submit your new app, click on create at the bottom of the form.
+ +
+
+
That’s it. You can copy and paste your new API and secret keys in your Home Assistant configuration file just as said above.
+ +
+
+
+The Home Assistant Netatmo platform has only be tested with the classic indoor, outdoor module and rainmeter. There is no support for the windmeter module at this time because developers does not own these modules. +
+ + +The apns platform uses the Apple Push Notification service (APNS) to deliver notifications from Home Assistant.
To use the APNS service you will need an Apple developer account and you will need to create an App to receive push notifications. For more information see the apple developer documentation.
+ +# Example configuration.yaml entry
+notify:
+ name: NOTIFIER_NAME
+ platform: apns
+ cert_file: cert_file.pem
+Configuration variables:
+ +notify.NOTIFIER_NAME.The APNS platform will register two services, notify.NOTIFIER_NAME and apns.NOTIFIER_NAME.
This service will register device id’s with home assistant. In order to receive a notification a device must be registered. The app on the device can use this service to send an ID to Home Assistant during startup, the ID will be stored in [NOTIFIER_NAME]_apns.yaml.
See didRegisterForRemoteNotificationsWithDeviceToken in the Apple developer documentation for more information about how to obtain a device id.
+ +This service will send messages to a registered device. The following parameters can be used:
+ +message: The message to send
+target: The desired state of the device, only devices that match the state will receive messages. To enable state tracking a registered device must have a tracking_device_id attribute added to the [NOTIFIER_NAME]_apns.yaml file. If this ID matches a device in known_devices.yaml the device state will be tracked.
data:
+The aws_lambda notification platform enables invoking AWS Lambda functions.
To use this notification platform in your installation, add the following to your configuration.yaml file:
# Example configuration.yaml entry
+notify:
+ - name: NOTIFIER_NAME
+ platform: aws_lambda
+ aws_access_key_id: AWS_ACCESS_KEY_ID
+ aws_secret_access_key: AWS_SECRET_ACCESS_KEY
+ region_name: 'us-east-1'
+Configuration variables:
+ +aws_secret_access_key and must not provide a profile_name.aws_access_key_id and must not provide a profile_name.us-east-1.name allows multiple notifiers to be created. The default value is notify. The notifier will bind to the service notify.NOTIFIER_NAME.context dictionary (if any) is combined with the same data available at the /api/config HTTP API route.AWS Lambda is a notify platform and thus can be controlled by calling the notify service as described here. It will invoke a Lambda for all targets given in the notification payload. A target can be formatted as a function name, an entire ARN (Amazon Resource Name) or a partial ARN. For more information, please see the boto3 docs.
+ +The Lambda event payload will contain everything passed in the service call payload. Here is an example payload that would be sent to Lambda:
+ +{
+ "title": "Test message!",
+ "target": "arn:aws:lambda:us-east-1:123456789012:function:ProcessKinesisRecords",
+ "data": {
+ "test": "okay"
+ },
+ "message": "Hello world!"
+}
+The context will look like this:
+ +{
+ "hass": {
+ "components": ["recorder", "logger", "http", "logbook", "api", "frontend"],
+ "latitude": 44.1234,
+ "location_name": "Home",
+ "longitude": 5.5678,
+ "unit_system": "metric",
+ "time_zone": "Europe/Zurich",
+ "version": "0.20.0.dev0"
+ },
+ "custom": {
+ "two": "three",
+ "test": "one"
+ }
+}
+The aws_sns notification platform enables publishing to an AWS SNS topic or application.
To use this notification platform in your installation, add the following to your configuration.yaml file:
# Example configuration.yaml entry
+notify:
+ - name: NOTIFIER_NAME
+ platform: aws_sns
+ aws_access_key_id: AWS_ACCESS_KEY_ID
+ aws_secret_access_key: AWS_SECRET_ACCESS_KEY
+ region_name: 'us-east-1'
+Configuration variables:
+ +aws_secret_access_key and must not provide a profile_name.aws_access_key_id and must not provide a profile_name.us-east-1.name allows multiple notifiers to be created. The default value is notify. The notifier will bind to the service notify.NOTIFIER_NAME.AWS SNS is a notify platform and thus can be controlled by calling the notify service as described here. It will publish a message to all targets given in the notification payload. A target must be a SNS topic or endpoint ARN (Amazon Resource Name). For more information, please see the boto3 docs.
+ +If one exists, the SNS Subject will be set to the title. All attributes from the payload except message will be sent as stringified message attributes.
+ ++ If you do not download them you will lose them and will have to recreate a new user. +
+ +configuration.yaml file respectively.The aws_sqs notification platform enables publishing to an AWS SQS message queue.
To use this notification platform in your installation, add the following to your configuration.yaml file:
# Example configuration.yaml entry
+notify:
+ - name: NOTIFIER_NAME
+ platform: aws_sqs
+ aws_access_key_id: AWS_ACCESS_KEY_ID
+ aws_secret_access_key: AWS_SECRET_ACCESS_KEY
+ region_name: 'us-east-1'
+Configuration variables:
+ +aws_secret_access_key and must not provide a profile_name.aws_access_key_id and must not provide a profile_name.us-east-1.name allows multiple notifiers to be created. The default value is notify. The notifier will bind to the service notify.NOTIFIER_NAME.AWS SQS is a notify platform and thus can be controlled by calling the notify service as described here. It will publish a message to the queue for all targets given in the notification payload. A target must be a SQS topic URL. For more information, please see the SQS docs.
+ +The SQS event payload will contain everything passed in the service call payload. SQS payloads will be published as stringified JSON. All attributes from the payload except message will also be sent as stringified message attributes. Here is an example message that would be published to the SQS queue:
+ +{
+ "title": "Test message!",
+ "target": "http://sqs.us-east-1.amazonaws.com/123456789012/queue2",
+ "data": {
+ "test": "okay"
+ },
+ "message": "Hello world!"
+}
+The command_line platform allows you to use external tools for notifications from Home Assistant. The message will be passed in as STDIN.
To enable those notifications in your installation, add the following to your configuration.yaml file:
# Example configuration.yaml entry
+notify:
+ - name: NOTIFIER_NAME
+ platform: command_line
+ command: "espeak -vmb/mb-us1"
+Configuration variables:
+ +name allows multiple notifiers to be created. The default value is notify. The notifier will bind to the service notify.NOTIFIER_NAME.To use notifications, please see the getting started with automation page.
+ + +To get your Ecobee notifications working with Home Assistant, you must first have the main Ecobee component loaded and running. Once you have that configured, you can setup this component to send messages to your Ecobee device.
+ +To use this notification platform in your installation, add the following to your configuration.yaml file:
# Example configuration.yaml entry
+notify:
+ - name: NOTIFIER_NAME
+ platform: ecobee
+Configuration variables:
+ +name allows multiple notifiers to be created. The default value is notify. The notifier will bind to the service notify.NOTIFIER_NAME.To use notifications, please see the getting started with automation page.
+ + + +The file platform allows you to store notifications from Home Assistant as a file.
To enable file notifications in your installation, add the following to your configuration.yaml file:
# Example configuration.yaml entry
+notify:
+ - name: NOTIFIER_NAME
+ platform: file
+ filename: FILENAME
+Configuration variables:
+ +name allows multiple notifiers to be created. The default value is notify. The notifier will bind to the service notify.NOTIFIER_NAME.config/ folder.timestamp to True adds a timestamp to every entry.To use notifications, please see the getting started with automation page.
+ + +The free_mobile platform is using the French mobile operator Free Mobile to send SMS to your own cell phone.
Before doing anything, you have to activate the SMS API option in your Free Mobile account (In “Gérer mon compte -> Mes Options”). Activating this option will automatically generate a token which is required in your configuration.
+ +
+
+
This API only send classic SMS and only on the cell phone of the account owner. So you only have to provide a text message in your payload.
+ ++If you disable and re-enable the SMS API option, please be sure to update your token in your configuration. +
+ +To enable SMS notifications in your installation, add the following to your configuration.yaml file:
# Example configuration.yaml entry
+notify:
+ - name: NOTIFIER_NAME
+ platform: free_mobile
+ username: YOUR_ACCOUNT_ID
+ access_token: TOKEN
+Configuration variables:
+ +GNTP is a specification for sending and receiving notifications between computers. The most well known server implementations are Growl for Mac and Growl for Windows.
+ +To use GNTP notifications, add the following to your configuration.yaml file:
# Example configuration.yaml entry
+notify:
+ - name: NOTIFER_NAME
+ platform: gntp
+GNTP will attempt to connect to a local server running on port 23053 if no hostname is provided.
Configuration variables:
+ +name allows multiple notifiers to be created. The default value is notify. The notifier will bind to the service notify.NOTIFIER_NAME.file:// URL. File URLs only work if Home Assistant and the GNTP server are running on the same machine. If no app_icon is set a local copy of the Home Assistant logo will be used. If you choose to use a HTTP URL please make the maximum image size 150 px by 150 px as Growl for Mac will sometimes timeout when registering.port is provided here just in case.The group notification platform allows you to combine multiple notify platforms into a single service.
To use this notification platform in your installation, add the following to your configuration.yaml file:
# Example configuration.yaml entry
+notify:
+ - name: NOTIFIER_NAME
+ platform: group
+ services:
+ - service: html5
+ data:
+ target: "macbook"
+ - service: html5_nexus
+Configuration variables:
+ +name sets the name of the group.notify.html5 normally, just put html5.data, message, target, title.The html5 notification platform enables you to receive push notifications to Chrome or Firefox, no matter where you are in the world. html5 also supports Chrome and Firefox on Android, which enables native-app-like integrations without actually needing a native app.
To enable this platform, add the following lines to your configuration.yaml file:
# Example configuration.yaml entry
+notify:
+ - name: NOTIFIER_NAME
+ platform: html5
+ gcm_api_key: 'gcm-sender-key'
+ gcm_sender_id: 'gcm-sender-id'
+Configuration variables:
+ +name allows multiple notifiers to be created. The default value is notify. The notifier will bind to the service notify.NOTIFIER_NAME.Create new project at https://console.cloud.google.com/home/dashboard +Go to https://console.cloud.google.com/apis/credentials/domainverification and verify your domain +After that, go to https://console.firebase.google.com and select import Google project, select the project you created +Then, click the clogwheel on top left and select Project settings +Select Cloud messaging tab +if under server key is button Regenerate key, click that
+ +The html5 platform can only function if all of the following requirements are met:
Assuming you have already added the platform to your configuration:
+ +html5_push_registrations.conf file in your configuration directory. You will see a new entry for the browser you just added. Rename it from unnamed device to a name of your choice, which will make it easier to identify later. Do not change anything else in this file! You need to restart Home Assistant after making any changes to the file.The html5 platform accepts a standard notify payload. However, there are also some special features built in which you can control in the payload.
Chrome supports notification actions, which are configurable buttons that arrive with the notification and can cause actions on Home Assistant to happen when pressed. You can send up to 2 actions.
+ +{
+ "message": "Anne has arrived home",
+ "data": {
+ "actions": [
+ {
+ "action": "open",
+ "icon": "/static/icons/favicon-192x192.png",
+ "title": "Open Home Assistant"
+ },
+ {
+ "action": "open_door",
+ "title": "Open door"
+ }
+ ]
+ }
+}
+Any parameters that you pass in the notify payload that aren’t valid for use in the HTML5 notification (actions, badge, body, dir, icon, lang, renotify, requireInteraction, tag, timestamp, vibrate) will be sent back to you in the callback events.
{
+ "title": "Front door",
+ "message": "The front door is open",
+ "data": {
+ "my-custom-parameter": "front-door-open"
+ }
+}
+By default, every notification sent has a randomly generated UUID (v4) set as its tag or unique identifier. The tag is unique to the notification, not to a specific target. If you pass your own tag in the notify payload you can replace the notification by sending another notification with the same tag. You can provide a tag like so:
{
+ "title": "Front door",
+ "message": "The front door is open",
+ "data": {
+ "tag": "front-door-notification"
+ }
+}
+Example of adding a tag to your configuration. This won’t create new notification if there already exists one with the same tag.
+ + - alias: Push/update notification of sensor state with tag
+ trigger:
+ - platform: state
+ entity_id: sensor.sensor
+ action:
+ service: notify.html5
+ data_template:
+ message: "Last known sensor state is {{ states('sensor.sensor') }}."
+ data:
+ data:
+ tag: 'notification-about-sensor'
+If you do not provide a target parameter in the notify payload a notification will be sent to all registered targets as listed in html5_push_registrations.conf. You can provide a target parameter like so:
{
+ "title": "Front door",
+ "message": "The front door is open",
+ "target": "unnamed device"
+}
+target can also be a string array of targets like so:
{
+ "title": "Front door",
+ "message": "The front door is open",
+ "target": ["unnamed device", "unnamed device 2"]
+}
+You can pass any of the parameters listed here in the data dictionary. Please note, Chrome specifies that the maximum size for an icon is 320px by 320px, the maximum badge size is 96px by 96px and the maximum icon size for an action button is 128px by 128px.
You can provide a URL to open when the notification is clicked by putting url in the data dictionary like so:
{
+ "title": "Front door",
+ "message": "The front door is open",
+ "data": {
+ "url": "https://google.com"
+ }
+}
+If no URL or actions are provided, interacting with a notification will open your Home Assistant in the browser. You can use relative URLs to refer to Home Assistant, i.e. /map would turn into https://192.168.1.2:8123/map.
During the lifespan of a single push notification, Home Assistant will emit a few different events to the event bus which you can use to write automations against.
+ +Common event payload parameters are:
+ +| Parameter | +Description | +
|---|---|
action |
+ The action key that you set when sending the notification of the action clicked. Only appears in the clicked event. |
+
data |
+ The data dictionary you originally passed in the notify payload, minus any parameters that were added to the HTML5 notification (actions, badge, body, dir, icon, lang, renotify, requireInteraction, tag, timestamp, vibrate). |
+
tag |
+ The unique identifier of the notification. Can be overridden when sending a notification to allow for replacing existing notifications. | +
target |
+ The target that this notification callback describes. | +
type |
+ The type of event callback received. Can be received, clicked or closed. |
+
You can use the target parameter to write automations against a single target. For more granularity, use action and target together to write automations which will do specific things based on what target clicked an action.
You will receive an event named html5_notification.received when the notification is received on the device.
- alias: HTML5 push notification received and displayed on device
+ trigger:
+ platform: event
+ event_type: html5_notification.received
+You will receive an event named html5_notification.clicked when the notification or a notification action button is clicked. The action button clicked is available as action in the event_data.
- alias: HTML5 push notification clicked
+ trigger:
+ platform: event
+ event_type: html5_notification.clicked
+or
+ +- alias: HTML5 push notification action button clicked
+ trigger:
+ platform: event
+ event_type: html5_notification.clicked
+ event_data:
+ action: open_door
+You will receive an event named html5_notification.closed when the notification is closed.
- alias: HTML5 push notification clicked
+ trigger:
+ platform: event
+ event_type: html5_notification.closed
+The instapush platform uses Instapush to delivery notifications from Home Assistant to your Android or iOS device.
The Instapush Getting Started page will guide through the process of creating the required items.
+ +To add Instapush to your installation, add the following to your configuration.yaml file:
# Example configuration.yaml entry
+notify:
+ - name: NOTIFIER_NAME
+ platform: instapush
+ api_key: ABCDEFGHJKLMNOPQRSTUVXYZ
+ app_secret: ABCDEFGHJKLMNOPQRSTUVXYZ
+ event: ABCDEFGHJKLMNOPQRSTUVXYZ
+ tracker: ABCDEFGHJKLMNOPQRSTUVXYZ
+Configuration variables:
+ +name allows multiple notifiers to be created. The default value is notify. The notifier will bind to the service notify.NOTIFIER_NAME.To retrieve the needed values for existing settings, log into your account at https://instapush.im and go to your Dashboard. Then click the APPS tab, choose an app, and check the Basic Info section. The Application ID is the api_key and app_secret is the Application Secret.
Assuming that your setup looks look in the image below…
+ +
+ 
+
…then your entry for the configuration.yaml file needs to be like this sample.
notify:
+ platform: instapush
+ [...]
+ event: msg
+ tracker: state
+It’s easy to test your Instapush setup outside of Home Assistant. Assuming you have an event notification and a tracker home-assistant, just fire a request and check the Instapush dashboard for a new entry.
+ +curl -X POST \
+ -H "x-instapush-appid: YOUR_APP_KEY" \
+ -H "x-instapush-appsecret: YOUR_APP_SECRET" \
+ -H "Content-Type: application/json" \
+ -d '{"event":"notification","trackers":{"home-assistant":"Switch 1"}}' \
+ https://api.instapush.im/v1/post
+For further details, please check the API.
+ +To use notifications, please see the getting started with automation page.
+ + +See the Joaoapps Join component page for information how to get the join notify platform running.
+ + + +The Kodi platform allows you so send messages to your Kodi multimedia system from Home Assistant.
To add Kodi to your installation, add the following to your configuration.yaml file:
# Example configuration.yaml entry
+notify:
+ - name: NOTIFIER_NAME
+ platform: kodi
+ host: http://192.168.0.123
+notify.NOTIFIER_NAME.8080.kodi_notification:
+ sequence:
+ - service: notify.NOTIFIER_NAME
+ data:
+ title: "Home Assistant"
+ message: "Message to KODI from Home Assistant!"
+ data:
+ displaytime: 20000
+ icon: "warning"
+info, warning and error, an URL to an image is also valid. Defaults to info10000 msTo use notifications, please see the getting started with automation page.
+ + +The llamalab_automate platform uses Googles Cloud Messaging Services to push messages from Home Assistant to your Android device running the LlamaLab Automate app. This can serve as an alternative to Tasker + AutoRemote.
Go to https://llamalab.com/automate/cloud/ and create a new API key/secret.
+ +To add Automate to your installation, add the following to your configuration.yaml file:
# Example configuration.yaml entry
+notify:
+ - name: NOTIFIER_NAME
+ platform: llamalab_automate
+ api_key: ABCDEFGHJKLMNOPQRSTUVXYZ
+ to: example@gmail.com
+Configuration variables:
+ +name allows multiple notifiers to be created. The default value is notify. The notifier will bind to the service notify.NOTIFIER_NAME.Receiving cloud messages in Automate:
+ +If you have multiple devices paired to one Google Mail account and want to control each instance of Automate individually, you can set the notifier to target a specific device. To determine your devices name, add a Cloud Message send block to your flow, tap it and scroll all the way to the bottom. Device names are case sensitive.
+ + +The matrix platform allows you to deliver notifications from Home Assistant to a Matrix room. Rooms can be both direct as well as group chats.
To enable Matrix notifications in your installation, add the following to your configuration.yaml file:
# Example configuration.yaml entry
+notify:
+ - platform: matrix
+ homeserver: HOMESERVER
+ username: USERNAME
+ password: PASSWORD
+ default_room: ROOM_ID_OR_ALIAS
+Configuration variables:
+ +name allows multiple notifiers to be created. The default value is notify. The notifier will bind to the service notify.NOTIFIER_NAME.https://matrix.org).true.The target room has to be precreated, the room id can be obtained from the rooms settings dialog. Rooms by default have a canonical id of the form !<randomid>:homeserver.tld, but can also be allocated aliases like #roomname:homeserver.tld. The notifying account may need to be invited to the room, depending on the individual rooms policies.
To use notifications, please see the getting started with automation page.
+ + +The MessageBird notification platform sends notifications as SMS messages using MessageBird to your mobile phone.
To enable MessageBird notifications in your installation, add the following to your configuration.yaml file:
# Example configuration.yaml entry
+notify:
+ - name: NOTIFIER_NAME
+ platform: message_bird
+ api_key: YOUR_API_KEY
+Configuration variables:
+ +name allows multiple notifiers to be created. The default value is notify. The notifier will bind to the service notify.NOTIFIER_NAME.sender. This will be the sender of the SMS. It may be either a telephone number (e.g. +4915112345678) or a text with a maximum length of 11 characters. Defaults to HA.MessageBird is a notify platform and thus can be controlled by calling the notify service as described here. It will send a notification to the specified mobile phone number(s).
+ +{
+ "message": "A message for many people",
+ "target": [ "+49123456789", "+43123456789" ]
+}
+The MQTT notification support is different than the other notification platforms. It is a service. This means that you don’t have to create a configuration entry but you need to provide more details while calling the service.
+ +Call Service section from the Developer Tools allows you to send MQTT messages. Choose mqtt/publish from the list of Available services: and enter something like the sample below into the Service Data field and hit CALL SERVICE.
+ +{"payload": "Test message from HA", "topic": "home/notification", "qos": 0, "retain": 0}
+
+
+
Using the REST API to send a message to a given topic.
+ +$ curl -X POST -H "x-ha-access: YOUR_PASSWORD" \
+ -H "Content-Type: application/json" \
+ -d '{"payload": "Test message from HA", "topic": "home/notification"}' \
+ http://IP_ADDRESS:8123/api/services/mqtt/publish
+Notification platform for Notifications for Android TV and Notifications for FireTV. +The notifications are in the global scope of your Android TV device. They will be displayed regardless of which application is running. +The In-App purchases only apply to the client for Android smartphones, so there isn’t any limit when pushing notifications from HASS.
+ +To enable the notification platform, add the following to your configuration.yaml file:
# Example configuration.yaml entry
+notify:
+- platform: nfandroidtv
+ name: Kitchen
+ host: 192.168.1.12
+Configuration variables:
+ +name allows multiple notifiers to be created. The default value is notify. The notifier will bind to the service notify.NOTIFIER_NAME.The configuration will be used to configure the default values for the notification for the host specified by the IP. However, you can override most of the settings by passing them with the data-attribute when calling the service. +This is a fully customized JSON you can use to test how the final notification will look like:
+ +{
+"message": "Messagetext",
+"title": "My Notification",
+"data":{
+ "position":"center",
+ "duration":2,
+ "transparency":"0%",
+ "color": "red",
+ "interrupt": 1
+ }
+}
+The nma platform uses Notify My Android (NMA) to delivery notifications from Home Assistant to your Android device.
Go to the NMA website and create a new API key. If you are using the trial offer then keep in mind that your limit is five messages per day.
+ +To add NMA to your installation, add the following to your configuration.yaml file:
# Example configuration.yaml entry
+notify:
+ - name: NOTIFIER_NAME
+ platform: nma
+ api_key: ABCDEFGHJKLMNOPQRSTUVXYZ
+Configuration variables:
+ +name allows multiple notifiers to be created. The default value is notify. The notifier will bind to the service notify.NOTIFIER_NAME.Details for the API.
+ +To use notifications, please see the getting started with automation page.
+ + +The pushbullet notification platform sends messages to Pushbullet, a free service to send information between your phones, browsers, and friends.
To enable Pushbullet notifications in your installation, add the following to your configuration.yaml file:
# Example configuration.yaml entry
+notify:
+ - name: NOTIFIER_NAME
+ platform: pushbullet
+ api_key: YOUR_API_KEY
+Configuration variables:
+ +name allows multiple notifiers to be created. The default value is notify. The notifier will bind to the service notify.NOTIFIER_NAME.Pushbullet is a notify platform and thus can be controlled by calling the notify service as described here. It will send a notification to all devices registered in the Pushbullet account. An optional target parameter can be given to Pushbullet to specify specific account’s devices, contacts or channels.
+ +| Type | +Prefix | +Suffix | +Example | +
|---|---|---|---|
| Device | +device/ |
+ Device nickname | +device/iphone |
+
| Channel | +channel/ |
+ Channel tag | +channel/my_home |
+
email/ |
+ Contact’s email address | +email/email@example.com |
+
If using targets, your own account’s email address functions as ‘send to all devices’. All targets are verified (if exists) before sending, except email.
+ +{
+ "message": "A message for many people",
+ "target": [
+ "device/telephone",
+ "email/hello@example.com",
+ "channel/my_home"
+ ]
+}
+To use notifications, please see the getting started with automation page.
+ +...
+
+action:
+ service: notify.NOTIFIER_NAME
+ data:
+ title: Send URL
+ message: This is an url
+ data:
+ url: google.com
+The pushetta notify platform uses Pushetta to delivery notifications from Home Assistant to your devices.
To retrieve the API token, log into your account at http://www.pushetta.com and go to your Dashboard. Create a new channel by clicking on Channels and then Add a Channel.
+ +To enable Pushetta notifications in your installation, add the following to your configuration.yaml file:
# Example configuration.yaml entry
+notify:
+ - name: NOTIFIER_NAME
+ platform: pushetta
+ api_key: YOUR_API_KEY
+ channel_name: YOUR_CHANNEL_NAME
+Configuration variables:
+ +name allows multiple notifiers to be created. The default value is notify. The notifier will bind to the service notify.NOTIFIER_NAME.False.It’s easy to test your Pushetta setup outside of Home Assistant. Assuming you have a channel home-assistant, just fire a request and check the channel page in the dashboard for a new message.
+ +curl -X POST \
+ -H "Authorization: Token YOUR_API_KEY" \
+ -H "Content-Type: application/json" \
+ -d "{ \"body\" : \"Hello World\", \"message_type\" : \"text/plain\" }" \
+ http://api.pushetta.com/api/pushes/home-assistant/
+For further details, please check the API.
+ +To use notifications, please see the getting started with automation page.
+ + +The Pushover service is a platform for the notify component. This allows components to send messages to the user using Pushover.
+ +In order to get an API key you need to go to the Pushover website and register a new application. From the website you can also retrieve your user key.
+ +To use Pushover notifications, add the following to your configuration.yaml file:
# Example configuration.yaml entry
+notify:
+ - name: NOTIFIER_NAME
+ platform: pushover
+ api_key: ABCDEFGHJKLMNOPQRSTUVXYZ
+ user_key: ABCDEFGHJKLMNOPQRSTUVXYZ
+Configuration variables:
+ +name allows multiple notifiers to be created. The default value is notify. The notifier will bind to the service notify.NOTIFIER_NAME.This is a quote from the Pushover website regarding free/open source apps:
+ +++ +If you are creating a client-side library, application, or open source project that will be redistributed and installed by end-users, you may want to require each of your users to register their own application rather than including your own API token with the software.
+
When setting up the application you can use this icon.
+ +To use notifications, please see the getting started with automation page.
+ + +The rest notification platform allows you to deliver RESTful notifications from Home Assistant to another party.
To enable the REST notification in your installation, add the following to your configuration.yaml file:
# Example configuration.yaml entry
+notify:
+ - name: NOTIFIER_NAME
+ platform: rest
+ resource: http://IP_ADDRESS/ENDPOINT
+Configuration variables:
+ +name allows multiple notifiers to be created. The default value is notify. The notifier will bind to the service notify.NOTIFIER_NAME.message.To use notifications, please see the getting started with automation page.
+ + + +The sendgrid notification platform sends email notifications via SendGrid, a proven cloud-based email platform.
To enable notification emails via SendGrid in your installation, add the following to your configuration.yaml file:
# Example configuration.yaml entry
+notify:
+ - name: NOTIFIER_NAME
+ platform: sendgrid
+ api_key: API_KEY
+ sender: SENDER_EMAIL_ADDRESS
+ recipient: YOUR_RECIPIENT
+Configuration variables:
+ +name allows multiple notifiers to be created. The default value is notify. The notifier will bind to the service notify.NOTIFIER_NAME.To use notifications, please see the getting started with automation page.
+ + +The simplepush platform uses Simplepush to delivery notifications from Home Assistant to your Android device. Unlike similar apps the Simplepush app requires no registration.
To add Simplepush to your installation, add the following to your configuration.yaml file:
# Example configuration.yaml entry
+notify:
+ - name: NOTIFIER_NAME
+ platform: simplepush
+ device_key: ABCDE
+Configuration variables:
+ +name allows multiple notifiers to be created. The default value is notify. The notifier will bind to the service notify.NOTIFIER_NAME.To test if the service works, just send a message with curl from the command-line.
$ curl 'https://api.simplepush.io/send/device_key/title/message'
+To use notifications, please see the getting started with automation page.
+ + +The slack platform allows you to deliver notifications from Home Assistant to Slack.
If you are planning to use Slack as yourself then you need to obtain a Slack API token to be able to send notifications.
+ +It is also possible to use Slack bots as users. Just create a new bot at https://[YOUR_TEAM].slack.com/apps/build/custom-integration and use the provided token for that. You can add an icon from the frontend for Home Assistant and give the bot a meaningful name.
+ +Don’t forget to invite the bot to the room where you want to get the notifications.
+ +To enable the slack notification in your installation, add the following to your configuration.yaml file:
# Example configuration.yaml entry
+notify:
+ - name: NOTIFIER_NAME
+ platform: slack
+ api_key: ABCDEFGHJKLMNOPQRSTUVXYZ
+ default_channel: '#general'
+Configuration variables:
+ +name allows multiple notifiers to be created. The default value is notify. The notifier will bind to the service notify.NOTIFIER_NAME.To use notifications, please see the getting started with automation page.
+ + + +The smtp platform allows you to deliver notifications from Home Assistant to an e-mail recipient.
To enable notification by e-mail in your installation, add the following to your configuration.yaml file:
# Example configuration.yaml entry
+notify:
+ - name: NOTIFIER_NAME
+ platform: smtp
+ server: MAIL_SERVER
+ recipient: YOUR_RECIPIENT
+Configuration variables:
+ +name allows multiple notifiers to be created. The default value is notify. The notifier will bind to the service notify.NOTIFIER_NAME.localhost.A sample configuration entry for Google Mail.
+ +# Example configuration.yaml entry
+notify:
+ - name: NOTIFIER_NAME
+ platform: smtp
+ server: smtp.gmail.com
+ port: 587
+ sender: john@gmail.com
+ starttls: true
+ username: john@gmail.com
+ password: thePassword
+ recipient: james@gmail.com
+Keep in mind that Google has some extra layers of protection which need special attention (Hint: ‘Less secure apps’).
+ +To use the SMTP notification, refer to it in an automation or script like in this example:
+ + burglar:
+ alias: Burglar Alarm
+ sequence:
+ - service: shell_command.snapshot
+ - delay:
+ seconds: 1
+ - service: notify.NOTIFIER_NAME
+ data:
+ title: 'Intruder alert'
+ message: 'Intruder alert at apartment!!'
+ data:
+ images:
+ - /home/pi/snapshot1.jpg
+ - /home/pi/snapshot2.jpg
+The optional images field adds in-line image attachments to the email. This sends a text/HTML multi-part message instead of the plain text default.
This platform is fragile and not able to catch all exceptions in a smart way because of the large number of possible configuration combinations.
+ +A combination that will work properly is port 587 and STARTTLS. It’s recommended to enable STARTTLS, if possible.
+ +Keep in mind that if the password contains a colon, it needs to be wrapped in apostrophes in the configuration.yaml file.
For Google Mail (smtp.gmail.com) an additional step in the setup process is needed. Google has some extra layers of protection +which need special attention. By default, the usage by external applications, especially scripts, is limited. Visit the Less secure apps page and enable it.
+ +To use notifications, please see the getting started with automation page.
+ + +The syslog platform allows you to deliver notifications from Home Assistant to the local syslog.
To enable syslog notifications in your installation, add the following to your configuration.yaml file:
# Example configuration.yaml entry
+notify:
+ - name: NOTIFIER_NAME
+ platform: syslog
+Configuration variables:
+ +name allows multiple notifiers to be created. The default value is notify. The notifier will bind to the service notify.NOTIFIER_NAME.The table contains values to use in your configuration.yaml file.
| facility | +option | +priority | +
|---|---|---|
| kernel | +pid | +5 | +
| user | +cons | +4 | +
| ndelay | +3 | +|
| daemon | +nowait | +2 | +
| auth | +perror | +1 | +
| LPR | ++ | 0 | +
| news | ++ | -1 | +
| uucp | ++ | -2 | +
| cron | ++ | + |
| syslog | ++ | + |
| local0 | ++ | + |
| local1 | ++ | + |
| local2 | ++ | + |
| local3 | ++ | + |
| local4 | ++ | + |
| local5 | ++ | + |
| local6 | ++ | + |
| local7 | ++ | + |
For details about facility, option, and priority please consult the wikpedia article and RFC 3164.
+ +To use notifications, please see the getting started with automation page.
+ + +The telegram platform uses Telegram to delivery notifications from Home Assistant to your Android device, your Windows phone, or your iOS device.
The requirements are:
+ +chat_id of an user.The quickest way to retrieve your chat_id is visiting https://api.telegram.org/botYOUR_API_TOKEN/getUpdates or to use $ curl -X GET https://api.telegram.org/botYOUR_API_TOKEN/getUpdates. Replace YOUR_API_TOKEN with your actual token.
The result set will include your chat ID as id in the from section:
{"ok":true,"result":[{"update_id":254199982,
+"message":{"message_id":27,"from":{"id":123456789,"first_name":"YOUR_FIRST_NAME YOUR_NICK_NAME","last_name":"YOUR_LAST_NAME","username":"YOUR_NICK_NAME"},"chat":{"id":123456789,"first_name":"YOUR_FIRST_NAME YOUR_NICK_NAME","last_name":"YOUR_LAST_NAME","username":"YOUR_NICK_NAME","type":"private"},"date":1678292650,"text":"test"}}]}
+Another way to get your chat ID directly is described below. Start your Python interpreter from the command-line:
+ +$ python3
+>>> import telegram
+>>> bot = telegram.Bot(token='YOUR_API_TOKEN')
+>>> chat_id = bot.getUpdates()[-1].message.chat_id
+>>> print(chat_id)
+123456789
+To enable Telegram notifications in your installation, add the following to your configuration.yaml file:
# Example configuration.yaml entry
+notify:
+ - name: NOTIFIER_NAME
+ platform: telegram
+ api_key: ABCDEFGHJKLMNOPQRSTUVXYZ
+ chat_id: YOUR_CHAT_ID
+Configuration variables:
+ +name allows multiple notifiers to be created. The default value is notify. The notifier will bind to the service notify.NOTIFIER_NAME.To use notifications, please see the getting started with automation page.
+ +...
+action:
+ service: notify.NOTIFIER_NAME
+ data:
+ title: Send an images
+ message: That's a example that sends an image.
+ data:
+ photo:
+ - url: http://192.168.1.28/camera.jpg
+ username: admin
+ password: secrete
+ - file: /tmp/picture.jpg
+ caption: Picture Title xy
+ - url: http://somebla.ie/video.png
+ caption: I.e. for a Title
+...
+action:
+ service: notify.NOTIFIER_NAME
+ data:
+ title: Send a document
+ message: That's a example that sends a document.
+ data:
+ document:
+ file: /tmp/whatever.odf
+ caption: Picture Title xy
+
+...
+
+action:
+ service: notify.NOTIFIER_NAME
+ data:
+ title: Send location
+ message: Location updated.
+ data:
+ location:
+ latitude: 32.87336
+ longitude: 117.22743
+The telstra notification platform allows you to deliver Home Assistant notifications to Australian phone numbers over the Telstra SMS API.
To enable the Telstra notifications in your installation, you must first create an account and API app over at dev.telstra.com. The free tier allows for 1000 notifications to be sent per month.
+ +After your API app is approved, add the following to your configuration.yaml file:
# Example configuration.yaml entry
+notify:
+ name: NOTIFIER_NAME
+ platform: telstra
+ consumer_key: TELSTRA_API_CONSUMER_KEY_HERE
+ consumer_secret: TELSTRA_API_CONSUMER_SECRET_HERE
+ phone_number: SMS_RECIPIENT_PHONE_NUMBER_HERE
+Configuration variables:
+ +name allows multiple notifiers to be created. The default value is notify. The notifier will bind to the service notify.NOTIFIER_NAME.To use notifications, please see the getting started with automation page.
+ + +The twilio notification platform enables sending notifications via SMS, powered by Twilio.
To use this notification platform in your installation, add the following to your configuration.yaml file:
# Example configuration.yaml entry
+notify:
+ - name: NOTIFIER_NAME
+ platform: twilio_sms
+ account_sid: ACCOUNT_SID_FROM_TWILIO
+ auth_token: AUTH_TOKEN_FROM_TWILIO
+ from_number: E164_PHONE_NUMBER
+Configuration variables:
+ +AC.account_sid.name allows multiple notifiers to be created. The default value is notify. The notifier will bind to the service notify.NOTIFIER_NAME.Twilio is a notify platform and thus can be controlled by calling the notify service as described here. It will send a notification to all E.164 phone numbers in the notification target. See the notes above regarding the from_number configuration variable for information about formatting phone numbers.
# Example automation notification entry
+automation:
+ - alias: The sun has set
+ trigger:
+ platform: sun
+ event: sunset
+ action:
+ service: notify.twilio_sms
+ data:
+ message: 'The sun has set'
+ target:
+ - +14151234567
+ - +15105555555
+The twitter platform uses Twitter to delivery notifications from Home Assistant.
Go to Twitter Apps and create an application. Visit “Keys and Access Tokens” of the application to get the details (“Consumer Key”, “Consumer Secret”, “Access Token” and “Access Token Secret” which needs to be generated).
+ +To add Twitter to your installation, add the following to your configuration.yaml file:
# Example configuration.yaml entry
+notify:
+ - name: NOTIFIER_NAME
+ platform: twitter
+ consumer_key: ABCDEFGHJKLMNOPQRSTUVXYZ
+ consumer_secret: ABCDEFGHJKLMNOPQRSTUVXYZ
+ access_token: ABCDEFGHJKLMNOPQRSTUVXYZ
+ access_token_secret: ABCDEFGHJKLMNOPQRSTUVXYZ
+Configuration variables:
+ +name allows multiple notifiers to be created. The default value is notify. The notifier will bind to the service notify.NOTIFIER_NAME.To use notifications, please see the getting started with automation page.
+ + +The webostv platform allows you to send notifications to a LG WebOS Smart TV.
When the TV is first connected, you will need to accept Home Assistant on the TV to allow communication.
+ +To add a TV to your installation, add the following to your configuration.yaml file and follow the configurator instructions:
# Example configuration.yaml entry
+notify:
+ - platform: webostv
+ host: 192.168.0.112
+ name: livingroom_tv
+Configuration variables:
+ +A possible automation could be:
+ +# Example configuration.yaml entry
+automation:
+ - alias: Open a window
+ trigger:
+ platform: numeric_state
+ entity_id: sensor.netatmo_livingroom_co2
+ above: 999
+ action:
+ service: notify.livingroom_tv
+ data:
+ message: "You should open a window! (Livingroom Co2: ppm)"
+The xmpp platform allows you to deliver notifications from Home Assistant to a Jabber (XMPP) account.
To enable Jabber notifications in your installation, add the following to your configuration.yaml file:
# Example configuration.yaml entry
+notify:
+ - name: NOTIFIER_NAME
+ platform: xmpp
+ sender: YOUR_JID
+ password: YOUR_JABBER_ACCOUNT_PASSWORD
+ recipient: YOUR_RECIPIENT
+Configuration variables:
+ +name allows multiple notifiers to be created. The default value is notify. The notifier will bind to the service notify.NOTIFIER_NAME.true.All Jabber IDs (JID) must include the domain. Make sure that the password matches the account provided as sender.
+ +To use notifications, please see the getting started with automation page.
+ + +The notify component makes it possible to send notifications to a wide variety of platforms. Please check the sidebar for a full list of platforms that are supported.
# Example configuration.yaml entry
+notify:
+ - platform: pushbullet
+ name: paulus
+ api_key: ABCDEFG
+The name parameter is optional but needed if you want to use multiple platforms. The platform will be exposed as service notify/<name>. The name will default to notify if not supplied.
Once loaded, the notify platform will expose a service that can be called to send notifications.
| Service data attribute | +Optional | +Description | +
|---|---|---|
message |
+ no | +Body of the notification. | +
title |
+ yes | +Title of the notification. Default is Home Assistant. |
+
target |
+ yes | +Some platforms will allow specifying a recipient that will receive the notification. See your platform page if it is supported. | +
data |
+ yes | +On platforms who have extended functionality. See your platform page if it is supported. | +
The notification component supports specifying templates with data_template. This will allow you to use the current state of Home Assistant in your notifications.
In an action of your automation setup it could look like this with a customized subject.
+ +action:
+ service: notify.notify
+ data:
+ message: "Your message goes here"
+ title: "Custom subject"
+A simple way to test if you have set up your notify platform correctly is to use Services from the Developer Tools. Choose your service (notify/xyz) from the list of Available services: and enter something like the sample below into the Service Data field and hit CALL SERVICE.
{
+ "message": "The sun is {% if is_state('sun.sun', 'above_horizon') %}up{% else %}down{% endif %}!"
+}
+For services which have support for sending images.
+ +{ "message": "Test plugin",
+ "data": {
+ "photo": {
+ "url": "http://www.gbsun.de/gbpics/berge/berge106.jpg"
+ }
+ }
+}
+If the service support sending the location, the data from this sample can be used.
+ +{ "message": "Test plugin",
+ "data": {
+ "location": {
+ "latitude": 7.3284,
+ "longitude": 46.38234
+ }
+ }
+}
+The nuimo_controller component allows you to connect to a Nuimo device for receiving input events and displaying on the LED matrix via the Nuimo SDK for Python on Linux.
To connect to a Nuimo device add the following section to your configuration.yaml file:
# Example configuration.yaml entry
+nuimo_controller:
+Configuration variables:
+ +Example for testing rotation value and sending to the LED matrix:
+ +automation Nuimo_rotate_right:
+ trigger:
+ platform: event
+ event_type: nuimo_input
+ event_data:
+ type: ROTATE
+ condition:
+ condition: template
+ value_template: '{{ trigger.event.data.value > 100 }}'
+ action:
+ service: nuimo_controller.led_matrix
+ data:
+ matrix:
+ '........
+ 0000000.
+ .000000.
+ ..00000.
+ .0.0000.
+ .00.000.
+ .000000.
+ .000000.
+ ........ '
+ interval: 0.5
+Troubleshooting:
+ +use hcitool lescan to see the mac address of your device
allow non-root user access to Bluetooth LE with sudo setcap cap_net_raw+eip $(eval readlink -f $(which python))
install the newest version of pygattlib from the repository, either because there is no binary package for your system or the pip version contains errors, with pip install hg+https://bitbucket.org/OscarAcena/pygattlib --target $HOME/.homeassistant/deps.
+(Dependencies of pygattlib: sudo apt-get install pkg-config libboost-python-dev libboost-thread-dev libbluetooth-dev libglib2.0-dev python-dev)
+Then invoke home-assistant with hass --skip-pip.
OctoPrint is a web interface for your 3D printer. This is the main component to integrate OctoPrint sensors, you will have to setup sensors and binary sensors separately.
+ +To get started with the OctoPrint API, please follow the directions on their site. Once OctoPrint is configured you will need to add your API key and host to your configuration.yaml.
octoprint:
+ host: YOUR_OCTOPRINT_HOST
+ api_key: YOUR_API_KEY
+Configuration variables:
+ +NOTE If your 3D printer isn’t connected to the OctoPrint server during the startup of Home Assistant this component will fail to load.
+ + +OpenAlpr integration for Home Assistant allows you to process licences plates from a camera. You can use them to open a garage door or trigger any other automation.
+ ++If you want use a video stream. You need setup the ffmpeg component. See also there for troubleshooting local ffmpeg installation. +
+ +If you want process all data local you need the command line tool alpr in version > 2.3.1
If you don’t found binarys for you distribution you can compile from source. A documention how to build a openalpr is found here.
+ +On a debian system you can use this cmake command to build only the command line tool (which second part on linux build instruction - ubuntu 14.04+):
+cmake -DWITH_TEST=FALSE -DWITH_BINDING_JAVA=FALSE --DWITH_BINDING_PYTHON=FALSE --DWITH_BINDING_GO=FALSE -DWITH_DAEMON=FALSE -DCMAKE_INSTALL_PREFIX:PATH=/usr ..
+Verify your alpr installation with:
+wget -O- -q http://plates.openalpr.com/h786poj.jpg | alpr -
+# Example configuration.yaml entry
+openalpr:
+ engine: local
+ region: eu
+ confidence: 80.0
+ entities:
+ - name: Camera garage 1
+ interval: 5
+ render: ffmpeg
+ input: INPUT_STREAM
+ extra_arguments: SOME OTHER FFMPEG STUFF
+ - name: Camera garage 2
+ interval: 5
+ render: image
+ input: https://camera_ip/still_image.jpg
+ username: admin
+ password: bla
+Configuration variables:
+ +local or cloud for processingopenalpr.scan service.ffmpeg for video streams and image for a still image.# Example configuration.yaml entry
+openalpr:
+ engine: local
+ region: eu
+ alpr_binary: /usr/bin/alpr
+ entities:
+...
+Configuration variables:
+ +alpr. The command line tool alpr from OpenAlpr software for local processing.# Example configuration.yaml entry
+openalpr:
+ engine: local
+ region: eu
+ api_key: SK_AAABBBBCCCEEEE
+ entities:
+...
+Configuration variables:
+ +openalpr.scan: Scan immediately a picture from input.openalpr.restart: Restart a ffmpeg process# Example configuration.yaml automation entry
+automation:
+- alias: Open garage door
+ trigger:
+ platform: event
+ Event_type: openalpr.found
+ Event_data:
+ entity_id: openalpr.camera_garage_1
+ plate: BE2183423
+...
+This event is trigger after openalpr found a new licence plate.
+ + +The panel_custom support allows you to add additional panels to your Home Assistant frontend. The panels are listed in the sidebar if wished and can be highly customized.
To enable customized panels in your installation, add the following to your configuration.yaml file:
# Example configuration.yaml entry
+panel_custom:
+ - name: todomvc
+ sidebar_title: TodoMVC
+ sidebar_icon: mdi:work
+ url_path: my-todomvc
+ webcomponent_path: /home/hass/hello.html
+ config:
+ hello: world
+Configuration variables:
+ +mdi:. For example mdi:car, mdi:ambulance, or mdi:motorbike.<config dir>/panels/<component name>.htmlThe panel_iframe support allows you to add additional panels to your Home Assistant frontend. The panels are listed in the sidebar and can contain external resources like the web frontend of your router, your monitoring system, or your media server.
If you are accessing home Assistant over HTTPS using SSL, you cannot access HTTP sites through an iframe panel.
+ +To enable Panel iFrames in your installation, add the following to your configuration.yaml file:
# Example configuration.yaml entry
+panel_iframe:
+ router:
+ title: 'Router'
+ url: 'http://192.168.1.1'
+ fridge:
+ title: 'Fridge'
+ url: 'http://192.168.1.5'
+Configuration variables:
+ +mdi:. For example mdi:car, mdi:ambulance, or mdi:motorbike.The persistent_notification can be used to show a message on the frontend that has to be dismissed by the user.
+ 
+
The service persistent_notification/create takes in message, title, and notification_id.
| Service data attribute | +Optional | +Description | +
|---|---|---|
message |
+ no | +Body of the notification. | +
title |
+ yes | +Title of the notification. | +
notification_id |
+ yes | +If notification_id is given, it will overwrite the notification if there already was a notification with that ID. |
+
The persistent_notification component supports specifying templates for both the message and the title. This will allow you to use the current state of Home Assistant in your notifications.
In an action of your automation setup it could look like this with a customized subject.
+ +action:
+ service: persistent_notification.create
+ data:
+ message: "Your message goes here"
+ title: "Custom subject"
+Choose Services from the Developer Tools to call the persistent_notification service. Select persistent_notification/create from the list of Available services: and enter something like the sample below into the Service Data field and hit CALL SERVICE.
{
+ "notification_id": "1234",
+ "title": "Sample notification",
+ "message": "This is a sample text"
+}
+This will create the notification entry shown above.
+ +NOTE: if you have defined a default_view: in your Groups: configuration you will need to include persistent_notification.<notification_id> e.g. persistent_notification.1234 as per the example above, to your Groups configuration, in order to see the notification after creating it.
Pilight is a modular and open source solution to communicate with 433 MHz devices and runs on various small form factor computers. A lot of common protocols are already available.
+ +This pilight hub connects to the pilight-daemon via a socket connection to receive and send codes. Thus home assistant does not have to run on the computer in charge of the RF communication.
+ +The received and supported RF codes are put on the event bus of home assistant and are therefore directly usable by other components (e.g. automation). Additionally a send service is provided to send RF codes.
+ +To integrate pilight into Home Assistant, add the following section to your configuration.yaml file:
# Example configuration.yaml entry
+pilight:
+ host: 127.0.0.1
+ port: 5000
+Configuration variables:
+ +In this example only received RF codes using a daycom or intertechno protocol are put on the event bus and only when the device id is 42. For more possible settings please look at the receiver section of the pilight API.
+ +A full configuration sample could look like the sample below:
+ +# Example configuration.yaml entry
+pilight:
+ host: 127.0.0.1
+ port: 5000
+ send_delay: 0.4
+ whitelist: # optional
+ protocol:
+ - daycom
+ - intertechno
+ id:
+ - 42
+pilight-debug. Remember the pulslen parameter.libs/pilight/protocols/433.92 subfolder of the pilight source code and open the .c file of your protocol. Search for MIN_PULSE_LENGTH, MAX_PULSE_LENGTH and AVG_PULSE_LENGTH. Change the pulse lengths to match your measured one. Recompile and install pilight by re-running $ sudo ./setup.sh.The proximity component allows you to monitor the proximity of devices to a particular zone and the direction of travel. The result is an entity created in Home Assistant which maintains the proximity data.
This component is useful to reduce the number of automation rules required when wanting to perform automations based on locations outside a particular zone. The zone and state based triggers allow similar control but the number of rules grows exponentially when factors such as direction of travel need to be taken into account.
+ +Some examples of its use include:
+ +The Proximity entity which is created has the following values:
+ +state: Distance from the monitored zone (in km)dir_of_travel: Direction of the closest device to the monitored zone. Values are:
+ dist_to_zone: Distance from the monitored zone (in km)To enable this component in your installation, add the following to your configuration.yaml file:
# Example configuration.yaml entry
+proximity:
+ home:
+ ignored_zones:
+ - twork
+ devices:
+ - device_tracker.nwaring_nickmobile
+ tolerance: 50
+ unit_of_measurement: mi
+Configuration variables:
+ +To add multiple proximity components, simply use a list in your configuration.yaml file:
# Example configuration.yaml entry
+proximity:
+ home:
+ ignored_zones:
+ - twork
+ - elschool
+ devices:
+ - device_tracker.nwaring_nickmobile
+ - device_tracker.eleanorsiphone
+ - device_tracker.tsiphone
+ tolerance: 50
+ unit_of_measurement: mi
+ home3:
+ devices:
+ - device_tracker.tsiphone
+ tolerance: 50
+ work:
+ devices:
+ - device_tracker.elanorsiphone
+ tolerance: 10
+The qwikswitch component is the main component to integrate various QwikSwitch devices with Home Assistant.
Loading the qwikswitch component automatically adds all devices from the QS Mobile application. QS Mobile controls the QSUSB Modem device.
Currently QwikSwitch relays and LED dimmers are supported (tested). QwikSwitch relay devices can be switches or lights in Home-Assistant. If the device name in the QSUSB app ends with ` Switch` it will be created as a switch, otherwise as a light.
+ +Example configuration:
+ +# Example configuration.yaml entry
+qwikswitch:
+ url: http://127.0.0.1:2020
+Configuration variables:
+ +QwikSwitch devices (i.e. transmitter buttons) will fire events on the Home Assistant bus. These events can then be used as triggers for any automation action, as follows:
automation:
+ - alias: Action - Respond to button press
+ trigger:
+ platform: event
+ event_type: qwikswitch.button.@12df34
+event_type names should be in the format qwikswitch.button.@__ID__. where @__ID__ will be captured in the Home Assistant log when pressing the button. Alternatively, you can also get the device ID from the QS Mobile application or using the listen API call by browsing to http://127.0.0.1:2020/&listen and then pressing the button.
By default events will be fired if the value in the command (cmd) field of the listen packet equals:
+TOGGLE - Normal QwikSwitch Transmitter buttonSCENE EXE - QwikSwitch Scene Transmitter buttonsLEVEL - QwikSwitch OFF Transmitter buttonsThe list of recognized commands can be extended for Keyfobs, door sensors, and PIR transmitters with the button_events configuration option. button_events contain a comma separated list of commands that will fire Home Assistant events. By default it is: TOGGLE,SCENE EXE,LEVEL.
+ +On some QS Mobile servers button events are only generated for switches added to the QS Mobile application, so it might be best to test button presses through the /&listen API
The recorder component is storing details in a database which then are handled by the history component.
Home Assistant uses SQLAlchemy as Object Relational Mapper (ORM). This means that you can now use any SQL backend for the recorder that is supported by SQLAlchemy, like MySQL, MariaDB, or PostgreSQL.
+ +The default database engine is SQLite which doesn’t require any configuration. The database is stored in your Home Assistant configuration directory (.homeassistant) and called home-assistant.db.
To setup the recorder component in your installation, add the following to your configuration.yaml file:
# Example configuration.yaml entry
+recorder:
+Configuration variables:
+ +# Example configuration.yaml entry
+recorder:
+ purge_days: 5
+ db_url: sqlite:///home/user/.homeassistant/test
+| Database engine | +db_url |
+
|---|---|
| SQLite | +sqlite:///PATH/TO/DB_NAME |
+
| MySQL | +mysql://SERVER_IP/DB_NAME |
+
| MySQL | +mysql://user:password@SERVER_IP/DB_NAME |
+
| PostgreSQL | +postgresql://SERVER_IP/DB_NAME |
+
| PostgreSQL | +postgresql://scott:tiger@SERVER_IP/DB_NAME |
+
Not all Python bindings for the choosen database engine can be installed directly. This section contains additional details which should help you to get it working.
+ +For MySQL you may have to install a few dependencies:
+ +$ sudo apt-get install libmysqlclient-dev
+$ pip3 install mysqlclient
+The rfxtrx component supports RFXtrx devices by RFXCOM which communicate in the frequency range of 433.92 MHz.
To enable RFXtrx in your installation, add the following to your configuration.yaml file:
# Example configuration.yaml entry
+rfxtrx:
+ device: PATH_TO_DEVICE
+Configuration variables:
+ +/dev/serial/by-id/usb-RFXCOM_RFXtrx433_A1Y0NJGR-if00-port0Supported protocols
+ +Not all protocols as advertised are enabled on inital setup of your transceiver. Enabling all protocols is not recommmended either. Your 433.92 product not showing in the logs? Visit the RFXtrx website to download RFXmgmr and enable the required protocol.
+ + +The rpi_gpio component is the base for all related GPIO platforms in Home Assistant. There is no setup needed for the component itself, for the platforms please check their corresponding pages.
Implements the Hunter Douglas PowerView platform scene control. It queries the PowerView Hub and Home Assistant displays them as scenes.
+ +Scenes can be activated using the service scene.turn_on.
# Example configuration.yaml entry
+scene:
+ platform: hunterdouglas_powerview
+ address: IP_ADDRESS
+Configuration variables:
+ +To get your LiteJet scenes working with Home Assistant, follow the instructions for the general LiteJet component.
+ + +You can create scenes that capture the states you want certain entities to be. For example a scene can specify that light A should be turned on and light B should be bright red.
+ +# Example configuration.yaml entry
+scene:
+ - name: Romantic
+ entities:
+ light.tv_back_light: on
+ light.ceiling:
+ state: on
+ xy_color: [0.33, 0.66]
+ brightness: 200
+ - name: Movies
+ entities:
+ light.tv_back_light:
+ state: on
+ brightness: 100
+ light.ceiling: off
+Configuration variables:
+ +Scenes can be activated using the service scene.turn_on (there is no ‘scene.turn_off’ service).
# Example automation
+...
+automation:
+ trigger:
+ platform: state
+ entity_id: device_tracker.sweetheart
+ from: 'not_home'
+ to: 'home'
+ action:
+ service: scene.turn_on
+ entity_id: scene.romantic
+The script component allows users to specify a sequence of actions to be executed by Home Assistant when turned on. The script component will create an entity for each script and allow them to be controlled via services.
+ +The sequence of actions is specified using the Home Assistant Script Syntax.
+ +# Example configuration.yaml entry
+script:
+ message_temperature:
+ sequence:
+ # This is Home Assistant Script Syntax
+ - service: notify.notify
+ data_template:
+ message: Current temperature is {{ states.sensor.temperature.state }}
+
+ # Turns on the bedroom lights and then the living room lights 1 minute later
+ wakeup:
+ alias: Wake Up
+ sequence:
+ # This is Home Assistant Script Syntax
+ - event: LOGBOOK_ENTRY
+ event_data:
+ name: Paulus
+ message: is waking up
+ entity_id: device_tracker.paulus
+ domain: light
+ - alias: Bedroom lights on
+ service: light.turn_on
+ data:
+ entity_id: group.bedroom
+ brightness: 100
+ - delay:
+ # supports seconds, milliseconds, minutes, hours
+ minutes: 1
+ - alias: Living room lights on
+ service: light.turn_on
+ data:
+ entity_id: group.living_room
+As part of the service, variables can be passed along to a script so they become available within templates in that script.
+ +There are two ways to achieve this. One way is using the generic script.turn_on service. To pass variables to the script with this service, call it with the desired variables:
# Example configuration.yaml entry
+automation:
+ trigger:
+ platform: state
+ entity_id: light.bedroom
+ from: 'off'
+ to: 'on'
+ action:
+ service: script.turn_on
+ entity_id: script.notify_pushover
+ data:
+ variables:
+ title: 'State change'
+ message: 'The light is on!'
+The other way is calling the script as a service directly. In this case, all service data will be made available as variables. If we apply this approach on the script above, it would look like this:
+ +# Example configuration.yaml entry
+automation:
+ trigger:
+ platform: state
+ entity_id: light.bedroom
+ from: 'off'
+ to: 'on'
+ action:
+ service: script.notify_pushover
+ data:
+ title: 'State change'
+ message: 'The light is on!'
+Using the variables in the script requires the use of data_template:
# Example configuration.yaml entry
+script:
+ notify_pushover:
+ sequence:
+ - condition: state
+ entity_id: switch.pushover_notifications
+ state: 'on'
+ - service: notify.pushover
+ data_template:
+ title: "{{ title }}"
+ message: "{{ message }}"
+The SCSGate component support the SCSGate device. This a homebrew device allows to interact with the MyHome system from BTicino/Legrande.
+ +To enable SCSGate in your installation, add the following to your configuration.yaml file:
# Example configuration.yaml entry
+scsgate:
+ device: PATH_TO_DEVICE
+Configuration variables:
+ +/dev/ttyACM0The SCSGate component relies on the scsgate python module.
+ +This module provides also a command line tool called scs-monitor. This program can be used to find the IDs of your lights, switches and roller shutters and produce the YAML snippet to insert into your configuration.yaml file.
For more information checkout this section of scsgate’s documentation.
The apcupsd sensor platform allows you to monitor a UPS (battery backup) by using data from the apcaccess command.
To use this sensor platform, you first have to set up apcupsd, and add the following to your configuration.yaml file:
# Example configuration.yaml entry
+sensor:
+ - platform: apcupsd
+ resources:
+ - bcharge
+ - linev
+ - loadpct
+ - nominv
+ - nompower
+ - numxfers
+ - outputv
+ - status
+ - timeleft
+ - tonbatt
+Configuration variables:
+ +Given the following output from apcaccess:
APC : 001,051,1149
+DATE : 2016-02-09 17:13:31 +0000
+HOSTNAME : localhost
+VERSION : 3.14.12 (29 March 2014) redhat
+UPSNAME : netrack
+CABLE : Custom Cable Smart
+DRIVER : APC Smart UPS (any)
+UPSMODE : Stand Alone
+STARTTIME: 2016-02-09 16:06:47 +0000
+MODEL : SMART-UPS 1400
+STATUS : TRIM ONLINE
+LINEV : 247.0 Volts
+LOADPCT : 13.0 Percent
+BCHARGE : 100.0 Percent
+TIMELEFT : 104.0 Minutes
+MBATTCHG : 5 Percent
+MINTIMEL : 3 Minutes
+MAXTIME : 0 Seconds
+MAXLINEV : 249.6 Volts
+MINLINEV : 244.4 Volts
+OUTPUTV : 218.4 Volts
+SENSE : High
+DWAKE : 0 Seconds
+DSHUTD : 180 Seconds
+DLOWBATT : 2 Minutes
+LOTRANS : 196.0 Volts
+HITRANS : 253.0 Volts
+RETPCT : 15.0 Percent
+ITEMP : 30.6 C
+ALARMDEL : Low Battery
+BATTV : 27.6 Volts
+LINEFREQ : 50.0 Hz
+LASTXFER : High line voltage
+NUMXFERS : 0
+TONBATT : 0 Seconds
+CUMONBATT: 0 Seconds
+XOFFBATT : N/A
+SELFTEST : NO
+STESTI : 336
+STATFLAG : 0x0500000A
+DIPSW : 0x00
+REG1 : 0x00
+REG2 : 0x00
+REG3 : 0x00
+MANDATE : 07/13/99
+SERIALNO : GS9888761008
+BATTDATE : 13/11/15
+NOMOUTV : 230 Volts
+NOMBATTV : 24.0 Volts
+EXTBATTS : 0
+FIRMWARE : 70.11.I
+END APC : 2016-02-09 17:13:46 +0000
+Use the (case insensitive) values from the left hand column:
+ +sensor:
+ - platform: apcupsd
+ resources:
+ - linev
+ - loadpct
+ - itemp
+The arduino sensor platform allows you to get an numerical values from an analog input pin of an Arduino board. Usually the value is between 0 and 1024.
To enable an Arduino sensor with Home Assistant, add the following section to your configuration.yaml file:
# Example configuration.yaml entry
+sensor:
+ platform: arduino
+ pins:
+ 1:
+ name: Door switch
+ 0:
+ name: Brightness
+
+Configuration variables:
+ +The 6 analog pins of an Arduino UNO are numbered from A0 to A5.
+ + + +The arest sensor platform allows you to get all data from your devices (like Arduinos with a ethernet/wifi connection, the ESP8266, and the Raspberry Pi) running the aREST RESTful framework.
To use your aREST enabled device in your installation, add the following to your configuration.yaml file:
# Example configuration.yaml entry
+ - platform: arest
+ resource: http://10.100.0.117
+ monitored_variables:
+ temperature:
+ name: temperature
+ pins:
+ A0:
+ name: Pin 0 analog
+Configuration variables:
+ +The variables in the monitored_variables array must be available in the response of the device. As a starting point you could use the one of the example sketches (eg. Ethernet for an Arduino with Ethernet shield). In those sketches are two variables (temperature and humidity) available which will act as endpoints.
Accessing one of the endpoints (eg. http://192.168.1.10/temperature) will give you the value inside a JSON response.
+ +{"temperature": 23, "id": "sensor01", "name": "livingroom", "connected": true}
+The root will give you a JSON response that contains all variables and their current values along with some device details.
+ +{
+ "variables" : {
+ "temperature" : 23,
+ "humidity" : 82
+ },
+ "id" : "sensor01",
+ "name" : "livingroom",
+ "connected" : true
+}
+return_value contains the sensor’s data in a JSON response for a given pin (eg. http://192.168.1.10/analog/2/ or http://192.168.1.10/digital/7/).
{"return_value": 34, "id": "sensor02", "name": "livingroom", "connected": true}
+The arwn sensor platform is a client for the Ambient Radio Weather Network project. This collects weather station data and makes it available in an MQTT subtree.
To use your ARWN setup, you must already have configured the MQTT platform. Then add the following to your configuration.yaml file:
# Example configuration.yaml entry
+sensor:
+ platform: arwn
+Currently all temperature, barometer, and wind sensors will be displayed. Support for rain guage sensors will happen in the future.
+ + +The bbox platform uses the Bbox Modem Router from the French Internet provider Bouygues Telecom. Sensors are mainly bandwidth measures.
+Due to third party limitation, the sensors will only be available if Home Assistant and the Bbox are on the same local area network. You can check this by going to 192.168.1.254 with your web browser. +
+ +To add Bbox sensors to your installation, add the following to your configuration.yaml file:
# Example configuration.yaml entry
+sensor:
+ - platform: bbox
+ monitored_variables:
+ - down_max_bandwidth
+ - up_max_bandwidth
+ - current_down_bandwidth
+ - current_up_bandwidth
+Configuration variables:
+ +The bitcoin sensor platform displays various details about the Bitcoin network.
To add the Bitcoin sensor to your installation, add a selection of the available display options to your configuration.yaml file:
# Example configuration.yaml entry
+sensor:
+ platform: bitcoin
+ display_options:
+ - exchangerate
+ - trade_volume_btc
+ - miners_revenue_usd
+ - btc_mined
+ - trade_volume_usd
+ - difficulty
+ - minutes_between_blocks
+ - number_of_transactions
+ - hash_rate
+ - timestamp
+ - mined_blocks
+ - blocks_size
+ - total_fees_btc
+ - total_btc_sent
+ - estimated_btc_sent
+ - total_btc
+ - total_blocks
+ - next_retarget
+ - estimated_transaction_volume_usd
+ - miners_revenue_btc
+ - market_price_usd
+Configuration variables:
+ +The bloomsky sensor component allows you to view the measurements made by sensors in the BloomSky weather station. This can work in concert with the BloomSky camera.
To enable these sensors in your installation, set up the BloomSky component with your API key add the following to your configuration.yaml file:
# Example configuration.yaml entry
+sensor:
+ platform: bloomsky
+ monitored_conditions:
+ - Temperature
+ - Humidity
+ - Rain
+ - Pressure
+ - UVIndex
+ - Luminance
+ - Night
+ - Voltage
+Configuration variables:
+ +The bom platform allows you to get the current weather conditions from the Bureau of Meteorology (BOM) Australia.
device_id of “bom [optionalname] friendlyname units”To get the station ID [zone_id] and [wmo_id] for your local BOM station:
To add the BOM weather observation to your installation, add the following to your configuration.yaml file:
# Example configuration.yaml entry
+sensor:
+ - platform: bom
+ zone_id: IDS60801
+ wmo_id: 94675
+ monitored_conditions:
+ - wmo
+ - name
+ - history_product
+ - local_date_time
+ - local_date_time_full
+ - aifstime_utc
+ - lat
+ - lon
+ - apparent_t
+ - cloud
+ - cloud_base_m
+ - cloud_oktas
+ - cloud_type_id
+ - cloud_type
+ - delta_t
+ - gust_kmh
+ - gust_kt
+ - air_temp
+ - dewpt
+ - press
+ - press_qnh
+ - press_msl
+ - press_tend
+ - rain_trace
+ - rel_hum
+ - sea_state
+ - swell_dir_worded
+ - swell_height
+ - swell_period
+ - vis_km
+ - weather
+ - wind_dir
+ - wind_spd_kmh
+ - wind_spd_kt
+Configuration variables:
+ +The coinmarketcap sensor platform displays various details about a crypto currency provided by CoinMarketCap.
To add the CoinMarketCap sensor to your installation, add the following lines to your configuration.yaml:
# Example configuration.yaml entry
+sensor:
+ - platform: coinmarketcap
+Configuration variables:
+ +bitcoin, litecoin, steem, etc. Default is bitcoin.The command_line sensor platform that issues specific commands to get data. This might become our most powerful platform as it allows anyone to integrate any type of sensor into Home Assistant that can get data from the command line.
To enable it, add the following lines to your configuration.yaml:
# Example configuration.yaml entry
+sensor:
+ - platform: command_line
+ command: SENSOR_COMMAND
+Configuration variables:
+ +In this section you find some real life examples of how to use this sensor.
+ +There are several ways to get the temperature of your hard drive. A simple solution is to use hddtemp.
+ +$ hddtemp -n /dev/sda
+To use those information, the entry for a command-line sensor in the configuration.yaml file will look like this.
# Example configuration.yaml entry
+sensor:
+ - platform: command_line
+ name: HD Temperature
+ command: "hddtemp -n /dev/sda"
+ unit_of_measurement: "°C"
+Thanks to the proc file system, various details about a system can be retrieved. Here the CPU temperature is of interest. Add something similar to your configuration.yaml file:
# Example configuration.yaml entry
+ - platform: command_line
+ name: CPU Temperature
+ command: "cat /sys/class/thermal/thermal_zone0/temp"
+ unit_of_measurement: "°C"
+ value_template: '{{ value | multiply(0.001) }}'
+If you want to get the fillowing in case you want to know if someone is hammering your server is open on the net
+ +# Example configuration.yaml entry
+sensor:
+ - platform: command_line
+ name: badlogin
+ command: grep -c 'Login attempt' /home/hass/.homeassistant/home-assistant.log
+Make sure to configure the logger to monitor the proper component at the proper level.
+ +# Example working logger settings that works
+logger:
+ default: critical
+ logs:
+ homeassistant.components.http: warning
+You can see directly in the frontend (Developer tools -> About) what release of Home Assistant you are running. The Home Assistant releases are available on the Python Package Index. This makes it possible to get the current release.
+ +sensor:
+ - platform: command_line
+ command: python3 -c "import requests; print(requests.get('https://pypi.python.org/pypi/homeassistant/json').json()['info']['version'])"
+ name: HA release
+If you own a devices which are storing values in text files which are accessible over HTTP then you can use the same approach as shown in the previous section. Instead of looking at the JSON response we directly grab the sensor’s value.
+ +sensor:
+ - platform: command_line
+ command: python3 -c "import requests; print(requests.get('http://remote-host/sensor_data.txt').text)"
+ name: File value
+The example is doing the same as the aREST sensor but with an external Python script. It should give you an idea about interacting with devices which are exposing a RESTful API.
+ +The one-line script to retrieve a value is shown below. Of course would it be possible to use this directly in the configuration.yaml file but need extra care about the quotation marks.
$ python3 -c "import requests; print(requests.get('http://10.0.0.48/analog/2').json()['return_value'])"
+The script (saved as arest-value.py) that is used looks like the example below.
#!/usr/bin/python3
+from requests import get
+response = get('http://10.0.0.48/analog/2')
+print(response.json()['return_value'])
+To use the script you need to add something like the following to your configuration.yaml file.
# Example configuration.yaml entry
+sensor:
+ - platform: command_line
+ name: Brightness
+ command: "python3 /path/to/script/arest-value.py"
+ unit_of_measurement: "°C"
+The cpuspeed sensor platform to allow you to monitor the current CPU speed.
To add this platform to your installation, add the following to your configuration.yaml file:
# Example configuration.yaml entry
+sensor:
+ - platform: cpuspeed
+Configuration variables:
+ +The cups sensor platform is using the open source printing system CUPS to show details about your printers.
To set up the sensor the “Queue Name” of the printer is needed. The fastest way to get it, is to visit the CUPS webinterface at “http://[IP ADDRESS PRINT SERVER]:631” and go to “Printers”.
+ +
+ 
+
To enable the CUPS sensor, add the following lines to your configuration.yaml:
# Example configuration.yaml entry
+sensor:
+ - platform: cups
+ printers:
+ - C410
+ - C430
+Configuration variables:
+ +
+You will need to install the python3-dev or python3-devel and the development files for CUPS (libcups2-dev orcups-devel) package on your system manually (eg. sudo apt-get install python3-dev libcups2-dev or sudo dnf -y install python3-devel cups-devel) along with a compiler (gcc).
+
The currencylayer sensor will show you the current exchange rate from Currencylayer that provides realtime exchange rates for 170 currencies. The free account is limited to only USD as a base currency, allows 1000 requests per month, and updates every hour.
Obtain your API key here
+ +To enable this sensor, add the following lines to your configuration.yaml file:
# Example configuration.yaml entry
+sensor:
+ - platform: currencylayer
+ api_key: YOUR_API_KEY
+ base: USD
+ quote:
+ - EUR
+ - INR
+Configuration variables:
+ +The darksky platform uses the Dark Sky web service as a source for meteorological data for your location. The location is based on the longitude and latitude coordinates configured in your configuration.yaml file. The coordinates are auto-detected but to take advantage of the hyper-local weather reported by Dark Sky, you can refine them down to your exact home address. GPS coordinates can be found by using Google Maps and clicking on your home or Openstreetmap.
You need an API key which is free but requires registration. You can make up to 1000 calls per day for free which means that you could make one approximately every 86 seconds.
+ ++Dark Sky will charge you $0.0001 per API call if you enter your credit card details and create more than 1000 calls per day. +
+ +To add Dark Sky to your installation, add the following to your configuration.yaml file:
# Example configuration.yaml entry
+sensor:
+ - platform: darksky
+ api_key: YOUR_API_KEY
+ monitored_conditions:
+ - summary
+ - icon
+ - nearest_storm_distance
+ - nearest_storm_bearing
+ - precip_type
+ - precip_intensity
+ - precip_probability
+ - temperature
+ - apparent_temperature
+ - dew_point
+ - wind_speed
+ - wind_bearing
+ - cloud_cover
+ - humidity
+ - pressure
+ - visibility
+ - ozone
+ - minutely_summary
+ - hourly_summary
+ - daily_summary
+ - temperature_max
+ - temperature_min
+ - apparent_temperature_max
+ - apparent_temperature_min
+ - precip_intensity_max
+Configuration variables:
+ +si or us based on the temperature preference in Home Assistant. Other options are auto, us, si, ca, and uk2.
+auto will let forecast.io decide the unit system based on location.+Note: While the platform is called “darksky” the sensors will show up in Home Assistant as “dark_sky” (eg: sensor.dark_sky_summary). +
+ +Details about the API are available in the Dark Sky documentation.
+ + +The deutsche_bahn sensor will give you the departure time of the next train for the given connection. In case of a delay, the delay is also shown. Additional details are used to inform about eg. the type of the train, price, and if it is ontime.
To enable this sensor, add the following lines to your configuration.yaml file:
# Example configuration.yaml entry
+sensor:
+ - platform: deutsche_bahn
+ from: NAME_OF_START_STATION
+ to: NAME_OF_FINAL_STATION
+Configuration variables:
+ +As already mentioned this sensor contains a lot of information to access those a template senosr can come handy.
+ +# Example configuration.yaml entry
+sensor:
+ platform: template
+ sensors:
+ next_departure:
+ value_template: '{{ states.sensor.munich_to_ulm.attributes.next }}'
+ friendly_name: 'Next departure'
+The data is coming from the bahn.de website.
+ + +The dht sensor platform allows you to get the current temperature and humidity from a DHT11, DHT22, or AM2302 device.
To use your DHTxx sensor in your installation, add the following to your configuration.yaml file:
# Example configuration.yaml entry
+sensor:
+ platform: dht
+ sensor: DHT22
+ pin: 23
+ monitored_conditions:
+ - temperature
+ - humidity
+Configuration variables:
+ +The name of the pin to which the sensor is connected has different names on different platforms. ‘P8_11’ for Beaglebone, ‘23’ for Raspberry Pi.
+ + + +The dovado platform let you monitor your router from Dovado
To add a Dovado sensor to your installation, add the following to your configuration.yaml file:
# Example configuration.yaml entry
+sensor:
+ - platform: dovado
+ username: YOUR_USERNAME
+ password: YOUR_PASSWORD
+ host: IP_ADDRESS
+ port: PORT
+ sensors:
+ - network
+Configuration variables:
+ +192.168.1.1.999.A sensor platform for the DTE Energy Bridge.
+ +To enable this sensor, add the following lines to your configuration.yaml file:
# Example configuration.yaml entry
+sensor:
+ - platform: dte_energy_bridge
+ ip: 192.168.1.11
+Configuration variables:
+ +The dweet sensor platform allows you to get details from your devices which are publishing their values to Dweet.io.
To use Dweet.io in your installation, add the following to your configuration.yaml file:
# Example configuration.yaml entry
+sensor:
+ platform: dweet
+ name: Dweet.io Temperature
+ device: THING_NAME
+ value_template: '{{ value_json.VARIABLE }}'
+ unit_of_measurement: "°C"
+Configuration variables:
+ +thing).You can easily send dweets from the commandline to test your sensor with curl.
$ curl -H 'Content-Type: application/json' -d '{"temperature": 40, "humidity": 65}' https://dweet.io/dweet/for/ha-sensor
+will give you a response like the one below:
+ +{"this":"succeeded","by":"dweeting","the":"dweet","with":{"thing":"ha-sensor","created":"2015-12-10T09:43:31.133Z","content":{"temperature":40,"humidity":65}}}
+The dweepy module gives you another option to work with Dweet.io.
+ +Send a dweet.
+ +$ python3
+>>> import dweepy
+>>> dweepy.dweet_for('ha-sensor', {'temperature': '23', 'humiditiy':'81'})
+{'thing': 'ha-sensor', 'created': '2015-12-10T09:46:08.559Z', 'content': {'humiditiy': 81, 'temperature': 23}}
+Recieve the latest dweet.
+ +>>> dweepy.get_latest_dweet_for('ha-sensor')
+[{'thing': 'ha-sensor'', 'created': '2015-12-10T09:43:31.133Z', 'content': {'humidity': 65, 'temperature': 40}}]
+Integrate your Efergy meter information into Home Assistant. To get an app token:
+ +Log in to your efergy account
+Go to the Settings page
+Click on App tokens
+Click “Add token”
+# Example configuration.yaml entry
+sensor:
+ - platform: efergy
+ app_token: APP_TOKEN
+ utc_offset: UTC_OFFSET
+ monitored_variables:
+ - type: instant_readings
+ - type: budget
+ - type: cost
+ period: day
+ currency: $
+Configuration variables:
+ +Integrate your ELIQ Online smart meter information into Home Assistant. To get an access token and the Channel ID, log in to your account.
+ +To enable this sensor in your installation, add the following to your configuration.yaml file:
# Example configuration.yaml entry
+sensor:
+ - platform: eliqonline
+ access_token: ACCESS_TOKEN
+Configuration variables:
+ +For details please check the API documentation.
+ + + +The emoncms sensor platform creates sensors for the feeds available in your local or cloud based version of Emoncms.
To enable this sensor, add the following lines to your configuration.yaml, it will list all feeds as a sensor:
# Example configuration.yaml entry using cloud based Emoncms
+sensor:
+ platform: emoncms
+ api_key: API_KEY
+ url: https://emoncms.org
+ id: 1
+exclude_feed_id is specified.include_only_feed_id is specified.feedid: name pairs. Sensors for feeds with their feed ID mentioned here will get the chosen name instead of the default nameThe names of the sensors created by this component, will be a combination of static text, id from the config and feedid from the Emoncms feed, unless sensor_names is used. An example name would be emoncms1_feedid_10.
In this section you find some more examples of how this sensor can be used.
+ +Display only feeds with their feed IDs specified in include_only_feed_id.
# Example configuration.yaml entry
+sensor:
+ - platform: emoncms
+ api_key: API_KEY
+ url: https://emoncms.org
+ id: 1
+ unit_of_measurement: "W"
+ include_only_feed_id:
+ - 107
+ - 105
+Display all feeds except feeds with their feed id specified in exclude_feed_id.
# Example configuration.yaml entry
+sensor:
+ - platform: emoncms
+ api_key: API_KEY
+ url: https://emoncms.org
+ id: 1
+ unit_of_measurement: "KWH"
+ exclude_feed_id:
+ - 107
+ - 105
+Display only feeds with their feed id’s specified in include_only_feed_id and give the feed sensors a name using “sensor_names”. You don’t have to specify all feeds names in “sensor_names”, the remaining sensor names will be chosen based on “id” and the Emoncms feedid.
# Example configuration.yaml entry
+sensor:
+ - platform: emoncms
+ api_key: API_KEY
+ url: https://emoncms.org
+ id: 1
+ unit_of_measurement: "KW"
+ include_only_feed_id:
+ - 5
+ - 120
+ sensor_names:
+ 5: "feed 1"
+ 48: "kwh feed"
+ 61: "amp feed"
+ 110: "watt feed"
+Use a value_template to add 1500 to the feed value for all specified feed IDs in include_feed_id.
# Example configuration.yaml entry
+sensor:
+ - platform: emoncms
+ api_key: API_KEY
+ url: https://emoncms.org
+ scan_interval: 15
+ id: 1
+ value_template: "{{ value | float + 1500 }}"
+ include_only_feed_id:
+ - 107
+ - 106
+Display feeds from the same Emoncms instance with 2 groups of feeds, diffrent scan_interval and a diffrent unit_of_measurement.
# Example configuration.yaml entry
+sensor:
+ - platform: emoncms
+ api_key: API_KEY
+ url: https://emoncms.org
+ scan_interval: 30
+ id: 1
+ unit_of_measurement: "W"
+ include_only_feed_id:
+ - 107
+ - 106
+ - platform: emoncms
+ api_key: put your emoncms read api key here
+ url: https://emoncms.org
+ id: 2
+ scan_interval: 60
+ unit_of_measurement: "A"
+ include_only_feed_id:
+ - 108
+ - 61
+The enocean sensor platform currently only allows reading out the power measured in a Permundo PSC234 switch.
To use your EnOcean device, you first have to set up your EnOcean hub and then add the following to your configuration.yaml file:
# Example configuration.yaml entry
+sensor:
+ - name: Television
+ platform: enocean
+ id: [0x01,0x90,0x84,0x3C]
+Configuration variables:
+ +enocean.The envisalink platform allows you to get data from your Envisalink sensors from within Home Assistant.
The requirement is that you have setup your Envisalink hub.
+ + + +The fastdotcom sensor component uses the Fast.com web service to measure network bandwidth performance.
+Currently fast.com only supports measuring download bandwidth. If you want to measure bandwidth metrics other then download such as ping and upload, utilize the speedtest component. +
+ +By default, it will run every hour. The user can change the update frequency in the config by defining the minute, hour, and day for a speedtest to run.
+ +To add a Fast.com sensor to your installation, add the following to your configuration.yaml file:
Once per hour, on the hour (default):
+ +sensor:
+ - platform: fastdotcom
+More examples:
+ +Every half hour of every day:
+ +sensor:
+ - platform: fastdotcom
+ minute:
+ - 0
+ - 30
+Configuration variables:
+ +There is also a service named sensor.update_fastdotcom that you can use to run a fast.com speedtest on demand.
The Fitbit sensor allows you to expose data from Fitbit to Home Assistant.
+ +Enable the sensor by adding the following to your configuration.yaml file:
# Example configuration.yaml entry
+sensor:
+ - platform: fitbit
+ monitored_resources:
+ - "body/weight"
+Restart Home Assistant once this is complete. Go to the frontend. You will see a new entry for configuring Fitbit. Follow the instructions there to complete the setup process.
+ +Please be aware that Fitbit has very low rate limits, 150 per user per hour. The clock resets at the top of the hour (meaning it is not a rolling 60 minutes). There is no way around the limits. Due to the rate limits, the sensor only updates every 30 minutes. You can manually trigger an update by restarting Home Assistant. Keep in mind that 1 request is used for every entry in monitored_resources.
The unit system that the sensor will use is based on the country you set in your Fitbit profile.
+ +Configuration variables:
+ +activities/steps.Below is the list of resources that you can add to monitored_resources. One sensor is exposed for every resource.
activities/activityCalories
+activities/calories
+activities/caloriesBMR
+activities/distance
+activities/elevation
+activities/floors
+activities/heart
+activities/minutesFairlyActive
+activities/minutesLightlyActive
+activities/minutesSedentary
+activities/minutesVeryActive
+activities/steps
+activities/tracker/activityCalories
+activities/tracker/calories
+activities/tracker/distance
+activities/tracker/elevation
+activities/tracker/floors
+activities/tracker/minutesFairlyActive
+activities/tracker/minutesLightlyActive
+activities/tracker/minutesSedentary
+activities/tracker/minutesVeryActive
+activities/tracker/steps
+body/bmi
+body/fat
+body/weight
+sleep/awakeningsCount
+sleep/efficiency
+sleep/minutesAfterWakeup
+sleep/minutesAsleep
+sleep/minutesAwake
+sleep/minutesToFallAsleep
+sleep/startTime
+sleep/timeInBed
+The fixer sensor will show you the current exchange rate from Fixer.io which is using data from the European Central Bank (ECB).
To get an overview about the available currencies.
+ +To enable this sensor, add the following lines to your configuration.yaml file:
# Example configuration.yaml entry
+sensor:
+ - platform: fixer
+ target: CHF
+Configuration variables:
+ ++This platform has been deprecated in favor of the “darksky” platform and will be removed in the future. Please use the “darksky” platform. +
+ +The forecast platform uses the Forecast.io web service as a source of meteorological data for your location. The location is based on the longitude and latitude coordinates configured in your configuration.yaml file. The coordinates are auto-detected but to take advantage of the hyper-local weather reported by forecast.io, you can refine them down to your exact home address. GPS coordinates can be found by using Google Maps and clicking on your home or Openstreetmap.
You need an API key which is free but requires registration. You can make up to 1000 calls per day for free which means that you could make one approximately every 86 seconds.
+ ++Forecast.io will charge you $0.0001 per API call if you enter your credit card details and create more than 1000 calls per day. +
+ +To add Forecast.io to your installation, add the following to your configuration.yaml file:
# Example configuration.yaml entry
+sensor:
+ - platform: forecast
+ api_key: YOUR_APP_KEY
+ monitored_conditions:
+ - summary
+ - icon
+ - nearest_storm_distance
+ - nearest_storm_bearing
+ - precip_type
+ - precip_intensity
+ - precip_probability
+ - temperature
+ - apparent_temperature
+ - dew_point
+ - wind_speed
+ - wind_bearing
+ - cloud_cover
+ - humidity
+ - pressure
+ - visibility
+ - ozone
+ - minutely_summary
+ - hourly_summary
+ - daily_summary
+ - temperature_max
+ - temperature_min
+ - apparent_temperature_max
+ - apparent_temperature_min
+ - precip_intensity_max
+Configuration variables:
+ +si or us based on the temperature preference in Home Assistant. Other options are auto, us, si, ca, and uk2.
+auto will let forecast.io decide the unit system based on location.update_interval: 'HH:MM:SS'update_interval: 'HH:MM'update_interval: + # At least one of these must be specified: + days: 0 + hours: 0 + minutes: 3 + seconds: 30 + milliseconds: 0 ++ +
Details about the API are available in the Forecast.io documentation.
+ + +The fritzbox_callmonitor sensor monitors the call monitor exposed by AVM Fritz!Box routers
+on TCP port 1012. It will assume the values idle, ringing, dialing, or talking with the phone numbers involved contained in the state attributes.
To activate the call monitor on your Fritz!Box, dial #965 from any phone connected to it.
+ +To use the Fritz!Box call monitor in your installation, add the following to your configuration.yaml file:
# Example configuration.yaml entry
+sensor:
+ - platform: fritzbox_callmonitor
+Configuration variables:
+ +The glances sensor platform is consuming the system information provided by the Glances API. This enables one to track remote host and display their stats in Home Assistant.
This sensors needs a running instance of glances on the host. The minimal supported version of glances is 2.3:
$ sudo glances -w
+Glances web server started on http://0.0.0.0:61208/
+Check if you are able to access the API located at http://IP_ADRRESS:61208/api/2. The details about your memory usage is provided as a JSON response. If so, you are good to proceed.
$ curl -X GET http://IP_ADDRESS:61208/api/2/mem/free
+{"free": 203943936}
+For details about auto-starting glances, please refer to Start Glances through Systemd.
To enable the Glances sensor, add the following lines to your configuration.yaml:
# Example configuration.yaml entry
+sensor:
+ - platform: glances
+ host: IP_ADDRESS
+ resources:
+ - 'disk_use_percent'
+ - 'disk_use'
+ - 'disk_free'
+ - 'memory_use_percent'
+ - 'memory_use'
+ - 'memory_free'
+ - 'swap_use_percent'
+ - 'swap_use'
+ - 'swap_free'
+ - 'processor_load'
+ - 'process_running'
+ - 'process_total'
+ - 'process_thread'
+ - 'process_sleeping'
+Configuration variables:
+ +192.168.1.32.61208.Sensor to provide travel time from the Google Distance Matrix API.
+ +You need to register for an API key by following the instructions here. You only need to turn on the Distance Matrix API.
+ +A free API Key allows 2500 requests per day. The sensor will update the travel time every 5 minutes.
+ +# Example entry for configuration.yaml
+sensor:
+ - platform: google_travel_time
+ api_key: XXXX_XXXXX_XXXXX
+ origin: Trondheim, Norway
+ destination: Paris, France
+Configuration variables:
+ +place_id:.now, a Unix timestamp, or a 24 hour time string like 08:00:00. If you provide a time string, it will be combined with the current date to get travel time for that moment.departure_time. arrival_time can not be now, only a Unix timestamp or time string. You can not provide both departure_time and arrival_time. If you do provide both, arrival_time will be removed from the request.Tracking can be setup to track entities of type device_tracker, zone, and sensor. If an entity is placed in the origin or destination then every 5 minutes when the component updates it will use the latest location of that entity.
+ +# Example entry for configuration.yaml
+sensor:
+ # Tracking entity to entity
+ - platform: google_travel_time
+ name: Phone To Home
+ api_key: XXXX_XXXXX_XXXXX
+ origin: device_tracker.mobile_phone
+ destination: zone.home
+
+ # Tracking entity to zone friendly name
+ - platform: google_travel_time
+ name: Home To Eddie's House
+ api_key: XXXX_XXXXX_XXXXX
+ origin: zone.home
+ destination: Eddies House # Friendly name of a zone
+The gpsd component is using the GPS information collected by gpsd and a GPS receiver.
A requirement is that gpsd is installed ($ sudo apt-get install gpsd or $ sudo dnf -y install gpsd). gpsd uses the socket activation feature of systemd on recent Linux distributions for USB receivers. This means that if you plug your GPS receiver in, gpsd is started. Other GPS device may work too, but this was not tested.
$ sudo systemctl status gpsdctl@ttyUSB0.service
+● gpsdctl@ttyUSB0.service - Manage ttyUSB0 for GPS daemon
+ Loaded: loaded (/usr/lib/systemd/system/gpsdctl@.service; static; vendor preset: disabled)
+ Active: active (exited) since Sat 2016-07-16 09:30:33 CEST; 1 day 23h ago
+ Process: 5303 ExecStart=/bin/sh -c [ "$USBAUTO" = true ] && /usr/sbin/gpsdctl add /dev/%I || : (code=exited, status=0/SUCCESS)
+ Main PID: 5303 (code=exited, status=0/SUCCESS)
+
+Jul 16 09:30:33 laptop019 systemd[1]: Starting Manage ttyUSB0 for GPS daemon...
+Jul 16 09:30:33 laptop019 gpsdctl[5305]: gpsd_control(action=add, arg=/dev/ttyUSB0)
+Jul 16 09:30:33 laptop019 gpsdctl[5305]: reached a running gpsd
+To check if your setup is working, connect to port 2947 on the host where gpsd is running with telnet. This may need adjustments to your firewall.
+$ telnet localhost 2947
+Trying 127.0.0.1...
+Connected to localhost.
+Escape character is '^]'.
+{"class":"VERSION","release":"3.15","rev":"3.15-2.fc23","proto_major":3,"proto_minor":11}
+To setup a GPSD sensor in your installation, add the following to your configuration.yaml file:
# Example configuration.yaml entry
+senosr:
+ - platform: gpsd
+Configuration variables:
+ +localhost.2947.The gtfs sensor will give you the next departure time and associated data from your public transit station/stop. The data comes from your chosen public transit authority and is formatted as General Transit Feed Specification data, commonly known as GTFS.
You need to find a valid GTFS data set, which you can usually find just by searching the internet. Most public transit authorities have GTFS available somewhere, as Google requires public transit authorities to provide the data if they wish to appear on Google Maps. You may also be able to find data at either TransitFeeds or GTFS Data Exchange.
+ +Here are some examples:
+ +You need to download a GTFS ZIP file and put it into a folder named gtfs in your configuration directory. For ease of use, it is suggested that you rename the file to just the agency/data source name (i.e. bart.zip instead of google_transit_20160328_v1.zip). You can also unzip and place a folder in the gtfs folder.
The data will be converted into a queryable format and saved as a SQLite3 database alongside the source data. The sensor will check for the existence of this SQLite3 data at every startup and will re-import the ZIP/Folder if none is found.
+ +To update the data, delete the SQLite3 file and restart Home Assistant.
+ +To find your stop ID, open the stops.txt file inside the ZIP file/unzipped folder. The format of the ID is different for every transit agency but will be the first “column” (meaning the string before the first comma) in a row.
The sensor attributes will contain all related information for the specific trip, such as agency information, origin and destination stop information, origin and destination stop time and the route information.
+ +Your mileage may vary depending on the transit agency used. Most agencies respect the GTFS format but some will do weird things like adding extra columns or using different data formatting. If you have any data specific issues, please report them to the PyGTFS project, which is what the GTFS sensor uses to parse data.
+ +Please note: This is a static data source. Currently, there is no GTFS Realtime support in this sensor due to issues surrounding parsing the protocol buffer format in Python 3. Once those issues have been fixed Realtime support will be added. Once added, the sensor will check for any delays and advisories and report them in the sensor as needed.
+ +# Example configuration.yaml entry
+sensor:
+ - platform: gtfs
+ origin: STOP_ID
+ destination: STOP_ID
+ data: DATA_SOURCE
+Configuration variables:
+ +gtfs folder of your configuration directory.The haveibeenpwned sensor platform creates sensors that check for breached email accounts on haveibeenpwned.
+To enable this sensor, add the following lines to your configuration.yaml, it will list every specified email address as a sensor showing
+the number of breaches on that email account:
# Example configuration.yaml entry using cloud based emoncms
+sensor:
+ platform: haveibeenpwned
+ email:
+ - your_email1@domain.com
+ - your_email2@domain.com
+If one of your email accounts is breached the sensor will display breach meta data. It will list the title of the site where your email
+account has been breached as well as the added date of the breach data. This data is displayed in descending order so that the state attribute
+breach 1 will always contain the last known breach for the specific email account, if there are any breaches detected.
+ 
+
+ The sensor will scan all email addresses specified with a 5 second delay between all breach data requests on Home Assistant startup. + After this initial startup scanning, the sensor will only scan one email account per 15 minutes to prevent abuse, and not hammer “the + Have I been Pwned” service, as this breach data almost never changes. +
+ + +The hddtemp sensor platform is using the data provided by HDDTemp.
It required that hddtemp is started or running in daemon mode on a local or remote system.
$ hddtemp -dF
+To setup a HDDTemp to your installation, add the following to your configuration.yaml file:
# Example configuration.yaml entry
+sensor:
+ - platform: hddtemp
+Configuration variables:
+ +hddtemp is running. Default to localhost.hddtemp . Default to 7634.The hp_ilo platform allows you to do an API call to the HP ILO (Integrated Lights-Out) sensor of your server, and use this data in (template) sensors.
The component will output the ILO information in the sensor attributes so they can be accessed like that.
+ +If the ILO only returns a single value (e.g. a temperature or state), it will be put in the state field.
+ +Some more details about what can be retrieved from these sensors is available in the python-hpilo documentation.
+ +
+ 
+
To use this component in your installation, add the following to your configuration.yaml file:
# Example configuration.yaml entry
+sensor:
+ - platform: hp_ilo
+ host: IP_ADDRESS or HOSTNAME
+ username: USERNAME
+ password: PASSWORD
+ monitored_variables:
+ - server_name
+ - server_fqdn
+ - server_host_data
+ - server_oa_info
+ - server_power_status
+ - server_power_readings
+ - server_power_on_time
+ - server_asset_tag
+ - server_uid_status
+ - server_health
+ - network_settings
+Configuration variables:
+ +443.server_name.
+ The URL for a sensor looks like the example below:
+ +http://IP_ADDRESS:8123/api/states/sensor.DEVICE_NAME
++You should choose a unique device name (DEVICE_NAME) to avoid clashes with other devices. +
+ +The JSON payload must contain the new state and should include the unit of measurement and a friendly name. The friendly name is used in the frontend to name the sensor.
+ +{"state": "20", "attributes": {"unit_of_measurement": "°C", "friendly_name": "Bathroom Temperature"}}
+For a quick test curl can be useful to “simulate” a device.
$ curl -X POST -H "x-ha-access: YOUR_PASSWORD" \
+ -H "Content-Type: application/json" \
+ -d '{"state": "20", "attributes": {"unit_of_measurement": "°C", "friendly_name": "Bathroom Temp"}}' \
+ http://localhost:8123/api/states/sensor.bathroom_temperature
+Use again curl to retrieve the current state to check if the sensor is working.
$ curl -X GET -H "x-ha-access: YOUR_PASSWORD" \
+ -H "Content-Type: application/json" \
+ http://localhost:8123/api/states/sensor.bathroom_temperature
+{
+ "attributes": {
+ "friendly_name": "Bathroom Temp",
+ "unit_of_measurement": "\u00b0C"
+ },
+ "entity_id": "sensor.bathroom_temperature",
+ "last_changed": "09:46:17 06-02-2016",
+ "last_updated": "09:48:46 06-02-2016",
+ "state": "20"
+}
+For more examples please visit the HTTP Binary Sensor page.
+ + +The imap sensor platform is observing your IMAP server and reporting the amount of unread emails.
To enable this sensor, add the following lines to your configuration.yaml file:
# Example configuration.yaml entry
+sensor:
+ - platform: imap
+ server: imap.gmail.com
+ port: 993
+ username: USERNAME
+ password: PASSWORD
+Configuration variables:
+ +The imap_email_content sensor platform will read emails from an IMAP email server and report them as a state change within Home Assistant. This is useful if you have a device that only reports its state via email.
To enable this sensor, add the following lines to your configuration.yaml file:
# Example configuration.yaml entry
+sensor:
+ - platform: imap_email_content
+ server: imap.gmail.com
+ port: 993
+ username: USERNAME
+ password: PASSWORD
+ senders:
+ - example@gmail.com
+Configuration variables:
+ +value_template (Optional): If specified this template will be used to render the state of sensor. If a template is not supplied the raw message body will be used for the sensor value. The following attributes will be supplied to the template:
+ +The InfluxDB sensor allows you to use values from an InfluxDB database to populate a sensor state. This can be use to present statistic about home_assistant sensors if used with the influxdb history component. It can also be used with an external data source.
To configure this sensor, you need to define the sensor connection variables and a list of queries to your configuration.yaml file. A sensor will be created for each query:
# Example configuration.yaml entry
+sensor:
+ - platform: influxdb
+ queries:
+ - name: mean value of foo
+ where: '"name" = ''foo'''
+ measurement: '"°C"'
+Configuration variables for the server:
+ +localhost.https instead of http to connect. Defaults to false.https request. Defaults to false.home_assistant.mean.The example configuration entry bellow create two request to your local InfluxDB instance, one to the database db1, the other to db2:
select last(value) as value from "°C" where "name" = "foo"select min(tmp) as value from "%" where "entity_id" = ''salon'' and time > now() - 1hsensor:
+ platform: influxdb
+ host: localhost
+ username: home-assistant
+ password: password
+ queries:
+ - name: last value of foo
+ unit_of_measurement: °C
+ value_template: '{{ value | round(1) }}'
+ group_function: last
+ where: '"name" = ''foo'''
+ measurement: '"°C"'
+ field: value
+ database: db1
+ - name: Min for last hour
+ unit_of_measurement: '%'
+ value_template: '{{ value | round(1) }}'
+ group_function: min
+ where: '"entity_id" = ''salon'' and time > now() - 1h'
+ measurement: '"%"'
+ field: tmp
+ database: db2
+The isy994 platform allows you to get data from your ISY994 sensor from within Home Assistant.
They will be automatically discovered if the isy994 component is loaded.
+ + +The knx sensor platform allows you to monitor KNX sensors.
The knx component must be configured correctly, see KNX Component.
There is currently support for the following KNX data point types:
+ +| Condition | +KNX Datapoint Type | +Unit of measurement | +Data type | +
|---|---|---|---|
| Temperature | +9.001 | +°C | +2 Byte Float | +
| Speed (Wind speed) | +9.005 | +m/s | +2 Byte Float | +
| Illuminance (Lux) | +9.004 | +Lux | +2 Byte Float | +
To use your KNX sensor in your installation, add the following to your configuration.yaml file:
# Example configuration.yaml entry
+sensor:
+ - platform: knx
+ type: temperature
+ address: 1/0/3
+
+ - platform: knx
+ name: Wind speed
+ type: speed_ms
+ address: 1/0/0
+
+ - platform: knx
+ name: Lux
+ type: illuminance
+ address: 1/0/1
+Configuration variables:
+ +The lastfm sensor platform will allow you to see whenever a user starts scrobbling, their play count, last song played, and top song played on Last.fm.
To get an API key you need to create an API account.
+ +To use Last.fm with your installation, add the following to your configuration.yaml file:
# Example configuration.yaml entry
+sensor:
+ - platform: lastfm
+ api_key: YOUR_API_KEY
+ users:
+ - user1
+ - user2
+Configuration variables:
+ +The linux_battery sensor platform is using the information stored in /sys/class/power_supply/ on your local Linux system to display details about the current state of your battery.
To setup a battery sensor to your installation, add the following to your configuration.yaml file:
# Example configuration.yaml entry
+sensor:
+ - platform: linux_battery
+Configuration variables:
+ +1.Integrate your Loop Energy meter information into Home Assistant. To use this sensor you need the the client serial number and secret keys for your devices.
+ +The library used to get the data isn’t officially supported and the only way to get the keys is to log into loop energy’s website and type a command into your browser console.
+ +To do this log into Loop Energy. Once you’re logged in you should be able see see your live readings on the webpage.
+ +You can then open your browser’s console window, how you do this varies by browser but in Chrome you click on `More Tools / Developer Tools’ and click on the console window. You then type:
+ +Drupal.settings.navetas_realtime.
This should show something like
+ +client_ip: "127.0.0.1"
+gas_secret: "GAS_SECRET"
+gas_serial: "GAS_SERIAL"
+host: "www.your-loop.com"
+...
+secret: "ELECTRICAL_SECRET"
+serial: "ELECTRICAL_SERIAL"
+The serial and secret tokens are the ones you need. If you just have an electricity monitor then you won’t see the gas keys.
+ +Now you have the keys, add the following lines to your configuration.yaml, replacing the *_SERIAL and *_SECRET keys with the ones you found in the console:
# Example configuration.yaml entry
+sensor:
+ - platform: loopenergy
+ electricity:
+ electricity_serial: 'ELECTRICAL_SERIAL'
+ electricity_secret: 'ELECTRICAL_SECRET'
+ gas:
+ gas_serial: 'GAS_SERIAL'
+ gas_secret: 'GAS_SECRET'
+Configuration variables:
+ +imperial or metric. Defaults to metric.The electricity readings are updated every 10 seconds and the gas readings every 15 minutes.
+ +The gas readings are experimental and not all gas meters are properly supported. So if the data you see doesn’t agree with the readings you see via loop energy please report an issue.
+ + +The mfi sensor platform to allow you to monitor mFi mPort interface and sensors.
To add this platform to your installation, add the following to your configuration.yaml file:
# Example configuration.yaml entry
+sensor:
+ platform: mfi
+ host: IP_ADDRESS
+ port: PORT
+ username: USERNAME
+ password: PASSWORD
+ ssl: true
+ verify_ssl: true
+Configuration variables:
+ +True, use SSL/TLS to contact the mFi controller. Defaults to True.False if your mFi controller has a self-signed certificate. Defaults to True.The MH-Z19 is a small nondispersive infrared sensor that can measure CO2 sensors. High CO2 levels can lead to drowsiness, poor concentration, loss of attention or increased heart rate. The CO2 level outside is around 400ppm, but inside levels can reach between 1000 and 5000 ppm. High CO2 levels indicate that you should increase ventilation.
+ +Check out the Open Home Automation web site for a quick guide how to connect the sensor to your PC or Raspberry Pi.
+ +To use this sensor in your installation, add the following to your configuration.yaml file:
sensor:
+ - platform: mhz19
+ serial_device: /dev/tty.SLAB_USBtoUART
+$ ls /dev/tty*The Mi Flora plant sensor is a small Bluetooth Low Energy device that monitors not only the moisture, but also light, temperature and +conductivity. As only a single BLE device can be polled at the same time, the library implements locking to make sure this is the case.
+ +To use your Mi Flora plant sensor in your installation, add the following to your configuration.yaml file:
# Example configuration.yaml entry
+sensor
+ platform: miflora
+ mac: xx:xx:xx:xx:xx:xx
+ name: Flower 1
+ force_update: false
+ median: 3
+ monitored_conditions:
+ - moisture
+ - light
+ - temperature
+ - conductivity
+hcitool lescan from command line.Note that by default the sensor is only polled once every 15 minutes. This means with the median=3 setting, it will take as least 30 minutes before the sensor will report a value after a Home Assistant restart. As the values usually change very slowly, this isn’t a big problem. +Reducing polling intervals will have a negative effect on the battery life.
+ + +The min_max sensor platform is consuming the state from other sensors and determine the minimum, maximum, and the mean of the collected states. The sensor will always show you the highest/lowest value which was received from your all monitored sensors. If you have spikes in your values, it’s recommanded filter/equalize your values with a statistics sensor first.
It’s an alternative to the template sensor’s value_template: to get the average of multiple sensors.
{{ ((float(states.sensor.kitchen_temperature.state) +
+ float(states.sensor.living_room_temperature.state) +
+ float(states.sensor.office_temperature.state)) / 3) | round(2)
+}}
+To enable the minimum/maximum sensor, add the following lines to your configuration.yaml:
# Example configuration.yaml entry
+sensor:
+ - platform: min_max
+ entity_ids:
+ - sensor.kitchen_temperature
+ - sensor.living_room_temperature
+ - sensor.office_temperature
+Configuration variables:
+ +max.The modbus sensor allows you to gather data from Modbus registers.
To use your Modbus sensors in your installation, add the following to your configuration.yaml file:
# Example configuration.yml entry
+sensor:
+ platform: modbus
+ registers:
+ - name: Sensor1
+ unit_of_measurement: °C
+ slave: 1
+ register: 100
+ - name: Sensor2
+ unit_of_measurement: mg
+ slave: 1
+ register: 110
+ count: 2
+ - name: Sensor3
+ unit_of_measurement: °C
+ slave: 1
+ register: 120
+ scale: 0.01
+ offset: -273.16
+ precision: 2
+Configuration variables:
+ +The Mold Indicator sensor component consumes information of two temperature sensors and a humidity sensor to give an indication for possible mold growth in your home. In case of bad ventilation and insulation, the indoor humidity may lead to condensation on cold surfaces as the windows or even walls. Condensation or a high relative humidity near those cold surfaces leads to a higher risk for mold growth. This sensor component estimates the temperature at a pre-calibrated critical point in the room (the coldest surface) and calculates the relative humidity of the air at that point. If the sensor value rises above approximately 70 percent, mold growth might occur and the room should be ventilated. At 100%, the air humidity condensates at the critical point.
+ +The sensor data may be used e.g. to signal bad air quality (too high air humidity) or to automate operation of indoor air humidifiers to keep the indoor humidity at an optimum. To use the Mold Indicator sensor in your installation, add the following to your configuration.yaml file:
# Example configuration.yaml entry
+sensor:
+ - platform: mold_indicator
+ indoor_temp_sensor: sensor.temp
+ indoor_humidity_sensor: sensor.humidity
+ outdoor_temp_sensor: sensor.weather_temperature
+ calibration_factor: 2.0
+Configuration variables:
+ +In this case, the weather forecast temperature sensor is used for the outside temperature.
+ +The Mold Indicator sensor component needs to be calibrated in order to estimate the temperature at the critical point from the outdoor and indoor temperature. First find the coldest surface in the room (critical point), which is typically near the window frames, but depends on the insulation of your home. For calibration you need to measure the temperature at this critical point and simultaneously write down the values for the indoor- and outdoor temperature sensors used for the Mold Indicator. Be sure that there is a significant indoor to outdoor temperature difference to get the best calibration results. +With the three measured temperatures (in Celsius or Fahrenheit), the calibration_factor for your configuration file is given by:
+ +calibration_factor = (temp_indoor - temp_outdoor) / (temp_criticalpoint - temp_outdoor)
+This mqtt sensor platform uses the MQTT message payload as the sensor value. If messages in this state_topic are published with RETAIN flag, the sensor will receive an instant update with last known value. Otherwise, the initial state will be undefined.
To use your MQTT sensor in your installation, add the following to your configuration.yaml file:
# Example configuration.yml entry
+sensor:
+ - platform: mqtt
+ state_topic: "home/bedroom/temperature"
+Configuration variables:
+ +In this section you find some real life examples of how to use this sensor.
+ +If you are using the Owntracks and enable the reporting of the battery level then you can use a MQTT sensor to keep track of your battery. A regular MQTT message from Owntracks looks like this:
+ +owntracks/tablet/tablet {"_type":"location","lon":7.21,"t":"u","batt":92,"tst":144995643,"tid":"ta","acc":27,"lat":46.12}
+Thus the trick is extract the battery level from the payload.
+ +# Example configuration.yml entry
+sensor:
+ - platform: mqtt
+ state_topic: "owntracks/tablet/tablet"
+ name: "Battery Tablet"
+ unit_of_measurement: "%"
+ value_template: '{{ value_json.batt }}'
+If you are using a DHT sensor and a NodeMCU board (esp8266), you can retrieve temperature and humidity with a MQTT sensor. A code example can be found here. A regular MQTT message from this example looks like this:
+ +office/sensor1
+ {
+ "temperature": 23.20,
+ "humidity": 43.70
+ }
+Then use this configuration example to extract the data from the payload:
+ +# Example configuration.yml entry
+sensor:
+ - platform: mqtt
+ state_topic: 'office/sensor1'
+ name: 'Temperature'
+ unit_of_measurement: '°C'
+ value_template: '{{ value_json.temperature }}'
+ - platform: mqtt
+ state_topic: 'office/sensor1'
+ name: 'Humidity'
+ unit_of_measurement: '%'
+ value_template: '{{ value_json.humidity }}'
+The mqtt_room sensor platform allows you to detect the indoor location of devices using MQTT clients.
To use this device tracker in your installation, add the following to your configuration.yaml file:
# Example configuration.yaml entry
+sensor:
+ platform: mqtt_room
+ device_id: 123testid
+ name: 'Cool device'
+ state_topic: 'room_presence'
+ timeout: 5
+ away_timeout: 60
+Configuration variables:
+ +away if there were no updates. 0 disables the check and is the default.Example JSON that should be published to the room topics:
+ +{
+ "id": "123testid",
+ "name": "Test Device",
+ "distance": 5.678
+}
+This component works with any software that is sending data in the given format. +Each client should post the discovered devices in its own subtopic of the configured topic. +Instead of developing your own application, you can also use any of these already existing clients:
+ +Integrates MySensors sensors into Home Assistant. See the main component for configuration instructions.
+ +The following sensor types are supported:
+ +| S_TYPE | +V_TYPE | +
|---|---|
| S_TEMP | +V_TEMP | +
| S_HUM | +V_HUM | +
| S_BARO | +V_PRESSURE, V_FORECAST | +
| S_WIND | +V_WIND, V_GUST | +
| S_RAIN | +V_RAIN, V_RAINRATE | +
| S_UV | +V_UV | +
| S_WEIGHT | +V_WEIGHT, V_IMPEDANCE | +
| S_POWER | +V_WATT, V_KWH | +
| S_DISTANCE | +V_DISTANCE | +
| S_LIGHT_LEVEL | +V_LIGHT_LEVEL | +
| S_IR | +V_IR_RECEIVE | +
| S_WATER | +V_FLOW, V_VOLUME | +
| S_AIR_QUALITY | +V_DUST_LEVEL | +
| S_CUSTOM | +V_VAR1, V_VAR2, V_VAR3, V_VAR4, V_VAR5 | +
| S_DUST | +V_DUST_LEVEL | +
| S_SCENE_CONTROLLER | +V_SCENE_ON, V_SCENE_OFF | +
| S_TYPE | +V_TYPE | +
|---|---|
| S_COLOR_SENSOR | +V_RGB | +
| S_MULTIMETER | +V_VOLTAGE, V_CURRENT, V_IMPEDANCE | +
| S_SOUND | +V_LEVEL | +
| S_VIBRATION | +V_LEVEL | +
| S_MOISTURE | +V_LEVEL | +
| S_LIGHT_LEVEL | +V_LEVEL | +
| S_AIR_QUALITY | +V_LEVEL (replaces V_DUST_LEVEL) | +
| S_DUST | +V_LEVEL (replaces V_DUST_LEVEL) | +
| S_TYPE | +V_TYPE | +
|---|---|
| S_INFO | +V_TEXT | +
| S_GAS | +V_FLOW, V_VOLUME | +
| S_GPS | +V_POSITION | +
| S_WATER_QUALITY | +V_TEMP, V_PH, V_ORP, V_EC | +
Some sensor value types are not specific for a certain sensor type. These do not have a default unit of measurement in Home Assistant. For example, the V_LEVEL type can be used for different sensor types, dust, sound, vibration etc.
+ +By using V_UNIT_PREFIX, it’s possible to set a custom unit for any sensor. The string value that is sent for V_UNIT_PREFIX will be used in preference to any other unit of measurement, for the defined sensors. V_UNIT_PREFIX can’t be used as a standalone sensor value type. Sending a supported value type and value from the tables above is also required. V_UNIT_PREFIX is available with MySensors version 1.5 and later.
+ +For more information, visit the serial api of MySensors.
+ +/**
+ * Documentation: http://www.mysensors.org
+ * Support Forum: http://forum.mysensors.org
+ *
+ * http://www.mysensors.org/build/light
+ */
+
+#include <SPI.h>
+#include <MySensor.h>
+#include <BH1750.h>
+#include <Wire.h>
+
+#define SN "LightLuxSensor"
+#define SV "1.0"
+#define CHILD_ID 1
+unsigned long SLEEP_TIME = 30000; // Sleep time between reads (in milliseconds)
+
+BH1750 lightSensor;
+MySensor gw;
+MyMessage msg(CHILD_ID, V_LEVEL);
+MyMessage msgPrefix(CHILD_ID, V_UNIT_PREFIX); // Custom unit message.
+uint16_t lastlux = 0;
+
+void setup()
+{
+ gw.begin();
+ gw.sendSketchInfo(SN, SV);
+ gw.present(CHILD_ID, S_LIGHT_LEVEL);
+ lightSensor.begin();
+ gw.send(msg.set(lastlux));
+ gw.send(msgPrefix.set("lux")); // Set custom unit.
+}
+
+void loop()
+{
+ uint16_t lux = lightSensor.readLightLevel(); // Get Lux value
+ if (lux != lastlux) {
+ gw.send(msg.set(lux));
+ lastlux = lux;
+ }
+
+ gw.sleep(SLEEP_TIME);
+}
+The nest sensor platform let you monitor sensors connected to your Nest thermostat and/or your Nest Protect Smoke Alarm.
+You must have the Nest component configured to use those sensors. +
+ +To set it up, add the following information to your configuration.yaml file:
# Example configuration.yaml entry
+sensor:
+ platform: nest
+ monitored_conditions:
+ - 'temperature'
+ - 'target'
+ - 'humidity'
+ - 'operation_mode'
+ - 'last_connection'
+ - 'co_status' # Nest Protect only
+ - 'smoke_status' # Nest Protect only
+Configuration variables:
+ +The nest weather sensor platform let you monitor current weather conditions based on the location of your Nest thermostat.
+You must have the Nest component configured to use those sensors. +
+ +To set it up, add the following information to your configuration.yaml file:
sensor:
+ - platform: nest
+ monitored_conditions:
+ - 'weather_temperature'
+ - 'weather_humidity'
+ - 'weather_condition'
+ - 'wind_speed'
+ - 'wind_direction'
+Configuration variables:
+ +The netatmo sensor platform is consuming the information provided by a Netatmo device.
To enable the Netatmo sensor, you have to set up netatmo, this will use discovery to add your sensor.
+ +If you want to select a specific sensor, set discovery to False for netatmo and add the following lines to your configuration.yaml:
The netatmo sensor platform is consuming the information provided by a Netatmo device.
To enable the Netatmo sensor, you first have to set up netatmo, and add the following lines to your configuration.yaml:
# Example configuration.yaml entry
+sensor:
+ platform: netatmo
+ station: STATION_NAME
+ modules:
+ module_name1:
+ - temperature
+ module_name2:
+ - temperature
+ - battery_vp
+Configuration variables:
+ +You can find your modules name in your online NetAtmo account. These names can be found and changed in parameters. You have to provide these name in your Home Assistant configuration.yaml file.
+
+
Integrate your Neurio meter information into Home Assistant. To get an API key and secret, login to your Neurio account and register an application. Note the Homepage URL and Callback URL are optional.
+ +To enable this sensor in your installation, add the following to your configuration.yaml file:
# Example configuration.yaml entry
+sensor:
+ platform: neurio_energy
+ api_key: CLIENT_ID
+ api_secret: CLIENT_SECRET
+Configuration variables:
+ +The nzbget platform will allow you to monitor your downloads with NZBGet from within Home Assistant and setup automation based on the information.
To use NZBGet with your installation, add the following to your configuration.yaml file:
# Example configuration.yaml entry
+sensor:
+ platform: nzbget
+ host: YOUR_NZBGET_HOST
+ monitored_variables:
+ - article_cache
+ - download_rate
+ - download_paused
+Configuration variables:
+ +The octoprint sensor platform let you monitor various states of your 3D printer and its print jobs.
+You must have the OctoPrint component configured to use this sensor. +
+ +To set it up, add the following information to your configuration.yaml file:
sensor:
+ - platform: octoprint
+ name: OctoPrint
+ monitored_conditions:
+ - Current State
+ - Temperatures
+ - Job Percentage
+Configuration variables:
+ +print, head, print bed, etc. These will be displayed as tool0, tool1, or toolN please refer to your OctoPrint frontend to associate the tool number with an actual device.The ohmconnect sensor will show you the current OhmConnect status for the given OhmConnect ID.
++ +OhmConnect monitors real-time conditions on the electricity grid. When dirty and unsustainable power plants turn on, our users receive a notification to save energy. By saving energy at that time, California does not have to turn on additional power plants and California’s energy authorities pay you for that.
+
You can find your OhmConnect ID under “Open Source Projects” on the settings page. It’s the string after the last / in the URL, i.e. for the URL https://login.ohmconnect.com/verify-ohm-hour/AbCd1e your ID is AbCd1e.
# Example configuration.yaml entry
+sensor:
+ - platform: ohmconnect
+ id: AbCd1e
+Configuration variables:
+ +The onewire platform supports sensors which are using the One wire (1-wire) bus for communication.
Supported devices:
+ + + +The 1-Wire bus can be connected directly to the IO pins of Raspberry Pi or using dedicated interface adapter (e.g DS9490R). When an interface adapter is used, sensors can be accessed on Linux hosts via owfs 1-Wire file system. When using an interface adapter and the owfs, the ‘mount_dir’ option must be configured to correspond a directory, where owfs device tree has been mounted. If you are using Raspberry Pi and IO pin connected bus setup, don’t use the ‘mount_dir’ option.
+ +To enable One wire sensors in your installation, add the following to your configuration.yaml file:
# Example configuration.yaml entry
+sensor:
+ - platform: onewire
+ names:
+ some_id: your name
+Configuration variables:
+ +The openexchangerates sensor will show you the current exchange rate from Open Exchange Rates that provides realtime exchange rates for 170 currencies. The free account is limited to only USD as a base currency, allows 1000 requests per month, and updates every hour.
Obtain your API key here
+ +To enable this sensor, add the following lines to your configuration.yaml file:
# Example configuration.yaml entry
+sensor:
+ - platform: openexchangerates
+ api_key: YOUR_API_KEY
+ quote: EUR
+Configuration variables:
+ +The openweathermap platform uses OpenWeatherMap as an source for current meteorological data for your location. The forecast will show you the condition in 3 h.
You need an API key which is free but requires a registration.
+ +To add OpenWeatherMap to your installation, add the following to your configuration.yaml file:
# Example configuration.yaml entry
+sensor:
+ - platform: openweathermap
+ api_key: YOUR_API_KEY
+ monitored_conditions:
+ - weather
+ - temperature
+ - wind_speed
+ - humidity
+ - pressure
+ - clouds
+ - rain
+ - snow
+Configuration variables:
+ +Details about the API are available in the OpenWeatherMap documentation.
+ +Only metric measurements are supported at the moment.
+ + + +The pi_hole sensor platform is displaying the statistical summary of a Pi-Hole system.
To enable this sensor, add the following lines to your configuration.yaml file for a GET request:
# Example configuration.yaml entry
+sensor:
+ - platform: pi_hole
+Configuration variables:
+ +localhost.true, use SSL/TLS to connect to the Pi-Hole system. Defaults to False.True.This pilight sensor platform for 433 MHz devices uses a value in the message payload as the sensor value. Unique identifiers (e.g. uuid) can be set to distinguish between multile pilight devices. To use a pilight sensor the pilight home assistant hub has to be set up.
To use your sensor via pilight, make sure it is supported and add the following to your configuration.yaml file:
# Example configuration.yml entry
+sensor:
+ - platform: pilight
+ variable: temperature
+ payload:
+ uuid: '0000-b8-27-eb-f447d3'
+Configuration variables:
+ +This section shows a real life example how to use values of a weather station.
+ +# Example configuration.yml entry
+sensor:
+ - platform: pilight
+ name: 'Temperature'
+ variable: 'temperature'
+ payload:
+ uuid: 0000-b8-27-eb-f1f72e
+ unit_of_measurement: '°C'
+ - platform: pilight
+ name: 'Humidity'
+ variable: 'humidity'
+ payload:
+ uuid: 0000-b8-27-eb-f1f72e
+ unit_of_measurement: '%'
+ - platform: pilight
+ name: 'Battery'
+ variable: 'battery'
+ payload:
+ uuid: 0000-b8-27-eb-f1f72e
+ unit_of_measurement: '%'
+The plex sensor platform will monitor activity on a given Plex Media Server. It will create a sensor that shows the number of currently watching users as the state. If you click the sensor for more details it will show you who is watching what.
If your Plex server is on the same local network as Home Assistant, all you need to provide in the configuration.yaml is the host or IP address. If you want to access a remote Plex server, you must provide the Plex username, password, and optionally the server name of the remote Plex server. If no server name is given it will use the first server listed. If you use the username and password, all servers in that account are monitored.
If you want to enable the plex sensor, add the following lines to your configuration.yaml:
# Example configuration.yaml entry
+sensor:
+ - platform: plex
+Configuration variables:
+ +localhost.32400.The random sensor platform is creating random sensor values (integers) out of a given range. This can be useful if you want to test automation rules.
To enable the random sensor, add the following lines to your configuration.yaml:
# Example configuration.yaml entry
+sensor:
+ - platform: random
+Configuration variables:
+ +Random Sensor.0.20.The rest sensor platform is consuming a given endpoint which is exposed by a RESTful API of a device, an application, or a web service. The sensor has support for GET and POST requests.
To enable this sensor, add the following lines to your configuration.yaml file for a GET request:
# Example configuration.yaml entry
+sensor:
+ - platform: rest
+ resource: http://IP_ADDRESS/ENDPOINT
+or for a POST request:
+ +# Example configuration.yaml entry
+sensor:
+ - platform: rest
+ resource: http://IP_ADDRESS/ENDPOINT
+ method: POST
+ payload: '{ "device" : "heater" }'
+Configuration variables:
+ +GET.True.basic or digest.+Make sure that the URL exactly matches your endpoint or resource. +
+ +curl can help you identify the variable you want to display in your Home Assistant frontend. The example below shows the JSON response of a device that is running with aREST.
$ curl -X GET http://192.168.1.31/temperature/
+{"temperature": 77, "id": "sensor02", "name": "livingroom", "connected": true}
+In this section you find some real life examples of how to use this sensor.
+ +You can find your external IP address using the service JSON Test at their http://ip.jsontest.com/ endpoint.
+ +To display the IP address, the entry for a sensor in the configuration.yaml file will look like this.
sensor:
+ - platform: rest
+ resource: http://ip.jsontest.com
+ name: External IP
+ value_template: '{{ value_json.ip }}'
+The glances sensor is doing the exact same thing for all exposed values.
+ +Add something similar to the entry below to your configuration.yaml file:
sensor:
+ - platform: rest
+ resource: http://IP_ADRRESS:61208/api/2/mem/used
+ name: Used mem
+ value_template: '{{ value_json.used| multiply(0.000000954) | round(0) }}'
+ unit_of_measurement: MB
+The Home Assistant API exposes the data from your attached sensors. If you are running multiple Home Assistant instances which are not connected you can still get information from them.
+ +If the Home Assistant instance in the resource variable is protected by an API password, you can append ?api_password=YOUR_PASSWORD to the resource URL to authenticate or use headers:.
sensor:
+ - platform: rest
+ resource: http://IP_ADDRESS:8123/api/states/sensor.weather_temperature
+ name: Temperature
+ value_template: '{{ value_json.state }}'
+ unit_of_measurement: "°C"
+The REST sensor supports HTTP authentication and customized headers.
+ +sensor:
+ - platform: rest
+ resource: http://IP_ADDRESS:5000/sensor
+ username: ha1
+ password: test1
+ authentication: basic
+ headers:
+ User-Agent: Home Assistant
+ Content-Type: application/json
+The headers will contain all relevant details. This will also give you the ability to access endpoints that are protected by tokens.
+ +Content-Length: 1024
+Host: IP_ADDRESS1:5000
+Authorization: Basic aGExOnRlc3Qx
+Accept-Encoding: identity
+Content-Type: application/json
+User-Agent: Home Assistant
+This sample is very similar to the updater component but the information is recieved from GitHub.
sensor:
+ - platform: rest
+ resource: https://api.github.com/repos/home-assistant/home-assistant/releases/latest
+ username: YOUR_GITHUB_USERNAME
+ password: YOUR_GITHUB_ACCESS_TOKEN
+ authentication: basic
+ value_template: '{{ value_json.tag_name }}'
+ headers:
+ Accept: application/vnd.github.v3+json
+ Content-Type: application/json
+ User-Agent: Home Assistant REST sensor
+The rfxtrx platform support sensors that communicate in the frequency range of 433.92 MHz.
First you have to set up your rfxtrx hub.
+The easiest way to find your sensors is to add this to your configuration.yaml:
# Example configuration.yaml entry
+sensor:
+ platform: rfxtrx
+ automatic_add: True
+Then when the sensor emits a signal it will be automatically added:
+ +
+
+
Here the name is 0a52080000301004d240259 and you can verify that it works from the frontend.
+Then you should update your configuration to:
# Example configuration.yaml entry
+sensor:
+ platform: rfxtrx
+ devices:
+ 0a52080000301004d240259:
+ name: device_name
+If you want to display several data types from one sensor:
+ +# Example configuration.yaml entry
+sensor:
+ platform: rfxtrx
+ devices:
+ 0a520802060100ff0e0269:
+ name: Bath
+ data_type:
+ - Humidity
+ - Temperature
+Example configuration:
+ +# Example configuration.yaml entry
+sensor:
+ platform: rfxtrx
+ automatic_add: True
+ devices:
+ 0a52080705020095220269:
+ name: Lving
+ fire_event: True
+ 0a520802060100ff0e0269:
+ name: Bath
+ data_type:
+ - Humidity
+ - Temperature
+Configuration variables:
+ +The sabnzbd platform will allow you to monitor your downloads with SABnzbd from within Home Assistant and setup automation based on the information.
To use SABnzbd with your installation, add the following to your configuration.yaml file:
# Example configuration.yaml entry
+sensor:
+ platform: sabnzbd
+ host: YOUR_SABNZBD_HOST
+ api_key: YOUR_API_KEY
+ monitored_variables:
+ - 'current_status'
+ - 'speed'
+ - 'queue_size'
+ - 'queue_remaining'
+ - 'disk_size'
+ - 'disk_free'
+Configuration variables:
+ +8080.https instead of http to connect. Defaults to False.Note that this will create sensors under the name ‘sab’ and NOT ‘sabnzbd’ as follows:
+ + - sensor.sab_status
+ - sensor.sab_speed
+ - sensor.sab_queue
+ - sensor.sab_left
+ - sensor.sab_disk
+ - sensor.sab_disk_free
+As always, you can determine the names of sensors by looking at the dev-state page < > in the web interface.
The scrape sensor platform is scraping information from websites. The sensor loads a HTML page and gives you the option to search and split out a value. As this is not a full-blown web scraper like scrapy. It will most likely only works with simple webpage and it can be time-consuming to get the right section.
To enable this sensor, add the following lines to your configuration.yaml file:
# Example configuration.yaml entry
+sensor:
+ - platform: scrape
+ resource: https://home-assistant.io
+ select: ".current-version h1"
+Configuration variables:
+ +In this section you find some real life examples of how to use this sensor. There is also a Jupyter notebook available for this example to give you a bit more insight.
+ +The current release Home Assistant is published on https://home-assistant.io/
+ +sensor:
+# Example configuration.yaml entry
+ - platform: scrape
+ resource: https://home-assistant.io
+ name: Release
+ select: ".current-version h1"
+ value_template: '{{ value.split(":")[1] }}'
+Get the counter for all our implementations from the Component overview page.
+ +# Example configuration.yaml entry
+sensor:
+ - platform: scrape
+ resource: https://home-assistant.io/components/
+ name: Home Assistant impl.
+ select: 'a[href="#all"]'
+ value_template: '{{ value.split("(")[1].split(")")[0] }}'
+The German Federal Office for Radiation protection (Bundesamt für Strahlenschutz) is publishing various details about optical radiation including an UV index. This example is getting the index for a region in Germany.
+ +sensor:
+# Example configuration.yaml entry
+ - platform: scrape
+ resource: http://www.bfs.de/DE/themen/opt/uv/uv-index/prognose/prognose_node.html
+ name: Coast Ostsee
+ select: 'p:nth-of-type(19)'
+ unit_of_measurement: 'UV Index'
+If you make heavy use of the IFTTT web service for your automations and are curious about the status of IFTTT then you can display the current state of IFTTT in your frontend.
+ +sensor:
+# Example configuration.yaml entry
+ - platform: scrape
+ resource: http://status.ifttt.com/
+ name: IFTTT status
+ select: '.component-status'
+Particulate matter sensors measure the amount of very small particles in the air. A short introduction how these sensors work can be found on Open Home Automation.
+ +Cheap LED based sensors usually use a GPIO interface that is hard to attach to computers. However, there are a lot of laser LED based sensors on the market that use a serial interface and can be connected to your Home Assistant system easily with an USB to serial converter.
+ +At this time, the following sensors are supported:
+ +To use your PM sensor in your installation, add the following to your configuration.yaml file:
sensor:
+ - platform: serial_pm
+ serial_device: /dev/tty.SLAB_USBtoUART
+ name: Nova
+ brand: novafitness,sds011
+$ ls /dev/tty*To get your SleepIQ sensors working with Home Assistant, follow the instructions for the general SleepIQ component.
+ + +The snmp sensor platform simple displays the information which are available through the Simple Network Management Protocol (SNMP). SNMP uses a tree-like hierarchy where each node is an object.
To enable this sensor in your installation, add the following to your configuration.yaml file:
# Example configuration.yaml entry
+sensor:
+ - platform: snmp
+ host: 192.168.1.32
+ baseoid: 1.3.6.1.4.1.2021.10.1.3.1
+Configuration variables:
+ +192.168.1.32.161.public with read-only permission (which is sufficient).The OIDs may vary on different system because they are vendor-specific. Beside the device’s manual is the OID Repository a good place to start if you are looking for OIDs. The following OIDs are for the load of a Linux systems.
+ +There is a large amount of tools available to work with SNMP. snmpwalk let you easily retrieve the value of a OID.
$ snmpwalk -Os -c public -v 2c 192.168.1.32 1.3.6.1.4.1.2021.10.1.3.1
+laLoad.1 = STRING: 0.19
+The speedtest sensor component uses the Speedtest.net web service to measure network bandwidth performance.
By default, it will run every hour. The user can change the update frequency in the configuration by defining the minute, hour, and day for a speedtest to run. For the server_id check the list of available servers.
To add a Speedtest.net sensor to your installation, add the following to your configuration.yaml file:
Once per hour, on the hour (default):
+ +# Example configuration.yaml entry
+sensor:
+ platform: speedtest
+ monitored_conditions:
+ - ping
+ - download
+ - upload
+Configuration variables:
+ +This component uses speedtest-cli to gather network performance data from Speedtest.net. Please be aware of the potential inconsistencies that this component may display.
+ +When Home Assistant first starts up, the values of the speedtest will show as Unknown. You can use the service sensor.update_speedtest to run a manual speedtest and populate the data or just wait for the next regularly scheduled test.
In this section you find some real life examples of how to use this sensor.
+ +Every half hour of every day:
+ +# Example configuration.yaml entry
+sensor:
+ - platform: speedtest
+ minute:
+ - 0
+ - 30
+ monitored_conditions:
+ - ping
+ - download
+ - upload
+Everyday at 12:30AM, 6:30AM, 12:30PM, 6:30PM:
+ +# Example configuration.yaml entry
+sensor:
+ platform: speedtest
+ minute: 30
+ hour:
+ - 0
+ - 6
+ - 12
+ - 18
+ monitored_conditions:
+ - ping
+ - download
+ - upload
+The statistics sensor platform is consuming the state from other sensors. Beside the maximal and the minimal value also the total, the mean, the median, the variance, and the standard deviation are as attributes available. If it’s a binary sensor then only the state changes are counted.
It can take time till the sensor starts to work because a couple of atrributes need more than one value to do the calculation.
+ +To enable the statistics sensor, add the following lines to your configuration.yaml:
# Example configuration.yaml entry
+sensor:
+ - platform: statistics
+ entity_id: sensor.cpu
+ - platform: statistics
+ entity_id: binary_sensor.movement
+Configuration variables:
+ +Stats.20.
+
+
The Steam component will allow you to track the online status of public Steam accounts.
+ +You need an API key which is free to use the component
+ +To find an account’s 64-bit SteamID you can check the URL of the profile page, if it ends with a long string on numbers then that’s the 64-bit SteamID. However, if the profile has a custom URL you will have to copy the it and enter it into STEAMID I/O to find the 64-bit SteamID.
+ +To use Steam in your installation, add the following to your configuration.yaml file:
# Example configuration.yaml entry
+sensor:
+ - platform: steam_online
+ api_key: YOUR_API_KEY
+ accounts:
+ - account1
+ - account2
+Configuration variables:
+ +If you want to add the accounts to a group for example you will have to use:
+ +# Example configuration.yaml entry
+group:
+ steam:
+ name: Steam
+ entities:
+ - sensor.steam_account1
+ - sensor.steam_account2
+The supervisord platform allows you to track the states of Supervisord.
To use this sensor in your installation, add the following to your configuration.yaml file:
# Example configuration.yaml entry
+sensor:
+ - platform: supervisord
+Configuration variables:
+ +http://localhost:9001/RPC2.The swiss_hydrological_data sensor will show you details (temperature, level, and discharge) of rivers and lakes in Switzerland.
The station overview contains a list of all available measuring points and will help to determine the ID of station which is needed for the configuration.
+ +To enable this sensor, add the following lines to your configuration.yaml file:
# Example configuration.yaml entry
+sensor:
+ platform: swiss_hydrological_data
+ station: STATION_ID
+Configuration variables:
+ +The hydrological measurings are coming from the Swiss Federal Office for the Environment (Bundesamt für Umwelt - Abt. Hydrologie) and are updated almost in real-time.
+ +This sensor contains additional information which an easily accessed by a template sensor.
+ +# Example configuration.yaml entry
+sensor:
+ platform: template
+ sensors:
+ discharge:
+ value_template: '{{ states.sensor.aare.attributes.Discharge }}'
+ friendly_name: 'Discharge'
+The swiss_public_transport sensor will give you the next two departure times from a given location to another one in Switzerland.
The Stationboard website can help to determine the exact name of the start and the end station. With the station names it’s necessary to search for the ID of those stations:
+ +http://transport.opendata.ch/v1/locations?query=[Station name]
+ +If the score is 100 (“score”:”100” in the response), it is a perfect match. Then add the data to your configuration.yaml file as shown in the example:
# Example configuration.yaml entry
+sensor:
+ - platform: swiss_public_transport
+ from: STATION_ID
+ to: STATION_ID
+Configuration variables:
+ +The public timetables are coming from Swiss public transport.
+ + +This synologydsm sensor allows getting various statistics from your Synology NAS. Please note that using this sensor wakes up your synology if in hibernation mode.
To use the SynologyDSM sensor in your installation, add the following to your configuration.yaml file:
# Example configuration.yml entry
+sensor:
+ - platform: synologydsm
+ host: IP_ADDRESS_OF_SYNOLOGY_NAS
+ username: USERNAME
+ password: PASSWORD
+ monitored_conditions:
+ - cpu_total_load
+ - memory_real_usage
+ - network_up
+Note: After booting HASS it can take up to 15 minutes for the sensors to show up. This is due to the fact that sensors are created after HASS has fully been initialised.
+ +Configuration variables:
+ +5000.Seperate User Configuration:
+ +Due to the nature of the Synology DSM Api it is required to grant de user admin rights. This is related to the fact that utilisation information is stored in the core module.
+ +When creating the user it is possible to deny access to all locations and applications. By doing this the user will not be able to login to the web interface or view any of the files on the NAS. It is still able to read the utilisation and storage information using the API.
+ + +The systemmonitor sensor platform allows you to monitor disk usage, memory usage, CPU usage, and running processes. This platform has superseded the process component which is now considered deprecated.
To add this platform to your installation, add the following to your configuration.yaml file:
# Example configuration.yaml entry
+sensor:
+ - platform: systemmonitor
+ resources:
+ - type: disk_use_percent
+ arg: /home
+ - type: memory_free
+ - type: processor_use
+Configuration variables:
+ +The table contains types and their argument to use in your configuration.yaml file.
Type (type:) |
+ Argument (arg:) |
+
|---|---|
| disk_use_percent | +Path, eg. / |
+
| disk_use | +Path, eg. / |
+
| disk_free | +Path, eg. / |
+
| memory_use_percent | ++ |
| memory_use | ++ |
| memory_free | ++ |
| swap_use_percent | ++ |
| swap_use | ++ |
| swap_free | ++ |
| network_in | +Interface, eg. eth0 |
+
| network_out | +Interface, eg. eth0 |
+
| packets_in | +Interface, eg. eth0 |
+
| packets_out | +Interface, eg. eth0 |
+
| ipv4_address | +Interface, eg. eth0 |
+
| ipv6_address | +Interface, eg. eth0 |
+
| processor_use | ++ |
| process | +Binary, eg. octave-cli |
+
| last_boot | ++ |
| since_last_boot | ++ |
The TCP component allows the integration of some services for which a specific Home Assistant component does not exist. If the service communicates over a TCP socket with a simple request/reply mechanism then the chances are that this component will allow integration with it.
+ +To enable this sensor, add the following lines to your configuration.yaml:
# Example configuration.yaml entry
+sensor:
+ - platform: tcp
+ host: IP_ADDRESS
+ port: PORT
+ payload: PAYLOAD
+Configuration options for the a TCP Sensor:
+ +101024.In this section you find some real life examples of how to use this sensor.
+ +The EBUSd service enables connection to an EBUS serial bus on some home heating/cooling systems. Using this service it is possible to extract various metrics which may be useful to have within Home Assistant. In order to use EBUSd, you connect to it using a TCP socket and send it a command. The service will respond with the value it has received from EBUS. On the command line, this would look something like:
+ +$ echo "r WaterPressure" | nc 10.0.0.127 8888
+0.903;ok
+You will notice that the output from the service is not just a single value (it contains “;ok” as well). To grab the value we’re interested in, we can use a Jinja2 template. The response received is injected into the template as the value variable. To use this value within Home Assistant, use the following configuration:
sensor:
+# Example configuration.yaml entry
+ platform: tcp
+ name: Central Heating Pressure
+ host: 10.0.0.127
+ port: 8888
+ timeout: 5
+ payload: "r WaterPressure\n"
+ value_template: "{{ value.split(';')[0] }}"
+ unit: Bar
+The tool hddtemp collects the temperature of your harddisks.
$ hddtemp
+/dev/sda: SAMSUNG MZMTE256HMHP-000L1: 39°C
+With hddtemp -d you can run the tool in TCP/IP daemon mode on port 7634 which enables you to get the data across the network.
$ telnet localhost 7634
+Trying 127.0.0.1...
+Connected to localhost.
+Escape character is '^]'.
+|/dev/sda|SAMSUNG MZMTE256HMHP-000L1|38|C|Connection closed by foreign host.
+The entry for the configuration.yaml file for a hddtemp sensor could look like the example below.
sensor:
+# Example configuration.yaml entry
+ platform: tcp
+ name: HDD temperature
+ host: 127.0.0.1
+ port: 7634
+ timeout: 5
+ payload: "\n"
+ value_template: "{{ value.split('|')[3] }}"
+ unit: "°C"
+layout: page +title: “TED5000 electricity monitoring” +description: “How to add a TED5000 to Home Assistant.” +date: 2016-09-27 11:19 +sidebar: true +comments: false +sharing: true +footer: true +logo: ted.png +ha_category: Sensor +ha_release: 0.30
+ +The ted 5000 monitors electricity consumption/production by connecting to the
+TED gateway, itself connected to one
+or several Measuring Transmitting Units (MTU).
+The platform creates up to two sensors per MTU, one for Wattage the other for
+Voltage. If you want to enable the ted5000 sensor, add the following lines to
+your configuration.yaml:
# Example configuration.yaml entry
+sensor:
+ platform: ted5000
+ name: main
+ host: 192.168.1.100
+ port: 80
+Configuration variables:
+ +For each plugged MTU, using an index starting at 1, the platorm creates 2 sensors:
+sensor.<name>_mtu<MTU id>_power
+sensor.<name>_mtu<MTU id>_voltage
+Integrates Telldus Live sensors into Home Assistant. See the main component for configuration instructions.
+ + + +The tellstick sensor platform allows you to get current meteorological data from a TellStick device.
To use your TellStick device, you first have to set up your Tellstick hub and then add the following to your configuration.yaml file:
# Example configuration.yaml entry
+sensor:
+ - platform: tellstick
+Configuration variables:
+ +True to hide sensors.In this section you find some real life examples of how to use this sensor.
+ +# Example configuration.yaml entry
+sensor:
+ - platform: tellstick
+ 135: Outside
+ 21: Inside
+ only_named: True
+ temperature_scale: "°C"
+ datatype_mask: 1
+This temper sensor platform allows you to get the current temperature from a TEMPer device.
To use your TEMPer sensor in your installation, add the following to your configuration.yaml file:
# Example configuration.yaml entry
+sensor:
+ - platform: temper
+Configuration options for the a TCP Sensor:
+ +Since some of these sensors consistently show higher temperatures the scale and offset values can be used to fine-tune your sensor.
+The calculation follows the formula scale * sensor value + offset.
The TEMPer sensors can only be accessed as root by default. To fix the USB permissions on your system create the file /etc/udev/rules.d/99-tempsensor.rules and add the following line to it:
SUBSYSTEMS=="usb", ACTION=="add", ATTRS{idVendor}=="0c45", ATTRS{idProduct}=="7401", MODE="666"
+After that re-plug the device and restart Home Assistant.
+ + +The template platform supports sensors which breaks out state_attributes from other entities.
To enable Template sensors in your installation, add the following to your configuration.yaml file:
# Example configuration.yaml entry
+sensor:
+ - platform: template
+ sensors:
+ solar_angle:
+ value_template: '{{ states.sun.sun.attributes.elevation }}'
+ friendly_name: 'Sun angle'
+ unit_of_measurement: 'degrees'
+ sunrise:
+ value_template: '{{ states.sun.sun.attributes.next_rising }}'
+Configuration variables:
+ +In this section you find some real life examples of how to use this sensor.
+ +This example shows the sun angle in the frontend.
+ +sensor:
+ - platform: template
+ sensors:
+ solar_angle:
+ value_template: '{{ "%+.1f"|format(states.sun.sun.attributes.elevation) }}'
+ friendly_name: 'Sun Angle'
+ unit_of_measurement: '°'
+If you don’t like the wording of a sensor output then the template sensor can help too. Let’s rename the output of the Sun component as a simple example:
+ +sensor:
+ - platform: template
+ sensors:
+ sun_state:
+ value_template: '{% if is_state("sun.sun", "above_horizon") %}up{% else %}down{% endif %}'
+ friendly_name: 'Sun state'
+Processes monitored by the System Monitor sensor show on or off if they are running or not. This example shows how the output of a monitored glances process can be renamed.
sensor:
+ - platform: template
+ sensors:
+ glances:
+ value_template: '{% if is_state("sensor.process_glances", "off") %}not running{% else %}running{% endif %}'
+ friendly_name: 'Glances'
+By comparing the details published on the template page the same can be archived with a different approach:
+ +value_template: "{%if states.sensor.ENTITY_ID.state == 'on' %}running{%elif states.switch.ENTITY_ID.state == 'off' %}not running{% endif %}"
+The Binary template sensor is the one in similar cases if you prefer to see an icon instead of text.
+ +This example shows a multiple line template with and if test. It looks at a sensing switch and shows on/off in the frontend.
+ +sensor:
+ - platform: template
+ sensors:
+ kettle:
+ friendly_name: 'Kettle'
+ value_template: >-
+ {%- if is_state("switch.kettle", "off") %}
+ off
+ {% elif states.switch.kettle.attributes.kwh < 1000 %}
+ standby
+ {% elif is_state("switch.kettle", "on") %}
+ on
+ {% else %}
+ failed
+ {%- endif %}
+
+ next_sensor:
+ [...]
++Please note the blank line to close the multi-line template. +
+ +With a template sensor it’s easy to convert given values into others if the unit of measurement don’t fit your needs.
+ +sensor:
+ - platform: template
+ sensors:
+ transmission_down_speed_kbps:
+ value_template: '{{ states.sensor.transmission_down_speed.state | multiply(1024) }}'
+ friendly_name: 'Transmission Down Speed'
+ unit_of_measurement: 'kB/s'
+ transmission_up_speed_kbps:
+ value_template: '{{ states.sensor.transmission_up_speed.state | multiply(1024) }}'
+ friendly_name: 'Transmission Up Speed'
+ unit_of_measurement: 'kB/s'
+The thinkingcleaner sensor platform simple displays information about your Thinking Cleaner addon.
To enable this sensor in your installation, add the following to your configuration.yaml file:
# Example configuration.yaml entry
+sensor:
+ - platform: thinkingcleaner
+This will automatically add sensors for each Thinking Cleaner in your network.
+ + +The time and date (time_date) sensor platform simple displays the time in various formats, the date, or both.
To enable this sensor in your installation, add the following to your configuration.yaml file:
# Example configuration.yaml entry
+sensor:
+ - platform: time_date
+ display_options:
+ - 'time'
+ - 'date'
+ - 'date_time'
+ - 'time_date'
+ - 'time_utc'
+ - 'beat'
+
+ 
+
The torque platform will allow you to monitor Torque data relayed from a bluetooth OBD2 stick via the Torque mobile application.
To use Torque sensors with your installation, you must configure both the Torque mobile application and Home Assistant.
+ +In Settings -> Data Logging & Upload:
+ +Under the Logging Preferences header:
+ +Under the Realtime Web Upload header:
+ +http://HOST:PORT/api/torque?api_password=YOUR_PASSWORD as the Webserver URL, where HOST and PORT are your externally-accessible Home Assistant HTTP host and port and YOUR_PASSWORD is your password.Add the following to your configuration.yaml file:
# Example configuration.yaml entry
+sensor:
+ - platform: torque
+ email: your_configured@email.com
+Configuration variables:
+ +The transmission platform allows you to monitor your downloads with Transmission from within Home Assistant and setup automation based on the information.
To enable this sensor, add the following lines to your configuration.yaml:
# Example configuration.yaml entry
+sensor:
+ platform: transmission
+ host: IP_ADDRESS
+ monitored_variables:
+ - 'current_status'
+ - 'download_speed'
+ - 'upload_speed'
+Configuration variables:
+ +To use the monitoring, your transmission client needs to allow remote access. If you are running the graphical transmission client (transmission-gtk) go to Edit -> Preferences and choose the tab Remote. Check Allow remote access, enter your username and your password, and uncheck the network restriction as needed.
+ +
+ 
+
If everything is setup correctly, the details will show up in the frontend.
+ +
+ 
+
The twitch platform will allow you to monitor Twitch channel status from within Home Assistant and setup automation based on the information.
To use Twitch with your installation, add the following to your configuration.yaml file:
# Example configuration.yaml entry
+sensor:
+ platform: twitch
+ channels:
+ - channel1
+ - channel2
+Configuration variables:
+ +The uber sensor will give you time and price estimates for all available Uber products at the given start_latitude and start_longitude.The ATTRIBUTES are used to provide extra information about products, such as estimated trip duration, distance and vehicle capacity. By default, 2 sensors will be created for each product at the given start location, one for pickup time and one for current price. The sensor is powered by the official Uber API.
You must create an application here to obtain a server_token.
To enable this sensor, add the following lines to your configuration.yaml file:
# Example configuration.yaml entry
+sensor:
+ - platform: uber
+ server_token: 'BeAPPTDsWZSHLf7fd9OWjZkIezweRw18Q8NltY27'
+ start_latitude: 37.8116380
+ start_longitude: -122.2648050
+Configuration variables:
+ +end_latitude is optional, it is strongly recommended to provide an end_latitude/end_longitude when possible as you will get more accurate price and time estimates.end_longitude is optional, it is strongly recommended to provide an end_latitude/end_longitude when possible as you will get more accurate price and time estimates.A full configuration entry could look like the sample below:
+ +# Example configuration.yaml entry
+sensor:
+ - platform: uber
+ start_latitude: 37.8116380
+ start_longitude: -122.2648050
+ end_latitude: 37.7768520
+ end_longitude: -122.4155500
+ server_token: 'BeAPPTDsWZSHLf7fd9OWjZkIezweRw18Q8NltY27'
+ product_ids:
+ - '04a497f5-380d-47f2-bf1b-ad4cfdcb51f2'
+The vasttrafik sensor will provide you travelling details for the larger Göteborg area in Sweden from the Västtrafik public transportation service.
You must create an application here to obtain a key and a secret.
Add the data to your configuration.yaml file as shown in the example:
# Example configuration.yaml entry
+sensor:
+ - platform: vasttrafik
+ key: XXXXXXXXXXXXXXXXXXX
+ secret: YYYYYYYYYYYYYYYYY
+ departures:
+ - name: Mot järntorget
+ from: Musikvägen
+ heading: Järntorget
+ delay: 10
+Configuration variables:
+ +The data are coming from Västtrafik.
+ + +The vera platform allows you to get data from your Vera sensors from within Home Assistant.
They will be automatically discovered if the vera component is loaded.
+ + + +Integrates Verisure sensors into Home Assistant. See the main component for configuration instructions.
+ +The following sensor types are supported:
+ +The worldclock sensor platform simple displays the current time in a different time zone
To enable this sensor in your installation, add the following to your configuration.yaml file:
# Example configuration.yaml entry
+sensor:
+ - platform: worldclock
+ time_zone: America/New_York
+Configuration variables:
+ +For valid time zones check the TZ column in the Wikipedia overview. Or get the full list from the pytz module.
+ +python3 -c "import pytz;print(pytz.all_timezones)"
+The wunderground platform uses Weather Underground as a source for current weather information.
+Obtain a WUnderground API key here. A free account allows 500 requests per day or 10 per minute. +
+ +To add Wunderground to your installation, add the following to your configuration.yaml file:
# Example configuration.yaml entry
+sensor:
+ - platform: wunderground
+ api_key: your_api_key
+ monitored_conditions:
+ - weather
+ - temp_f
+ - temp_c
+ - station_id
+ - feelslike_c
+ - feelslike_f
+ - feelslike_string
+ - heat_index_c
+ - heat_index_f
+ - heat_index_string
+ - dewpoint_c
+ - dewpoint_f
+ - dewpoint_string
+ - wind_kph
+ - wind_mph
+ - UV
+ - pressure_in
+ - pressure_mb
+ - wind_dir
+ - wind_string
+ - relative_humidity
+ - visibility_mi
+ - visibility_km
+ - precip_today_in
+ - precip_today_metric
+ - precip_today_string
+ - solarradiation
+ - alerts
+
+Configuration variables:
+configuration.yaml will be used to display weather conditions.All the conditions listed above will be updated each 5 minutes with exception of alerts that will be updated each 15 minutes by default.
Additional details about the API are available here.
+ + + +The Xbox Live component is able to track Xbox profiles.
+ +To use this sensor you need a free API key from XboxAPI.com. Please also make sure to connect your Xbox account on that site.
+ +The configuration requires you to specify XUIDs which are the unique identifiers for profiles. These can be determined on XboxAPI.com by either looking at your own profile page or using their interactive documentation to search for gamertags.
+ +To use the Xbox Live sensor in your installation, add the following to your configuration.yaml file:
# Example configuration.yaml entry
+sensor:
+ - platform: xbox_live
+ api_key: YOUR_API_KEY
+ xuid:
+ - account1
+ - account2
+Configuration variables:
+ +The yahoo_finance platform uses Yahoo Finance to monitor the stock market.
To enable the yahoo_finance platform, add the following lines to your configuration.yaml file:
# Example configuration.yaml entry
+sensor:
+ - platform: yahoo_finance
+Configuration variables:
+ +In this section you find some real life examples of how to use this sensor.
+ +sensor:
+ - platform: yahoo_finance
+ symbols:
+ - RHT
+ - GOOGL
+The yr platform uses YR.no as an source for current meteorological data for your location. The
+weather forecast is delivered by the Norwegian Meteorological Institute and the NRK.
To add YR to your installation, add the following to your configuration.yaml file:
# Example configuration.yaml entry
+sensor:
+ - platform: yr
+Configuration variables:
+ +A full configuration example can be found below:
+ +# Example configuration.yaml entry
+sensor:
+ - platform: yr
+ monitored_conditions:
+ - temperature
+ - symbol
+ - precipitation
+ - windSpeed
+ - pressure
+ - windDirection
+ - humidity
+ - fog
+ - cloudiness
+ - lowClouds
+ - mediumClouds
+ - highClouds
+ - dewpointTemperature
+The yweather platform uses Yahoo Weather as an source for current meteorological data. The forecast will show you the condition for 5 days, 0 is the current day. You can use only weather, temp_min, and temp_max with forecast.
+Use of the Yahoo Weather API should not exceed reasonable request volume. Access is limited to 2,000 signed calls per day. +
+ +The woeid (Where On Earth ID) for your location, as shown in the example below. You can find your woeid by copying the numeric digits at the end of the URL for your location at Yahoo Weather. If you don’t add a woeid it generate it from Home Assistant’s latitude and longitude.
To add Yahoo Weather to your installation, add the following to your configuration.yaml file:
# Example configuration.yaml entry
+sensor:
+ - platform: yweather
+ monitored_conditions:
+ - weather
+ - weather_current
+ - temp_min
+ - temp_max
+ - wind_speed
+ - pressure
+ - visibility
+ - humidity
+ - temperature
+Configuration variables:
+ +Yweather.Details about the API are available in the Yahoo! Developer Network.
+ + + +There are two types of ZigBee sensor available to Home Assistant:
+ +To configure an analog input pin sensor, add the following to your configuration.yaml file:
# Example configuration.yaml entry
+sensor:
+ - platform: zigbee
+ name: My Analog ZigBee Input
+ type: analog
+ pin: 0
+ address: 0013A2004233D138
+Configuration variables:
+ +analog or temperature.1.2.The analog input pins on an XBee (non-Pro) will read 0V to 1.2 V. This is translated by the xbee-helper library into a percentage. The maximum voltage your ZigBee device will read is configurable using the max_volts configuration variable.
To configure an analog input pin sensor, add the following to your configuration.yaml file:
## Example configuration.yaml entry
+sensor:
+ - platform: zigbee
+ name: My Analog ZigBee Input
+ type: analog
+ pin: 0
+ address: 0013A2004233D138
+See the Digi knowledge base for more XBee sampling details.
+ +The XBee Pro (and perhaps other third party modules) contains a thermometer device which can be read by using the TP AT command.
To configure a temperature sensor device, add the following to your configuration.yaml file:
# Example configuration.yaml entry
+sensor:
+ - platform: zigbee
+ name: Living Room Temperature ZigBee
+ type: temperature
+ address: 0013A20050E752C5
+The zoneminder sensor platform let you monitor the current state of your zoneminder install including the number of events and the current state of the cameras.
+You must have the ZoneMinder component configured to use those sensors. +
+ +To set it up, add the following information to your configuration.yaml file:
# Example configuration.yaml entry
+sensor:
+ - platform: zoneminder
+To get your Z-Wave sensors working with Home Assistant, follow the instructions for the general Z-Wave component.
+ + +Sensors are gathering information about states and conditions.
+ +Home Assistant currently supports a wide range of sensors. They are able to display information which are provides by Home assistant directly, are gathered from webservices, and, of course, physical devices. Please check the sidebar for a full list of supported sensor platforms.
+ + + +This component can expose regular shell commands as services. Services can be called from a script or in automation.
+ +# Example configuration.yaml entry
+# Exposes service shell_command.restart_pow
+shell_command:
+ restart_pow: touch ~/.pow/restart.txt
+Configuration variables:
+ +The commands can be dynamic, using templates to insert values of other entities. When using templates you are limited to only template the arguments. You are also no longer allowed to use pipe symbols when using templates.
+ +Any service data passed into the service call to activate the shell command will be available as a variable within the template.
+ +# Apply value of a GUI slider to the shell_command
+input_slider:
+ ac_temperature:
+ name: A/C Setting
+ initial: 24
+ min: 18
+ max: 32
+ step: 1
+
+shell_command:
+ set_ac_to_slider: 'irsend SEND_ONCE DELONGHI AC_{{ states.input_slider.ac_temperature.state}}_AUTO'
+
+The component simple_alarm is capable of detecting intruders. It does so by checking if lights are being turned on while there is no one at home. When this happens it will turn the lights red, flash them for 30 seconds and send a message via the notifiy component. It will also flash a specific light when a known person comes home.
This component depends on the components device_tracker and light being setup.
+ +To set it up, add the following lines to your configuration.yaml file:
simple_alarm:
+# Example configuration.yaml entry
+ known_light: light.Bowl
+ unknown_light: group.living_room
+Configuration variables:
+ +The SleepIQ implementation lets you view sensor data from SleepIQ by SleepNumber. In particular, it lets you see the occupancy and current SleepNumber (ie current firmness) of each side of a SleepNumber bed.
+ +You will need an account on SleepIQ to use this component.
+ +To set it up, add the following information to your configuration.yaml file:
# Example configuration.yaml entry
+sleepiq:
+ username: you@example.com
+ password: omgsecure
+Configuration variables:
+ +The splunk component makes it possible to log all state changes to an external Splunk database using Splunk’s HTTP Event Collector feature. You can either use this alone, or with the HomeAssistant for Splunk app. Since the HEC feature is new to Splunk, you will need to use at least version 6.3.
To use the splunk component in your installation, add the following to your configuration.yaml file:
# Example configuration.yaml entry
+splunk:
+ token: B4415DFF-683C-5C6C-3994-4F6D4A5DB03A
+Configuration variables:
+ +localhost if not supplied.The statsd component makes it possible to transfer all state changes to an external StatsD instance.
To use the statsd component in your installation, add the following to your configuration.yaml file:
# Example configuration.yaml entry
+statsd:
+Configuration variables:
+ +localhost.hass.StatsD supports various backends.
+ + + +The sun component will use your current location to track if the sun is above or below the horizon.The sun can be used within automation as a trigger with an optional offset to simulate dawn/dusk.
+ +# Example configuration.yaml entry
+sun:
+Configuration variables:
+ +
+
+
The sun’s event listener will call the service when the sun rises or sets with an offset.
+ +The sun event need to have the type ‘sun’, which service to call, which event (sunset or sunrise) and the offset.
+ +{
+ "type": "sun",
+ "service": "switch.turn_on",
+ "event": "sunset",
+ "offset": "-01:00:00"
+}
+sun.sun| Possible state | +Description | +
|---|---|
above_horizon |
+ When the sun is above the horizon. | +
below_horizon |
+ When the sun is below the horizon. | +
| State Attributes | +Description | +
|---|---|
next_rising |
+ Date and time of the next sun rising (in UTC). | +
next_setting |
+ Date and time of the next sun setting (in UTC). | +
elevation |
+ Solar elevation. This is the angle between the sun and the horizon. Negative values mean the sun is below the horizon. | +
azimuth |
+ Solar azimuth. The angle is shown clockwise from north. | +
The acer_projector switch platform allows you to control the state of RS232 connected projectors from Acer.
To use your Acer Projector in your installation, add the following to your configuration.yaml file:
# Example configuration.yaml entry
+switch:
+ - platform: acer_projector
+ filename: /dev/ttyUSB0
+Configuration variables:
+ +The anel_pwrctrl switch platform allows you to control ANEL PwrCtrl devices.
Supported devices (tested):
+ +To add this platform to your installation, add the following to your configuration.yaml file:
# Example configuration.yaml entry
+switch:
+ platform: anel_pwrctrl
+ host: IP_ADDRESS
+ port_recv: PORT
+ port_send: PORT
+ username: USERNAME
+ password: PASSWORD
+Configuration variables:
+ +If no host is given the platform will try to autodiscover all devices on the network, that are listening on the given port_recv.
+ + +The arduino switch platform allows you to control the digital pins of your Arduino board. Support for switching pins is limited to high/on and low/off of the digital pins. PWM (pin 3, 5, 6, 9, 10, and 11 on an Arduino Uno) is not supported yet.
To enable the Arduino pins with Home Assistant, add the following section to your configuration.yaml file:
# Example configuration.yaml entry
+switch:
+ platform: arduino
+ pins:
+ 11:
+ name: Fan Office
+ 12:
+ name: Light Desk
+ initial: true
+ negate: true
+Configuration variables:
+ +False .False.The digital pins are numbered from 0 to 13 on a Arduino UNO. The available pins are 2 till 13. For testing purposes you can use pin 13 because with that pin you can control the internal LED.
+ + + +The arest switch platform allows you to toggle pins of your devices (like Arduino boards with a ethernet/wifi connection, ESP8266 based devices, and the Raspberry Pi) running the aREST RESTful framework.
To use your aREST enabled device with pins in your installation, add the following to your configuration.yaml file:
# Example configuration.yaml entry
+switch:
+ - platform: arest
+ resource: http://IP_ADDRESS
+ pins:
+ 11:
+ name: Fan
+ 12:
+ name: Light Desk
+If you want to use custom functions, then add the following to your configuration.yaml file:
# Example configuration.yaml entry
+switch:
+ - platform: arest
+ resource: http://IP_ADDRESS
+ name: Office
+ functions:
+ function1:
+ name:
+ function2:
+ name: Light Desk
+Configuration variables:
+ +or
+ +You can still switch your pins with a web browser or a command line tool. Use the URL http://192.168.1.10/digital/8/1 to set pin 8 to high/on, the JSON response will give you the feedback.
+ +{"message": "Pin D8 set to 1", "id": "sensor02", "name": "livingroom", "connected": true}
+The command_line switch platform issues specific commands when it is turned on and off. This might very well become our most powerful platform as it allows anyone to integrate any type of switch into Home Assistant that can be controlled from the command line, including calling other scripts!
To enable it, add the following lines to your configuration.yaml:
# Example configuration.yaml entry
+switch:
+ platform: command_line
+ switches:
+ kitchen_light:
+ command_on: switch_command on kitchen
+ command_off: switch_command off kitchen
+Configuration variables:
+ +0 will indicate that the switch is on.command_state will ignore the result code of the command but the template evaluating to true will indicate the switch is on.In this section you find some real life examples of how to use this switch.
+ +The example below is doing the same as the aREST switch. The commandline tool curl is used to toogle a pin which is controllable through REST.
# Example configuration.yaml entry
+switch:
+ platform: command_line
+ switches:
+ arest_pin4:
+ command_on: "/usr/bin/curl -X GET http://192.168.1.10/digital/4/1"
+ command_off: "/usr/bin/curl -X GET http://192.168.1.10/digital/4/0"
+ command_state: "/usr/bin/curl -X GET http://192.168.1.10/digital/4"
+ value_template: '{{ return_value == "1" }}'
+ friendly_name: aREST Pin 4
+This switch will shutdown your system that is hosting Home Assistant.
+ ++This switch will shutdown your host immediately, there will be no confirmation. +
+ +# Example configuration.yaml entry
+switch:
+ platform: command_line
+ switches:
+ Home Assistant system shutdown:
+ command_off: "/usr/sbin/poweroff"
+This switch will control a local VLC media player (Source).
+ +# Example configuration.yaml entry
+switch:
+ platform: command_line
+ switches:
+ VLC:
+ command_on: "cvlc 1.mp3 vlc://quit &"
+ command_off: "pkill vlc"
+This switch will control the motion sensor of Foscam Webcams which Support CGI Commands (Source). This switch supports statecmd, which checks the current state of motion detection.
+ +# Example configuration.yaml entry
+switch:
+ platform: command_line
+ switches:
+ foscam_motion:
+ command_on: 'curl -k "https://ipaddress:443/cgi-bin/CGIProxy.fcgi?cmd=setMotionDetectConfig&isEnable=1&usr=admin&pwd=password"'
+ command_off: 'curl -k "https://ipaddress:443/cgi-bin/CGIProxy.fcgi?cmd=setMotionDetectConfig&isEnable=0&usr=admin&pwd=password"'
+ command_state: 'curl -k --silent "https://ipaddress:443/cgi-bin/CGIProxy.fcgi?cmd=getMotionDetectConfig&usr=admin&pwd=password" | grep -oP "(?<=isEnable>).*?(?=</isEnable>)"'
+ value_template: '{{ value == "1" }}'
+The digital_ocean switch platform allows you to control (start/stop) your Digital Ocean droplets.
To use your Digital Ocean droplets, you first have to set up your Digital Ocean hub and then add the following to your configuration.yaml file:
# Example configuration.yaml entry
+switch:
+ - platform: digital_ocean
+ droplets:
+ - 'fedora-512mb-nyc3-01'
+ - 'coreos-512mb-nyc3-01'
+Configuration variables:
+ +The dlink switch platform allows you to control the state of your D-Link Wi-Fi Smart Plugs.
Supported devices (tested):
+ +To use your D-Link smart plugs in your installation, add the following to your configuration.yaml file:
# Example configuration.yaml entry
+switch:
+ platform: dlink
+ host: IP_ADRRESS
+ username: YOUR_USERNAME
+ password: YOUR_PASSWORD
+Configuration variables:
+ +admin.PIN inlcuded on the configuration card.This edimax switch platform allows you to control the state of your Edimax switches.
To use your Edimax switch in your installation, add the following to your configuration.yaml file:
# Example configuration.yaml entry
+switch:
+ - platform: edimax
+ host: 192.168.1.32
+Configuration variables:
+ +192.168.1.32.admin.1234.An EnOcean switch can take many forms. Currently only one type has been tested: Permundo PSC234
+ +To use your EnOcean device, you first have to set up your EnOcean hub and then add the following to your configuration.yaml file:
# Example configuration.yaml entry
+switch:
+ - platform: enocean
+ id: [0x01,0x90,0x84,0x3C]
+Configuration variables:
+ +EnOcean Switch.The flux switch platform will change the temperature of your lights similar to the way flux works on your computer, using circadian rhythm. They will be bright during the day, and gradually fade to a red/orange at night.
The component will update your lights based on the the time of day. It will only affect lights that are turned on and listed in the flux configuration.
+ +During the day (in between start time and sunset time), it will fade the lights from the start_colortemp to the sunset_colortemp. After sunset (between sunset_time and stop_time), the lights will fade from the the sunset_colortemp to the stop_colortemp. If the lights are still on after the stop_time it will continue to change the light to the stop_colortemp until the light is turned off. The fade effect is created by updating the lights every 30 seconds with a 30 second transition time.
If you don’t wish to have flux update on 30 second intervals, you can leave the switch turned off and use automation rules that call the service switch.flux_update whenever you want the lights updated.
To use the Flux switch in your installation, add the following to your configuration.yaml file:
# Example configuration.yaml entry
+switch:
+ platform: flux
+ lights:
+ - light.desk
+ - light.lamp
+ name: Fluxer
+ start_time: '7:00'
+ stop_time: '23:00'
+ start_colortemp: 4000
+ sunset_colortemp: 3000
+ stop_colortemp: 1900
+ brightness: 200
+ mode: xy
+Configuration variables:
+ +4000.3000.1900.RGB_to_xy by default.xy and mired. Defaults to xy.This hikvisioncam switch platform allows you to control your motion detection setting on your Hikvision camera.
+Currently works using default https port only. +
+ +To use your Hikvision cam in your installation, add the following to your configuration.yaml file:
# Example configuration.yaml entry
+switch:
+ - platform: hikvisioncam
+ host: 192.168.1.32
+Configuration variables:
+ +192.168.1.32.80.admin.12345.The isy994 platform allows you to get data from your ISY994 switch from within Home Assistant.
They will be automatically discovered if the isy994 component is loaded.
+ + +The knx switch component is used as in interface to switching actuators.
To use your KNX switch in your installation, add the following to your configuration.yaml file:
# Example configuration.yaml entry
+switch:
+ - platform: knx
+ name: KNX Switch
+ address: 0/0/1
+state_address can be used to inform Home Assistant about these state changes. If a KNX message is seen on the bus addressed to the given state address, this wil overwrite the state of the switch object.
+For switching actuators that are only controlled by a single group address and can’t change their state internally, you don’t have to configrue the state address.To get your LiteJet switches working with Home Assistant, follow the instructions for the general LiteJet component.
+ + +The mfi switch platform to allow you to control mFi Controllable Power Outlets.
To add this platform to your installation, add the following to your configuration.yaml file:
# Example configuration.yaml entry
+sensor:
+ - platform: mfi
+ host: IP_ADDRESS
+ username: USERNAME
+ password: PASSWORD
+Configuration variables:
+ +True, use SSL/TLS to contact the mFi controller. Defaults to True.False if your mFi controller has a self-signed certificate. Defaults to True.The mochad switch platform lets you control an X10 enabled switch device.
To enable this sensor, you first have to set up the mochad component and then add the following to your configuration.yaml file:
# Example configuration.yml entry
+switch:
+ - platform: mochad
+ devices:
+ - address: a1
+ - address: a5
+Configuration variables:
+ +The modbus switch platform allows you to control Modbus coils.
To use your Modbus switches in your installation, add the following to your configuration.yaml file:
# Example configuration.yml entry
+switch:
+ platform: modbus
+ slave: 1
+ coils:
+ - name: Switch1
+ slave: 1
+ coil: 13
+ - name: Switch2
+ slave: 2
+ coil: 14
+Configuration variables:
+ +The mqtt switch platform let you control your MQTT enabled light.
In an ideal scenario, the MQTT device will have a state topic to publish state changes. If these messages are published with RETAIN flag, the MQTT switch will receive an instant state update after subscription and will start with correct state. Otherwise, the initial state of the switch will be false/off.
+ +When a state topic is not available, the switch will work in optimistic mode. In this mode, the switch will immediately change state after every command. Otherwise, the switch will wait for state confirmation from device (message from state_topic).
Optimistic mode can be forced, even if state topic is available. Try to enable it, if experiencing incorrect switch operation.
+ +To enable this switch in your installation, add the following to your configuration.yaml file:
# Example configuration.yml entry
+switch:
+ - platform: mqtt
+ command_topic: "home/bedroom/switch1/set"
+Configuration variables:
+ +
+Make sure that your topic match exact. some-topic/ and some-topic are different topics.
+
In this section you find some real life examples of how to use this sensor.
+ +The example below shows a full configuration for a switch.
+ +# Example configuration.yml entry
+switch:
+ - platform: mqtt
+ name: "Bedroom Switch"
+ state_topic: "home/bedroom/switch1"
+ command_topic: "home/bedroom/switch1/set"
+ payload_on: "ON"
+ payload_off: "OFF"
+ optimistic: false
+ qos: 0
+ retain: true
+For a check you can use the command line tools mosquitto_pub shipped with mosquitto to send MQTT messages. This allows you to operate your cover manually:
$ mosquitto_pub -h 127.0.0.1 -t home/bedroom/switch1set -m "ON"
+Integrates MySensors switches into Home Assistant. See the main component for configuration instructions.
+ +The following actuator types are supported:
+ +| S_TYPE | +V_TYPE | +
|---|---|
| S_DOOR | +V_ARMED | +
| S_MOTION | +V_ARMED | +
| S_SMOKE | +V_ARMED | +
| S_LIGHT | +V_LIGHT | +
| S_LOCK | +V_LOCK_STATUS | +
| S_IR | +V_IR_SEND, V_LIGHT | +
| S_TYPE | +V_TYPE | +
|---|---|
| S_LIGHT | +V_STATUS | +
| S_BINARY | +[V_STATUS or V_LIGHT] | +
| S_SPRINKLER | +V_STATUS | +
| S_WATER_LEAK | +V_ARMED | +
| S_SOUND | +V_ARMED | +
| S_VIBRATION | +V_ARMED | +
| S_MOISTURE | +V_ARMED | +
| S_TYPE | +V_TYPE | +
|---|---|
| S_WATER_QUALITY | +V_STATUS | +
All V_TYPES for each S_TYPE above are required to activate the actuator for the platform. Use either V_LIGHT or V_STATUS depending on library version for cases where that V_TYPE is required.
+ +For more information, visit the serial api of MySensors.
+ +The MySensors switch platform exposes a service to change an IR code attribute for an IR switch device and turn the switch on. The IR switch will automatically be turned off after being turned on, if optimistic is set to true in the config for the MySensors component. This will simulate a push button on a remote. If optimistic is false, the MySensors device will have to report its updated state to reset the switch. See the example sketch for the IR switch below.
| Service | +Description | +
|---|---|
| mysensors_send_ir_code | +Set an IR code as a state attribute for a MySensors IR device switch and turn the switch on. | +
The service can be used as part of an automation script. For example:
+ +# Example configuration.yaml automation entry
+automation:
+ - alias: turn hvac on
+ trigger:
+ platform: time
+ after: '5:30:00'
+ action:
+ service: switch.mysensors_send_ir_code
+ entity_id: switch.hvac_1_1
+ data:
+ V_IR_SEND: '0xC284' # the IR code to send
+
+ - alias: turn hvac off
+ trigger:
+ platform: time
+ after: '0:30:00'
+ action:
+ service: switch.mysensors_send_ir_code
+ entity_id: switch.hvac_1_1
+ data:
+ V_IR_SEND: '0xC288' # the IR code to send
+/*
+ * Documentation: http://www.mysensors.org
+ * Support Forum: http://forum.mysensors.org
+ *
+ * http://www.mysensors.org/build/relay
+ */
+
+#include <MySensor.h>
+#include <SPI.h>
+
+#define SN "Relay"
+#define SV "1.0"
+#define CHILD_ID 1
+#define RELAY_PIN 3
+
+MySensor gw;
+MyMessage msgRelay(CHILD_ID, V_STATUS);
+
+void setup()
+{
+ gw.begin(incomingMessage);
+ gw.sendSketchInfo(SN, SV);
+ // Initialize the digital pin as an output.
+ pinMode(RELAY_PIN, OUTPUT);
+ gw.present(CHILD_ID, S_BINARY);
+ gw.send(msgRelay.set(0));
+}
+
+void loop()
+{
+ gw.process();
+}
+
+void incomingMessage(const MyMessage &message)
+{
+ if (message.type == V_STATUS) {
+ // Change relay state.
+ digitalWrite(RELAY_PIN, message.getBool() ? 1 : 0);
+ gw.send(msgRelay.set(message.getBool() ? 1 : 0));
+ }
+}
+/*
+ * Documentation: http://www.mysensors.org
+ * Support Forum: http://forum.mysensors.org
+ *
+ * http://www.mysensors.org/build/ir
+ */
+
+#include <MySensor.h>
+#include <SPI.h>
+#include <IRLib.h>
+
+#define SN "IR Sensor"
+#define SV "1.0"
+#define CHILD_ID 1
+
+MySensor gw;
+
+char code[10] = "abcd01234";
+char oldCode[10] = "abcd01234";
+MyMessage msgCodeRec(CHILD_ID, V_IR_RECEIVE);
+MyMessage msgCode(CHILD_ID, V_IR_SEND);
+MyMessage msgSendCode(CHILD_ID, V_LIGHT);
+
+void setup()
+{
+ gw.begin(incomingMessage);
+ gw.sendSketchInfo(SN, SV);
+ gw.present(CHILD_ID, S_IR);
+ // Send initial values.
+ gw.send(msgCodeRec.set(code));
+ gw.send(msgCode.set(code));
+ gw.send(msgSendCode.set(0));
+}
+
+void loop()
+{
+ gw.process();
+ // IR receiver not implemented, just a dummy report of code when it changes
+ if (String(code) != String(oldCode)) {
+ Serial.print("Code received ");
+ Serial.println(code);
+ gw.send(msgCodeRec.set(code));
+ strcpy(oldCode, code);
+ }
+}
+
+void incomingMessage(const MyMessage &message) {
+ if (message.type==V_LIGHT) {
+ // IR sender not implemented, just a dummy print.
+ if (message.getBool()) {
+ Serial.print("Sending code ");
+ Serial.println(code);
+ }
+ gw.send(msgSendCode.set(message.getBool() ? 1 : 0));
+ // Always turn off device
+ gw.wait(100);
+ gw.send(msgSendCode.set(0));
+ }
+ if (message.type == V_IR_SEND) {
+ // Retrieve the IR code value from the incoming message.
+ String codestring = message.getString();
+ codestring.toCharArray(code, sizeof(code));
+ Serial.print("Changing code to ");
+ Serial.println(code);
+ gw.send(msgCode.set(code));
+ }
+}
+The mystrom switch platform allows you to control the state of your myStrom switches. The built-in sensor is measuring the power consumption while the switch is on.
To use your myStrom switch in your installation, add the following to your configuration.yaml file:
# Example configuration.yaml entry
+switch:
+ - platform: mystrom
+ host: IP_ADRRESS
+Configuration variables:
+ +http://192.168.1.32.Check if you are able to access the device located at http://IP_ADRRESS. The details about your switch is provided as a JSON response.
$ curl -X GET -H "Content-Type: application/json" http://IP_ADDRESS/report
+{
+ "power": 0,
+ "relay": false
+}
+or change its state:
+ +$ curl -G -X GET http://IP_ADDRESS/relay -d 'state=1'
+The neato switch platform allows you to control your Neato Botvac Connected.
This will automatically add a switch for each Botvac Connected that you have. The switch will start a full home cleaning when turned ON and return the robot to base when turned OFF.
+ +To enable this switch in your installation, add the following to your configuration.yaml file:
# Example configuration.yaml entry
+switch:
+ - platform: neato
+ username: USERNAME
+ password: PASSWORD
+Configuration variables:
+ ++The Home Assistant Neato platform has only be tested with a Botvac Connected. There is no support for the Botvac D3 Connected and Botvac D5 Connected robots at this time. +
+ + +The netio switch platform allows you to control your Netio Netio4, Netio4 All, and Netio 230B. These are smart outlets controllable through ethernet and/or WiFi that reports consumptions (Netio4all).
To use Netio devices in your installation, add the following to your configuration.yaml file:
# Example configuration.yaml entry
+switch:
+ - platform: netio
+ host: 192.168.1.43
+ username: YOUR_USERNAME
+ password: YOUR_PASSWORD
+ outlets:
+ 1: Free
+ 2: TV
+ 4: Lamp
+Configuration variables:
+ +http://192.168.1.32.1234.To get pushed updates from the Netio devices, one can add this Lua code in the device interface as an action triggered on “Netio” “System variables updated” with an ‘Always’ schedule:
+ +-- this will send socket and consumption status updates via CGI
+-- to given address. Associate with 'System variables update' event
+-- to get consumption updates when they show up
+
+local address='ha:8123'
+local path = '/api/netio/<host>'
+
+
+local output = {}
+for i = 1, 4 do for _, what in pairs({'state', 'consumption',
+ 'cumulatedConsumption', 'consumptionStart'}) do
+ local varname = string.format('output%d_%s', i, what)
+ table.insert(output,
+ varname..'='..tostring(devices.system[varname]):gsub(" ","|"))
+end end
+
+local qs = table.concat(output, '&')
+local url = string.format('http://%s%s?%s', address, path, qs)
+devices.system.CustomCGI{url=url}
+The orvibo switch platform allows you to toggle your Orvibo S20 Wifi Smart Sockets.
To automatically discover Orvibo sockets on your network:
+ +# Example configuration.yaml entry
+switch:
+ - platform: orvibo
+To specify Orvibo sockets and skip discovery:
+ +# Example configuration.yaml entry
+switch:
+ - platform: orvibo
+ discovery: false
+ switches:
+ - host: IP_ADDRESS
+ mac: MA:CA:DD:RE:SS:00
+ name: "My Socket"
+Configuration variables:
+ +true.192.168.1.10.The pilight switch platform is issuing 433 MHz commands using pilight to turn a 433 MHz device on or off. The Pilight Home Assistant hub has to be set up.
Additionally RF commands can be defined that trigger this switch to turn on and off. This allows you to also use the remote shipped with your 433 MHz switch without mixing up the Home Assistant states. You can even define several on/off commands, thus several RF remotes to toggle this switch.
+ +To be really sure that Home Assistant knows the actual state of your device it is recommended to use the RF remote with codes unknown to any of your 433 MHz devices. Thus you use the remote to trigger this switch to send the correct RF code to the device.
+ +To define a Pilight switch, add the following lines to your configuration.yaml:
# Example configuration.yaml entry
+switch:
+ - platform: pilight
+ switches:
+ Bed light:
+ on_code:
+ protocol: intertechno_old
+ 'on': 1
+ off_code:
+ protocol: intertechno_old
+ 'off': 1
+Configuration variables:
+ +Variables for the different codes:
+ +intertechno_old or daycom.'on' or 'off' has to be in apostrophes to be parsed correctly.1 or 01 or 0For possible code entries look at the pilight API. All commands allowed by pilight-send can be used. Which means that if for a certain protocol there are different parameters used, you should be able to replace the variables above by the proper ones required by the specific protocol. When using the elro_800_switch or mumbi protocol for example, you will have to replace the variable unit with unitcode or there will be errors occuring.
switch:
+ - platform: pilight
+ switches:
+ Bed light:
+ on_code:
+ protocol: intertechno_old
+ unit: 3
+ id: 4
+ 'on': 1
+ off_code:
+ protocol: intertechno_old
+ unit: 3
+ id: 4
+ 'off': 1
+ on_code_receive:
+ protocol: daycom
+ systemcode: 14462
+ unit: 6
+ id: 34
+ state: 'on'
+ off_code_receive:
+ protocol: daycom
+ systemcode: 14462
+ unit: 6
+ id: 34
+ state: 'off'
+The goal behind this switch is to allow a very flexible whole home audio system based upon PulseAudio.
+ +For example, for a system with a 7.1 surround sound card, and 3 instances of MPD running, it is possible to quickly route the output of any MPD instance to any of the 8 possible (4 stereo) channels on the sound card, by loading/unloading a loopback module. This loading/unloading functionality is provided by this component. When the switch is on, the loopback module is loaded. When the switch is off, the module is not loaded.
The benefit of this approach is that this audio routing can occur without modifying the design-time configuration of MPD or PulseAudio.
+ +This component uses a TCP connection to control a local or remote PulseAudio server. So there are no local dependencies.
+ +To enable this switch, add the following lines to your configuration.yaml file:
# Example configuration.yaml entry
+switch:
+ - platform: pulseaudio_loopback
+Configuration variables:
+ +
+This component relies on raw TCP commands to PulseAudio. In order for PulseAudio to accept commands with this component, module-cli-protocol must be loaded on the PulseAudio server.
+
The qwikswitch platform allows you to control your QwikSwitch relays as switches from within Home Assistant.
If the device name in the QS Mobile application ends with Switch it will be created as a switch, otherwise as a light.
The platform is configured through the QwikSwitch component.
+ + +The rest switch platform allows you to control a given endpoint that supports a RESTful API. The switch can get the state via GET and set the state via POST on a given REST resource.
To enable this switch, add the following lines to your configuration.yaml file:
# Example configuration.yaml entry
+switch:
+ - platform: rest
+ resource: http://IP_ADDRESS/ENDPOINT
+Configuration variables:
+ +'{"rem_temp":}'.'{{ value.json == body_on }}'. This means that by default, the state of the switch is on if and only if the response to the GET request matches body_on.+Make sure that the URL matches exactly your endpoint or resource. +
+ + + +The rfxtrx platform support switches that communicate in the frequency range of 433.92 MHz.
First you have to set up your rfxtrx hub.
+The easiest way to find your switches is to add this to your configuration.yaml:
# Example configuration.yaml entry
+switch:
+ platform: rfxtrx
+ automatic_add: True
+Launch your homeassistant and go the website. +Push your remote and your device should be added:
+ +
+
+
Here the name is 0b11000102ef9f210010f70 and you can verify that it works from the frontend.
+Then you should update your configuration to:
# Example configuration.yaml entry
+switch:
+ platform: rfxtrx
+ devices:
+ 0b11000102ef9f210010f70:
+ name: device_name
+Configuration variables:
+ +Generate codes:
+ +If you need to generate codes for switches you can use a template (usefull for example COCO switches).
+ +0b11000{{ range(100,700) | random | int }}bc0cfe0{{ range(0,10) | random | int }}010f70
+Basic configuration with 3 devices:
+ +# Example configuration.yaml entry
+switch:
+ platform: rfxtrx
+ automatic_add: False
+ signal_repetitions: 2
+ devices:
+ 0b1100ce3213c7f210010f70:
+ name: Movment1
+ 0b11000a02ef2gf210010f50:
+ name: Movment2
+ 0b1111e003af16aa10000060:
+ name: Door
+ fire_event: True
+Doorbell configuration:
+ +# Example configuration.yaml entry
+switch:
+ platform: rfxtrx
+ automatic_add: False
+ devices:
+ 0710014c440f0160:
+ name: Hall
+ 0710010244080780:
+ name: Door
+ fire_event: true
+
+automation:
+ - alias: Switch light on when door bell rings if sun is below horizon and light was off
+ trigger:
+ platform: event
+ event_type: button_pressed
+ event_data: {"entity_id": "switch.door"}
+ condition:
+ condition: and
+ conditions:
+ - condition: state
+ entity_id: sun.sun
+ state: "below_horizon"
+ - condition: state
+ entity_id: switch.hall
+ state: 'off'
+ action:
+ - service: switch.turn_on
+ entity_id: switch.hall
+Use remote to enable scene:
+ +# Example configuration.yaml entry
+switch:
+ platform: rfxtrx
+ automatic_add: False
+ devices:
+ 0b1100ce3213c7f210010f70:
+ name: Light1
+ 0b11000a02ef2gf210010f50:
+ name: Light2
+ 0b1111e003af16aa10000060:
+ name: Keychain remote
+ fire_event: true
+scene:
+ name: Livingroom
+ entities:
+ switch.light1: on
+ switch.light2: on
+
+automation:
+ - alias: Use remote to enable scene
+ trigger:
+ platform: event
+ event_type: button_pressed
+ event_data: {"state": "on", "entity_id": "switch.keychain_remote"}
+ action:
+ service: scene.turn_on
+ entity_id: scene.livingroom
+The rpi_gpio switch platform allows you to control the GPIOs of your Raspberry Pi.
To use your Raspberry Pi’s GPIO in your installation, add the following to your configuration.yaml file:
# Example configuration.yaml entry
+switch:
+ - platform: rpi_gpio
+ ports:
+ 11: Fan Office
+ 12: Light Desk
+Configuration variables:
+ +For more details about the GPIO layout, visit the Wikipedia article about the Raspberry Pi.
+ + + +The rpi_rf switch platform allows you to control devices over 433/315MHz LPD/SRD signals with generic low-cost GPIO RF modules on a Raspberry Pi.
Interoperable with codes sniffed via the rpi-rf module or rc-switch. +For more info see the PyPi module description: rpi-rf.
+ +To enable, add the following to your configuration.yaml:
# Example configuration.yaml entry
+switch:
+ platform: rpi_rf
+ gpio: 17
+ switches:
+ bedroom_light:
+ code_on: 1234567
+ code_off: 1234568
+ ambilight:
+ pulselength: 200
+ code_on: 987654
+ code_off: 133742
+ living_room_light:
+ protocol: 5
+ code_on: 654321
+ code_off: 654320
+Configuration variables:
+ +1).The SCSGate device can control switches of the BTicino MyHome system.
+ +To enable SCSGate switches in your installation, add the following to your configuration.yaml file:
# Example configuration.yaml entry
+switch:
+ - platform: scsgate
+ devices:
+ living_room:
+ scs_id: XXXXX
+Configuration variables:
+ +Integrates Telldus Live switches into Home Assistant. See the main component for configuration instructions.
+ + + +This tellstick switch platform allows you to control TellStick devices.
To use your TellStick device, you first have to set up your Tellstick hub and then add the following to your configuration.yaml file:
# Example configuration.yaml entry
+switch:
+ - platform: tellstick
+The template platform creates switches that combine components.
For example, if you have a garage door with a toggle switch that operates the motor and a sensor that allows you know whether the door is open or closed, you can combine these into a switch that knows whether the garage door is open or closed.
+ +This can simplify the gui, and make it easier to write automations. You can mark the components you have combined as hidden so they don’t appear themselves.
To enable Template switches in your installation, add the following to your configuration.yaml file:
# Example configuration.yaml entry
+switch:
+ - platform: template
+ switches:
+ skylight:
+ value_template: '{{ is_state('sensor.skylight', 'on') }}'
+ turn_on:
+ service: switch.turn_on
+ entity_id: switch.skylight_open
+ turn_off:
+ service: switch.turn_on
+ entity_id: switch.skylight_close
+Configuration variables:
+ +If you are using the state of a platform that takes extra time to load, the template switch may get an ‘unknown’ state during startup. This results in error messages in your log file until that platform has completed loading. If you use is_state() function in your template, you can avoid this situation. For example, you would replace ‘{{ states.switch.source.state }}’ with this equivalent that returns true/false and never gives an unknown result: +‘{{ is_state(‘switch.source’, ‘on’) }}’
+ +In this section you find some real life examples of how to use this switch.
+ +This example shows a switch that copies another switch.
+ +switch:
+ - platform: template
+ switches:
+ copy:
+ value_template: '{{ is_state('switch.source', 'on') }}'
+ turn_on:
+ service: switch.turn_on
+ entity_id: switch.source
+ turn_off:
+ service: switch.turn_off
+ entity_id: switch.source
+This example shows a switch that takes its state from a sensor, and toggles a switch.
+ +switch:
+ - platform: template
+ switches:
+ blind:
+ friendly_name: 'Blind'
+ value_template: '{{ is_state_attr("switch.blind_toggle", "sensor_state", "on") }}'
+ turn_on:
+ service: switch.toggle
+ entity_id: switch.blind_toggle
+ turn_off:
+ service: switch.toggle
+ entity_id: switch.blind_toggle
+This example shows a switch that takes its state from a sensor, and uses two momentary switches to control a device.
+ +switch:
+ - platform: template
+ switches:
+ skylight:
+ friendly_name: 'Skylight'
+ value_template: '{{ is_state('sensor.skylight.state', 'on') }}'
+ turn_on:
+ service: switch.turn_on
+ entity_id: switch.skylight_open
+ turn_off:
+ service: switch.turn_on
+ entity_id: switch.skylight_close
+The thinkingcleaner switch platform allows you to control your Thinking Cleaner addon.
To enable this switch in your installation, add the following to your configuration.yaml file:
# Example configuration.yaml entry
+switch:
+ - platform: thinkingcleaner
+This will automatically add switches for each Thinking Cleaner in your network.
+ + +The tplink switch platform allows you to control the state of your TPLink smart switch.
Supported units:
+ +To use your TPLink switch in your installation, add the following to your configuration.yaml file:
# Example configuration.yaml entry
+switch:
+ - platform: tplink
+ host: IP_ADRRESS
+Configuration variables:
+ +http://192.168.1.32.The transmission switch platform allows you to control your Transmission client from within Home Assistant. The platform enables you switch to your ‘Alternative Speed Limits’ (aka ‘Turtle mode’) setting.
To add Transmission to your installation, add the following to your configuration.yaml file:
# Example configuration.yaml entry
+switch:
+ platform: transmission
+ host: IP_ADDRESS
+Configuration variables:
+ +The vera platform allows you to control your Vera switches from within Home Assistant.
They will be automatically discovered if the vera component is loaded.
+ +For more configuration information see the Vera component documentation.
+ + +The Verisure switch platform allows you to control your Verisure SmartPlugs.
+ +The requirement is that you have setup your Verisure hub.
+ + + +The wake_on_lan (WOL) switch platform allows you to turn on a WOL enabled computer.
+The WOL switch can only turn on your computer and monitor the state. There is no universal way to turn off a computer remotely. +
+ +To enable this switch in your installation, add the following to your configuration.yaml file:
# Example configuration.yml entry
+switch:
+ - platform: wake_on_lan
+ mac_address: "00-01-02-03-04-05"
+Configuration variables:
+ +The wemo platform allows you to control your Belkin WeMo switches from within Home Assistant.
They will be automatically discovered if the discovery component is enabled.
+ +For more configuration information see the WeMo component documentation.
+ + +A ZigBee switch in this context is a device connected to one of the digital output pins on a ZigBee module. It can simply be switched on and off. By default, a switch is considered on when the ZigBee device’s digital output is held high and considered off when it is held low. This behaviour can be inverted by setting the on_state configuration variable to low.
To configure a digital output pin as switch, add the following to your configuration.yaml file:
switch:
+ - name: Pond Fountain
+ platform: zigbee
+ pin: 0
+ address: 0013A20040791FA2
+ on_state: low
+Configuration variables:
+ +high (default) or low, depicting whether the digital output pin is pulled high or low when the switch is turned on.The zoneminder switch platform allows you to toggle the current function of cameras attached to your ZoneMinder instance.
+You must have the ZoneMinder component configured to use this. +
+ +To enable this switch, add the following lines to your configuration.yaml file:
# Example configuration.yaml entry
+switch:
+ - platform: zoneminder
+ command_on: Modect
+ command_off: Monitor
+Configuration variables:
+ ++The default functions installed by ZoneMinder are: None, Monitor, Modect, Record, Mocord, Nodect. +
+ + + +To get your Z-Wave switches working with Home Assistant, follow the instructions for the general Z-Wave component.
+ + +Keeps track which switches are in your environment, their state and allows you to control them.
+ +all_switches.switch/turn_on, switch/turn_off, and switch/toggle to control switches.Go the the Developer Tools, then to Call Service in the frontend, and choose switch/turn_on or switch/turn_off from the list of available services (Available services: on the left). Enter something like the sample below into the Service Data field and hit CALL SERVICE.
{"entity_id":"livingroom_pin2"}
+| Service data attribute | +Optional | +Description | +
|---|---|---|
entity_id |
+ yes | +Only act on specific switch. Else targets all. | +
The tellduslive component let you connect to Telldus Live. It’s cloud platform that connects to your Tellstick connected gear at home.
To get started using Telldus Live, you will have to obtain developer keys from the developer page.
+ +To integrate your Telldus Live with Home Assistant, add the following section to your configuration.yaml file:
# Example configuration.yaml entry
+tellduslive:
+ public_key: ABCDEFGHJKLMNOPQRSTUVXYZ
+ private_key: ABCDEFGHJKLMNOPQRSTUVXYZ
+ token: ABCDEFGHJKLMNOPQRSTUVXYZ
+ token_secret: ABCDEFGHJKLMNOPQRSTUVXYZ
+Configuration variables:
+ +Tellstick Net devices can be auto discovered using this method.
+ +It might be possible to communicate with the Tellstick Net device directly, bypassing the Tellstick Live service. This however is poorly documented and yet not fully supported.
+ ++API requests to certain methods are limited to one request every 10 minutes. +
+ + + +The tellstick component integrates TellStick devices into Home Assistant. This integration allows users to add switches, lights, and sensors which are communicating with 433 Mhz. There are a number of vendors (Capidi Elro, Intertechno, Nexa, Proove, Sartano, and Viking) who are selling products that work with TellStick. For more details, please check the TellStick protocol list.
To get started, add the devices to your configuration.yaml file.
# Example configuration.yaml entry
+tellstick:
+Configuration variables:
+ +The thingspeak components makes Home Assistant communicate with the ThingSpeak API.
+For now, it records exactly one entity at once, which is great for testing purposes. For long-time storage you should rely
+on the InfluxDB component.
You will have to create a new channel on ThingSpeak and grab your API key from your account page.
+ +To setup the ThinkSpeak component in your installation, add the following to your configuration.yaml file:
# Example configuration.yaml entry
+thingspeak:
+ api_key: MY_API_KEY
+ id: 1337
+ whitelist: sensor.yr_temperature
+Configuration variables:
+ +The updater component will check daily for new releases. It will show a badge in the frontend if a new version was found.
The updater component will also collect basic information about Home Assistant and its environment. The information includes the current Home Assistant version, the timezone, Python version and operating system infomation. No identifiable information (i.e. IP address, GPS coordinates, etc.) will ever be collected. If you are concerned about your privacy, you are welcome to scrutinize the Python source code.
+ +To integrate this into Home Assistant, add the following section to your configuration.yaml file:
updater:
+If you choose not to share any information when checking for updates, you can add reporting: False.
For an added bonus, an automation component can be created to send a message with a notifier when that state of this component’s entity changes.
+ +# Example configuration.yaml entry
+automation:
+ alias: 'Update Available Notifications'
+ trigger:
+ platform: state
+ entity_id: updater.updater
+ action:
+ service: notify.notify
+ data:
+ message: 'Update for Home Assistant is available.'
+The upnp component automatically creates port forwarding mappings on your router for Home Assistant. UPnP or NAT-PMP needs to be enabled on your router for this component to work.
You need to install miniupnpc before using the UPnP component:
+ +$ git clone https://github.com/miniupnp/miniupnp.git
+$ cd miniupnp/miniupnpc
+$ make
+$ make pythonmodule3
+$ sudo make installpythonmodule3
+To integrate this into Home Assistant, add the following section to your configuration.yaml file:
# Example configuration.yaml entry
+upnp:
+A port mapping will be created using the IP address and port that Home Assistant is running on. The mapping will never automatically expire. Upon stopping Home Assistant, the mapping will be removed from your router.
+ + +The Vera hub is a controller mainly connecting to Z-Wave devices.
+ +Switches, Lights (inc Dimmers), Locks, Sensors and Binary sensors are supported - and will be automatically added when HA connects to your Vera controller.
+ +To use Vera devices in your installation, add the following to your configuration.yaml file using the IP and port number of your Vera controller:
+ +vera:
+ vera_controller_url: http://192.168.1.161:3480/
+Configuration variables:
+ +
+ It is recommended to assign a static IP address to your Vera Controller. This ensures that it won’t change IP addresses, so you won’t have to change the vera_controller_url if it reboots and comes up with a different IP address. See your router’s manual for details on how to set this up. If you need the MAC address of your Vera, check the label on the bottom.
+
By default your switches will be added to Home Assistant as switches, however if some of them are light switches, you can tell Home Assistant this using the optional lights parameter as shown below.
Vera imports detailed zwave devices into Home Assistant. This can include system devices and other devices that you don’t use, you can tell Home Assistant not to load these devices using the exclude: parameter as shown below.
You can find the vera device id either by looking at your vera controller or by checking the Vera Device Id attribute on each device imported into Home Assistant.
vera:
+ vera_controller_url: http://192.168.1.161:3480/
+ # Optional to exclude devices - this is a list of vera device ids
+ exclude: [ 13, 14, 16, 20, 23, 72, 73, 74, 75, 76, 77, 78, 88, 89, 99]
+ # Optional to import switches as lights - this is a list of vera device ids
+ lights: [15, 17, 19, 21, 22, 24, 26, 43, 64, 70, 87]
+Home Assistant has support to integrate your Verisure devices.
+ +We support:
+ +To integrate Verisure with Home Assistant, add the following section to your configuration.yaml file:
# Example configuration.yaml entry
+verisure:
+ username: USERNAME
+ password: PASSWORD
+Configuration variables:
+ +The openweathermap weather platform uses OpenWeatherMap as an source for current meteorological data for your location.
You need an API key which is free but requires a registration.
+ +To add OpenWeatherMap to your installation, add the following to your configuration.yaml file:
# Example configuration.yaml entry
+weather:
+ - platform: openweathermap
+ api_key: YOUR_API_KEY
+ latitude: 46.1234
+ longitude: 7.1234
+Configuration variables:
+ +configuration.yaml file.configuration.yaml file.
+This platform is an alternative to the openweathermap sensor.
+
The weather platforms are gathering meteorological information from web services and displays the conditions and other details about the weather at the given location.
Home Assistant currently supports free web services and such which requires a registration. Please check the sidebar for a full list of supported weather platforms.
The weblink component allows you to display links in the Home Assistant frontend.
To use this component in your installation, add something like the following to your configuration.yaml file:
# Example configuration.yaml entry
+weblink:
+ entities:
+ - name: Router
+ url: http://192.168.1.1/
+ - name: Home Assistant
+ url: https://home-assistant.io
+Configuration variables:
+ +Pick an icon that you can find on materialdesignicons.com to use for your input and prefix the name with mdi:. For example mdi:car, mdi:ambulance, or mdi:motorbike.
The wemo component is the main component to integrate various Belkin WeMo devices with Home Assistant.
Supported devices will be automatically discovered if the discovery component is enabled. If you are not using the discovery component, loading the wemo component will scan for WeMo devices on the local network.
# Example configuration.yaml entry
+wemo:
+Alternately, WeMo devices that are not discoverable can be statically configured. If you have WeMo devices on subnets other than where Home Assistant is running, and/or devices in a remote location reachable over a VPN, you will need to manually configure them. This is also useful if you wish to disable discovery for some wemos, even if they are local. Example static configuration:
+ +wemo:
+ static:
+ - 192.168.1.23
+ - 192.168.52.172
+Any WeMo devices that are not statically configured but reachable via discovery will still be added automatically.
+ +Note that if you use this, you may want to configure your router (or whatever runs your DHCP server) to force your WeMo devices to use a static IP address. Check the DHCP section of your router configuration for this ability.
+ + +Wink is a home automation hub that can control a whole wide range of devices on the market. Or, as they say in their own words:
+ +++ +Wink offers one, quick and simple way to connect people with the products they rely on every day in their home.
+
Home Assistant integrates the Wink hub and allows you to get the status and control connected switches, lights, locks, and sensors.
+ +To get started with the Wink API, you will first need to get yourself an API access token. Because it is very difficult right now to get access to their API, John McLaughlin has created the form below to get you one.
+ + + +After you have gotten your access token, add the following to your configuration.yaml:
wink:
+ access_token: YOUR_ACCESS_TOKEN
+You can also request API access via Wink’s contact us page.
+ +You will be provided with a client ID and a client secret via email. These can then be used in your configuration in place of the access_token this will prevent you from having to manually refresh your access token.
+ +wink:
+ email: YOUR_WINK_EMAIL_ADDRESS
+ password: YOUR_WINK_PASSWORD
+ client_id: YOUR_WINK_CLIENT_ID
+ client_secret: YOUR_WINK_CLIENT_SECRET
+The following can also be provied to allow access to the Wink Relay sensors. This value could change at any time.
+ +wink:
+ user_agent: Manufacturer/Home-Assistant WinkAndroid/4
+Configuration variables:
+ +This will connect to the Wink hub and automatically set up any lights, switches and sensors that it finds.
+ ++The Wink hub can only be accessed via the cloud. This means it requires an active internet connection and you will experience delays when controlling and updating devices (~3s). +
+ + +The zeroconf component exposes your Home Assistant to the local network using Zeroconf. Zeroconf is also sometimes known as Bonjour, Rendezvous and Avahi.
To integrate this into Home Assistant, add the following section to your configuration.yaml file:
# Example configuration.yaml entry
+zeroconf:
+The registration will include metadata about the Home Assistant instance, including a base URL that can be used to access Home Assistant, the currently running Home Assistant version, and whether an API password is needed to access the instance.
+ +$ avahi-browse -alr
++ eth0 IPv4 Home _home-assistant._tcp local
+= eth0 IPv4 Home _home-assistant._tcp local
+ hostname = [Home._home-assistant._tcp.local]
+ address = [192.168.0.5]
+ port = [8123]
+ txt = ["version=0.27.0.dev0" "base_url=http://192.168.0.5:8123" "requires_api_password=true"]
+ZigBee integration for Home Assistant allows you to utilise modules such as the XBee as wireless General Purpose Input/Output (GPIO) devices. The component requires a local ZigBee device to be connected over a serial port. Through this it will send and receive commands to and from other devices on the ZigBee mesh network.
+ +There is currently support for the following device types within Home Assistant:
+ +The local ZigBee device (assuming XBee) must have an up to date Router or Coordinator API firmware installed.
+ +A zigbee section must be present in the configuration.yaml file and contain the following options as required:
# Example configuration.yaml entry
+zigbee:
+/dev/ttyUSB09600To find the possible serial port names of your device, run:
+ +$ ls /dev/ttyUSB*
++The port may also appear as /dev/ttyACM* if you’re communicating with the ZigBee device through an Arduino. +
+ +# Example configuration.yaml entry
+zigbee:
+ device: /dev/ttyACM1
+ baud: 115200
+Zones allow you to specify certain regions on earth (for now). When a device tracker sees a device to be within a zone, the state will take the name from the zone. Zones can also be used as a trigger or condition inside automation setups.
+ +Zones support the usual method to specify multiple zones, use keys zone:, zone 2: etc.
# Example configuration.yaml entry
+zone:
+ name: School
+ latitude: 32.8773367
+ longitude: -117.2494053
+ radius: 250
+ icon: mdi:school
+
+zone 2:
+ name: Work
+ latitude: 32.8753367
+ longitude: -117.2474053
+
+# This will override the default home zone
+zone 3:
+ name: Home
+ latitude: 32.8793367
+ longitude: -117.2474053
+ radius: 100
+ icon: mdi:account-multiple
+Configuration variables:
+ +If no configuration is given, the zone component will create a zone for home. This zone will use location given in the configuration.yaml file and have a radius of 100 meters. To override this, create a zone configuration and name it ‘Home’.
+Devices that are in the zone ‘Home’ will not appear on the map in the Home Assistant UI. +
+ +It is preferred to pick an icon to use for your zone. Pick any icon that you can find on materialdesignicons.com and prefix the name with mdi:. For example mdi:school, mdi:worker, mdi:home, mdi:cart, or mdi:castle.
zoning is the state a zone has when it is configured. A zone doesn’t have another state, all configured zones are zoning all the time.
The ZoneMinder component is the main component to integrate all the sensors and switches for controlling your ZoneMinder instance.
+ +# Example configuration.yaml entry
+zoneminder:
+ host: ZM_HOST
+Configuration variables:
+/zm/.True if your ZoneMinder installation is using SSL. Default to False.# Example configuration.yaml entry
+zoneminder:
+ host: ZM_HOST
+ path: ZM_PATH
+ ssl: False
+ username: USERNAME
+ password: PASSWORD
+Please see the getting started section for in-depth documentation on how to use the Z-Wave component.
+ + + +This example demonstrates how you can configure Apache to act as a proxy for home assistant.
+ +This is useful if you want to have:
+ +So you already have a working Apache server available at example.org. +Your home assistant is correctly working on this web server and available at localhost:8123
+ +To be able to access to your home assistant instance by using https://home.example.org, add to following file into /etc/httpd/conf/extra/hass.conf
<VirtualHost *:443>
+ ProxyPreserveHost On
+ ProxyRequests Off
+ ServerName home.example.org
+ ProxyPass / http://localhost:8123/
+ ProxyPassReverse / http://localhost:8123/
+</VirtualHost>
+and make sure that this file is read by Apache’s main configuration file /etc/httpd/conf/httpd.conf
...
+Include conf/extra/hass.conf
+...
+If you don’t want HTTPS, you can change <VirtualHost *:443> to <VirtualHost *:80> or better consider redirecting all HTTP to HTTPS.
You already have home assistant running on localhost:8123 and available at home.example.org as describe before.
+The configuration file for this home assistant is available in /home/alice/.homeassistant/configuration.yaml
You want another instance available at https://countryside.example.org
+ +You can either :
+bob, to hold the configuration file in /home/bob/.homeassistant/configuration.yaml and run home assistant as this new user/home/alice/.homeassistan2/configuration.yaml and run home assistant using hass --config /home/alice/.homeassistant2/In both solution, change port number used by modifying configuration.yaml
http:
+ server_port: 8124
+ ...
+Start home assistant: Now, you have another instance running on localhost:8124
+ +To access this instance by using https://countryside.example.org add to /etc/httpd/conf/extra/hass.conf
<VirtualHost *:443>
+ ProxyPreserveHost On
+ ProxyRequests Off
+ ServerName countryside.example.org
+ ProxyPass / http://localhost:8124/
+ ProxyPassReverse / http://localhost:8124/
+</VirtualHost>
+Add to your /etc/httpd/conf/extra/hass.conf
<VirtualHost *:80>
+ ServerName example.org
+ ServerSignature Off
+
+ RewriteEngine on
+ RewriteCond %{HTTPS} !=on
+ RewriteRule .* https://%{SERVER_NAME}%{REQUEST_URI} [NE,R,L]
+</VirtualHost>
+Assume that you have an enocean wall switch and some Philips Hue lamps. The enocean wall switch will fire the event button_pressed and pass along several parameters which is used to turn on/off the lamps.
+ +event_data:
+ +enocean:
+ device: /dev/ttyUSB0
+
+binary_sensor:
+ - platform: enocean
+ id: [0x00,0x01,0x02,0x03]
+ name: living_room_switch
+
+automation:
+ - alias: Turn on living room light
+ trigger:
+ platform: event
+ event_type: button_pressed
+ event_data:
+ onoff: 1
+ devname: living_room_switch
+ action:
+ service: light.turn_on
+ entity_id: light.hue_color_lamp_3
+
+ - alias: Turn off living room light
+ trigger:
+ platform: event
+ event_type: button_pressed
+ event_data:
+ onoff: 0
+ devname: living_room_switch
+ action:
+ service: light.turn_off
+ entity_id: light.hue_color_lamp_3
+For flashing regular lights in case the the triggering of an alarm.
+ +# AlmAct1 - switch to activate the alarm in Room1
+# AlmSnd1 - switch for a buzzer
+
+automation:
+- alias: 'Alarm_PIR_Room1'
+ trigger:
+ platform: state
+ entity_id: binary_sensor.PIR1
+ state: 'on'
+ condition:
+ - condition: state
+ entity_id: switch.AlmAct1
+ state: 'on'
+ - condition: state
+ entity_id: script.alarm_room1
+ state: 'off'
+ action:
+ # start alarm on movement if alarm activated
+ # and the alarm is not triggered
+ service: script.turn_on
+ entity_id: script.alarm_room1
+
+- alias: 'flash_room1_start'
+ trigger:
+ platform: state
+ entity_id: switch.AlmSnd1
+ state: 'on'
+ action:
+ service: script.turn_on
+ entity_id: script.flash_room1
+
+- alias: 'flash_room1_stop'
+ trigger:
+ platform: state
+ entity_id: switch.REL1
+ state: 'off'
+ condition:
+ condition: state
+ entity_id: switch.AlmSnd1
+ state: 'off'
+ action:
+ service: script.turn_off
+ entity_id: script.flash_room1
+
+script:
+ alarm_room1:
+ alias: Alarm room1
+ sequence:
+ - alias: Alarm Room1 Start
+ service: homeassistant.turn_on
+ data:
+ entity_id: switch.AlmSnd1
+ - alias: Set Ack Room1
+ service: homeassistant.turn_on
+ data:
+ entity_id: input_boolean.ack1
+ - alias: email_Room1
+ service: notify.email
+ data:
+ message: 'Movement alarm in Room1'
+ - delay:
+ # time interval for alarm sound and light flashing
+ seconds: 60
+ - alias: Alarm Room1 Stop
+ service: homeassistant.turn_off
+ data:
+ entity_id: switch.AlmSnd1
+
+ flash_room1:
+ alias: Flash Room1 On
+ sequence:
+ - alias: Light Room1 On
+ service: homeassistant.turn_on
+ data:
+ entity_id: switch.REL1
+ - delay:
+ # time for flash light on
+ seconds: 1
+ - alias: Light Room1 Off
+ service: homeassistant.turn_off
+ data:
+ entity_id: switch.REL1
+ - delay:
+ # time for flash light off
+ seconds: 1
+ - alias: loop_room1
+ service: script.turn_on
+ data:
+ entity_id: script.flash_room1
+This requires a Dark Sky sensor with the condition precip_intensity that tells if it’s raining or not. You could also experiment with other attributes such as cloud_cover.
Turn on a light in the living room when it starts raining, someone is home, and it’s afternoon or later.
+ +automation:
+ alias: 'Rainy Day'
+
+ trigger:
+ - platform: state
+ entity_id: sensor.precip_intensity
+ state: 'rain'
+ - platform: state
+ entity_id: group.all_devices
+ state: 'home'
+ - platform: time
+ after: '14:00'
+ before: '23:00'
+
+ condition: use_trigger_values
+
+ action:
+ service: light.turn_on
+ entity_id: light.couch_lamp
+And then of course turn off the lamp when it stops raining but only if it’s within an hour before sunset.
+ +automation 2:
+ alias: 'Rain is over'
+ trigger:
+ - platform: state
+ entity_id: sensor.precip_intensity
+ state: 'None'
+ - platform: sun
+ event: 'sunset'
+ offset: '-01:00:00'
+
+ condition: use_trigger_values
+ action:
+ service: light.turn_off
+ entity_id: light.couch_lamp
+automation:
+ trigger:
+ platform: sun
+ event: sunset
+ offset: "-00:45:00"
+ condition:
+ condition: state
+ entity_id: group.all_devices
+ state: home
+ action:
+ service: homeassistant.turn_on
+ entity_id: group.living_room_lights
+Note, Philips Hue is currently the only light platform that support transitions.
+ +automation:
+ trigger:
+ platform: time
+ after: "07:15:00"
+ action:
+ service: light.turn_on
+ entity_id: light.bedroom
+ data:
+ # 900 seconds = 15 minutes
+ transition: 900
+Send notifications through PushBullet when the sun state is changed.
+ +automation:
+ - alias: 'Send notification when sun rises'
+ trigger:
+ platform: sun
+ event: sunrise
+ offset: '+00:00:00'
+ action:
+ service: notify.pushbullet
+ data:
+ message: 'The sun is up.'
+ - alias: 'Send notification when sun sets'
+ trigger:
+ platform: sun
+ event: sunset
+ offset: '+00:00:00'
+ action:
+ service: notify.pushbullet
+ data:
+ message: 'The sun is down.'
+Solar elevation automations can cope with offsets from sunset / sunrise as the seasons change better than using a time based offsets.
+ +- alias: 'Turn a few lights on when the sun gets dim'
+ trigger:
+ platform: numeric_state
+ entity_id: sun.sun
+ value_template: '{{ state.attributes.elevation }}'
+ below: 3.5
+ action:
+ service: scene.turn_on
+ entity_id: scene.background_lights
+
+- alias: 'Turn more lights on as the sun gets dimmer'
+ trigger:
+ platform: numeric_state
+ entity_id: sun.sun
+ value_template: '{{ state.attributes.elevation }}'
+ below: 1.5
+ action:
+ service: scene.turn_on
+ entity_id: scene.more_lights
+
+- alias: 'Close blind at dusk'
+ trigger:
+ platform: numeric_state
+ entity_id: sun.sun
+ value_template: '{{ state.attributes.elevation }}'
+ below: -2.5
+ action:
+ service: switch.turn_off
+ entity_id: switch.blind
+
+Note, Philips Hue is currently the only light platform that support the random effect.
+ +input_boolean:
+ loop_livingcolors:
+ name: Loop LivingColors
+ initial: off
+ icon: mdi:spotlight
+
+automation:
+# Changes Hue light every two minutes to random color if input boolean is set to on
+- alias: 'Set LivingColors to random color'
+ trigger:
+ platform: time
+ minutes: '/2'
+ seconds: 0
+ condition:
+ condition: state
+ entity_id: input_boolean.loop_livingcolors
+ state: 'on'
+ action:
+ service: light.turn_on
+ entity_id: light.woonkamer_livingcolors
+ data:
+ effect: random
+ transition: 5
+ brightness: 255
+homeassistant:
+ # Name of the location where Home Assistant is running
+ name: example.com
+ # Location required to calculate the time the sun rises and sets
+ latitude: 37
+ longitude: -121
+ # 'metric' for Metric, 'imperial' for Imperial
+ unit_system: imperial
+ # Pick yours from here: http://en.wikipedia.org/wiki/List_of_tz_database_time_zones
+ time_zone: America/Los_Angeles
+ customize:
+ switch.aeon_labs_smart_energy_switch_switch_2:
+ friendly_name: Mac Switch-Meter
+ switch.leviton_unknown_type1a02_id0334_switch_3:
+ friendly_name: W Nightstand
+ entity_picture: /local/zwvapl.jpg
+ switch.hub_switch:
+ friendly_name: Wink Hub Switch
+ entity_picture: /local/wemoswitch.jpg
+ switch.leviton_unknown_type1a02_id0334_switch_4:
+ friendly_name: Christmas Tree
+ entity_picture: /local/zwvapl.jpg
+ switch.leviton_unknown_type1a02_id0334_switch_5:
+ friendly_name: Roof Lights
+ entity_picture: /local/zwvapl.jpg
+
+ light.w_bedroom_ceiling_:
+ friendly_name: Will's Bedroom Ceiling Lights (Wink)
+ entity_picture: /local/casetta.jpg
+ light.living_room_wall_:
+ friendly_name: Living Room Couch Lights (Wink)
+ entity_picture: /local/casetta.jpg
+
+ media_player.my_shield_android_tv:
+ friendly_name: Dalek (Cast)
+ entity_picture: /local/shieldtv.jpg
+ media_player.chromecast:
+ friendly_name: Jeff chromecast
+ entity_picture: /local/chromecast.jpg
+ media_player.kodi:
+ friendly_name: Tardis-Win7 (Kodi)
+ entity_picture: /local/kodi.png
+ media_player.kodi_2:
+ friendly_name: Dalek (Kodi)
+ media_player.roku_2_xd__12a18n045363:
+ friendly_name: Parents Roku
+ entity_picture: /local/roku2xd.jpg
+
+ sensor.aeon_labs_smart_energy_switch_power_2:
+ friendly_name: Mac Usage (W)
+ sensor.aeon_labs_smart_energy_switch_previous_reading_2:
+ friendly_name: Mac Usage Previous (W)
+ hidden: true
+ sensor.aeon_labs_smart_energy_switch_energy_2:
+ friendly_name: Mac Usage (kWh)
+ hidden: true
+
+#####################
+## GROUPS
+#####################
+group:
+ w_bedroom:
+ - switch.leviton_unknown_type1a02_id0334_switch_3
+ - light.w_bedroom_ceiling_
+ christmas:
+ - switch.leviton_unknown_type1a02_id0334_switch_4
+ - switch.leviton_unknown_type1a02_id0334_switch_5
+ almanac:
+ - sensor.date
+ - sensor.time
+ - sensor.time_utc
+ - sun.sun
+ tracker:
+ - device_tracker.will_wnexus
+# OpenWeatherMap:
+# - sensor.weather_temperature
+# - sensor.weather_humidity
+# - sensor.weather_pressure
+# - sensor.weather_rain
+# - sensor.weather_wind_speed
+# - sensor.weather_cloud_coverage
+# - sensor.weather_forecast
+ Meteobridge:
+ - sensor.outdoor_temp_meteobridge
+ - sensor.outdoor_humidity_meteobridge
+ - sensor.outdoor_dewpoint_meteobridge
+ - sensor.precip_rate_meteobridge
+ - sensor.wind_direction_meteobridge
+ - sensor.wind_gust_meteohub
+ - sensor.wind_chill_meteobridge
+ - sensor.wind_speed_meteobridge
+ - sensor.indoor_dewpoint_meteobridge
+ - sensor.indoor_humidity_meteobridge
+ - sensor.indoor_temp_meteobridge
+ - sensor.precip_change_meteobridge
+ - sensor.precip_total_meteobridge
+ - sensor.sea_level_pressure_meteobridge
+ - sensor.barometric_pressure_meteobridge
+
+####################
+## ZONES
+####################
+zone:
+ name: Home
+ latitude: 37
+ longitude: -121
+ radius: 200
+ icon: mdi:home
+
+zone 2:
+ name: Barracuda_(SJ)
+ latitude: 37
+ longitude: -121
+ radius: 100
+
+zone 3:
+ name: SFC
+ latitude: 37
+ longitude: -122
+ radius: 95
+
+####################
+## NOTIFICATIONS
+####################
+
+
+####################
+## AUTOMATION
+####################
+automation:
+#- alias: 'W_at_work'
+# trigger:
+# - platform: zone
+# entity_id: device_tracker.will_wnexus
+# zone: zone.barracuda_sj
+# event: enter
+# - platform: time
+# after: '07:15'
+# before: '09:00'
+# action:
+# service: ifttt.trigger
+# data: {"event":"hassnotification_dadsms", "value1": "Will's at Work"}
+- alias: "Update_Update"
+ trigger:
+ platform: state
+ entity_id: updater.updater
+ action:
+ service: ifttt.trigger
+ data: {"event":"hassnotification_willsms","value1":"HASS has an update"}
+- alias: 'Christmas Roof ON'
+ trigger:
+ platform: sun
+ event: sunset
+ offset: '-01:00:00'
+ action:
+ service: homeassistant.turn_on
+ entity_id: switch.leviton_unknown_type1a02_id0334_switch_5
+- alias: 'Christmas Roof OFF'
+ trigger:
+ platform: time
+ hours: 1
+ minutes: 0
+ seconds: 0
+ action:
+ service: homeassistant.turn_off
+ entity_id: switch.leviton_unknown_type1a02_id0334_switch_5
+- alias: 'Christmas Tree ON'
+ trigger:
+ platform: time
+ hours: 8
+ minutes: 0
+ seconds: 0
+ action:
+ service: homeassistant.turn_on
+ entity_id: switch.leviton_unknown_type1a02_id0334_switch_4
+- alias: 'Christmas Tree (OFF)'
+ trigger:
+ platform: time
+ hours: 23
+ minutes: 0
+ seconds: 0
+ action:
+ service: homeassistant.turn_off
+ entity_id: switch.leviton_unknown_type1a02_id0334_switch_4
+#- alias: test notify
+# trigger:
+# platform: time
+# minutes: '/5' #every 5 min
+# action:
+# service: notify.pushEtta
+# data:
+# message: 5 Min Test
+
+
+#################################
+### COMPONENTS ###
+#################################
+#discovery:
+sun:
+#updater:
+history:
+#conversation:
+frontend:
+logbook:
+
+http:
+ api_password: Austin12#
+ server_port: 8123
+ ssl_certificate: /etc/letsencrypt/live/example.com/fullchain.pem
+ ssl_key: /etc/letsencrypt/live/example.com/privkey.pem
+
+ifttt:
+ key: [redacted]
+
+media_player 1:
+ platform: plex
+#media_player 2:
+# platform: squeezebox
+# host: 192.168.2.80
+# port: 9000
+media_player 3:
+ platform: cast
+media_player 4:
+ platform: kodi
+ url: http://192.168.2.129:8080/jsonrpc
+ user: kodi
+ password: kodi
+media_player 5:
+ platform: plex
+media_player 6:
+ platform: kodi
+ url: http://192.168.2.165/jsonrpc
+media_player 7:
+ platform: samsungtv
+ host: 192.168.2.90
+ name: Parents TV
+
+wink:
+ access_token: [redacted]
+ refresh_token: [redacted]
+
+zwave:
+ usb_path: /dev/ttyUSB0
+ config_path: /usr/local/share/python-openzwave/config
+ polling_interval: 10000
+
+#zigbee:
+# device: /dev/ttyUSB1
+# baud: 115200
+
+mqtt:
+ broker: 127.0.0.1
+ port: 8883
+ username: [redacted]
+ password: [redacted]
+
+device_tracker 1:
+ platform: owntracks
+
+ track_new_devices: yes
+ interval_seconds: 40
+ consider_home: 120
+
+device_tracker 2:
+ platform: nmap_tracker
+ hosts: 192.168.2.0/24
+ home_interval: 3
+
+#sensor:
+# platform: openweathermap
+# api_key: [redacted]
+# forecast: 1
+# monitored_conditions:
+# - temperature
+# - wind_speed
+# - humidity
+# - pressure
+# - clouds
+# - rain
+
+sensor 2:
+ platform: time_date
+ display_options:
+ - 'time'
+ - 'date'
+ - 'time_utc'
+
+### BEGIN METEO SENSORS ###
+sensor 3:
+ platform: tcp
+ name: Outdoor Temp (Meteobridge)
+ host: 192.168.2.82
+ port: 5556
+ timeout: 6
+ payload: "Content-type: text/xml; charset=UTF-8\n\n"
+ value_template: "{{value.split (' ')[2]}}"
+ unit: C
+
+sensor 4:
+ platform: tcp
+ name: Outdoor Humidity (Meteobridge)
+ host: 192.168.2.82
+ port: 5556
+ timeout: 6
+ payload: "Content-type: text/xml; charset=UTF-8\n\n"
+ value_template: "{{value.split (' ')[3]}}"
+ unit: Percent
+
+sensor 5:
+ platform: tcp
+ name: Outdoor Dewpoint (Meteobridge)
+ host: 192.168.2.82
+ port: 5556
+ timeout: 6
+ payload: "Content-type: text/xml; charset=UTF-8\n\n"
+ value_template: "{{value.split (' ')[4] }}"
+ unit: C
+
+sensor 6:
+ platform: tcp
+ name: Wind Direction (Meteobridge)
+ host: 192.168.2.82
+ port: 5556
+ timeout: 6
+ payload: "Content-type: text/xml; charset=UTF-8\n\n"
+ value_template: "{{value.split (' ')[7]}}"
+ unit: Degrees
+
+sensor 7:
+ platform: tcp
+ name: Wind Gust (Meteohub)
+ host: 192.168.2.82
+ port: 5556
+ timeout: 6
+ payload: "Content-type: text/xml; charset=UTF-8\n\n"
+ value_template: "{{value.split (' ')[8]}}"
+ unit: m/s
+
+sensor 8:
+ platform: tcp
+ name: Wind Speed (Meteobridge)
+ host: 192.168.2.82
+ port: 5556
+ timeout: 6
+ payload: "Content-type: text/xml; charset=UTF-8\n\n"
+ value_template: "{{value.split (' ')[9]}}"
+ unit: m/s
+
+sensor 9:
+ platform: tcp
+ name: Wind Chill (Meteobridge)
+ host: 192.168.2.82
+ port: 5556
+ timeout: 6
+ payload: "Content-type: text/xml; charset=UTF-8\n\n"
+ value_template: "{{value.split (' ')[10]}}"
+ unit: C
+
+sensor 10:
+ platform: tcp
+ name: Precip Rate (Meteobridge)
+ host: 192.168.2.82
+ port: 5556
+ timeout: 6
+ payload: "Content-type: text/xml; charset=UTF-8\n\n"
+ value_template: "{{value.split (' ')[13]}}"
+ unit: mm/hr
+
+sensor 11:
+ platform: tcp
+ name: Precip Total (Meteobridge)
+ host: 192.168.2.82
+ port: 5556
+ timeout: 6
+ payload: "Content-type: text/xml; charaset=UTF-8\n\n"
+ value_template: "{{value.split (' ')[14]}}"
+ unit: mm
+
+sensor 12:
+ platform: tcp
+ name: Precip Change (Meteobridge)
+ host: 192.168.2.82
+ port: 5556
+ timeout: 6
+ payload: "Content-type: text/xml; charaset=UTF-8\n\n"
+ value_template: "{{value.split (' ')[15]}}"
+ unit: mm
+
+sensor 13:
+ platform: tcp
+ name: Indoor Temp (Meteobridge)
+ host: 192.168.2.82
+ port: 5556
+ timeout: 6
+ payload: "Content-type: text/xml; charaset=UTF-8\n\n"
+ value_template: "{{value.split (' ')[18]}}"
+ unit: C
+
+sensor 14:
+ platform: tcp
+ name: Indoor Humidity (Meteobridge)
+ host: 192.168.2.82
+ port: 5556
+ timeout: 6
+ payload: "Content-type: text/xml; charaset=UTF-8\n\n"
+ value_template: "{{value.split (' ')[19]}}"
+ unit: percent
+
+sensor 15:
+ platform: tcp
+ name: Indoor Dewpoint (Meteobridge)
+ host: 192.168.2.82
+ port: 5556
+ timeout: 6
+ payload: "Content-type: text/xml; charaset=UTF-8\n\n"
+ value_template: "{{value.split (' ')[20]}}"
+ unit: C
+
+sensor 16:
+ platform: tcp
+ name: Barometric Pressure (Meteobridge)
+ host: 192.168.2.82
+ port: 5556
+ timeout: 6
+ payload: "Content-type: text/xml; charaset=UTF-8\n\n"
+ value_template: "{{value.split (' ')[21]}}"
+ unit: mb
+
+sensor 17:
+ platform: tcp
+ name: Sea Level Pressure (Meteobridge)
+ host: 192.168.2.82
+ port: 5556
+ timeout: 6
+ payload: "Content-type: text/xml; charaset=UTF-8\n\n"
+ value_template: "{{value.split (' ')[22]}}"
+ unit: mb
+
+sensor 18:
+ platform: steam_online
+ api_key: [Redact]
+ accounts:
+ - 76561198012067051
+
+switch:
+ platform: wemo
+This is a React implementation of TodoMVC but instead of checking off to do items, you are turning lights and switches on/off.
+ +configuration.yaml file for rendering.All you need is available as a custom panel. Download the file and save it in <config dir>/panels/ (you might have to create the directory if it doesn’t exist).
Create a entry for the panel in your configuration.yaml file to enable it.
panel_custom:
+ - name: react
+ sidebar_title: TodoMVC
+ sidebar_icon: mdi:work
+ url_path: todomvc
+ config:
+ title: hello
+This video shows the example in action.
+ +Like it how the lights dim up/down at the movies? Do it at home as well!
+ +This example uses the media player, Philips Hue (transitions) and the sun component. We’ll use actions to detect media player state changes and scenes to control multiple lights, color settings and transition between scenes.
+ +One scene for normal light, one for when movies are on. A 2 second transition gives a nice ‘feel’ to the switch.
+ +scene:
+ - name: Livingroom normal
+ entities:
+ light.light1:
+ state: on
+ transition: 2
+ brightness: 150
+ xy_color: [ 0.4448, 0.4066 ]
+ light.light2:
+ state: on
+ transition: 2
+ brightness: 215
+ xy_color: [ 0.4448, 0.4066 ]
+ - name: Livingroom dim
+ entities:
+ light.light1:
+ state: on
+ transition: 2
+ brightness: 75
+ xy_color: [ 0.5926, 0.3814 ]
+ light.light2:
+ state: on
+ transition: 2
+ brightness: 145
+ xy_color: [ 0.5529, 0.4107 ]
+The paused/stopped state is best matched using “from: ‘playing’”. Adding in the sun condition as we only want this when it’s dark.
+ +automation:
+ - alias: "Media player paused/stopped"
+ trigger:
+ - platform: state
+ entity_id: media_player.htpc
+ from: 'playing'
+ condition:
+ - condition: state
+ entity_id: sun.sun
+ state: 'below_horizon'
+ action:
+ service: scene.turn_on
+ entity_id: scene.livingroom_normal
+
+ - alias: "Media player playing"
+ trigger:
+ - platform: state
+ entity_id: media_player.htpc
+ to: 'playing'
+ condition:
+ - condition: state
+ entity_id: sun.sun
+ state: 'below_horizon'
+ action:
+ service: scene.turn_on
+ entity_id: scene.livingroom_dim
+This requires a Foscam IP Camera camera with PTZ (Pan, Tilt, Zoom) and CGI functionality (Source)
+ +Foscam Cameras can be controlled by Home Assistant through a number of CGI commands. +The following outlines examples of the switch, services, and scripts required to move between 2 preset destinations while controlling motion detection, but many other options of movement are provided in the Foscam CGI User Guide linked above.
+ +The switch.foscam_motion will control whether the motion detection is on or off. This switch supports statecmd, which checks the current state of motion detection.
# Replace admin and password with an "Admin" privileged Foscam user
+# Replace ipaddress with the local IP address of your Foscam
+switch:
+ platform: command_line
+ switches:
+ #Switch for Foscam Motion Detection
+ foscam_motion:
+ oncmd: 'curl -k "https://ipaddress:443/cgi-bin/CGIProxy.fcgi?cmd=setMotionDetectConfig&isEnable=1&usr=admin&pwd=password"'
+ offcmd: 'curl -k "https://ipaddress:443/cgi-bin/CGIProxy.fcgi?cmd=setMotionDetectConfig&isEnable=0&usr=admin&pwd=password"'
+ statecmd: 'curl -k --silent "https://ipaddress:443/cgi-bin/CGIProxy.fcgi?cmd=getMotionDetectConfig&usr=admin&pwd=password" | grep -oP "(?<=isEnable>).*?(?=</isEnable>)"'
+ value_template: '{{ value == "1" }}'
+The service shell_command.foscam_turn_off sets the camera to point down and away to indicate it is not recording, and shell_command.foscam_turn_on sets the camera to point where I’d like to record. h of these services require preset points to be added to your camera. See source above for additional information.
shell_command:
+ #Created a preset point in Foscam Web Interface named Off which essentially points the camera down and away
+ foscam_turn_off: 'curl -k "https://ipaddress:443/cgi-bin/CGIProxy.fcgi?cmd=ptzGotoPresetPoint&name=Off&usr=admin&pwd=password"'
+ #Created a preset point in Foscam Web Interface named Main which points in the direction I would like to record
+ foscam_turn_on: 'curl -k "https://ipaddress:443/cgi-bin/CGIProxy.fcgi?cmd=ptzGotoPresetPoint&name=Main&usr=admin&pwd=password"'
+The script.foscam_off and script.foscam_on can be used to set the motion detection appropriately, and then move the camera. These scripts can be called as part of an automation with device_tracker triggers to set home and not_home modes for your Foscam and disable motion detection recording while home.
script:
+ foscam_off:
+ sequence:
+ - service: switch.turn_off
+ data:
+ entity_id: switch.foscam_motion
+ - service: shell_command.foscam_turn_off
+ foscam_on:
+ sequence:
+ - service: switch.turn_off
+ data:
+ entity_id: switch.foscam_motion
+ - service: shell_command.foscam_turn_on
+ - service: switch.turn_on
+ data:
+ entity_id: switch.foscam_motion
+To automate Foscam being set to “on” (facing the correct way with motion sensor on), I used the following simple automation:
+ +automation:
+ - alias: Set Foscam to Away Mode when I leave home
+ trigger:
+ platform: state
+ entity_id: group.family
+ from: 'home'
+ action:
+ service: script.foscam_on
+ - alias: Set Foscam to Home Mode when I arrive Home
+ trigger:
+ platform: state
+ entity_id: group.family
+ to: 'home'
+ action:
+ service: script.foscam_off
+Using the generic camera platform you can present any image on the internet as a camera. Starting release 0.27 these urls can also be based on a template. This example uses this functionality to point a generic camera at the Google Maps static image API and pass in the location of a device.
+ +It also leverages the limit_refetch_to_url_change option to ensure that we do not make a lot of requests to the Google Maps API.
# Example configuration.yaml entry.
+# Shows device_tracker.demo_paulus on a map.
+camera:
+ name: Paulus
+ platform: generic
+ still_image_url: https://maps.googleapis.com/maps/api/staticmap?center={{ states.device_tracker.demo_paulus.attributes.latitude }},{{ states.device_tracker.demo_paulus.attributes.longitude }}&zoom=13&size=500x500&maptype=roadmap&markers=color:blue%7Clabel:P%7C{{ states.device_tracker.demo_paulus.attributes.latitude }},{{ states.device_tracker.demo_paulus.attributes.longitude }}
+ limit_refetch_to_url_change: true
+
+
+
This is a community curated list of different ways to use Home Assistant. Most of these examples are using the automation component and other built-in automation related and organization components available.
+ +New recipes can be added via the home-assistant.io repository.
+ +Foscam Recording during Away Mode Only using Pan/Tilt/Zoom Control and Motion Detection
+The Jupyter Notebooks allows you to create and share documents that contain live code, equations, visualizations, and explanatory text directly in your browser. The web application what is formerly known as the IPython Notebook supports over 40 programming languages.
+ +Visit https://try.jupyter.org/ to get a preview before you install it locally.
+ +The very first step is to install the requirement to run Jupyter Notebooks.
+ +$ pip3 install jupyter matplotlib
+
+Certain notebooks hosted in the Home Assistant notebooks repository require access to a running Home Assistant instance or parts of a Home Assistant installation. If you want to run those notebooks install Home Assistant with $ pip3 install homeassistant as well.
+
Now you are able to start the application.
+ +$ jupyter notebook
+[I 17:22:18.081 NotebookApp] Writing notebook server cookie secret to /run/user/1000/jupyter/notebook_cookie_secret
+[I 17:22:18.921 NotebookApp] Serving notebooks from local directory: /home/fabaff/home-assistant
+[I 17:22:18.921 NotebookApp] 0 active kernels
+[I 17:22:18.921 NotebookApp] The Jupyter Notebook is running at: http://localhost:8888/
+[I 17:22:18.922 NotebookApp] Use Control-C to stop this server and shut down all kernels (twice to skip confirmation).
+Open http://localhost:8888/ in your browser. Press “New” -> “Python3” to open a new notebook.
+ +
+ 
+
You will get an emtpy notebook with one cell. Cells can contain code or text. To get the output of a cell you need to execute them with “Cell” -> “Run Cells” from the menu or by pressing the icon.
+ +
+ 
+
The downloadable version of this notebook is available in the Home Assistant notebooks repository.
+ +As you can see is the workflow very similar to working directly with a Python shell. One advantage is that you can go back and forth as you please and save your work.
+ + + +The following example sends a notification via XMPP if a new Home Assistant release is available:
+ +notify:
+ - platform: xmpp
+ name: jabber
+ sender: sender@jabber.org
+ password: !secret xmpp_password
+ recipient: recipient@jabber.org
+
+automation:
+ - alias: Update notifications
+ trigger:
+ - platform: state
+ entity_id: updater.updater
+ action:
+ service: notify.jabber
+ data:
+ message: 'There is a new Home Assistant release available.'
+You can use templates to include the release number of Home Assistant if you prefer. The following example sends a notification via Pushbullet with the Home Assistant version in the message.
+ +notify:
+ platform: pushbullet
+ api_key: 'YOUR_KEY_HERE'
+ name: pushbullet
+
+automation:
+ - alias: Update notifications
+ trigger:
+ - platform: state
+ entity_id: updater.updater
+ action:
+ service: notify.pushbullet
+ data:
+ title: 'New Home Assistant Release'
+ target: 'YOUR_TARGET_HERE' #See Pushbullet component for usage
+ message: "Home Assistant {{ states.updater.updater.state }} is now available."
+The following example sends a notification via pushbullet if a sensor is over a critical value:
+ +
+notify me:
+ platform: pushbullet
+ api_key: "API_KEY_HERE"
+ name: mypushbullet
+
+automation:
+ - alias: FanOn
+ trigger:
+ platform: numeric_state
+ entity_id: sensor.furnace
+ above: 2
+ action:
+ service: notify.mypushbullet
+ data_template:
+ title: "Furnace fan is running"
+ message: "Fan running because current is {{ states.sensor.furnace.state }} amps"
+If you also want a notification when it drops back down below that limit, you could add this as well:
+ + - alias: FanOff
+ trigger:
+ platform: numeric_state
+ entity_id: sensor.furnace
+ below: 2
+ action:
+ service: notify.mypushbullet
+ data_template:
+ title: "Furnace fan is stopped"
+ message: "Fan stopped because current is {{ states.sensor.furnace.state }} amps"
+I (surge919) successfully tied in OwnTracks to Home Assistant and SmartThings while using authentication for external access. The MQTT bridge doesn’t support authentication so I set up 2 MQTT instances.
+ +Here are the steps I performed. Hopefully it saves someone else some time.
+ +It seems to be working pretty well but if anyone sees something incorrect in my configuration, please let me know. This is my first real interaction with MQTT.
+ +Here’s a summary of my setup:
+ +Two Docker instances for MQTT
+ +All Docker configuration files are on my NAS so the Docker containers can be destroyed without affecting my actual configuration files.
+ +$ docker run -ti -p 1883:1883 \
+ -v /volume1/data/mosquitto-int/config:/mqtt/config:ro \
+ -v /volume1/data/mosquitto-int/log:/mqtt/log \
+ -v /volume1/data/mosquitto-int/data/:/mqtt/data/ \
+ --name mosquitto-int -d toke/mosquitto
+$ docker run -ti -p 1884:1883 \
+ -v /volume1/data/mosquitto-ext/config:/mqtt/config:ro \
+ -v /volume1/data/mosquitto-ext/log:/mqtt/log \
+ -v /volume1/data/mosquitto-ext/data/:/mqtt/data/ \
+ -v /volume1/data/mosquitto-ext/etc:/etc/mosquitto \
+ --name mosquitto-ext -d toke/mosquitto
+Here are the config files:
+ +/volume1/data/mosquitto-int/config/mosquitto.conf
connection mosquitto-ext
+persistence_file mosquitto.db
+try_private true
+address 10.0.0.20:1884
+start_type automatic
+sername test
+password test
+notifications true
+topic owntracks/# in
+log_type all
+log_dest file /mqtt/log/mqtt.log
+log_facility 5
+/volume1/data/mosquitto-ext/config/mosquitto.conf
connection mosquitto-int
+persistence_file mosquitto.db
+try_private true
+address 10.0.0.20:1883
+start_type automatic
+username test
+password test
+notifications true
+topic owntracks/# out
+log_type all
+log_dest file /mqtt/log/mqtt.log
+log_facility 5
+allow_anonymous false
+password_file /etc/mosquitto/pwfile
+Create a password for mosquitto-ext
$ docker exec -it mosquitto-ext /bin/bash
+$ cd /etc/mosquitto/
+$ mosquitto_passwd -c /etc/mosquitto/pwfile <userID>
+Preferences / Connection / Mode - Private MQTT
+
+Fill out
+ Host
+ Identification
+ Security: TLS disabled
+
This example uses an input_select element to pick which mp3 file to play on a Chromecast.
# Define our dropdown list
+input_select:
+ lullaby:
+ name: Lullaby
+ options:
+ - Rain
+ - Babbling Brook
+ - None
+ initial: None
+ icon: mdi:weather-rainy
+
+# Define our media player
+media_player:
+ - platform: cast
+ host: chromecast-nursery
+ name: Nursery
+
+automation:
+ # If you select "Rain", play the "rain.mp3" file
+ - alias: Play Rain Lullaby
+
+ trigger:
+ platform: state
+ entity_id: input_select.lullaby
+ to: "Rain"
+
+ action:
+ service: media_player.play_media
+ data:
+ entity_id: media_player.nursery
+ media_id: http://fileserver/rain.mp3
+ media_type: audio/mp4
+
+
+ # If you select "Babbling Brook", play the "babbling_brook.mp3" file
+ - alias: Play Babbling Brook Lullaby
+
+ trigger:
+ platform: state
+ entity_id: input_select.lullaby
+ to: "Babbling Brook"
+
+ action:
+ service: media_player.play_media
+ data:
+ entity_id: media_player.nursery
+ media_id: http://fileserver/babbling_brook.mp3
+ media_type: audio/mp4
+
+ # If you select "None, turn the Chromecast off
+ - alias: Stop the Lullaby
+
+ trigger:
+ platform: state
+ entity_id: input_select.lullaby
+ to: "None"
+
+ action:
+ service: media_player.turn_off
+ data:
+ entity_id: media_player.nursery
+A little bit more complex example that uses input_select and template to decide what to play, and which Chromecast to play on.
input_select:
+ radio_station:
+ name: Radio Station
+ options:
+ - Z88.3
+ - Virgin
+ - RMC
+ - rmcHQ
+ - 105
+ - None
+ initial: None
+ icon: mdi:radio
+ radio_player:
+ name: Radio Player
+ options:
+ - Mansarda
+ - Doccia
+ - Bed
+ - Bath
+ - Salotto
+ - Salotto Video
+ - None
+ initial: None
+ icon: mdi:airplay
+
+automation:
+ - alias: Stop Streaming Radio
+ trigger:
+ - platform: state
+ entity_id: input_select.radio_station
+ to: "None"
+ action:
+ service: media_player.turn_off
+ data_template:
+ entity_id: >
+ {% if is_state("input_select.radio_player", "Mansarda") %}
+ media_player.bed_2
+ {%-elif is_state("input_select.radio_player", "Doccia") %}
+ media_player.bed_3
+ {%-elif is_state("input_select.radio_player", "Bed") %}
+ media_player.bed
+ {%-elif is_state("input_select.radio_player", "Bath") %}
+ media_player.bath
+ {%-elif is_state("input_select.radio_player", "Salotto") %}
+ media_player.salotto
+ {%-elif is_state("input_select.radio_player", "Salotto Video") %}
+ media_player.salotto_video
+ {% else %}
+ none
+ {% endif %}
+
+ - alias: Stream Radio - Template
+ trigger:
+ - platform: state
+ entity_id: input_select.radio_station
+ action:
+ - service: media_player.play_media
+ data_template:
+ entity_id: >
+ {% if is_state("input_select.radio_player", "Mansarda") %}
+ media_player.bed_2
+ {%-elif is_state("input_select.radio_player", "Doccia") %}
+ media_player.bed_3
+ {%-elif is_state("input_select.radio_player", "Bed") %}
+ media_player.bed
+ {%-elif is_state("input_select.radio_player", "Bath") %}
+ media_player.bath
+ {%-elif is_state("input_select.radio_player", "Salotto") %}
+ media_player.salotto
+ {%-elif is_state("input_select.radio_player", "Salotto Video") %}
+ media_player.salotto_video
+ {% else %}
+ none
+ {% endif %}
+ media_content_id: >
+ {% if is_state("input_select.radio_station", "Z88.3") %}
+ http://ice.zradio.org/z/high.mp3
+ {%-elif is_state("input_select.radio_station", "Virgin") %}
+ http://icecast.unitedradio.it/Virgin.mp3
+ {%-elif is_state("input_select.radio_station", "RMC") %}
+ http://icecast.unitedradio.it/RMC.mp3
+ {%-elif is_state("input_select.radio_station", "rmcHQ") %}
+ http://icecast.unitedradio.it/rmcHQ.mp3
+ {%-elif is_state("input_select.radio_station", "105") %}
+ http://icecast.unitedradio.it/Radio105.mp3
+ {% else %}
+ none
+ {% endif %}
+ media_content_type: 'audio/mp4'
+This is a simple “hello world” example to show the basics of registering a service. To use this example, create the file <config dir>/custom_components/hello_service.py and copy the below example code.
Services can be called from automation and from the service “Developer tools” in the frontend.
+ +# The domain of your component. Should be equal to the name of your component.
+DOMAIN = 'hello_service'
+
+ATTR_NAME = 'name'
+DEFAULT_NAME = 'World'
+
+
+def setup(hass, config):
+ """Setup is called when Home Assistant is loading our component."""
+
+ def handle_hello(call):
+ name = call.data.get(ATTR_NAME, DEFAULT_NAME)
+
+ hass.states.set('hello_service.hello', name)
+
+ hass.services.register(DOMAIN, 'hello', handle_hello)
+
+ # Return boolean to indicate that initialization was successfully.
+ return True
+Load the component by adding the following to your configuration.yaml. When your component is loaded, a new service should be available to call.
# configuration.yaml entry
+hello_service:
+Open the frontend and in the sidebar, click the first icon in the developer tool section. This will open the Call Service developer tool. On the right, find your service and click on it. This will automatically fill in the correct values.
+ +Pressing “Call Service” will now call your service without any parameters. This will cause your service to create a state with the default name ‘World’. If you want to specify the name, you have to specify parameters. Add the following JSON as Service Data and press “Call Service again”.
+ +{
+ "name": "Planet"
+}
+The service will now overwrite the previous state with “Planet”.
+ + +This is a simple tutorial/example on how to write a component for Home Assistant. We will work on a component called “hello_state” to begin with. The purpose of this component is to display a given text in the frontend.
+ +The setup of a development environment is described in the Developers section of the documentation.
+ +To get started, create the file <config dir>/custom_components/hello_state.py and copy the below example code.
"""
+Support for showing text in the frontend.
+
+For more details about this component, please refer to the documentation at
+https://home-assistant.io/components/hello_state/
+"""
+import logging
+
+_LOGGER = logging.getLogger(__name__)
+
+DOMAIN = 'hello_state'
+DEPENDENCIES = []
+
+def setup(hass, config=None):
+ """Setup the Hello State component. """
+ _LOGGER.info("The 'hello state' component is ready!")
+
+ return True
+The setup function will take care of the initialization of our component.
+The component will only write a log message. Keep in mind for later that you have several options for the severity:
_LOGGER.info(msg)_LOGGER.warning(msg)_LOGGER.error(msg)_LOGGER.critical(msg)_LOGGER.exception(msg)True if everything is ok.Add the component to your configuration.yaml file.
hello_state:
+After a start or a restart of Home Assistant the component will create an entry in the log.
+ +16-03-12 14:16:42 INFO (MainThread) [custom_components.hello_state] The 'hello state' component is ready!
+The next step is the introduction of configuration options. Most configuration details are coming out of the configuration.yaml file. To do that we need to update the def setup() method to accept configuration information and access the configuration variable in the setup method.
More details about this topic can be found in the User given configuration section.
+ +import logging
+
+_LOGGER = logging.getLogger(__name__)
+
+DOMAIN = 'hello_state'
+DEPENDENCIES = []
+
+CONF_TEXT = 'text'
+DEFAULT_TEXT = 'No text!'
+
+def setup(hass, config):
+ """Setup the Hello State component. """
+ # Get the text from the configuration. Use DEFAULT_TEXT if no name is provided.
+ text = config[DOMAIN].get(CONF_TEXT, DEFAULT_TEXT)
+
+ # States are in the format DOMAIN.OBJECT_ID
+ hass.states.set('hello_state.Hello_State', text)
+
+ return True
+To add the latest feature of our component, update the entry in your configuration.yaml file.
hello_state:
+ text: 'Hello, World!'
+Thanks to DEFAULT_TEXT variable the component will launch even if no text: field is used in the configuration.yaml file. Quite often there are variables which are required. It’s important to check if all mandatory configuration variables are provided. If not, the setup should fail. We will use the validate_config function as a helper to achive this. The next listing shows the essential parts.
from homeassistant.helpers import validate_config
+[...]
+ if not validate_config(config, {DOMAIN: [CONF_TEXT]}, _LOGGER):
+ return False
+If text: is missing, there will be a warning in the log file.
16-03-12 14:37:37 ERROR (MainThread) [custom_components.hello_state] Missing required configuration items in hello_state: text
+16-03-12 14:37:37 ERROR (MainThread) [homeassistant.bootstrap] component hello_state failed to initialize
+After a start or a restart of Home Assistant the component will be visible in the frontend if the configuration.yaml file is up-to-date.
+
+
To get your component included in the Home Assistant releases, follow the steps described in the Submitting improvements section. Basically you only need to move your component in the homeassistant/component/ directory of your fork and create a Pull Request.
+This example requires you to have the MQTT component up and running. +
+ +This is a simple hello world example to show the basics of using MQTT in a custom component. To use this example, create the file <config dir>/custom_components/hello_mqtt.py and copy the below example code.
This example follows a topic on MQTT and updates the state of an entity to the last message received on that topic. It will also register a service ‘set_state’ that will publish a message to the MQTT topic that we’re listening to.
+ +import homeassistant.loader as loader
+
+# The domain of your component. Should be equal to the name of your component.
+DOMAIN = "hello_mqtt"
+
+# List of component names (string) your component depends upon.
+DEPENDENCIES = ['mqtt']
+
+
+CONF_TOPIC = 'topic'
+DEFAULT_TOPIC = 'home-assistant/hello_mqtt'
+
+
+def setup(hass, config):
+ """Setup the Hello MQTT component."""
+ mqtt = loader.get_component('mqtt')
+ topic = config[DOMAIN].get('topic', DEFAULT_TOPIC)
+ entity_id = 'hello_mqtt.last_message'
+
+ # Listener to be called when we receive a message.
+ def message_received(topic, payload, qos):
+ """A new MQTT message has been received."""
+ hass.states.set(entity_id, payload)
+
+ # Subscribe our listener to a topic.
+ mqtt.subscribe(hass, topic, message_received)
+
+ # Set the intial state
+ hass.states.set(entity_id, 'No messages')
+
+ # Service to publish a message on MQTT.
+ def set_state_service(call):
+ """Service to send a message."""
+ mqtt.publish(hass, topic, call.data.get('new_state'))
+
+ # Register our service with Home Assistant.
+ hass.services.register(DOMAIN, 'set_state', set_state_service)
+
+ # Return boolean to indicate that initialization was successfully.
+ return True
+Load the component by adding the following to your configuration.yaml. When your component is loaded, a new entity should popup and there should be a new service available to call.
# configuration.yaml entry
+hello_mqtt:
+ topic: some_mqtt/topic/here
+You can call the service with example payload:
+ +{
+ "new_state": "some new state"
+}
+This example component will detect intruders. It does so by checking if lights are being turned on while there is no one at home. When this happens it will turn the lights red, flash them for 30 seconds and send a message via the notify component. It will also flash a specific light when a known person comes home.
+ +This component depends on the components device_tracker and light being setup.
+ +To set it up, add the following lines to your configuration.yaml file:
# Example configuration.yaml entry
+simple_alarm:
+ known_light: light.Bowl
+ unknown_light: group.living_room
+Configuration variables:
+ +Create the file <config dir>/custom_components/simple_alarm.py and copy paste the content below:
"""Simple alarm component."""
+import logging
+
+import homeassistant.loader as loader
+from homeassistant.components import device_tracker, light, notify
+from homeassistant.helpers.event import track_state_change
+from homeassistant.const import STATE_ON, STATE_OFF, STATE_HOME, STATE_NOT_HOME
+
+DOMAIN = "simple_alarm"
+
+DEPENDENCIES = ['group', 'device_tracker', 'light']
+
+# Attribute to tell which light has to flash when a known person comes home
+# If omitted will flash all.
+CONF_KNOWN_LIGHT = "known_light"
+
+# Attribute to tell which light has to flash when an unknown person comes home
+# If omitted will flash all.
+CONF_UNKNOWN_LIGHT = "unknown_light"
+
+# Services to test the alarms
+SERVICE_TEST_KNOWN_ALARM = "test_known"
+SERVICE_TEST_UNKNOWN_ALARM = "test_unknown"
+
+
+def setup(hass, config):
+ """ Sets up the simple alarms. """
+ logger = logging.getLogger(__name__)
+
+ light_ids = []
+
+ for conf_key in (CONF_KNOWN_LIGHT, CONF_UNKNOWN_LIGHT):
+ light_id = config[DOMAIN].get(conf_key, light.ENTITY_ID_ALL_LIGHTS)
+
+ if hass.states.get(light_id) is None:
+ logger.error(
+ 'Light id %s could not be found in state machine', light_id)
+
+ return False
+
+ light_ids.append(light_id)
+
+ # pylint: disable=unbalanced-tuple-unpacking
+ known_light_id, unknown_light_id = light_ids
+
+ if hass.states.get(device_tracker.ENTITY_ID_ALL_DEVICES) is None:
+ logger.error('No devices are being tracked, cannot setup alarm')
+
+ return False
+
+ def known_alarm():
+ """ Fire an alarm if a known person arrives home. """
+ light.turn_on(hass, known_light_id, flash=light.FLASH_SHORT)
+
+ def unknown_alarm():
+ """ Fire an alarm if the light turns on while no one is home. """
+ light.turn_on(
+ hass, unknown_light_id,
+ flash=light.FLASH_LONG, rgb_color=[255, 0, 0])
+
+ # Send a message to the user
+ notify.send_message(
+ hass, "The lights just got turned on while no one was home.")
+
+ # Setup services to test the effect
+ hass.services.register(
+ DOMAIN, SERVICE_TEST_KNOWN_ALARM, lambda call: known_alarm())
+ hass.services.register(
+ DOMAIN, SERVICE_TEST_UNKNOWN_ALARM, lambda call: unknown_alarm())
+
+ def unknown_alarm_if_lights_on(entity_id, old_state, new_state):
+ """ Called when a light has been turned on. """
+ if not device_tracker.is_on(hass):
+ unknown_alarm()
+
+ track_state_change(
+ hass, light.ENTITY_ID_ALL_LIGHTS,
+ unknown_alarm_if_lights_on, STATE_OFF, STATE_ON)
+
+ def ring_known_alarm(entity_id, old_state, new_state):
+ """ Called when a known person comes home. """
+ if light.is_on(hass, known_light_id):
+ known_alarm()
+
+ # Track home coming of each device
+ track_state_change(
+ hass, hass.states.entity_ids(device_tracker.DOMAIN),
+ ring_known_alarm, STATE_NOT_HOME, STATE_HOME)
+
+ return True
+This configuration example is restarting Home Assistant if a WeMo switch is not detected. An additional MQTT switch is present for stopping Home Assistant and can be triggered by IFTTT. The running batch script will automatically restart Home Assistant if the process isn’t found anymore.
+ +mqtt:
+ broker: 127.0.0.1
+ port: 1883
+ client_id: home-assistant-1
+ keepalive: 60
+
+device_tracker:
+ - platform: nmap_tracker
+ hosts: 192.168.0.1-255
+ home_interval: 1
+ interval_seconds: 30
+ consider_home: 900
+
+ifttt:
+ key: ***
+
+notify:
+ - platform: pushbullet
+ api_key: ***
+ name: pushbullet
+
+switch:
+ - platform: wemo
+ - platform: mqtt
+ state_topic: "home/killhass"
+ command_topic: "home/killhass"
+ name: "KillHass"
+ qos: 0
+ payload_on: "ON"
+ payload_of: "OFF"
+ optimistic: false
+
+script:
+ restarthawemo:
+ alias: "Restart HA if WeMo isn't found after 15 minutes"
+ sequence:
+ - delay:
+ minutes: 15
+ - service: notify.pushbullet
+ data:
+ message: 'WeMo not found, restarting HA'
+ - service: switch.turn_on
+ data:
+ entity_id: switch.killhass
+
+automation:
+- alias: "Restart HA if WeMo switch isn't found after 15 minutes"
+ trigger:
+ platform: state
+ entity_id: device_tracker.wemo
+ from: 'not_home'
+ to: 'home'
+ condition:
+ - condition: template
+ value_template: '{% if states.switch.wemo %}false{% else %}true{% endif %}'
+ - condition: state
+ entity_id: script.restarthawemo
+ state: 'off'
+ action:
+ service: homeassistant.turn_on
+ entity_id: script.restarthawemo
+- alias: 'Stop HA'
+ trigger:
+ - platform: state
+ entity_id: switch.KillHass
+ state: 'on'
+ action:
+ service: homeassistant.stop
+ - alias: 'Stop restarting HA is WeMo is found'
+ trigger:
+ platform: template
+ value_template: '{% if states.switch.wemo %}true{% else %}false{% endif %}'
+ condition:
+ condition: state
+ entity_id: script.restarthawemo
+ state: 'on'
+ action:
+ service: homeassistant.turn_off
+ entity_id: script.restarthawemo
+Always forget to eat lunch? Let Home Assistant send you a reminder.
+ +Add a notify platform of your choice.
+ +notify:
+ - platform: xmpp
+ name: jabber
+ sender: YOUR_JID
+ password: YOUR_JABBER_ACCOUNT_PASSWORD
+ recipient: YOUR_RECIPIENT
+and automation part to your configuration.yaml file.
automation:
+ - alias: Send message at a given time
+ trigger:
+ platform: time
+ hours: 12
+ minutes: 15
+ seconds: 0
+ action:
+ service: notify.jabber
+ data:
+ message: 'Time for lunch'
+If your Home Assistant instance is only accessible from your local network you can still protect the communication between your browsers and the frontend with SSL/TLS. Let’s encrypt will only work if you have a DNS entry and remote access is allowed. The solution is to use a self-signed certificate. As you most likely don’t have a certification authority (CA) your browser will conplain about the security. If you have a CA then this will not be an issue.
+ +To create locally a certificate you need the OpenSSL command-line tool.
+ +Change to your Home Assistant configuration directory like ~/.homeassistant. This will make it easier to backup your certificate and the key. Run the command shown below.
$ openssl req -new -x509 -sha256 -newkey rsa:4096 -nodes -keyout privkey.pem -days 730 -out fullchain.pem
+For details about the parameters, please check the OpenSSL documentation. Provide the requested information during the generation process. At the end you will have two files called privkey.pem and fullchain.pem. The key and the certificate.
Update the http: entry in your configuration.yaml file and let it point to your created files.
http:
+ api_password: YOUR_SECRET_PASSWORD
+ ssl_certificate: /home/fab/.homeassistant/fullchain.pem
+ ssl_key: /home/fab/.homeassistant/privkey.pem
+A tutorial “Working with SSL Certificates, Private Keys and CSRs” could give you some insight about special cases.
+ + +This is an example about how you can configure Tor to provide secure remote access to your Home Assistant instance as an Onion site, through Tor’s Hidden Service feature. With this enabled, you do not need to open your firewall ports or setup HTTPS to enable secure remote access.
+ +This is useful if you want to have:
+ +This configuration is part of an effort to apply strong cryptography technologies (like Onion Routing and End-to-End Encryption) to technology we increasingly depend on in our day to day lives. Just like when WhatsApp enabled end-to-end encryption messaging for everyone, every home automation and IoT platform should do the same, because A) the technology is all there, freely licensed and open-source and B) up to this point, all the commercial manufacturers have been doing a horrific job with security.
+ +You can learn more about how Tor can be used to secure home automation and IoT platforms through this short set of slides on the Internet of Onion Things
+ +This configuration was provided by @n8fr8 (github, twitter) of the Guardian Project and Tor Project. You can send questions, feedback and ideas to support@guardianproject.info.
+ +Tor allows clients and relays to offer hidden services. That is, you can offer a web server, SSH server, etc., without revealing your IP address to its users. In fact, because you don’t use any public address, you can run a hidden service from behind your firewall. Learn more about Hidden Services on the Tor Project website.
+ +Onion sites are websites that run on a Tor Hidden Service node. “dot onion” sites are an IETF recognized special use domain name.
+ +First, install Tor. On a Debian-based system, you can install the package easily:
+ +$ sudo apt-get install tor
+You can find more instructions for downloading and installing Tor on other platforms on the Tor Project Download Page.
+ +Next, modify Tor’s main configuration file /etc/tor/torrc to include the following lines:
############### This section is just for location-hidden services ###
+
+## Once you have configured a hidden service, you can look at the
+## contents of the file ".../hidden_service/hostname" for the address
+## to tell people.
+...
+HiddenServiceDir /var/lib/tor/homeassistant/
+HiddenServicePort 80 127.0.0.1:8123
+HiddenServiceAuthorizeClient stealth haremote1
+...
+The “stealth” entry above ensures traffic to and from your Home Assistant instance over Tor, is hidden even from other nodes on the Tor network. The haremote1 value is a generic client name entry that you can modify as you please.
Then, restart Tor:
+ +$ sudo /etc/init.d/tor restart
+Then read the new generated authentication cookie from the Tor-generated hostname file:
+ +$ sudo more /var/lib/tor/homeassistant/hostname
+The output of that command should look something like this, but with your own unique “dot onion” domain and authentication cookie:
+ +abcdef1234567890.onion ABCDEF1122334455667789 # client: haremote1
+You are now done with the Home Assistant Tor server configuration. Make sure your Home Assistant instance is running, and now you can move to client configuration.
+ +Using this setup, you can access your Home Assistant instance over Tor from your laptop or mobile device, using Tor Browser and other software.
+ +Add the authentication cookie to your torrc client configuration on your laptop or mobile device. Using the sample values from above, it would look like this:
HidServAuth abcdef1234567890.onion ABCDEF1122334455667789
+For Tor Browser on Windows, Mac or Linux, you can find the torrc file here: <tor browser install directory>/Browser/TorBrowser/Data/Tor/torrc-defaults
Once you have added the entry, restart the browser, and then browse to the “dot onion” site address to connect to your Home Assistant instance.
+ +For Orbot: Tor on Android, add it in Orbot -> Menu -> Settings to the “Torrc Custom Config” entry. Restart Orbot, and then use the Orfox browser app, and browse to the “dot onion” site name to access your Home Assistant instance. You can also use Orbot’s VPN mode, to enable Tor access from any application on your device, such as Tasker or Owntracks.
+ +On iOS, we have not fully tested this yet, but you should be able to add custom torrc entries on Onion Browser, Red Onion or TOBY browsers, all available in the iTunes App Store.
+ +With this configuration, only you can access your Home Assistant instance Onion site through Tor, and no one else. You can share the authentication cookie with multiple devices and users, or you can generate a unique one for each - up to you! If you have multiple, say for an industrial, business or corporate configuration, this would provide an easy way to revoke access to a specific user or device.
+ +If you always access your Home Assistant instance via Tor, you can easily run this on an isolated “IoT” network segment at your install site, keeping your internal home network traffic separate from any potentially compromised devices (like cheap “smart” lightbulbs with backdoors!).
+ +You could also use Tor as a means to connect your Home Assistant instance to a remote device, sensor or other service that you do not want to or connect provide a direct, open IP connection to. Again, Tor provides authenticated and confidential routing (aka “privacy and encryption”) by default, without having to setup TLS/SSL or VPN. It is just important to secure IoT nodes within your network, as it is to secure remote access!
+ +As mentioned, with Orbot on Android, you can enable a “full device” VPN mode, that allows any app you have to tunnel through Tor, even if it is not Tor or proxy aware. This means you should be able to enter your “dot onion” Onion site address into any app you want to access to your Home Assistant instance, and it should work.
+ + + +iOS Devices
+ +If you have a device running iOS (iPhone, iPad, etc), The iCloud is gathering various details about your device including the battery level. To display it in the Frontend use a template sensor.
+ + - platform: template
+ sensors:
+ battery_iphone:
+ unit_of_measurement: '%'
+ value_template: >-
+ {%- if states.device_tracker.iphone.attributes.battery %}
+ {{ states.device_tracker.iphone.attributes.battery }}
+ {% else %}
+ {{ states.sensor.battery_iphone.state }}
+ {%- endif %}
+The else part is used to have the sensor keep it’s last state if the newest iCloud update doesn’t have any battery state in it (which happens sometimes). Otherwise the sensor will be blank.
Android and iOS Devices
+ +While running the Owntracks device tracker you can retrieve the battery level with a MQTT sensor.
+ +sensor:
+ - platform: mqtt
+ state_topic: "owntracks/tablet/tablet"
+ name: "Battery Tablet"
+ unit_of_measurement: "%"
+ value_template: '{{ value_json.batt }}'
+This recipe will turn on a light when there is motion and turn off the light when ten minutes has passed without any motion events.
+ +automation:
+ alias: Turn on kitchen lights when there is movement
+ trigger:
+ - platform: state
+ entity_id: sensor.motion_sensor
+ to: 'on'
+ action:
+ service: homeassistant.turn_on
+ entity_id: script.timed_lamp
+
+script:
+ timed_lamp:
+ alias: "Turn on lamp and set timer"
+ sequence:
+ # Cancel ev. old timers
+ - service: script.turn_off
+ data:
+ entity_id: script.timer_off
+ - service: light.turn_on
+ data:
+ entity_id: light.kitchen
+ # Set new timer
+ - service: script.turn_on
+ data:
+ entity_id: script.timer_off
+
+ timer_off:
+ alias: "Turn off lamp after 10 minutes"
+ sequence:
+ - delay:
+ minutes: 10
+ - service: light.turn_off
+ data:
+ entity_id: light.kitchen
+
pip3 install homeassistant
hass --open-uiHere are some resources to get started.configuration.yaml and disable the introduction component.[[stateObj.attributes.description]] [[stateObj.attributes.link_name]]
[[stateObj.attributes.errors]]