jeena/home-assistant.github.io
1
0
Fork 0
Code Issues Pull requests Projects Packages Wiki Activity Actions

Merge branch 'pr/101'

Browse source 
Conflicts:
	source/components/index.markdown
This commit is contained in:
Paulus Schoutsen 2015-10-24 21:54:58 -07:00
commit 04f48395d6
127 changed files with 353 additions and 537 deletions
Download patch file Download diff file Expand all files Collapse all files

65
source/_components/alarm_control_panel.manual.markdown Normal file
View file

@ -0,0 +1,65 @@
---
layout: page
title: "Manual alarm support"
description: "Instructions how to integrate manual alarms into Home Assistant."
date: 2015-10-13 19:10
sidebar: false
comments: false
sharing: true
footer: true
ha_category: Alarm Control Panel
---
<img src='/images/supported_brands/preferences-system-privacy.png' class='brand pull-right' />
This platform enables you to set manual alarms in Home Assistant.
```yaml
# Example configuration.yaml entry
alarm_control_panel:
platform: manual
name: "HA Alarm"
code: PASSCODE
pending_time: 60
trigger_time: 120
```
Configuration variables:
- **name** (*Optional*): The name of the alarm. Default is 'HA Alarm'.
- **code** (*Optional*): If defined, specifies a code to enable or disable the alarm in the frontend.
- **pending_time** (*Optional*): The time in seconds of the pending time before arming the alarm. Default is 60 seconds.
- **trigger_time** (*Optional*): The time in seconds of the trigger time in which the alarm is firing. Default is 120 seconds.
## {% linkable_title Examples %}
In this section you find some real life examples of how to use this panel.
### {% linkable_title Sensors %}
Using sensors to trigger the alarm.
```yaml
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
```

18
source/_components/alarm_control_panel.markdown Normal file
View file

@ -0,0 +1,18 @@
---
layout: page
title: "Alarm panel support"
description: "Instructions how to integrate Alarm Control Panels into Home Assistant."
date: 2015-10-13 19:10
sidebar: false
comments: false
sharing: true
footer: true
---
<img src='/images/supported_brands/preferences-system-privacy.png' class='brand pull-right' />
Home Assistant can give you an interface with is similar to a classic alarm system. There are several panels supported:
- [Manual](/components/alarm_control_panel.manual.html)
- [MQTT](/components/alarm_control_panel.mqtt.html)
- [Verisure](/components/verisure.html)

45
source/_components/alarm_control_panel.mqtt.markdown Normal file
View file

@ -0,0 +1,45 @@
---
layout: page
title: "MQTT alarm support"
description: "Instructions how to integrate MQTT alarms into Home Assistant."
date: 2015-09-14 19:10
sidebar: false
comments: false
sharing: true
footer: true
logo: mqtt.png
ha_category: "Alarm Control Panel"
---
<img src='/images/supported_brands/mqtt.png' class='brand pull-right' />
This platform enables the possibility to control an MQTT alarm. The alarm will only change state after
receiving the a new state from `state_topic`. If these messages are published with RETAIN flag, the MQTT
alarm will receive an instant state update after subscription and will start with correct state. Otherwise,
the initial state will be `unknown`.
```yaml
# Example configuration.yaml entry
alarm_control_panel:
platform: mqtt
state_topic: "home/alarm"
command_topic: "home/alarm/set"
name: "MQTT Alarm"
qos: 0
payload_disarm: "DISARM"
payload_arm_home: "ARM_HOME"
payload_arm_away: "ARM_AWAY"
code: "mySecretCode"
```
Configuration variables:
- **state_topic** (*Required*): The MQTT topic subscribed to receive state updates.
- **command_topic** (*Required*): The MQTT topic to publish commands to change the alarm state.
- **name** (*Optional*): The name of the alarm. Default is 'MQTT Alarm'.
- **qos** (*Optional*): The maximum QoS level of the state topic. Default is 0. This QoS will also be used to publishing messages.
- **payload_disarm** (*Optional*): The payload do disarm alarm. Default is "DISARM".
- **payload_arm_home** (*Optional*): The payload to set armed-home mode. Default is "ARM_HOME".
- **payload_arm_away** (*Optional*): The payload to set armed-away mode. Default is "ARM_AWAY".
- **code** (*Optional*): If defined, specifies a code to enable or disable the alarm in the frontend.

54
source/_components/arduino.markdown Normal file
View file

@ -0,0 +1,54 @@
---
layout: page
title: "Arduino"
description: "Instructions how to setup an Arduino boards within Home Assistant."
date: 2015-06-27 10:28
sidebar: false
comments: false
sharing: true
footer: true
logo: arduino.png
ha_category: DIY
logo: arduino.png
ha_category: Hub
---
<img src='/images/supported_brands/arduino.png' class='brand pull-right' />
The [Arduino](https://www.arduino.cc/) 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](https://www.arduino.cc/en/Main/Products) 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](https://www.arduino.cc/en/Main/ArduinoShields)) 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.
## Basic Configuration
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](https://github.com/firmata/) on your board. Please upload the `StandardFirmata` sketch to your board, please refer to the [Arduino documentation](https://www.arduino.cc/en/Main/Howto) for further information.
To integrate an Arduino boards with Home Assistant, add the following section to your `configuration.yaml` file:
```yaml
# Example configuration.yaml entry
arduino:
port: /dev/ttyACM0
```
Configuration variables:
- **port** (*Required*): The port where your board is connected to your Home Assistant host. If you are using an original Arduino the port will be named `ttyACM*`. The exact number can be determined with `ls /dev/ttyACM*`.
```bash
ls /dev/ttyACM*
```
If that is not working, check your `dmesg` or `journalctl -f` output. Keep in mind that Arduino clones are often using a different name for the port (e.g. `/dev/ttyUSB*`).
<p class='note warning'>
A word of caution: The Arduino boards are not storing states. This means that with every initialization the pins are set to off/low.
</p>
## Building on top of the Arduino component
- [Arduino Sensor](/components/sensor.arduino.html)
- [Arduino Switch](/components/switch.arduino.html)

331
source/_components/automation.markdown Normal file
View file

@ -0,0 +1,331 @@
---
layout: page
title: "Automation"
description: "Instructions how to setup automation within Home Assistant."
date: 2015-01-20 22:36
sidebar: false
comments: false
sharing: true
footer: true
---
This page will go into more detail about the various options the `automation` component offers. If
you haven't yet, read the [getting started page on automation](/getting-started/automation.html).
A configuration section of an automation requires a `trigger` and an `action` section. `condition` and
`condition_type` are optional. To keep this page compact, all following sections will not show the
full configuration but only the relevant part.
```yaml
# Example of entry in configuration.yaml
automation:
# Turns on lights 1 hour before sunset if people are home
# and if people get home between 16:00-23:00
- alias: 'Rule 1 Light on in the evening'
trigger:
# Prefix the first line of each trigger configuration
# with a '-' to enter multiple
- platform: sun
event: sunset
offset: '-01:00:00'
- platform: state
entity_id: group.all_devices
state: 'home'
condition:
# Prefix the first line of each condition configuration
# with a '-'' to enter multiple
- 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
# Turn off lights when everybody leaves the house
- alias: 'Rule 2 - Away Mode'
trigger:
platform: state
entity_id: group.all_devices
state: 'not_home'
action:
service: light.turn_off
entity_id: group.all_lights
# Notify when Paulus leaves the house in the evening
- alias: 'Leave Home notification'
trigger:
platform: zone
event: leave
zone: zone.home
entity_id: device_tracker.paulus
condition:
platform: time
after: '20:00'
action:
service: notify.notify
data:
message: 'Paulus left the house'
```
- [Jump to conditions](#conditions)
- [Jump to actions](#actions)
- [Jump to troubleshooting](#troubleshooting)
## {% linkable_title Triggers %}
Triggers are what starts the processing of an automation rule. It is possible to specify multiple
triggers for the same rule. Once a trigger starts, Home Assistant will validate the conditions, if any,
and call the action.
#### {% linkable_title Event trigger %}
Triggers when an event is being processed. Events are the raw building blocks of Home Assistant.
You can match events on just the event name or also require specific event data to be present.
```yaml
automation:
trigger:
platform: event
event_type: MY_CUSTOM_EVENT
# optional
event_data:
mood: happy
```
#### {% linkable_title MQTT trigger %}
Triggers when a specific message is received on given topic. Optionally can match on the payload
being sent over the topic.
```yaml
automation:
trigger:
platform: mqtt
topic: living_room/switch/ac
# Optional
payload: 'on'
```
#### {% linkable_title Numeric state trigger %}
On state change of a specified entity, attempts to parse the state as a number and triggers if value
is above and/or below a threshold.
```yaml
automation:
trigger:
platform: numeric_state
entity_id: sensor.temperature
# At least one of the following required
above: 17
below: 25
```
#### {% linkable_title State trigger %}
Triggers when the state of an entity changes. If only entity_id given will match all state changes.
```yaml
automation:
trigger:
platform: state
entity_id: device_tracker.paulus
# Optional
from: 'not_home'
to: 'home'
```
<p class='note warning'>
Use quotes around your values for <code>from</code> and <code>to</code> to avoid the YAML parser
interpreting some values as booleans.
</p>
#### {% linkable_title Sun trigger %}
Trigger when the sun is setting or rising. An optional time offset can be given to have it trigger for
example 45 minutes before sunset, when dusk is setting in.
```yaml
automation:
trigger:
platform: sun
# Possible values: sunset, sunrise
event: sunset
# Optional time offset. This example is 45 minutes.
offset: '-00:45:00'
```
#### {% linkable_title Time trigger %}
Time can be triggered in many ways. The most common is to specify `after` and trigger at a specific
point in time each day. Alternatively, you can also match if the hour, minute or second of the current
time has a specific value. For example, by only setting minutes in the config to 5 it will trigger every
hour when it is 5 minutes past whole. You cannot use `after` together with hour, minute or second.
```yaml
automation:
trigger:
platform: time
# All following are optional.
# When 'after' is used, you cannot also match on hour, minute, seconds.
# Military time format.
# after: '15:32:00'
hours: 0
minutes: 5
seconds: 0
weekday:
- sat
- sun
```
You can use `weekday` to limit the trigger times to speific days as well (also available in conditions).
Valid values for `weekday` are (`sun`, `mon`, `tue`, `wed`, `thu`, `fri` & `sat`)
The above example will trigger on Saturday and Sunday every hour on the 5 (2:05, 3:05, 4:05, etc).
#### {% linkable_title Zone trigger %}
Zone triggers can trigger when an entity is entering or leaving the zone. For zone automation to work,
you need to have setup a device tracker platform that supports reporting GPS coordinates. Currently
this is limited to the [OwnTracks platform](/components/device_tracker.owntracks.html).
```yaml
automation:
trigger:
platform: zone
entity_id: device_tracker.paulus
zone: zone.home
# Event is either enter or leave
event: enter
```
## {% linkable_title Conditions %}
Conditions are an optional part of an automation rule and be used to prevent an action from happening
when triggered. Conditions look very familiar to triggers but are very different. A trigger will look
at events happening at the system while a condition only looks at how the system looks right now.
A trigger can observe that a switch is being turned on. A condition can only see if a switch is on
or off.
An automation rule can have mulitiple triggers. By default the action will only fire if all conditions
pass. An optional key `condition_type: 'or'` can be set on the automation rule to fire action if any
condition matches. In the example below, the automation would trigger if the time is before 05:00 _OR_ after 20:00.
```yaml
automation:
condition_type: or
condition:
- platform: time
before: '05:00'
- platform: time
after: '20:00'
```
If your triggers and conditions are exactly the same, you can use a shortcut to specify conditions.
In this case, triggers that are not valid conditions will be ignored.
```yaml
automation:
condition: use_trigger_values
```
#### {% linkable_title Numeric state condition %}
Attempts to parse the state of specified entity as a number and triggers if value is above and/or
below a threshold.
```yaml
automation:
condition:
platform: numeric_state
entity_id: sensor.temperature
# At least one of the following required
above: 17
below: 25
```
#### {% linkable_title State condition %}
Tests if an entity is a specified state.
```yaml
automation:
condition:
platform: state
entity_id: device_tracker.paulus
state: not_home
```
#### {% linkable_title Time condition %}
The time condition can test if it is after a specified time, before a specified time or if it is a
certain day of the week
```yaml
automation:
condition:
platform: time
# At least one of the following is required.
after: '15:00:00'
before: '23:00:00'
weekday:
- mon
- wed
- fri
```
Valid values for `weekday` are (sun, mon, tue, wed, thu, fri & sat)
#### {% linkable_title Zone condition %}
Zone conditions test if an entity is in a certain zone. For zone automation to work,
you need to have setup a device tracker platform that supports reporting GPS coordinates. Currently
this is limited to the [OwnTracks platform](/components/device_tracker.owntracks.html).
```yaml
automation:
condition:
platform: zone
entity_id: device_tracker.paulus
zone: zone.home
```
## {% linkable_title Actions %}
When an automation rule fires, it calls a service. For this service you can specify an entity id it
should apply to and optional service parameters (to specify for example the brightness).
```yaml
automation:
# Change the light in the kitchen and living room to 150 brightness and color red.
action:
service: homeassistant.turn_on
entity_id:
- light.kitchen
- light.living_room
data:
brightness: 150
rgb_color: [255, 0, 0]
```
```yaml
automation:
# Notify me on my mobile phone of an event
action:
service: notify.notify
data:
message: Something just happened, better take a look!
```
If you want to specify multiple services to be called or include a delay, have a look at the
[script component](/components/script.html). If you want to describe how certain entities should look,
check out the [scene component](/components/scene.html).
## {% linkable_title Troubleshooting %}
You can verify that your automation rules are being initialized correctly by watching both the realtime
logs and also the logbook. The realtime logs will show the rules being initialized (once for each trigger):
```bash
INFO [homeassistant.components.automation] Initialized rule Rainy Day
INFO [homeassistant.components.automation] Initialized rule Rainy Day
INFO [homeassistant.components.automation] Initialized rule Rainy Day
INFO [homeassistant.components.automation] Initialized rule Rain is over
```
The Logbook component will show a line entry when an automation is triggered. You can look at the
previous entry to determine which trigger in the rule triggered the event.
![Logbook example](/images/components/automation/logbook.png)

26
source/_components/browser.markdown Normal file
View file

@ -0,0 +1,26 @@
---
layout: page
title: "Browser"
description: "Instructions how to setup the browser component with Home Assistant."
date: 2015-01-24 14:39
sidebar: false
comments: false
sharing: true
footer: true
ha_category: Other
---
<img src='/images/supported_brands/web-browser.png' class='brand pull-right' />
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`:
```
browser:
```
#### Service `browser/browse_url`
| Service data attribute | Optional | Description |
| ---------------------- | -------- | ----------- |
| `url` | no | The url to open

37
source/_components/camera.foscam.markdown Normal file
View file

@ -0,0 +1,37 @@
---
layout: page
title: "Foscam IP camera support"
description: "Instructions how to integrate Foscam IP cameras within Home Assistant."
date: 2015-09-17 08:01
sidebar: false
comments: false
sharing: true
footer: true
logo: foscam.png
ha_category: Camera
---
<img src='/images/supported_brands/foscam.png' class='brand pull-right' />
The foscam platform allows you to watch the live stream of your [Foscam](http://www.foscam.com/) IP camera in Home Assistant.
To enable your Foscam IP camera in your installation, add the following to your `configuration.yaml` file:
```yaml
# Example configuration.yaml entry
camera:
platform: foscam
ip: 192.168.0.123
name: Door Camera
port: 88
username: USERNAME
password: PASSWORD
```
Configuration variables:
- **ip** *Required*: The IP address your camera.
- **port** *Optional*: The port that the camera is running on. The default is 88.
- **name** *Optional*: This parameter allows you to override the name of your camera.
- **username** *Required*: The username for accessing your camera.
- **password** *Required*: The password for accessing your camera.

40
source/_components/camera.generic.markdown Normal file
View file

@ -0,0 +1,40 @@
---
layout: page
title: "Generic IP Camera"
description: "Instructions how to integrate IP cameras within Home Assistant."
date: 2015-07-11 0:36
sidebar: false
comments: false
sharing: true
footer: true
ha_category: Camera
---
<img src='/images/supported_brands/camera-web.png' class='brand pull-right' />
This component allows you to integrate any IP camera into Home Assistant. It supports fetching images from a url with optional HTTP authentication.
Home Assistant will serve the images via its server, making it possible to view your IP camera's while outside of your network.
As part of the basic support the following features will be provided:
- MJPEG video streaming
- Saving a snapshot
- Recording(JPEG frame capture)
To enable this sensor in your installation, add the following to your `configuration.yaml` file:
```yaml
# Example configuration.yaml entry
camera:
platform: generic
still_image_url: http://194.218.96.92/jpg/image.jpg
name: my sample camera
username: USERNAME
password: PASSWORD
```
Configuration variables:
- **still_image_url** *Required*: The URL your camera serves the image on, eg. http://192.168.1.21:2112/
- **name** *Optional*: This parameter allows you to override the name of your camera.
- **username** *Optional*: The username for accessing your camera.
- **password** *Optional*: The password for accessing your camera.

20
source/_components/configurator.markdown Normal file
View file

@ -0,0 +1,20 @@
---
layout: page
title: "Configurator"
description: "Instructions how to integrate the configurator in your components."
date: 2015-03-15 00:51
sidebar: false
comments: false
sharing: true
footer: true
---
<p class='note'>
This component is intended for developers.
</p>
The configurator component allows components to request information from the user. It is currently implemented as the minimum viable product: it supports showing a text, image and button to the user. It will trigger a callback when the button is pressed.
The Hue component in [the demo](/demo) is implemented using the configurator. See [the source of the demo component](https://github.com/balloob/home-assistant/blob/master/homeassistant/components/demo.py#L72) for a simple example.
See [the source](https://github.com/balloob/home-assistant/blob/master/homeassistant/components/configurator.py#L39) for more details on how to use the configurator component.

25
source/_components/conversation.markdown Normal file
View file

@ -0,0 +1,25 @@
---
layout: page
title: "Conversation"
description: "Instructions how to have conversations with your Home Assistant."
date: 2015-03-15 00:39
sidebar: false
comments: false
sharing: true
footer: true
---
<img src='/images/supported_brands/system-users.png' class='brand pull-right' />
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:
```
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](/demo/) in Chrome to see it in action.
<p class='img'>
<img src="/images/screenshots/voice-commands.png" />
</p>

37
source/_components/device_sun_light_trigger.markdown Normal file
View file

@ -0,0 +1,37 @@
---
layout: page
title: "Automating your lights"
description: "Instructions how to automate your lights with Home Assistant."
date: 2015-01-20 22:36
sidebar: false
comments: false
sharing: true
footer: true
---
Home Assistant has a built-in component called `device_sun_light_trigger` to help you automate your lights. The component will:
* Fade in the lights when the sun is setting and there are people home
* Turn on the lights when people get home after the sun has set
* Turn off the lights when all people leave the house
This component requires the components [sun](/components/sun.html), [device_tracker](/components/device_tracker.html) and [light](/components/light.html) to be enabled.
To enable this component, add the following lines to your `configuration.yaml` file:
```yaml
# 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
```
Configuration variables:
- **light_group** (*Optional*): Specify a specific light/group of lights that has to be turned on.
- **light_profile** (*Optional*): Specify which light profile to use when turning lights on.
- **device_group** (*Optional*): Specify which group of devices to track.
- **disable_turn_off** (*Optional*): Disable lights being turned off when everybody leaves the house.

43
source/_components/device_tracker.actiontec.markdown Normal file
View file

@ -0,0 +1,43 @@
---
layout: page
title: "Actiontec support"
description: "Instructions how to integrate Actiontec routers into Home Assistant."
date: 2015-08-30 19:00
sidebar: false
comments: false
sharing: true
footer: true
logo: actiontec.png
ha_category: Presence Detection
---
<img src='/images/supported_brands/actiontec.png' class='brand pull-right' />
This platform allows you to detect presence by looking at connected devices to an [Actiontec](http://www.actiontec.com/) device.
Supported devices (tested):
- MI424WR (Verizon FIOS)
<p class='note warning'>
This device tracker needs telnet to be enabled on the router.
</p>
```yaml
# Example configuration.yaml entry
device_tracker:
platform: actiontec
host: YOUR_ROUTER_IP
username: YOUR_ADMIN_USERNAME
password: YOUR_ADMIN_PASSWORD
home_interval: MINUTES
```
Configuration variables:
- **host** (*Required*): The IP address of your router, eg. 192.168.1.1.
- **username** (*Required*: The username of an user with administrative privileges, usually *admin*.
- **password** (*Required*): The password for your given admin account.
- **home_interval** (*Optional*): If the home_interval is set then the component will not let a device be AWAY if it has been HOME in the last home_interval minutes. This is in addition to the 3 minute wait built into the device_tracker component.
See the [device tracker component page](/components/device_tracker.html) for instructions how to configure the people to be tracked.

41
source/_components/device_tracker.aruba.markdown Normal file
View file

@ -0,0 +1,41 @@
---
layout: page
title: "Aruba support"
description: "Instructions how to integrate Aruba routers into Home Assistant."
date: 2015-08-31 08:45
sidebar: false
comments: false
sharing: true
footer: true
logo: aruba.png
ha_category: Presence Detection
---
<img src='/images/supported_brands/aruba.png' class='brand pull-right' />
This platform allows you to detect presence by looking at connected devices to an [Aruba Instant](http://www.arubanetworks.com/products/networking/aruba-instant/) device.
Supported devices (tested):
- ARUBA AP-105
<p class='note warning'>
This device tracker needs telnet to be enabled on the router.
</p>
```yaml
# Example configuration.yaml entry
device_tracker:
platform: aruba
host: YOUR_ROUTER_IP
username: YOUR_ADMIN_USERNAME
password: YOUR_ADMIN_PASSWORD
```
Configuration variables:
- **host** *Required*: The IP address of your router, e.g. 192.168.1.1.
- **username** *Required*: The username of an user with administrative privileges, usually *admin*.
- **password** *Required*: The password for your given admin account.
See the [device tracker component page](/components/device_tracker.html) for instructions how to configure the people to be tracked.

38
source/_components/device_tracker.asuswrt.markdown Normal file
View file

@ -0,0 +1,38 @@
---
layout: page
title: "ASUSWRT support"
description: "Instructions how to integrate ASUSWRT based routers into Home Assistant."
date: 2015-08-06 19:00
sidebar: false
comments: false
sharing: true
footer: true
logo: asus.png
ha_category: Presence Detection
---
<img src='/images/supported_brands/asus.png' class='brand pull-right' />
This platform offers presence detection by looking at connected devices to a [ASUSWRT](http://event.asus.com/2013/nw/ASUSWRT/) based router.
<p class='note warning'>
This device tracker needs telnet to be enabled on the router.
</p>
To use an ASUSWRT router in your installation, add the following to your `configuration.yaml` file:
```yaml
# Example configuration.yaml entry
device_tracker:
platform: asuswrt
host: YOUR_ROUTER_IP
username: YOUR_ADMIN_USERNAME
password: YOUR_ADMIN_PASSWORD
```
Configuration variables:
- **host** (*Required*): The IP address of your router, e.g. 192.168.1.1.
- **username** (*Required*: The username of an user with administrative privileges, usually *admin*.
- **password** (*Required*): The password for your given admin account.
See the [device tracker component page](/components/device_tracker.html) for instructions how to configure the people to be tracked.

34
source/_components/device_tracker.ddwrt.markdown Normal file
View file

@ -0,0 +1,34 @@
---
layout: page
title: "DD-WRT support"
description: "Instructions how to integrate DD-WRT based routers into Home Assistant."
date: 2015-05-11 09:00
sidebar: false
comments: false
sharing: true
footer: true
logo: ddwrt.png
ha_category: Presence Detection
---
<img src='/images/supported_brands/ddwrt.png' class='brand pull-right' />
This platform offers presence detection by looking at connected devices to a [DD-WRT](http://www.dd-wrt.com/site/index) based router.
To use a DD-WRRT router in your installation, add the following to your `configuration.yaml` file:
```yaml
# Example configuration.yaml entry
device_tracker:
platform: ddwrt
host: ROUTER_IP_ADDRESS
username: YOUR_ADMIN_USERNAME
password: YOUR_ADMIN_PASSWORD
```
Configuration variables:
- **host** (*Required*): The IP address of your router, e.g. 192.168.1.1.
- **username** (*Required*: The username of an user with administrative privileges, usually *admin*.
- **password** (*Required*): The password for your given admin account.
See the [device tracker component page](/components/device_tracker.html) for instructions how to configure the people to be tracked.

23
source/_components/device_tracker.geofancy.markdown Normal file
View file

@ -0,0 +1,23 @@
---
layout: page
title: "Geofancy device tracker"
description: "Instructions how to use Geofancy to track devices in Home Assistant."
date: 2015-10-13 19:00
sidebar: false
comments: false
sharing: true
footer: true
logo: geofancy.png
ha_category: Presence Detection
---
<img src='/images/supported_brands/geofancy.png' class='brand pull-right' />
This platform allows you to detect presence using [Geofancy](https://my.geofancy.com/). Geofancy allows users to track their location on iOS devices.
To integrate Geofancy in Home Assistant, add the following section to your `configuration.yaml` file:
```yaml
# Example configuration.yaml entry
device_tracker:
platform: geofancy
```

32
source/_components/device_tracker.luci.markdown Normal file
View file

@ -0,0 +1,32 @@
---
layout: page
title: "OpenWRT support"
description: "Instructions how to integrate OpenWRT routers into Home Assistant."
date: 2015-03-23 19:59
sidebar: false
comments: false
sharing: true
footer: true
logo: openwrt.png
ha_category: Presence Detection
---
<img src='/images/supported_brands/openwrt.png' class='brand pull-right' />
Before this scanner can be used you have to install the luci RPC package on OpenWRT: <code>opkg install luci-mod-rpc</code>.
```yaml
# Example configuration.yaml entry
device_tracker:
platform: luci
host: ROUTER_IP_ADDRESS
username: YOUR_ADMIN_USERNAME
password: YOUR_ADMIN_PASSWORD
```
Configuration variables:
- **host** (*Required*): The IP address of your router, e.g. 192.168.1.1.
- **username** (*Required*): The username of an user with administrative privileges, usually *admin*.
- **password** (*Required*): The password for your given admin account.
See the [device tracker component page](/components/device_tracker.html) for instructions how to configure the people to be tracked.

53
source/_components/device_tracker.markdown Normal file
View file

@ -0,0 +1,53 @@
---
layout: page
title: "Device tracking"
description: "Instructions how to setup device tracking within Home Assistant."
date: 2015-01-20 22:36
sidebar: false
comments: false
sharing: true
footer: true
---
Home Assistant can get information from your wireless router to track which devices are connected. There are several brands of supported wireless routers:
- [Actiontec](/components/device_tracker.actiontec.html)
- [Aruba](/components/device_tracker.aruba.html)
- [ASUSWRT](/components/device_tracker.asuswrt.html)
- [DD-WRT](/components/device_tracker.ddwrt.html)
- [luci (OpenWRT)](/components/device_tracker.luci.html)
- [netgear](/components/device_tracker.netgear.html)
- [Thomson](/components/device_tracker.thomson.html)
- [tomato](/components/device_tracker.tomato.html)
- [TP-Link](/components/device_tracker.tplink.html)
- [Generic SNMP](/components/device_tracker.snmp.html)
Alternative trackers:
- [MQTT](/components/device_tracker.mqtt.html)
- [nmap scanner](/components/device_tracker.nmap_scanner.html) to scan the network for devices
- [Owntrack](/components/device_tracker.owntracks.html)
- [Geofancy](/components/device_tracker.geofancy.html)
To get started add the following lines to your `configuration.yaml` (example for Netgear):
```yaml
# Example configuration.yaml entry for Netgear device
device_tracker:
platform: netgear
host: 192.168.1.1
username: admin
password: YOUR_PASSWORD
# Optional configuration
# If new discovered devices are tracked by default (default: yes)
track_new_devices: yes
# Seconds between each scan for new devices (default: 12)
interval_seconds: 12
# Seconds to wait till marking someone as not home after not being seen
# (default: 180)
consider_home: 180
```
Once tracking, a file will be created in your config dir called `known_devices.yaml`. Edit this file to adjust which devices have to be tracked. Here you can also setup a url for each device to be used as the entity picture and set whether the device will be show in the UI when in away state.

32
source/_components/device_tracker.mqtt.markdown Normal file
View file

@ -0,0 +1,32 @@
---
layout: page
title: "MQTT device tracker"
description: "Instructions how to use MQTT to track devices in Home Assistant."
date: 2015-09-19 20:41
sidebar: false
comments: false
sharing: true
footer: true
logo: mqtt.png
ha_category: Presence Detection
---
<img src='/images/supported_brands/mqtt.png' class='brand pull-right' />
This 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.
```yaml
# Example configuration.yaml entry
device_tracker:
platform: mqtt
qos: 1
devices:
paulus_oneplus: /location/paulus
annetherese_n4: /location/annetherese
```
Configuration variables:
- **devices** (*Required*): List of devices with their topic.
- **qos** (*Optional*): The QoS level of the topic.

32
source/_components/device_tracker.netgear.markdown Normal file
View file

@ -0,0 +1,32 @@
---
layout: page
title: "Netgear support"
description: "Instructions how to integrate Netgear routers into Home Assistant."
date: 2015-03-23 19:59
sidebar: false
comments: false
sharing: true
footer: true
logo: netgear.png
ha_category: Presence Detection
---
<img src='/images/supported_brands/netgear.png' class='brand pull-right' />
This platform allows you to detect presence by looking at connected devices to a [Netgear](http://www.netgear.com/) device.
```yaml
# Example configuration.yaml entry
device_tracker:
platform: netgear
host: YOUR_ROUTER_IP
username: YOUR_ADMIN_USERNAME
password: YOUR_ADMIN_PASSWORD
```
Configuration variables:
- **host** (*Required*): The IP address of your router, e.g. 192.168.1.1.
- **username** (*Required*: The username of an user with administrative privileges, usually *admin*.
- **password** (*Required*): The password for your given admin account.
See the [device tracker component page](/components/device_tracker.html) for instructions how to configure the people to be tracked.

33
source/_components/device_tracker.nmap_scanner.markdown Normal file
View file

@ -0,0 +1,33 @@
---
layout: page
title: "Nmap support"
description: "Instructions how to integrate Nmap into Home Assistant."
date: 2015-03-23 19:59
sidebar: false
comments: false
sharing: true
footer: true
ha_category: Presence Detection
---
<img src='/images/supported_brands/network-workgroup.png' class='brand pull-right' />
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 `apt-get install net-tools nmap`.
```yaml
# Example configuration.yaml entry
device_tracker:
platform: nmap_tracker
hosts: 192.168.1.1/24
home_interval: 10
```
`home_interval` is an optional value set in minutes. This will be the number of minutes nmap will not
scan this device, assuming it is home, in order to preserve the device battery.
See the [device tracker component page](/components/device_tracker.html) for instructions how to
configure the people to be tracked.

31
source/_components/device_tracker.owntracks.markdown Normal file
View file

@ -0,0 +1,31 @@
---
layout: page
title: "Owntracks device tracker"
description: "Instructions how to use Owntracks to track devices in Home Assistant."
date: 2015-09-22 07:00
sidebar: false
comments: false
sharing: true
footer: true
logo: owntracks.png
ha_category: Presence Detection
---
<img src='/images/supported_brands/owntracks.png' class='brand pull-right' />
This platform allows you to detect presence using [Owntracks](http://owntracks.org/). 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](/components/mqtt.html) to be set up and works very well
together with [the zone component](/components/zone.html).
To integrate Owntracks in Home Assistant, add the following section to your `configuration.yaml` file:
```yaml
# Example configuration.yaml entry
device_tracker:
platform: owntracks
```
There is no further configuration needed for tracking Owntracks devices.

42
source/_components/device_tracker.snmp.markdown Normal file
View file

@ -0,0 +1,42 @@
---
layout: page
title: "Generic SNMP support"
description: "Instructions how to integrate SNMP into Home Assistant."
date: 2015-10-08 12:00
sidebar: false
comments: false
sharing: true
footer: true
logo: network-snmp.png
ha_category: Presence Detection
---
<img src='/images/supported_brands/network-snmp.png' class='brand pull-right' />
Most wifi-accesspoints (WAP) and wifi-routers (WRT) 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.
<p class='note warning'>
This device tracker needs SNMP to be enabled on the router.
</p>
OID examples:
- Microtik: 1.3.6.1.4.1.14988.1.1.1.2.1.1 (confirmed)
- Aruba: 1.3.6.1.4.1.14823.2.3.3.1.2.4.1.2 (untested)
To use the snmp platform in your installation, add the following to your `configuration.yaml` file:
```yaml
# Example configuration.yaml entry
device_tracker:
platform: snmp
hosts: 192.168.1.1
community: public
baseoid: 1.3.6.1.4.1.14988.1.1.1.2.1.1
```
Configuration variables:
- **host** (*Required*): The IP address of the router, eg. 192.168.1.1.
- **community** (*Required*): The SNMP community which is configured in the WAP/WRT. Most devices have a default community set to to `public` with read-only permission (which is sufficient).
- **baseoid** (*Required*): The OID prefix where wireless client registrations can be found, usually vendor specific. It's advised to use the numerical notation. To find this base OID, check vendor documentation or check the MIB file for your device.
See the [device tracker component page](/components/device_tracker.html) for instructions how to configure the people to be tracked.

34
source/_components/device_tracker.thomson.markdown Normal file
View file

@ -0,0 +1,34 @@
---
layout: page
title: "Thomson support"
description: "Instructions how to integrate Thomson routers into Home Assistant."
date: 2015-08-30 19:00
sidebar: false
comments: false
sharing: true
footer: true
logo: technicolor.png
ha_category: Presence Detection
---
<img src='/images/supported_brands/technicolor.png' class='brand pull-right' />
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](http://www.technicolor.com) device.
```yaml
# Example configuration.yaml entry
device_tracker:
platform: thomson
host: YOUR_ROUTER_IP
username: YOUR_ADMIN_USERNAME
password: YOUR_ADMIN_PASSWORD
```
Configuration variables:
- **host** (*Required*): The IP address of your router, eg. 192.168.1.1.
- **username** (*Required*: The username of an user with administrative privileges, usually *admin*.
- **password** (*Required*): The password for your given admin account.
See the [device tracker component page](/components/device_tracker.html) for instructions how to configure the people to be tracked.

33
source/_components/device_tracker.tomato.markdown Normal file
View file

@ -0,0 +1,33 @@
---
layout: page
title: "Tomato support"
description: "Instructions how to integrate Tomato routers into Home Assistant."
date: 2015-03-23 19:59
sidebar: false
comments: false
sharing: true
footer: true
ha_category: Presence Detection
---
<img src='/images/supported_brands/network-wired-disconnected.png' class='brand pull-right' />
Tomato 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.
```yaml
# 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:
- **host** (*Required*): The IP address of your router, e.g. 192.168.1.1.
- **username** (*Required*: The username of an user with administrative privileges, usually *admin*.
- **password** (*Required*): The password for your given admin account.
- **http_id** (*Required*): The value can be obtained by logging in to the Tomato admin interface and search for `http_id` in the page source code.
See the [device tracker component page](/components/device_tracker.html) for instructions how to configure the people to be tracked.

41
source/_components/device_tracker.tplink.markdown Normal file
View file

@ -0,0 +1,41 @@
---
layout: page
title: "TP-Link support"
description: "Instructions how to integrate TP-Link routers into Home Assistant."
date: 2015-06-22 10:30
sidebar: false
comments: false
sharing: true
footer: true
logo: tp-link.png
ha_category: Presence Detection
---
<img src='/images/supported_brands/tp-link.png' class='brand pull-right' />
This platform allows you to detect presence by looking at connected devices to a [TP-Link](https://www.tp-link.com) device. This includes the ArcherC9 line.
```yaml
# Example configuration.yaml entry
device_tracker:
platform: tplink
host: YOUR_ROUTER_IP
username: YOUR_ADMIN_USERNAME
password: YOUR_ADMIN_PASSWORD
```
Configuration variables:
- **host** (*Required*): The IP address of your router, e.g. 192.168.1.1.
- **username** (*Required*: The username of an user with administrative privileges, usually *admin*.
- **password** (*Required*): The password for your given admin account.
For Archer C9 models running firmware version 150811 or later please use the encrypted password you can retrieve like this:
1. Go to the login page of your router. (default: 192.168.0.1)
2. Type in the password you use to login into the passsword field.
3. Click somewhere else on the page so that the password field is not selected anymore.
4. Open the JavaScript console of your browser (usually by pressing F12 and then clicking on "Console").
5. Type ```document.getElementById("login-password").value;```.
6. Copy the returned value to your Home Assistant configuration as password.
See the [device tracker component page](/components/device_tracker.html) for instructions how to configure the people to be tracked.

33
source/_components/discovery.markdown Normal file
View file

@ -0,0 +1,33 @@
---
layout: page
title: "Discovery"
description: "Instructions how to setup Home Assistant to discover new devices."
date: 2015-01-24 14:39
sidebar: false
comments: false
sharing: true
footer: true
---
<img src='/images/supported_brands/system-search.png' class='brand pull-right' />
Home Assistant can discover and automatically configure zeroconf/mDNS and uPnP devices on your network. Currently the `discovery` component can detect:
* Google Chromecast
* Belkin WeMo switches
* Philips Hue
* Netgear routers
It will be able to add Google Chreomcasts 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`:
```yaml
# Example configuration.yaml entry
discovery:
```
If you are developing a new platform, please read [how to make your platform discoverable]({{site_root}}/developers/add_new_platform.html#discovery).
<p class='note warning'>
There is currently a <a href='https://bitbucket.org/al45tair/netifaces/issues/17/dll-fails-to-load-windows-81-64bit'>known issue</a> with running this playform on a 64-bit version of Python.
</p>

31
source/_components/downloader.markdown Normal file
View file

@ -0,0 +1,31 @@
---
layout: page
title: "Downloader"
description: "Instructions how to setup the downloader component with Home Assistant."
date: 2015-01-24 14:39
sidebar: false
comments: false
sharing: true
footer: true
ha_category: Other
---
<img src='/images/supported_brands/emblem-downloads.png' class='brand pull-right' />
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.
To enable it, add the following lines to your `configuration.yaml`:
```yaml
# Example configuration.yaml entry
downloader:
download_dir: downloads
```
#### Service `downloader/download_file`
Download the specified url.
| Service data attribute | Optional | Description |
| ---------------------- | -------- | ----------- |
| `url` | no | The url of the file to download.

26
source/_components/group.markdown Normal file
View file

@ -0,0 +1,26 @@
---
layout: page
title: "Group support"
description: "Instructions how to setup groups within Home Assistant."
date: 2015-03-23 19:59
sidebar: false
comments: false
sharing: true
footer: true
---
Groups allow the user to combine multiple entities into 1. If all entities are switches or lights they can be controlled as one.
```yaml
# Example configuration.yaml entry
# A comma seperated list of states that have to be tracked as a single group
# Grouped states should share the same type of states (ON/OFF or HOME/NOT_HOME)
group:
living_room:
- light.Bowl
- light.Ceiling
- light.TV_back_light
children:
- device_tracker.child_1
- device_tracker.child_2
```

55
source/_components/history.markdown Normal file
View file

@ -0,0 +1,55 @@
---
layout: page
title: "History support"
description: "Instructions how to enable history support for Home Assistant."
date: 2015-03-23 19:59
sidebar: false
comments: false
sharing: true
footer: true
---
<img src='/images/supported_brands/x-office-presentation.png' class='brand pull-right' />
This 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:
```yaml
# Example configuration.yaml entry
history:
```
<p class='img'>
<a href='{{site_root}}/images/screenshots/component_history_24h.png'>
<img src='{{site_root}}/images/screenshots/component_history_24h.png' />
</a>
</p>
<p class='note'>
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.
</p>
### Implementation details
The history is stored in a SQLite databse `home-assistant.db` within your config directory.
- events table is all events except time_changed that happened while recorder component was running.
- states table contains all the new_state values of state_changed events.
- Inside the states table you have:
- entity_id: the entity_id of the entity
- state: the state of the entity
- attributes: JSON of the state attributes
- last_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 database
When the history component queries the states table it only selects states where the state has changed: `WHERE last_changed=last_updated`
#### On dates
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:
```python
from datetime import datetime
datetime.fromtimestamp(1422830502)
```

76
source/_components/ifttt.manything.markdown Normal file
View file

@ -0,0 +1,76 @@
---
layout: page
title: "IFTTT - ManyThing Channel"
description: "Instructions how to setup ManyThing support with IFTTT."
date: 2015-09-07 18:00
sidebar: false
comments: false
sharing: true
footer: true
---
<img src='/images/supported_brands/manything.png' class='brand pull-right' />
[Manything](https://manything.com) 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](https://ifttt.com/maker) and the [ManyThing Channel](https://ifttt.com/manything).
Use the [IFTTT Setup instructions](/components/ifttt.html) to activate the IFTTT Platform.
After setting up IFTTT, Maker Channel and ManyThing Channel, you can use the following examples to configure Home Assistant.
```yaml
# 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"}
```
### {% linkable_title Setting up a recipe %}
<p class='img'>
<img src='/images/components/ifttt/IFTTT_manything_trigger.png' />
You need to setup a unique trigger for each event you sent to IFTTT.
For ManyThing support, you need to set up an <code>on</code> and <code>off</code> event.
</p>
### {% linkable_title Testing your trigger %}
You can use the developer tools to test your [Maker Channel](https://ifttt.com/maker) 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"}`

78
source/_components/ifttt.markdown Normal file
View file

@ -0,0 +1,78 @@
---
layout: page
title: "IFTTT"
description: "Instructions how to setup IFTTT within Home Assistant."
date: 2015-09-07 18:00
sidebar: false
comments: false
sharing: true
footer: true
logo: ifttt.png
ha_category: Other
---
<img src='/images/supported_brands/ifttt.png' class='brand pull-right' />
[IFTTT](https://ifttt.com) 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](/blog/2015/09/13/home-assistant-meets-ifttt/) for examples
how to use it.
```yaml
# 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](https://ifttt.com/maker).
<p class='img'>
<img src='/images/components/ifttt/finding_key.png' />
Property screen of the Maker Channel
</p>
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.
<p class='note'>
After restarting the server, be sure to watch the console for any logging errors that show up in red, white or yellow.
</p>
### {% linkable_title Testing your trigger %}
You can use the developer tools to test your [Maker Channel](https://ifttt.com/maker) 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"}`
<p class='img'>
<img src='/images/components/ifttt/testing_service.png' />
When your screen looks like this, click the 'call service' button.
</p>
### {% linkable_title Setting up a recipe %}
<p class='img'>
<img src='/images/components/ifttt/setup_trigger.png' />
You need to setup a unique trigger for each event you sent to IFTTT.
</p>
### {% linkable_title Sending events from IFTTT to Home Assistant %}
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][duck-dns].
[duck-dns]: https://duckdns.org
<p class='img'>
<img src='/images/components/ifttt/IFTTT_to_HA.png' />
</p>
### {% linkable_title Additional Channel Examples %}
Additional examples of using IFTTT channels can be found below.
Channel | Description
----- | -----
[Manything](/components/ifttt.manything.html) | Automates turning recording ON and OFF based on Home Assistant AWAY and HOME values.

116
source/_components/isy994.markdown Normal file
View file

@ -0,0 +1,116 @@
---
layout: page
title: "ISY994 Controller"
description: "Instructions how to setup the ISY994 controller within Home Assistant."
date: 2015-01-20 22:36
sidebar: false
comments: false
sharing: true
footer: true
ha_category: Hub
---
### Basic Configuration ###
The ISY994 is a home automation controller that is capable of controlling
Insteon and X10 devices. The controller is also capable of controlling Z-Wave
devices but that functionality has not yet been confirmed with Home Assistant.
The ISY994 controller is manufactured by [Universal
Devices](https://www.universal-devices.com/residential/isy994i-series/).
Home Assistant is capable of communicating with any switch, sensor, and light
that is configured on the controller. Using the programs on the controller,
custom switches and sensors can also be created.
To integrate your ISY994 controller with Home Assistant, add the following section to your `configuration.yaml` file:
```yaml
# Example configuration.yaml entry
isy994:
host: ISY_ADDRESS
username: ISY_USERNAME
password: ISY_PASSWORD
sensor_string: SENSOR_STRING
hidden_string: HIDDEN_STRING
tls: TLS_VERSION
```
Configuration variables:
- **host** (*Required*): The host entry should be in full URL format, eg. http://192.168.10.100:80
- **username** (*Required*): The username that used to access the ISY interface.
- **password** (*Required*): The password that used to access the ISY interface.
- **sensor_string** (*Optional*): This is the string that is used to identify which devices are to be assumed to be sensors instead of lights of switches. By default, this string is 'Sensor'. If this string is found in the device name, Home Assistant will
assume it is as a sensor.
- **hidden_string** (*Optional*): The HIDDEN_STRING is a string that is used to identify which devices are to be
hidden on Home Assistant's front page. This string will be stripped from the
device's name before being used. By default, this value is '{HIDE ME}'.
- **tls** (*Optional*): This entry should refelct the version of TLS that the ISY controller is using for HTTPS encryption. This value can be either 1.1 or 1.2. If this value is not set, it is assumed to be version 1.1. This is the default for most users.
ISY994 Pro users may likely be using 1.2. When using HTTPS in the host entry, it is best practice to set this value.
Once the ISY controller is configured, it will automatically import any lights, switches, and sensors it can locate.
### Creating Custom Switches ###
Using the Programs tab in the controller's Administrative Console, custom
switches can be created that will appear natively inside of Home Assistant.
Home Assistant will scan two different directories for switch configurations on
the controller. These directories must exist at the root level. The two
directories used to make switches are *HA.doors* and *HA.switches*. Currently,
the two receive identical treatment in Home Assistant.
A switch is created by creating a directory under either of these root
dirctories with the name you would like to call the switch. Two programs are
then required in this directory: *status* and *actions*. The image below shows
a sample configuration. This sample includes an extra program called *auto on*.
This is ignored by Home Assistant.
<p class='img'>
<img src='{{site_root}}/images/isy994/isy994_SwitchExample.png' />
</p>
The *status* program in this directory is what indicates if the switch is on or
off. Only the IF clause is evaluated. If the clause returns True, the switch
will be on. False will indicate the switch is off.
<p class='img'>
<img src='{{site_root}}/images/isy994/isy994_SwitchStatusExample.png' />
</p>
The *actions* program indicates what should be performed to turn the switch on
or off. The THEN clause gives instructions for turning the switch on while the
ELSE clause gives instructions for turning the switch off. Below is an example.
<p class='img'>
<img src='{{site_root}}/images/isy994/isy994_SwitchActionsExample.png' />
</p>
The example program above shows how to control a legacy X10 device from Home
Assistant using an ISY controller.
### Creating Custom Sensors ###
Custom sensors can also be created using the Programs tab in the ISY
controller's Administrative Console. For programs, three different root level
folders are evaluated that are all handled a little differently inside of Home
Assistant.
* *HA.sensors* will have states of Open or Closed
* *HA.states* will have states of On or Off
* *HA.locations* will have states of Home or Away
To create a custom sensor, create a program under any of the three root
directories. The name of the program will be the name of the sensor. An example
below shows a location indicator setup.
<p class='img'>
<img src='{{site_root}}/images/isy994/isy994_SensorExample.png' />
</p>
The program created only needs an IF clause. It will be evaluated to either
Open/On/Home when it returns True and Closed/Off/Away when it returns False. An
example is below.
<p class='img'>
<img src='{{site_root}}/images/isy994/isy994_SensorStatusExample.png' />
</p>

41
source/_components/keyboard.markdown Normal file
View file

@ -0,0 +1,41 @@
---
layout: page
title: "Keyboard"
description: "Instructions how to simulate key presses with Home Assistant."
date: 2015-01-24 14:39
sidebar: false
comments: false
sharing: true
footer: true
ha_category: Other
---
<img src='/images/supported_brands/input-keyboard.png' class='brand pull-right' />
The `keyboard` component simulates key presses on the host machine. It currently offers the following Buttons as a Service (BaaS):
* `keyboard/volume_up`
* `keyboard/volume_down`
* `keyboard/volume_mute`
* `keyboard/media_play_pause`
* `keyboard/media_next_track`
* `keyboard/media_prev_track`
To load this component, add the following lines to your `configuration.yaml`:
```
keyboard:
```
## {% linkable_title Dependencies %}
You may need to install platform-specific [dependencies for PyUserInput](https://github.com/SavinaRoja/PyUserInput#dependencies) in order to use the keyboard component. In most cases this can be done by running:
```
pip3 install [package name]
```
#### {% linkable_title Windows %}
x64 Windows users may have trouble installing pywin through pip. Using an [executable installer](http://sourceforge.net/projects/pywin32/files/pywin32/) should work around this issue.
[Similar installers](http://www.lfd.uci.edu/~gohlke/pythonlibs/#pyhook) (unofficial) for pyhook have been ported to python 3.4 and should help with x64 pip issues with pyhook.

30
source/_components/light.blinksticklight.markdown Normal file
View file

@ -0,0 +1,30 @@
---
layout: page
title: "Blinkstick support"
description: "Instructions how to setup Blinkstick lights within Home Assistant."
date: 2015-10-08 10:00
sidebar: false
comments: false
sharing: true
footer: true
logo: blinkstick.png
ha_category: Light
---
<img src='/images/supported_brands/blinkstick.png' class='brand pull-right' />
The blinkstick platform let you can control your [Blinkstick](https://www.blinkstick.com/) lights from within Home Assistant.
To add blinkstick to your installation, add the following to your `configuration.yaml` file:
```yaml
# Example configuration.yaml entry
light:
platform: blinksticklight
serial: BS000795-1.1
name: Living Room
```
Configuration variables:
- **serial** (*Required*): The serial number of your stick.
- **name** (*Required*): Name of the stick.

24
source/_components/light.hue.markdown Normal file
View file

@ -0,0 +1,24 @@
---
layout: page
title: "Philips Hue support"
description: "Instructions how to setup Philips Hue within Home Assistant."
date: 2015-03-23 20:09
sidebar: false
comments: false
sharing: true
footer: true
logo: philips_hue.png
ha_category: Light
---
<img src='/images/supported_brands/philips_hue.png' class='brand pull-right' />
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 [the discovery component]({{site_root}}/components/discovery.html).
If you want to enable the light component directly, add the following lines to your `configuration.yaml`:
```yaml
# Example configuration.yaml entry
light:
platform: hue
```

32
source/_components/light.limitlessled.markdown Normal file
View file

@ -0,0 +1,32 @@
---
layout: page
title: "LimitlessLED support"
description: "Instructions how to setup LimitlessLED within Home Assistant."
date: 2015-06-10 22:48
sidebar: false
comments: false
sharing: true
footer: true
ha_category: Light
---
<img src='/images/supported_brands/dialog-information.png' class='brand pull-right' />
The limitlessled can control your [LimitlessLED](http://www.limitlessled.com/) lights from within Home Assistant. The lights are also known as EasyBulb, AppLight, AppLamp, MiLight, LEDme, dekolight or iLight.
To add limitlessled to your installation, add the following to your `configuration.yaml` file:
```yaml
# Example configuration.yaml entry
light:
platform: limitlessled
host: IP_ADDRESS
group_1_name: Living Room
group_2_name: Bedroom
group_3_name: Office
group_4_name: Kitchen
```
Configuration variables:
- **host** (*Required*): IP address of the device, eg. 192.168.1.32
- **group_X_name** (*Required*): Name of the group. Multiple entries with a consecutive number.

54
source/_components/light.markdown Normal file
View file

@ -0,0 +1,54 @@
---
layout: page
title: "Lights"
description: "Instructions how to setup your lights with Home Assistant."
date: 2015-01-24 14:39
sidebar: false
comments: false
sharing: true
footer: true
---
This component allows you to track and control various light bulbs.
It has [4 built-in light profiles](https://github.com/balloob/home-assistant/blob/master/homeassistant/components/light/light_profiles.csv) which you're able to extend by putting a `light_profiles.csv` file in your config dir.
It supports the following platforms:
* `hue` for Philips Hue
* `wink` for Wink
Preferred way to setup the Philips Hue platform is through the [the discovery component]({{site_root}}/components/discovery.html). For the Wink light platform enable [the wink component]({{site_root}}/components/wink.html).
If you want to enable the light component directly, add the following lines to your `configuration.yaml`:
```
light:
platform: hue
```
<p class='note'>
The light component supports multiple entries in <code>configuration.yaml</code> by appending a sequential number to the section: <code>light 2:</code>, <code>light 3:</code> etc.
</p>
### Service `light.turn_on`
Turns one light on or multiple lights on using [groups]({{site_root}}/components/group.html).
| Service data attribute | Optional | Description |
| ---------------------- | -------- | ----------- |
| `entity_id` | no | Only act on specified lights. Else targets all.
| `transition` | yes | Seconds to take to switch to new state. *not supported by Wink
| `profile` | yes | Which light profile to use.
| `xy_color` | yes | Two comma seperated floats that represent the color in XY
| `rgb_color` | yes | Three comma seperated integers that represent the color in RGB
| `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
### Service `light.turn_off`
Turns one or multiple lights off.
| Service data attribute | Optional | Description |
| ---------------------- | -------- | ----------- |
| `entity_id` | no | Only act on specified lights. Else targets all.

30
source/_components/light.rfxtrx.markdown Normal file
View file

@ -0,0 +1,30 @@
---
layout: page
title: "RFXtrx light support"
description: "Instructions how to integrate RFXtrx lights into Home Assistant."
date: 2015-10-08 10:15
sidebar: false
comments: false
sharing: true
footer: true
ha_category: Light
---
The rfxtrx platform support lights that communicate in the frequency range of 433.92 MHz.
To enable RFXtrx lights in your installation, add the following to your `configuration.yaml` file:
```yaml
# Example configuration.yaml entry
light:
platform: rfxtrx
devices:
ac09c4f1: Bedroom Door
ac09c4f2: Kitchen Door
automatic_add: True
```
Configuration variables:
- **devices** (*Required*): A list of devices with their name to use in the frontend.
- **automatic_add** (*Optional*): To enable the automatic addition of new lights.

24
source/_components/light.tellstick.markdown Normal file
View file

@ -0,0 +1,24 @@
---
layout: page
title: "TellStick lights support"
description: "Instructions how to integrate TellStick lights into Home Assistant."
date: 2015-08-06 19:00
sidebar: false
comments: false
sharing: true
footer: true
logo: telldus_tellstick.png
ha_category: Light
---
<img src='/images/supported_brands/telldus_tellstick.png' class='brand pull-right' />
This tellstick light platform allows you to control your [TellStick](http://www.telldus.se/products/tellstick) dimmers.
To use your TellStick device in your installation, add the following to your `configuration.yaml` file:
```yaml
# Example configuration.yaml entry
light:
platform: tellstick
```

39
source/_components/light.vera.markdown Normal file
View file

@ -0,0 +1,39 @@
---
layout: page
title: "Vera lights support"
description: "Instructions how to integrate Vera lights into Home Assistant."
date: 2015-10-20 21:00
sidebar: false
comments: false
sharing: true
footer: true
logo: vera.png
ha_category: Light
---
<img src='/images/supported_brands/vera.png' class='brand pull-right' />
This vera light platform allows you to control your [Vera](http://getvera.com/) lights.
This platform is useful if you wish for switches connected to your Vera controller to appear as lights in Home Assistant. All switches will be added as a light unless you exclude them in the configuration file.
To use your Vera lights in your installation, add the following to your `configuration.yaml` file:
```yaml
# Example configuration.yaml entry
light:
platform: vera
vera_controller_url: http://YOUR_VERA_IP:3480/
device_data:
12:
name: My awesome sensor
exclude: true
13:
name: Another sensor
```
Configuration variables:
- **vera_controller_url** (*Required*): This is the base URL of your vera controller including the port number if not running on 80, eg. http://192.168.1.21:3480/
- **device_data** array (*Optional*):This contains an array additional device information for your Vera devices. It is not required and if not specified all sensors configured in your Vera controller will be added with default values. You should use the id of your Vera device as the key for the device within `device_data`.
- **name** (*Optional*):This parameter allows you to override the name of your Vera device in the frontend, if not specified the value configured for the device in your Vera will be used.
- **exclude** (*Optional*): This parameter allows you to exclude the specified device, it should be set to "True" if you want this device excluded.

17
source/_components/light.wink.markdown Normal file
View file

@ -0,0 +1,17 @@
---
layout: page
title: "Wink lights"
description: "Instructions how to setup the Wink lights within Home Assistant."
date: 2015-01-20 22:36
sidebar: false
comments: false
sharing: true
footer: true
logo: wink.png
ha_category: Light
---
<img src='/images/supported_brands/wink.png' class='brand pull-right' />
The wink sensor platform allows you to use your [Wink](http://www.wink.com/) lights.
The requirement is that you have setup your [Wink hub](/components/light.wink.html).

39
source/_components/logbook.markdown Normal file
View file

@ -0,0 +1,39 @@
---
layout: page
title: "Logbook support"
description: "Instructions how to enable the logbook component for Home Assistant."
date: 2015-04-25 9:23
sidebar: false
comments: false
sharing: true
footer: true
---
<img src='/images/screenshots/logbook.png' style='margin-left:10px; float: right;' height="100" />
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](/demo/).
To enable the logbook in your installation, add the following to your `configuration.yaml` file:
```yaml
# Example configuration.yaml entry
logbook:
```
It is possible to add custom entries to the logbook by using the script component to fire an event.
```yaml
# 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
```

33
source/_components/media_player.cast.markdown Normal file
View file

@ -0,0 +1,33 @@
---
layout: page
title: "Google Cast support"
description: "Instructions how to integrate Google Cast into Home Assistant."
date: 2015-03-23 19:59
sidebar: false
comments: false
sharing: true
footer: true
logo: google_cast.png
ha_category: Media Player
---
<img src='/images/supported_brands/google_cast.png' class='brand pull-right' />
Google Cast devices will be automatically discovered if you enable [the discovery component]({{site_root}}/components/discovery.html). 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`:
```yaml
# Example configuration.yaml entry
media_player:
platform: chromecast
host: 192.168.1.9
```
Configuration variables:
- **host** *Optional*: Use only if you don't want to scan for devices.
<p class='note warning'>
This platform is currently not working due to a changed Cast API.
</p>

42
source/_components/media_player.denon.markdown Normal file
View file

@ -0,0 +1,42 @@
---
layout: page
title: "Denon Network Receivers support"
description: "Instructions how to integrate Denon Network Receivers into Home Assistant."
date: 2015-09-08 09:00
sidebar: false
comments: false
sharing: true
footer: true
logo: denon.png
ha_category: Media Player
---
<img src='/images/supported_brands/denon.png' class='brand pull-right' />
The denon platform allows you to control a [Denon Network Receivers](http://www.denon.co.uk/chg/product/compactsystems/networkmusicsystems/ceolpiccolo) from Home Assistant.
Supported devices:
- Denon DRA-N5
- Denon RCD-N8 (untested)
To add a Denon Network Receiver to your installation, add the following to your `configuration.yaml` file:
```yaml
# Example configuration.yaml entry
media_player:
platform: denon
host: IP_ADDRESS
name: Music station
```
Configuration variables:
- **host** (*Required*): IP address of the device. Example: 192.168.1.32
- **name** (*Optional*): Name of the device
A few notes:
- The receiver handles only one telnet connection and refuses others.
- Be careful with the volume. 50% or even 100% are very loud.
- To be able to wake up the receiver, activate the "remote" setting in the receiver's settings.
- Play and pause are supported, toggling is not possible.
- Seeking cannot be implemented as the UI sends absolute positions. Only seeking via simulated button presses is possible.

54
source/_components/media_player.firetv.markdown Normal file
View file

@ -0,0 +1,54 @@
---
layout: page
title: "FireTV support"
description: "Instructions how to integrate Music Player Daemon into Home Assistant."
date: 2015-10-23 18:00
sidebar: false
comments: false
sharing: true
footer: true
logo: firetv.png
ha_category: Media Player
---
<img src='/images/supported_brands/firetv.png' class='brand pull-right' />
The firetv platform allows you to control a [Amazon Fire TV/stick](http://www.amazon.com/Amazon-DV83YW-Fire-TV/dp/B00U3FPN4U).
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:
- Turn on ADB Debugging on your Amazon Fire TV:
- From the main (Launcher) screen, select Settings.
- Select System > Developer Options.
- Select ADB Debugging.
- Find Amazon Fire TV device IP:
- From the main (Launcher) screen, select Settings.
- Select System > About > Network.
- `pip install firetv[firetv-server]` into a Python 2.x environment
- `firetv-server -d <fire tv device IP>:5555`, background the process
- Configure Home Assistant as follows:
To add FireTV to your installation, add the following to your `configuration.yaml` file:
```yaml
# Example configuration.yaml entry
media_player:
platform: firetv
host: localhost:5556
device: livingroom-firetv
name: My Amazon Fire TV
```
Configuration variables:
- **host** *Optional*: Where `firetv-server` is running. Default is *localhost:5556*.
- **device** *Optional*: The device ID, default is *default*.
- **name** *Optional*: The friendly name of the device, default is 'Amazon Fire TV'.
<p class='note warning'>
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 used. Run `firetv-server -h` and/or view the source for complete capabilities.
</p>

33
source/_components/media_player.itunes.markdown Normal file
View file

@ -0,0 +1,33 @@
---
layout: page
title: "iTunes support"
description: "Instructions how to integrate iTunes into Home Assistant."
date: 2015-06-22 11:00
sidebar: false
comments: false
sharing: true
footer: true
logo: itunes.png
ha_category: Media Player
---
<img src='/images/supported_brands/itunes.png' class='brand pull-right' />
The iTunes platform allows you to control [iTunes](http://apple.com/itunes/) from Home Assistant. It uses a 3rd party server that you run on your Mac called [itunes-api](https://github.com/maddox/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:
```yaml
# Example configuration.yaml entry
media_player:
platform: itunes
name: iTunes
host: http://192.168.1.50
port: 8181
```
Configuration variables:
- **host** *Required*: The URL of the itunes-api API, eg. http://192.168.1.50
- **port** *Optional*: The port where itunes-api is accessible, eg. 8181.

34
source/_components/media_player.kodi.markdown Normal file
View file

@ -0,0 +1,34 @@
---
layout: page
title: "Kodi support"
description: "Instructions how to integrate Kodi into Home Assistant."
date: 2015-06-22 11:00
sidebar: false
comments: false
sharing: true
footer: true
logo: kodi.png
ha_category: Media Player
---
<img src='/images/supported_brands/kodi.png' class='brand pull-right' />
The kodi platform allows you to control a [Kodi](http://kodi.tv/) multimedia system from Home Assistant.
To add Kodi to your installation, add the following to your `configuration.yaml` file:
```yaml
# Example configuration.yaml entry
media_player:
platform: kodi
url: http://192.168.0.123/jsonrpc
name: Kodi
user: USERNAME
password: PASSWORD
```
Configuration variables:
- **url** *Required*: The URL of the XBMC/Kodi JSON-RPC API, eg. http://192.168.0.123/jsonrpc
- **name** *Optional*: The name of the device used in the frontend.
- **username** *Optional*: The XBMC/Kodi HTTP username.
- **password** *Optional*: The XBMC/Kodi HTTP password.

52
source/_components/media_player.markdown Normal file
View file

@ -0,0 +1,52 @@
---
layout: page
title: "Media Player"
description: "Instructions how to setup your media players with Home Assistant."
date: 2015-01-24 14:39
sidebar: false
comments: false
sharing: true
footer: true
---
Interacts with media players on your network.
Currently supported devices:
- [Chromecasts](/components/media_player.cast.html)
- [Denon Network Receivers](/components/media_player.denon.html)
- [iTunes](/components/media_player.itunes.html)
- [Kodi](/components/media_player.kodi.html)
- [Music Player Daemon](/components/media_player.mpd.html)
- [Plex](/components/media_player.plex.html)
- [Sonos](/components/media_player.sonos.html)
- [Squeezebox](/components/media_player.squeezebox.html)
## Services
### Media control services
Available services: `turn_off`, `volume_up`, `volume_down`, `media_play_pause`, `media_play`, `media_pause`, `media_next_track`
| Service data attribute | Optional | Description |
| ---------------------- | -------- | ----------- |
| `entity_id` | yes | Target a specific media player. Defaults to all.
### Media play services
There are three services to start playing YouTube video's on the media player.
#### Service `media_player/play_youtube_video`
Service to start playing a YouTube video on the media player.
| Service data attribute | Optional | Description |
| ---------------------- | -------- | ----------- |
| `entity_id` | yes | Target a specific media player. Defaults to all.
| `video` | no | YouTube video to be played, ie. `L0MK7qz13bU`
#### Service `media_player/start_fireplace` and `media_player/start_epic_sax`
Will either start a fireplace or Epic Sax Guy 10h on the media player.
| Service data attribute | Optional | Description |
| ---------------------- | -------- | ----------- |
| `entity_id` | yes | Target a specific media player. Defaults to all.

37
source/_components/media_player.mpd.markdown Normal file
View file

@ -0,0 +1,37 @@
---
layout: page
title: "Music Player Daemon support"
description: "Instructions how to integrate Music Player Daemon into Home Assistant."
date: 2015-06-02 08:00
sidebar: false
comments: false
sharing: true
footer: true
logo: mpd.png
ha_category: Media Player
---
<img src='/images/supported_brands/mpd.png' class='brand pull-right' />
The mpd platform allows you to control a [Music Player Daemon](http://www.musicpd.org/) from Home Assistant. Unfortunatly you will not be able to manipulate the playlist (add or delete songs) or add transitions between the songs.
To add MPD to your installation, add the following to your `configuration.yaml` file:
```yaml
# Example configuration.yaml entry
media_player:
platform: mpd
server: IP_ADDRESS
port: 6600
location: bedroom
password: PASSWORD
```
Configuration variables:
- **server** *Required*: IP address of the Music Player Daemon, eg. 192.168.1.32
- **port** *Optional*: Port of the Music Player Daemon, defaults to 6600.
- **location** *Optional*: Location of your Music Player Daemon.
- **password** *Optional*: Password for your Music Player Daemon.
This platform works with [Music Player Daemon](http://www.musicpd.org/) and [mopidy](https://www.mopidy.com/) with [Mopidy-MPD](https://docs.mopidy.com/en/latest/ext/mpd/) as used by [Pi MusicBox](http://www.pimusicbox.com/).

32
source/_components/media_player.plex.markdown Normal file
View file

@ -0,0 +1,32 @@
---
layout: page
title: "Plex"
description: "Instructions how to integrate Plex into Home Assistant."
date: 2015-10-05 21:21
sidebar: false
comments: false
sharing: true
footer: true
logo: plex.png
ha_category: Media Player
---
<img src='/images/supported_brands/plex.png' class='brand pull-right' />
The Plex platform allows you to connect a [Plex Media Server](https://plex.tv) to Home Assistant. It will allow you to control media playback and see the current playing item.
To add Plex to your installation, add the following to your `configuration.yaml` file:
```yaml
# Example configuration.yaml entry
media_player:
platform: plex
name: plex_server
user: YOUR_USERNAME
password: YOUR_PASSWORD
```
Configuration variables:
- **name** *Required*: The name of the backend device (Under Plex Media Server > settings > server)
- **user** *Required*: The username for your Pley server.
- **password** *Required*: The password for your Plex server.

24
source/_components/media_player.sonos.markdown Normal file
View file

@ -0,0 +1,24 @@
---
layout: page
title: "Sonos support"
description: "Instructions how to integrateSonos devices into Home Assistant."
date: 2015-09-12 13:00
sidebar: false
comments: false
sharing: true
footer: true
logo: sonos.png
ha_category: Media Player
---
<img src='/images/supported_brands/sonos.png' class='brand pull-right' />
The sonos platform allows you to control your [Sonos](http://www.sonos.com) HiFi wireless speakers and audio components from Home Assistant.
To add your Sonos components to your installation, add the following to your `configuration.yaml` file. It will perform auto-discovery of your connected speakers.
```yaml
# Example configuration.yaml entry
media_player:
platform: sonos
```

34
source/_components/media_player.squeezebox.markdown Normal file
View file

@ -0,0 +1,34 @@
---
layout: page
title: "Logitech Squeezebox support"
description: "Instructions how to integrate a Logitech Squeezebox into Home Assistant."
date: 2015-08-09 11:00
sidebar: false
comments: false
sharing: true
footer: true
logo: logitech.png
ha_category: Media Player
---
<img src='/images/supported_brands/logitech.png' class='brand pull-right' />
The squeezebox platform allows you to control a [Logitech Squeezebox](https://en.wikipedia.org/wiki/Squeezebox_%28network_music_player%29) multimedia system from Home Assistant.
To add your Squeezebox to your installation, add the following to your `configuration.yaml` file:
```yaml
# Example configuration.yaml entry
media_player:
platform: squeezebox
host: IP_ADDRESS
port: 9090
username: USERNAME
password: PASSWORD
```
Configuration variables:
- **host** *Required*: The host name or address of the Logitech Media Server, eg. 192.168.1.21.
- **port** *Optional*: Telnet port to Logitech Media Server, default 9090.
- **username** *Optional*: The username, if password protection is enabled.
- **password** *Optional*: The password, if password protection is enabled.

62
source/_components/modbus.markdown Normal file
View file

@ -0,0 +1,62 @@
---
layout: page
title: "Modbus"
description: "Instructions how to integrate Modbus within Home Assistant."
date: 2015-04-25 9:16
sidebar: false
comments: false
sharing: true
footer: true
logo: modbus.png
ha_category: Hub
---
<img src='/images/supported_brands/modbus.png' class='brand pull-right' />
[Modbus](http://www.modbus.org/) 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:
#Modbus TCP
modbus:
type: tcp
host: IP_ADDRESS
port: 2020
```
Configuration variables:
- **type** (*Required*): Type of the connection to Modebus.
- **host** (*Required*): The IP address of your router, eg. 192.168.1.1.
- **port** (*Required*): The port for the comminication.
For a serial connection:
```yaml
# Example configuration.yaml entry
modbus:
type: serial
method: rtu
port: /dev/ttyUSB0
baudrate: 9600
stopbits: 1
bytesize: 8
parity: N
```
Configuration variables:
- **type** (*Required*): Type of the connection to Modebus.
- **method** (*Required*): Method of the connection to Modbus.
- **port** (*Required*): The port where your Modbus device is connected to your Home Assistant host.
- **baudrate** (*Required*): The speed for the serial connection.
- **stopbits** (*Required*): The stopbits for the serial connection.
- **bytesize** (*Required*): The bytesize for the serial connection.
- **parity** (*Required*): The parity for the serial connection.
## {% linkable_title Building on top of Modbus %}
- [Modbus Sensor](/components/sensor.modbus.html)
- [Modbus Switch](/components/switch.modbus.html)

147
source/_components/mqtt.markdown Normal file
View file

@ -0,0 +1,147 @@
---
layout: page
title: "MQTT"
description: "Instructions how to setup MQTT within Home Assistant."
date: 2015-08-07 18:00
sidebar: false
comments: false
sharing: true
footer: true
---
<img src='/images/supported_brands/mqtt.png' class='brand pull-right' />
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:
```yaml
# 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
```
Configuration variables:
- **broker** (*Required*): The IP address of your MQTT broker, e.g. 192.168.1.32.
- **port** (*Optional*): The network port to connect to. Default is 1883.
- **client_id** (*Optional*): Client ID that Home Assistant will use. Has to be unique on the server. Default is a random generated one.
- **keepalive** (*Optional*): The keep alive in seconds for this client. Default is 60.
- **username** (*Optional*): The username to use with your MQTT broker.
- **password** (*Optional*): The corresponding password for the username to use with your MQTT broker.
- **certificate** (*Optional*): Certificate to use to encrypt communication with the broker.
## {% linkable_title Picking a broker %}
The MQTT component needs you to run an MQTT broker for Home Assistant to connect to.
There are three options, each with various degrees of ease of setup and privacy.
#### {% linkable_title Run your own %}
Most private option but requires a bit more work. There are two free and open-source brokers to pick
from: [Mosquitto](http://mosquitto.org/) and [Mosca](http://www.mosca.io/).
```yaml
# Example configuration.yaml entry
mqtt:
broker: 192.168.1.100
port: 1883
client_id: home-assistant-1
keepalive: 60
username: USERNAME
password: PASSWORD
```
#### {% linkable_title Public MQTT %}
The Mosquitto project runs a [public broker](http://test.mosquitto.org). Easiest to setup but there
is 0 privacy as all messages are public. Use this only for testing purposes and not for real tracking
of your devices.
```yaml
mqtt:
broker: test.mosquitto.org
port: 1883
# Optional, 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
```
#### {% linkable_title CloudMQTT %}
[CloudMQTT](https://www.cloudmqtt.com) is a hosted private MQTT instance that is free up to 10
connected devices. This is enough to get started with for example
[OwnTracks](/components/device_tracker.owntracks.html) and give you a taste of what is possible.
<p class='note'>
Home Assistant is not affiliated with CloudMQTT nor will receive any kickbacks.
</p>
1. [Create an account](https://customer.cloudmqtt.com/login) (no payment details needed)
2. [Create a new CloudMQTT instance](https://customer.cloudmqtt.com/subscription/create)
(Cute Cat is the free plan)
3. From the control panel, click on the _Details_ button.
4. Create unique users for Home Assistant and each phone to connect<br>(CloudMQTT does not allow two
connections from the same user)
a. Under manage users, fill in username, password and click add
b. Under ACLs, select user, topic `#`, check 'read access' and 'write access'
5. Copy the instance info to your configuration.yaml:
```yaml
mqtt:
broker: <Server>
port: <SSL Port>
username: <User>
password: <Password>
```
<p class='note'>
Home Assistant will automatically load the correct certificate if you connect to an encrypted channel
of CloudMQTT (port range 20 000 - 30 000).
</p>
## {% linkable_title Building on top of MQTT %}
- [MQTT Sensor](/components/sensor.mqtt.html)
- [MQTT Switch](/components/switch.mqtt.html)
- [MQTT Device Tracker](/components/device_tracker.mqtt.html)
- [OwnTracks Device Tracker](/components/device_tracker.owntracks.html)
- [MQTT automation rule](/components/automation.html#mqtt-based-automation)
- [MQTT alarm](/components/alarm_control_panel.mqtt.html)
- Integrating it into a component. See the [MQTT example component](https://github.com/balloob/home-assistant/blob/dev/config/custom_components/mqtt_example.py) how to do this.
## {% linkable_title Testing your setup %}
For debugging purposes `mosquitto` is shipping commandline tools to send and recieve MQTT messages. For sending test messages to a broker running on localhost:
```bash
mosquitto_pub -h 127.0.0.1 -t home-assistant/switch/1/on -m "Switch is ON"
```
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.
```json
{
"topic":"home-assistant/switch/1/on",
"payload":"Switch is ON"
}
```
The message should appear on the bus:
```bash
... [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:
```bash
mosquitto_sub -h 127.0.0.1 -v -t "home-assistant/#"
```

33
source/_components/notify.file.markdown Normal file
View file

@ -0,0 +1,33 @@
---
layout: page
title: "File notification support"
description: "Instructions how to add file notifications to Home Assistant."
date: 2015-06-22 10:00
sidebar: false
comments: false
sharing: true
footer: true
ha_category: Notify
---
<img src='/images/supported_brands/text-x-generic.png' class='brand pull-right' />
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:
```yaml
# Example configuration.yaml entry
notify:
name: NOTIFIER_NAME
platform: file
filename: FILENAME
timestamp: 1 or 0
```
Configuration variables:
- **name** (*Optional*): Setting the optional parameter `name` allows multiple notifiers to be created. The default value is `notify`. The notifier will bind to the service `notify.NOTIFIER_NAME`.
- **filename** (*Required*): Name of the file to use. The file will be created if it doesn't exist and saved in your `config/` folder.
- **timestamp** (*Optional*): Setting `timestamp` to 1 adds a timestamp to every entry.
To use notifications, please see the [getting started with automation page]({{site_root}}/components/automation.html).

52
source/_components/notify.instapush.markdown Normal file
View file

@ -0,0 +1,52 @@
---
layout: page
title: "Instapush notification support"
description: "Instructions how to add Instapush notifications to Home Assistant."
date: 2015-05-01 18:00
sidebar: false
comments: false
sharing: true
footer: true
logo: instapush.png
ha_category: Notify
---
<img src='/images/supported_brands/instapush.png' class='brand pull-right' />
The instapush platform uses [Instapush](https://instapush.im) to delivery notifications from Home Assistant to your Android or iOS device.
The Instapush [Getting Started page](https://instapush.im/home/start/) will guide through the process of creating the required items.
```yaml
# Example configuration.yaml entry
notify:
name: NOTIFIER_NAME
platform: instapush
api_key: ABCDEFGHJKLMNOPQRSTUVXYZ
app_secret: ABCDEFGHJKLMNOPQRSTUVXYZ
event: ABCDEFGHJKLMNOPQRSTUVXYZ
tracker: ABCDEFGHJKLMNOPQRSTUVXYZ
```
Configuration variables:
- **name** (*Optional*): Setting the optional parameter `name` allows multiple notifiers to be created. The default value is `notify`. The notifier will bind to the service `notify.NOTIFIER_NAME`.
- **api_key** (*Required*): Your API key for Instapush.
- **app_secret** (*Required*): The secret for your created application.
- **event** (*Required*): TThe event
- **tracker** (*Required*): The name of tracker inside Instapush.
To retrieve those values for existing settings, log into your account at https://instapush.im and go to your **Dashboard**. Then click **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*.
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.
```bash
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](https://instapush.im/developer/rest).
To use notifications, please see the [getting started with automation page]({{site_root}}/components/automation.html).

43
source/_components/notify.markdown Normal file
View file

@ -0,0 +1,43 @@
---
layout: page
title: "Notifications"
description: "Instructions how to add user notifications to Home Assistant."
date: 2015-01-20 22:36
sidebar: false
comments: false
sharing: true
footer: true
---
One of the things most people want at some point in their home automation is to get notified when certain events occur. For this reason there is a `notify` component in Home Assistant.
Home Assistant currently supports a wide range of services for notifications:
- [E-Mail](/components/notify.smtp.html)
- [File](/components/notify.file.html)
- [Instapush](/components/notify.instapush.html)
- [Jabber (XMPP)](/components/notify.xmpp.html)
- [Notify My Android (NMA)](/components/notify.nma.html)
- [PushBullet](/components/notify.pushbullet.html)
- [PushOver](/components/notify.pushover.html)
- [Slack](/components/notify.slack.html)
- [Syslog](/components/notify.syslog.html)
### Automation example
Notifications are great to be used within Home Automation. Below is a an example configuration that you can add to your `configuration.yaml` to be notified when the sun sets.
```yaml
automation:
alias: Sun set notification
platform: state
state_entity_id: sun.sun
state_from: above_horizon
state_to: below_horizon
execute_service: notify.NOTIFIER_NAME
service_data: {"message":"YAY"}
```
For more automation examples, see the [getting started with automation page]({{site_root}}/components/automation.html).

34
source/_components/notify.nma.markdown Normal file
View file

@ -0,0 +1,34 @@
---
layout: page
title: "Notify My Android (NMA) notification support"
description: "Instructions how to add user notifications to Home Assistant."
date: 2015-05-01 18:00
sidebar: false
comments: false
sharing: true
footer: true
logo: nma.png
ha_category: Notify
---
<img src='/images/supported_brands/nma.png' class='brand pull-right' />
The nma platform uses [Notify My Android (NMA)](http://www.notifymyandroid.com/) to delivery notifications from Home Assistant to your Android device.
To add NMA to your installation, add the following to your `configuration.yaml` file:
```yaml
# Example configuration.yaml entry
notify:
name: NOTIFIER_NAME
platform: nma
api_key: ABCDEFGHJKLMNOPQRSTUVXYZ
```
Configuration variables:
- **name** (*Optional*): Setting the optional parameter `name` allows multiple notifiers to be created. The default value is `notify`. The notifier will bind to the service `notify.NOTIFIER_NAME`.
- **api_key** (*Required*): Enter the API key for NMA. Go to https://www.notifymyandroid.com and create a new API key.
Details for the API : https://www.notifymyandroid.com/api.jsp
To use notifications, please see the [getting started with automation page]({{site_root}}/components/automation.html).

32
source/_components/notify.pushbullet.markdown Normal file
View file

@ -0,0 +1,32 @@
---
layout: page
title: "PushBullet notification support"
description: "Instructions how to add user notifications to Home Assistant."
date: 2015-01-20 22:36
sidebar: false
comments: false
sharing: true
footer: true
logo: pushbullet.png
ha_category: Notify
---
<img src='/images/supported_brands/pushbullet.png' class='brand pull-right' />
Home Assistant currently supports the awesome [PushBullet](https://www.pushbullet.com/), a free service to send information between your phones, browsers and friends.
To add PushBullet to your installation, add the following to your `configuration.yaml` file:
```yaml
# Example configuration.yaml entry
notify:
name: NOTIFIER_NAME
platform: pushbullet
api_key: YOUR_API_KEY
```
Configuration variables:
- **name** (*Optional*): Setting the optional parameter `name` allows multiple notifiers to be created. The default value is `notify`. The notifier will bind to the service `notify.NOTIFIER_NAME`.
- **api_key** (*Required*): Enter the API key for PushBullet. Go to https://www.pushbullet.com/ to retrieve your API key.
For more automation examples, see the [getting started with automation page]({{site_root}}/components/automation.html).

40
source/_components/notify.pushover.markdown Normal file
View file

@ -0,0 +1,40 @@
---
layout: page
title: "Notifications"
description: "Instructions how to add user notifications to Home Assistant."
date: 2015-01-20 22:36
sidebar: false
comments: false
sharing: true
footer: true
logo: pushover.png
ha_category: Notify
---
<img src='/images/supported_brands/pushover.png' class='brand pull-right' />
The [PushOver service](https://pushover.net/) is a platform for the notify component. This allows components to send messages to the user using PushOver.
To use PushOver notifications, add the following to your `configuration.yaml` file:
```yaml
# Example configuration.yaml entry
notify:
name: NOTIFIER_NAME
platform: pushover
api_key: ABCDEFGHJKLMNOPQRSTUVXYZ
user_key: ABCDEFGHJKLMNOPQRSTUVXYZ
```
Configuration variables:
- **name** (*Optional*): Setting the optional parameter `name` allows multiple notifiers to be created. The default value is `notify`. The notifier will bind to the service `notify.NOTIFIER_NAME`.
- **api_key** (*Required*): This parameter is optional but should be configured, in order to get an API key you should go to https://pushover.net and register a new application.
- **user_key** (*Required*): To retrieve this value log into your account at https://pushover.net
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](https://home-assistant.io/images/favicon-192x192.png).
For more automation examples, see the [getting started with automation page]({{site_root}}/components/automation.html).

37
source/_components/notify.slack.markdown Normal file
View file

@ -0,0 +1,37 @@
---
layout: page
title: "Slack notification support"
description: "Instructions how to add Slack notifications to Home Assistant."
date: 2015-08-06 18:00
sidebar: false
comments: false
sharing: true
footer: true
logo: slack.png
ha_category: Notify
---
<img src='/images/supported_brands/slack.png' class='brand pull-right' />
The slack platform allows you to deliver notifications from Home Assistant to [Slack](https://slack.com/).
You need to obtain the [Slack API token](https://api.slack.com/web?sudo=1) to be able to send notifications.
To enable the slack notification in your installation, add the following to your `configuration.yaml` file:
```yaml
# Example configuration.yaml entry
notify:
name: NOTIFIER_NAME
platform: slack
api_key: ABCDEFGHJKLMNOPQRSTUVXYZ
default_channel: '#general'
```
Configuration variables:
- **name** (*Optional*): Setting the optional parameter `name` allows multiple notifiers to be created. The default value is `notify`. The notifier will bind to the service `notify.NOTIFIER_NAME`.
- **api_key** (*Required*): The slack API token to use for sending slack messages. You can get your slack API token here https://api.slack.com/web?sudo=1
- **default_channel** (*Required*): The default channel to post to if no channel is explicitly specified when sending the notification message.
To use notifications, please see the [getting started with automation page]({{site_root}}/components/automation.html).

54
source/_components/notify.smtp.markdown Normal file
View file

@ -0,0 +1,54 @@
---
layout: page
title: "SMTP notification support"
description: "Instructions how to add e-mail notifications to Home Assistant."
date: 2015-06-03 18:00
sidebar: false
comments: false
sharing: true
footer: true
logo: smtp.png
ha_category: Notify
---
<img src='/images/supported_brands/smtp.png' class='brand pull-right' />
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:
```yaml
# Example configuration.yaml entry
notify:
name: NOTIFIER_NAME
platform: smtp
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
```
Configuration variables:
- **name** (*Optional*): Setting the optional parameter `name` allows multiple notifiers to be created. The default value is `notify`. The notifier will bind to the service `notify.NOTIFIER_NAME`.
- **server** (*Required*): SMTP server which is used to end the notifications. For Google Mail, eg. smtp.gmail.com. Keep in mind that Google has some extra layers of protection which need special attention (Hint: 'Less secure apps').
- **port** (*Required*): The port that the SMTP server is using, eg. 587 for Google Mail and STARTTLS or 465/993 depending on your SMTP servers.
- **sender** (*Required*): E-Mail address of the sender.
- **username** (*Required*): Username for the SMTP account.
- **password** (*Required*):Password for the SMTP server that belongs to the given username. If the password contains a colon it need to be wrapped in apostrophes.
- **recipient** (*Required*): Recipient of the notification.
- **starttls** (*Optional*): Enables STARTTLS, eg. 1 or 0.
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 recommanded 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](https://www.google.com/settings/security/lesssecureapps) page and enable it.
To use notifications, please see the [getting started with automation page]({{site_root}}/components/automation.html).

60
source/_components/notify.syslog.markdown Normal file
View file

@ -0,0 +1,60 @@
---
layout: page
title: "Syslog notification support"
description: "Instructions how to add syslog notifications to Home Assistant."
date: 2015-06-09 16:00
sidebar: false
comments: false
sharing: true
footer: true
ha_category: Notify
---
<img src='/images/supported_brands/applications-system.png' class='brand pull-right' />
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:
```yaml
# Example configuration.yaml entry
notify:
name: NOTIFIER_NAME
platform: syslog
facility: SYSLOG_FACILITY
option: SYSLOG_LOG_OPTION
priority: SYSLOG_PRIORITY
```
Configuration variables:
- **name** (*Optional*): Setting the optional parameter `name` allows multiple notifiers to be created. The default value is `notify`. The notifier will bind to the service `notify.NOTIFIER_NAME`.
- **facility** (*Optional*): Facility according to RFC 3164 (http://tools.ietf.org/html/rfc3164). Default is 'syslog' if no value is given. Check the table below for entries.
- **option** (*Optional*): Log option. Default is 'pid' if no value is given. Check the table below for entries.
- **priority** (*Optional*): Priority of the messages. Default is 'info' if no value is given. Check the table below for entries.
The table contains values to use in your `configuration.yaml` file.
| facility | option | priority |
| :-------- |:--------| :---------|
| kernel | pid | 5 |
| user | cons | 4 |
| mail | 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](http://en.wikipedia.org/wiki/Syslog) and [RFC 3164](http://tools.ietf.org/html/rfc3164).
To use notifications, please see the [getting started with automation page]({{site_root}}/components/automation.html).

51
source/_components/notify.telegram.markdown Normal file
View file

@ -0,0 +1,51 @@
---
layout: page
title: "Telegram notification support"
description: "Instructions how to add Telegram notifications to Home Assistant."
date: 2015-10-09 18:00
sidebar: false
comments: false
sharing: true
footer: true
logo: telegram.png
ha_category: Notify
---
<img src='/images/supported_brands/telegram.png' class='brand pull-right' />
The telegram platform uses [Telegram](https://web.telegram.org) to delivery notifications from Home Assistant to your Android device, your Windows phone, or your iOS device.
The requirement are:
- You need a [Telegram bot](https://core.telegram.org/bots). Please follow those [instructions](https://core.telegram.org/bots#botfather) to create one and get the token. Keep in mind that bots are not allowed to contact users. You need to make the first contactwith your user.
- The chat ID of an user
An easy way to get your chat ID is described below:
```python
import telegram
bot = telegram.Bot(token='YOUR_API_TOKEN')
chat_id = bot.getUpdates()[-1].message.chat_id
print(chat_id)
```
To enable Telegram notifications in your installation, add the following to your `configuration.yaml` file:
```yaml
# Example configuration.yaml entry
notify:
name: NOTIFIER_NAME
platform: telegram
# Get those by creating a new bot on https://core.telegram.org/bots
api_key: ABCDEFGHJKLMNOPQRSTUVXYZ
chat_id: YOUR_CHAT_ID
```
Configuration variables:
- **name** (*Optional*): Setting the optional parameter `name` allows multiple notifiers to be created.
The default value is `notify`. The notifier will bind to the service
`notify.NOTIFIER_NAME`.
- **api_key** (*Required*): The API token of your bot.
- **chat_id** (*Required*: The chat ID of your user.
To use notifications, please see the [getting started with automation page]({{site_root}}/components/automation.html).

37
source/_components/notify.xmpp.markdown Normal file
View file

@ -0,0 +1,37 @@
---
layout: page
title: "Jabber (XMPP) notification support"
description: "Instructions how to add Jabber (XMPP) notifications to Home Assistant."
date: 2015-05-08 18:00
sidebar: false
comments: false
sharing: true
footer: true
logo: xmpp.png
ha_category: Notify
---
<img src='/images/supported_brands/xmpp.png' class='brand pull-right' />
The xmpp platform allows you to deliver notifications from Home Assistant to a [Jabber (XMPP)](http://xmpp.org) account.
```yaml
# Example configuration.yaml entry
notify:
name: NOTIFIER_NAME
platform: xmpp
sender: YOUR_JID
password: YOUR_JABBER_ACCOUNT_PASSWORD
recipient: YOUR_RECIPIENT
```
Configuration variables:
- **name** (*Optional*): Setting the optional parameter `name` allows multiple notifiers to be created. The default value is `notify`. The notifier will bind to the service `notify.NOTIFIER_NAME`.
- **sender** (*Required*): The Jabber ID (JID) that will act as origin of the messages. Add your JID including the domain, eg. your_name@jabber.org.
- **password** (*Required*): The password for your given Jabber account.
- **priority** (*Required*): The Jabber ID (JID) that will receive the messages.
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]({{site_root}}/components/automation.html).

37
source/_components/rfxtrx.markdown Normal file
View file

@ -0,0 +1,37 @@
---
layout: page
title: "RFXtrx support"
description: "Instructions how to integrate RFXtrx into Home Assistant."
date: 2015-10-08 10:15
sidebar: false
comments: false
sharing: true
footer: true
ha_category: Hub
---
The rfxtrx component supports RFXtrx devices by [RFXCOM](http://www.rfxcom.com) which communicate in the frequency range of 433.92 MHz.
To enable RFXtrx in your installation, add the following to your `configuration.yaml` file:
```yaml
# Example configuration.yaml entry
rfxtrx:
device: PATH_TO_DEVICE
debug: True
```
Configuration variables:
- **device** (*Required*): The path to your device, e.g. `/dev/serial/by-id/usb-RFXCOM_RFXtrx433_A1Y0NJGR-if00-port0`
- **debug** (*Optional*): If you want to receive debug output.
## {% linkable_title Building on top of RFXtrx %}
- [RFXtrx Sensor](/components/sensor.rfxtrx.html)
- [RFXtrx Switch](/components/switch.rfxtrx.html)
- [RFXtrx Light](/components/light.rfxtrx.html)

44
source/_components/scene.markdown Normal file
View file

@ -0,0 +1,44 @@
---
layout: page
title: "Scenes"
description: "Instructions how to setup scenes within Home Assistant."
date: 2015-03-23 19:59
sidebar: false
comments: false
sharing: true
footer: true
---
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.
A scene is active if all states of the scene match the actual states. An optional `fuzzy_match` option
can be given to allow entities to match if attributes are not exact but are in range of the preferred
state.
If a scene is manually activated it will store the previous state of the entities. These will be
restored when the state is deactivated manually. If one of the enties that are being tracked change
state on its own, the old state will not be restored when it is being deactivated.
Scenes can be activated using the service `scene.turn_on` and deactivated using the service `scene.turn_off`.
```yaml
# Example configuration.yaml entry
scene:
- name: Romantic
# Optional, allow fuzzy matching number atttributes to check if scene is on
fuzzy_match: 0.2
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
```

40
source/_components/script.markdown Normal file
View file

@ -0,0 +1,40 @@
---
layout: page
title: "Scripts"
description: "Instructions how to setup scripts within Home Assistant."
date: 2015-03-23 19:59
sidebar: false
comments: false
sharing: true
footer: true
---
The script component 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`.
```yaml
# Example configuration.yaml entry
script:
# Turns on the bedroom lights and then the living room lights 1 minute later
wakeup:
alias: Wake Up
sequence:
- event: logbook_entry
event_data:
name: Paulus
message: is waking up
# Optional
entity_id: device_tracker.paulus
domain: light
- alias: Bedroom lights on
service: light.turn_on
data:
entity_id: group.bedroom
- delay:
# supports seconds, milliseconds, minutes, hours, etc.
minutes: 1
- alias: Living room lights on
service: light.turn_on
data:
entity_id: group.living_room
```

39
source/_components/sensor.arduino.markdown Normal file
View file

@ -0,0 +1,39 @@
---
layout: page
title: "Arduino sensor support"
description: "Instructions how to integrate Arduino boards within Home Assistant."
date: 2015-09-14 18:28
sidebar: false
comments: false
sharing: true
footer: true
logo: arduino.png
ha_category: Sensor
---
<img src='/images/supported_brands/arduino.png' class='brand pull-right' />
The arduino sensor platform allows allow you to get an numerical values from an analog input pin of an [Arduino](https://www.arduino.cc/) 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:
```yaml
# Example configuration.yaml entry
sensor:
platform: arduino
pins:
1:
name: Door switch
type: analog
0:
name: Brightness
type: analog
```
Configuration variables:
- **pins** (*Required*): Array of pins to use. The number corresponds with the pin numbering schema of your board.
- **name**: Name that will be used in the frontend for the pin.
- **type**: The type of the pin. At the moment only 'analog' is supported.
The 6 analog pins of an Arduino UNO are numbered from A0 to A5.

135
source/_components/sensor.arest.markdown Normal file
View file

@ -0,0 +1,135 @@
---
layout: page
title: "aREST sensor support"
description: "Instructions how to integrate aREST sensors within Home Assistant."
date: 2015-09-07 18:15
sidebar: false
comments: false
sharing: true
footer: true
logo: arest.png
ha_category: Sensor
---
<img src='/images/supported_brands/arest.png' class='brand pull-right' />
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](http://arest.io/) RESTful framework.
To use your aREST enabled device in your installation, add the following to your `configuration.yaml` file:
```yaml
# Example configuration.yaml entry
sensor:
platform: arest
resource: http://IP_ADDRESS
name: Office
monitored_variables:
- name: temperature
unit_of_measurement: '°C'
- name: humidity
unit_of_measurement: '%'
pins:
A0:
name: Pin 0 analog
unit_of_measurement: "ca"
correction_factor: 0.01
decimal_places: 1
3:
name: Pin 3 digital
```
Configuration variables:
- **resource** (*Required*): IP address and schema of the device that is exposing an aREST API, e.g. http://192.168.1.10.
- **name** (*Optional*): Let you overwrite the the name of the device. By default *name* from the device is used.
- **monitored_variables** array (*Optional*): List of exposed variables.
- **name** (*Required*): The name of the variable you wish to monitor.
- **unit** (*Optional*): Defines the units of measurement of the sensor, if any.
- **pins** array (*Optional*): List of pins to monitor. Analog pins need a leading **A** for the pin number.
- **name** (*Optional*): The name of the variable you wish to monitor.
- **unit_of_measurement** (*Optional*): Defines the unit of measurement of the sensor, if any.
- **correction_factor** (*Optional*): A float value to do some basic calculations.
- **decimal_places** (*Optional*): Number of decimal places of the value. Default is 0.
The variables in the `monitored_variables` array must be available in the response of the device. As a starting point you find below a sketch for the Arduino device family. There are two variables (`temperature` and `humidity`) which will act as endpoints.
```c
/*
This modified sketch is based on the Ethernet example of the aREST
(http://arest.io/) library.
*/
// Libraries
#include <SPI.h>
#include <Ethernet.h>
#include <aREST.h>
#include <avr/wdt.h>
// Device settings
char* deviceId = "sensor02";
char* deviceName = "livingroom";
byte deviceMac[] = { 0x20, 0xD5, 0xD3, 0x03, 0xFE, 0x31 };
IPAddress deviceIp(192, 168, 1, 12);
EthernetServer server(80);
aREST rest = aREST();
// Variables to be exposed to the API
int temperature;
int humidity;
void setup(void) {
Serial.begin(57600);
// Init variables and expose them to REST API
temperature = 0;
humidity = 0;
rest.variable("temperature", &temperature);
rest.variable("humidity", &humidity);
// Give name and ID to device
rest.set_id(deviceId);
rest.set_name(deviceName);
Ethernet.begin(deviceMac, deviceIp);
server.begin();
Serial.print("Sensor is ready...");
// Start watchdog
wdt_enable(WDTO_4S);
}
void loop() {
EthernetClient client = server.available();
rest.handle(client);
wdt_reset();
// Replace this with your actual sensor readings, like
// temperature = (((analogRead(A0) * 5.0) / 1024) - 0.5) * 10;
temperature = random(400);
humidity = random(600);
delay(500);
}
```
Accessing one of the endpoints (eg. http://192.168.1.10/temperature) will give you the value inside a JSON response.
```json
{"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.
```json
{
"variables" : {
"temperature" : 23,
"humidity" : 82
},
"id" : "sensor01",
"name" : "livingroom",
"connected" : true
}
```

81
source/_components/sensor.bitcoin.markdown Normal file
View file

@ -0,0 +1,81 @@
---
layout: page
title: "Bitcoin support"
description: "Instructions how to integrate Bitcoin data within Home Assistant."
date: 2015-05-08 17:15
sidebar: false
comments: false
sharing: true
footer: true
logo: bitcoin.png
ha_category: Sensor
---
<img src='/images/supported_brands/bitcoin.png' class='brand pull-right' />
The bitcoin platform displays various details about the [Bitcoin](https://bitcoin.org) network.
If you have an online wallet from [Blockchain.info](https://blockchain.info/) the sensor is capable to show your current balance.
You need to enable the API access for your online wallet to get the balance. To do that log in and move to 'Account Setting', choose 'IP Restrictions', and check 'Enable Api Access'. You will get an email message from blockchain.info where you must authorize the API access.
To add the Bitcoin sensor to your installation, add a selection of the available display options to your `configuration.yaml` file:
```yaml
# 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
```
Configuration variables:
- **wallet** (*Optional*): This is your wallet identifier from https://blockchain.info to access the online wallet.
- **password** (*Optional*): Password for your online wallet.
- **currency** (*Optional*): The currency to exchange to, eg. CHF, USD, EUR, etc. Default is USD.
- **display_options** array (*Required*): Options to display in the frontend.
- **exchangerate**: Exchange rate of 1 BTC
- **trade_volume_btc**: Trade volume
- **miners_revenue_usd**: Miners revenue
- **btc_mined**: BTC mined
- **trade_volume_usd**: Trade volume in USD
- **difficulty**: Difficulty
- **minutes_between_blocks**: Time between blocks in minutes
- **number_of_transactions**: Number of transactions
- **hash_rate**: Hash rate in PH/s
- **timestamp**: Timestamp
- **mined_blocks**: Minded Blocks
- **blocks_size**: Block size
- **total_fees_btc**: Total fees in BTC
- **total_btc_sent**: Total sent in BTC
- **estimated_btc_sent**: Estimated sent in BTC
- **total_btc**: Total of BTC
- **total_blocks**: Total Blocks
- **next_retarget**: Next retarget
- **estimated_transaction_volume_usd**: Estimated transaction volume in BTC
- **miners_revenue_btc**: Miners revenue in BTC
- **market_price_usd**: Market price in USD

106
source/_components/sensor.command_sensor.markdown Normal file
View file

@ -0,0 +1,106 @@
---
layout: page
title: "Command line sensors support"
description: "Instructions how to integrate commandline sensors into Home Assistant."
date: 2015-09-13 10:10
sidebar: false
comments: false
sharing: true
footer: true
ha_category: Sensor
---
<img src='/images/supported_brands/utilities-terminal.png' class='brand pull-right' />
A sensor platform that issues specific commands to get data. 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`:
```yaml
# Example configuration.yaml entry
sensor:
platform: command_sensor
command: SENSOR_COMMAND
name: Command sensor
unit_of_measurement: "°C"
correction_factor: 0.4921
decimal_places: 0
```
Configuration variables:
- **command** (*Required*): The action to take to get the value.
- **name** (*Optional*): Name of the command sensor.
- **unit_of_measurement** (*Optional*): Defines the unit of measurement of the sensor, if any.
- **correction_factor** (*Optional*): A float value to do some basic calculations.
- **decimal_places** (*Optional*): Number of decimal places of the value. Default is 0.
## {% linkable_title Examples %}
In this section you find some real life examples of how to use this sensor.
### {% linkable_title Hard drive temperature %}
There are several ways to get the temperature of your hard drive. A simple solution is to use [hddtemp](https://savannah.nongnu.org/projects/hddtemp/).
```bash
hddtemp -n /dev/sda
```
To use those information, the entry for a sensor in the `configuration.yaml` file will look like this.
```yaml
# Example configuration.yaml entry
sensor:
platform: command_sensor
name: HD Temperature
command: "hddtemp -n /dev/sda"
unit_of_measurement: "°C"
```
### {% linkable_title CPU temperature %}
Thanks to the [`proc`](https://en.wikipedia.org/wiki/Procfs) 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:
```yaml
# Example configuration.yaml entry
- platform: command_sensor
name: CPU Temperature
command: "cat /sys/class/thermal/thermal_zone0/temp"
unit_of_measurement: "°C"
correction_factor: 0.001
```
The `correction_factor` will make sure that the value is shown in a useful format in the frontend.
### {% linkable_title Use an external script %}
The example is doing the same as the [aREST sensor](/components/sensor.arest.html) 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.
```python
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.
```python
#!/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.
```yaml
# Example configuration.yaml entry
sensor:
platform: command_sensor
name: Brightness
command: "python3 /path/to/script/arest-value.py"
unit_of_measurement: "°C"
```

27
source/_components/sensor.cpuspeed.markdown Normal file
View file

@ -0,0 +1,27 @@
---
layout: page
title: "Monitor CPU speed"
description: "Instructions how to integrate CPU speed within Home Assistant."
date: 2015-10-15 11:00
sidebar: false
comments: false
sharing: true
footer: true
ha_category: Sensor
---
<img src='/images/supported_brands/utilities-system-monitor.png' class='brand pull-right' />
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:
```yaml
# Example configuration.yaml entry
sensor:
platform: cpuspeed
name: CPU
```
Configuration variables:
- **name** (*Optional*): Name of the sensor.

45
source/_components/sensor.dht.markdown Normal file
View file

@ -0,0 +1,45 @@
---
layout: page
title: "DHT support"
description: "Instructions how to integrate DHTxx sensors within Home Assistant."
date: 2015-08-30 19:15
sidebar: false
comments: false
sharing: true
footer: true
logo: dht.png
ha_category: DIY
---
<img src='/images/supported_brands/dht.png' class='brand pull-right' />
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:
```yaml
# Example configuration.yaml entry
sensor:
platform: dht
sensor: DHT22
pin: 23
monitored_conditions:
- temperature
- humidity
```
Configuration variables:
- **sensor** (*Required*): The sensor type, supported devices are DHT11, DHT22, and AM2302
- **pin** (*Required*): The pin the sensor is connected to.
- **monitored_conditions** array: Conditions to monitor.
- **temperature**:
- **humidity**:
Available conditions are only *temperature* and *humidity*.
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.
<p class='note warning'>
As this requires access to the GPIO, you will need to run Home Assistant as root.
</p>

40
source/_components/sensor.efergy.markdown Normal file
View file

@ -0,0 +1,40 @@
---
layout: page
title: "Efergy support"
description: "Instructions how to integrate Efergy devices within Home Assistant."
date: 2015-07-11 0:15
sidebar: false
comments: false
sharing: true
footer: true
logo: efergy.png
ha_category: Sensor
---
<img src='/images/supported_brands/efergy.png' class='brand pull-right' />
Integrate your [Efergy](https://efergy.com) 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, and click "Add token".
```yaml
# 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:
- **app_token** (*Required*): The App Token for your account.
- **utc_offset** (*Required*): Some variables (currently only the daily_cost) require that the
negative number of minutes your timezone is ahead/behind UTC time.
- **monitored_variables** array (*Required*): Variables to monitor.
- **type** (*Required*): Name of the variable.
- **period** (*Optional*): Some variables take a period argument. Valid options are "day", "week", "month", and "year".
- **currency** (*Optional*): This is used to display the cost/period as the unit when monitoring the cost. It should correspond to the actual currency used in your dashboard.

64
source/_components/sensor.forecast.markdown Normal file
View file

@ -0,0 +1,64 @@
---
layout: page
title: "Forecast.io support"
description: "Instructions how to integrate Forecast.io within Home Assistant."
date: 2015-04-25 9:06
sidebar: false
comments: false
sharing: true
footer: true
ha_category: Weather
---
<img src='/images/supported_brands/weather-few-clouds.png' class='brand pull-right' />
The forecast platform uses the [Forecast.io](https://forecast.io/) web service as a source for meteorological data for your location. The location is based on the Longitude and Latitude cooridinates configured in `configuration.yaml`. The cooridinates 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 cooridinates can be found by using Google Maps and clicking on your home.
You need an API key which is free but requires a [registration](https://developer.forecast.io/register). You can make 1000 requests per day. This means that you could create approximately every 1.4 minute one.
To add Forecast.io to your installation, add the following to your `configuration.yaml` file:
```yaml
# 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
```
Configuration variables:
- **api_key** (*Required*): Your API key for http://forecast.io/.
- **monitored_conditions** array (*Required*): Conditions to display in the frontend.
- **summary**: A human-readable text summary.
- **precip_type**: The type of precipitation occurring.
- **precip_intensity**: The average expected intensity of precipitation occurring.
- **temperature**: The current temperature.
- **dew_point**: The dew point.
- **wind_speed**: The wind speed.
- **wind_bearing**: Where the wind is coming from in degrees, with true north at 0° and progressing clockwise.
- **cloud_cover**: The percentage of sky occluded by clouds.
- **humidity**: The relative humidity.
- **pressure**: The sea-level air pressure in millibars.
- **visibility**: The average visibility.
- **ozone**: The columnar density of total atmospheric ozone in Dobson.
- **units** (*Optional*): Specify the unit system. Default to `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.
Details about the API are available in the [Forecast.io documentation](https://developer.forecast.io/docs/v2).

70
source/_components/sensor.glances.markdown Normal file
View file

@ -0,0 +1,70 @@
---
layout: page
title: "Glances sensor support"
description: "Instructions how to integrate Glances sensors into Home Assistant."
date: 2015-09-14 19:10
sidebar: false
comments: false
sharing: true
footer: true
logo: glances.png
ha_category: Sensor
---
<img src='/images/supported_brands/glances.png' class='brand pull-right' />
The glances sensor platform is consuming the system information provided by the [Glances](https://github.com/nicolargo/glances) API. This enables one to track remote host and display their stats in Home Assistant.
This sensors needs a running isntance of `glances` on the host:
```bash
glances -w
Glances web server started on http://0.0.0.0:61208/
```
To enable the glances sensor, add the following lines to your `configuration.yaml`:
```yaml
# Example configuration.yaml entry
sensor:
platform: glances
name: Glances sensor
host: IP_ADDRESS
port: 61208
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:
- **host** (*Required*): The IP address of your host, eg. 192.168.1.32.
- **port** (*Option*): The network port to connect to. Default is 61208.
- **name** (*Optional*): Name of the Glances sensor.
- **resources** (*Required*): Entries to monitor.
- **'disk_use_percent'**: Used disk space in percent
- **'disk_use'**: Used disk space
- **'disk_free'**: Free disk space
- **'memory_use_percent'**: Used memory in percent
- **'memory_use'**: Used memory
- **'memory_free'**: Free memory
- **'swap_use_percent'**: Used swap space in percent
- **'swap_use'**: Used swap space
- **'swap_free'**: Free swap space
- **'processor_load'**: Load
- **'process_running'**: Number of running processes
- **'process_total'**: Total number of processes
- **'process_thread'**: Number of threads
- **'process_sleeping'**: Number of sleeping processes

54
source/_components/sensor.modbus.markdown Normal file
View file

@ -0,0 +1,54 @@
---
layout: page
title: "Modbus sensors support"
description: "Instructions how to integrate Modbus sensors into Home Assistant."
date: 2015-08-30 23:38
sidebar: false
comments: false
sharing: true
footer: true
logo: modbus.png
ha_category: Sensor
---
<img src='/images/supported_brands/modbus.png' class='brand pull-right' />
The modbus sensor platform allows you to gather data from your [Modbus](http://www.modbus.org/) sensors.
To use your Modbus sensors in your installation, add the following to your `configuration.yaml` file:
```yaml
# Example configuration.yml entry
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
coils:
0:
name: My coil switch
```
Configuration variables:
- **slave** (*Required*): The number of the slave (ignored and can be omitted if not serial Modbus).
- **registers** array (*Required*): The array contains a list of relevant registers to read from.
- **number of register** (*Required*): Listing relevant bits. It must contain a `bits` section.
- **bits** array (*Required*): Listing relevant bits. It must contain a `bits` section.
- **name** (*Required*): Name of the sensor.
- **unit** (*Required*): Unit to attach to value (optional, ignored for boolean sensors).
- **coils** (*Optional*): A list of relevant coils to read from/write to
- **number of coil** array (*Required*):
- **name** (*Required*): Name of the coil.
<p class='note warning'>
Each named register will create an integer sensor and each named bit will create a boolean sensor.
</p>

34
source/_components/sensor.mqtt.markdown Normal file
View file

@ -0,0 +1,34 @@
---
layout: page
title: "MQTT Sensor support"
description: "Instructions how to integrate MQTT sensors within Home Assistant."
date: 2015-05-30 23:21
sidebar: false
comments: false
sharing: true
footer: true
logo: mqtt.png
ha_category: Sensor
---
<img src='/images/supported_brands/mqtt.png' class='brand pull-right' />
This MQTT sensor implementation 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:
```yaml
# Example configuration.yml entry
sensor:
platform: mqtt
state_topic: "home/bedroom/temperature"
name: "MQTT Sensor"
qos: 0
unit_of_measurement: "°C"
```
Configuration variables:
- **state_topic** (*Required*): The MQTT topic subscribed to receive sensor values.
- **name** (*Optional*): The name of the sensor. Default is 'MQTT Sensor'.
- **qos** (*Optional*): The maximum QoS level of the state topic. Default is 0.
- **unit_of_measurement** (*Optional*): Defines the units of measurement of the sensor, if any.

39
source/_components/sensor.mysensors.markdown Normal file
View file

@ -0,0 +1,39 @@
---
layout: page
title: "MySensors sensors support"
description: "Instructions how to integrate MySensors sensors into Home Assistant."
date: 2015-05-14 21:57
sidebar: false
comments: false
sharing: true
footer: true
logo: mysensors.png
ha_category: Sensor
---
<img src='/images/supported_brands/mysensors.png' class='brand pull-right' />
The [MySensors](https://www.mysensors.org) project combines Arduino boards with NRF24L01 radio boards to build sensor networks.
Integrate your Serial MYSensors Gateway by adding the following to your `configuration.yaml` file:
```yaml
# Example configuration.yaml entry
sensor:
platform: mysensors
port: /dev/ttyACM0
```
Configuration variables:
- **port** (*Required*): The port where your board is connected to your Home Assistant host.
- **debug** (*Optional*): Enable or disable verbose debug logging.
- **persistence** (*Optional*): Enable or disable local persistence of sensor information. If this is disabled, then each sensor will need to send presentation messages after Home Assistant starts.
- **persistence_file** (*Optional*): Path to a file to save sensor information. The file extension determines the file type. Currently supported file types are 'pickle' and 'json'.
- **version** (*Optional*): Specifies the MySensors protocol version to use (ex. 1.4, 1.5).
If you are using an original Arduino the port will be named `ttyACM*`. The exact number can be determined with the command shown below.
```bash
ls /dev/ttyACM*
```

56
source/_components/sensor.openweathermap.markdown Normal file
View file

@ -0,0 +1,56 @@
---
layout: page
title: "OpenWeatherMap support"
description: "Instructions how to integrate OpenWeatherMap within Home Assistant."
date: 2015-04-25 9:06
sidebar: false
comments: false
sharing: true
footer: true
logo: openweathermap.png
ha_category: Weather
---
<img src='/images/supported_brands/openweathermap.png' class='brand pull-right' />
The openweathermap platform uses [OpenWeatherMap](http://openweathermap.org/) 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](http://home.openweathermap.org/users/sign_up).
To add OpenWeatherMap to your installation, add the following to your `configuration.yaml` file:
```yaml
# Example configuration.yaml entry
sensor:
platform: openweathermap
api_key: YOUR_API_KEY
forecast: 0 or 1
monitored_conditions:
- weather
- temperature
- wind_speed
- humidity
- pressure
- clouds
- rain
- snow
```
Configuration variables:
- **api_key** (*Required*): Your API key for http://openweathermap.org/.
- **forecast** (*Optional*): Enables the forecast. The default is to display the current conditions.
- **display_conditions** array (*Required*): Conditions to display in the frontend.
- **weather**: A human-readable text summary.
- **temperature**: The current temperature.
- **wind_speed**: The wind speed.
- **humidity**: The relative humidity.
- **pressure**: The sea-level air pressure in millibars.
- **clouds**: Description about cloud coverage.
- **rain**: The rain volume.
- **snow**: The snow volume
Details about the API are available in the [OpenWeatherMap documentation](http://bugs.openweathermap.org/projects/api/wiki).
Only metric measurements are supported at the moment.

103
source/_components/sensor.rest.markdown Normal file
View file

@ -0,0 +1,103 @@
---
layout: page
title: "RESTful sensor support"
description: "Instructions how to integrate REST sensors into Home Assistant."
date: 2015-09-14 19:10
sidebar: false
comments: false
sharing: true
footer: true
ha_category: Sensor
---
<img src='/images/supported_brands/rest.png' class='brand pull-right' />
The rest sensor platform is consuming a given endpoint which is exposed by a [RESTful API](https://en.wikipedia.org/wiki/Representational_state_transfer) 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:
```yaml
# Example configuration.yaml entry
sensor:
platform: rest
resource: http://IP_ADDRESS/ENDPOINT
method: GET
name: REST GET sensor
variable: 'return_value'
unit_of_measurement: "°C"
correction_factor: 0.01
decimal_places: 0
```
or for a POST request:
```yaml
# Example configuration.yaml entry
sensor:
platform: rest
resource: http://IP_ADDRESS/ENDPOINT
method: POST
variable: 'temperature' or ['Temperatures', 0, 'CurrentReading']
payload: '{ "device" : "heater" }'
name: REST POST sensor
unit_of_measurement: "°C"
correction_factor: 0.0001
decimal_places: 0
```
Configuration variables:
- **resource** (*Required*): The resource or endpoint that contains the value.
- **method** (*Optional*): The method of the request. Default is GET.
- **variable** (*Optional*): Defines the variable or a list of element for complex responses to extract, if any.
- **payload** (*Optional*): The payload to send with a POST request. Usualy formed as a dictionary-
- **name** (*Optional*): Name of the REST sensor.
- **unit_of_measurement** (*Optional*): Defines the unit of measurement of the sensor, if any.
- **correction_factor** (*Optional*): A float value to do some basic calculations.
- **decimal_places** (*Optional*): Number of decimal places of the value. Default is 0.
<p class='note warning'>
Make sure that the URL matches exactly your endpoint or resource.
</p>
`curl` could help you with the identification of the variable you want to display in your Home Assistant frontend. The example below show the JSON response of a device that is running with [aREST](http://arest.io/).
```bash
$ curl -X GET http://192.168.1.31/temperature/
{"temperature": 77, "id": "sensor02", "name": "livingroom", "connected": true}
```
## {% linkable_title Examples %}
In this section you find some real life examples of how to use this sensor.
### {% linkable_title External IP address %}
Always want to know your external IP address. [JSON Test](http://www.jsontest.com) will provide you this information 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.
```yaml
# Example configuration.yaml entry
- platform: rest
resource: http://ip.jsontest.com
name: External IP
variable: 'ip'
```
### {% linkable_title Single value from a local Glances instance %}
The [glances](/components/sensor.glances.html) sensor is doing a similar thing
Add something similar to the entry below to your `configuration.yaml` file:
```yaml
# Example configuration.yaml entry
- platform: rest
resource: http://IP_ADRRESS:61208/api/2/mem/used
name: Used mem
variable: 'used'
unit_of_measurement: MB
correction_factor: 0.000000954
decimal_places: 0
```

33
source/_components/sensor.rfxtrx.markdown Normal file
View file

@ -0,0 +1,33 @@
---
layout: page
title: "RFXtrx sensors support"
description: "Instructions how to integrate RFXtrx sensors into Home Assistant."
date: 2015-08-06 17:15
sidebar: false
comments: false
sharing: true
footer: true
ha_category: Sensor
---
The rfxtrx platform support sensors that communicate in the frequency range of 433.92 MHz.
To enable RFXtrx sensors in your installation, add the following to your `configuration.yaml` file:
```yaml
# Example configuration.yaml entry
sensor:
platform: rfxtrx
devices:
ac09c4f1: Temperature
ac09c4f2: Humidity
automatic_add: True
```
Configuration variables:
- **devices** (*Required*): A list of devices with their name to use in the frontend.
- **automatic_add** (*Optional*): To enable the automatic addition of new sensors.

48
source/_components/sensor.rpi_gpio.markdown Normal file
View file

@ -0,0 +1,48 @@
---
layout: page
title: "Raspberry PI GPIO sensor support"
description: "Instructions how to integrate the GPIO sensor capability of a Raspberry PI into Home Assistant."
date: 2015-08-30 19:00
sidebar: false
comments: false
sharing: true
footer: true
logo: raspberry-pi.png
ha_category: Sensor
---
<img src='/images/supported_brands/raspberry-pi.png' class='brand pull-right' />
The rpi_gpio sensor platform allows you to read sensor values of the GPIOs of your [Raspberry Pi](https://www.raspberrypi.org/).
To use your Raspberry Pi's GPIO in your installation, add the following to your `configuration.yaml` file:
```yaml
# Example configuration.yaml entry
sensor:
platform: rpi_gpio
ports:
11: PIR Office
12: PIR Bedroom
pull_mode: "UP"
value_high: "Active"
value_low: "Inactive"
```
Configuration variables:
- **ports** array (*Required*): Array of used ports.
- **port: name** (*Required*): Your username for the Edimax switch.
- **pull_mode** (*Optional*): The internal pull to use (UP or DOWN). Default is UP.
- **value_high** (*Optional*): The value of the sensor when the port is HIGH. Default is "HIGH".
- **value_low** (*Optional*): The value of the sensor when the port is LOW. Default is "LOW".
- **bouncetime** (*Optional*): The time in milliseconds for port debouncing. Default is 50ms.
For more details about the GPIO layout, visit the Wikipedia [article](https://en.wikipedia.org/wiki/Raspberry_Pi#GPIO_connector) about the Raspberry Pi.
<p class='note warning'>
If you are not running Raspbian Jessie, you will need to run Home Assistant as root.
</p>
<p class='note warning'>
To avoid having to run Home Assistant as root when using this component, run a Raspbian version released at or after September 29, 2015.
</p>

42
source/_components/sensor.sabnzbd.markdown Normal file
View file

@ -0,0 +1,42 @@
---
layout: page
title: "SABnzbd support"
description: "Instructions how to integrate SABnzbd within Home Assistant."
date: 2015-03-23 19:59
sidebar: false
comments: false
sharing: true
footer: true
logo: sabnzbd.png
ha_category: Sensor
---
<img src='/images/supported_brands/sabnzbd.png' class='brand pull-right' />
The sabnzbd platform will allow you to monitor your downloads with [SABnzbd](http://sabnzbd.org) 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:
```yaml
# Example configuration.yaml entry
sensor:
platform: sabnzbd
name: SAB
api_key: YOUR_API_KEY
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'
```
Configuration variables:
- **base_url** (*Required*): This is the base URL of your SABnzbd instance including the port number if not running on 80, eg. http://192.168.1.32:8124/
- **api_key** (*Required*): Name that will be used in the frontend for the pin.
- **name** (*Optional*): The name to use when displaying this SABnzbd instance.
- **monitored_variables** (*Required*): Array of the monitored variables.
- **type** (*Required*): Valid entries are: *'current_status'*, *'speed'*, *'queue_size'*, *'queue_remaining'*, *'disk_size'*, and *'disk_free'*

35
source/_components/sensor.swiss_public_transport.markdown Normal file
View file

@ -0,0 +1,35 @@
---
layout: page
title: "Swiss Public Transport support"
description: "Instructions how to integrate timetable data for travelling in Switzerland within Home Assistant."
date: 2015-06-02 21:45
sidebar: false
comments: false
sharing: true
footer: true
ha_category: Sensor
---
<img src='/images/supported_brands/appointment-new.png' class='brand pull-right' />
The swiss public transport sensor will give you the next two departure times from a given location to another one in Switzerland.
The [Stationboard](http://transport.opendata.ch/examples/stationboard.html) 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:
```yaml
# Example configuration.yaml entry
sensor:
platform: swiss_public_transport
from: STATION_ID
to: STATION_ID
```
Configuration variables:
- **from** (*Required*): The ID of the station of the start station.
- **to** (*Required*): The ID of the station of the end station.
The public timetables are coming from [Swiss public transport](http://transport.opendata.ch).

59
source/_components/sensor.systemmonitor.markdown Normal file
View file

@ -0,0 +1,59 @@
---
layout: page
title: "Monitor server resources"
description: "Instructions how to integrate server resources within Home Assistant."
date: 2015-03-23 19:59
sidebar: false
comments: false
sharing: true
footer: true
ha_category: Sensor
---
<img src='/images/supported_brands/utilities-system-monitor.png' class='brand pull-right' />
The system monitoring 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.
To add this platform to your installation, add the following to your `configuration.yaml` file:
```yaml
# Example configuration.yaml entry
sensor:
platform: systemmonitor
resources:
- type: disk_use_percent
arg: /home
- type: memory_free
- type: processor_use
```
Configuration variables:
- **resources** array (*Required*): Contains all entries to display.
- **type** (*Required*): The type of the information to display, please check the table below for details.
- **arg** (*Optional*): Argument to use, please check the table below for details.
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 | |
| disk_free | |
| 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 | Interface, eg. 'eth0' |
| process | Binary, eg. 'octave-cli' |
| last_boot | |
| since_last_boot | |

36
source/_components/sensor.tellstick.markdown Normal file
View file

@ -0,0 +1,36 @@
---
layout: page
title: "TellStick sensors support"
description: "Instructions how to integrate TellStick sensors into Home Assistant."
date: 2015-08-06 19:00
sidebar: false
comments: false
sharing: true
footer: true
logo: telldus_tellstick.png
ha_category: Sensor
---
<img src='/images/supported_brands/telldus_tellstick.png' class='brand pull-right' />
This tellstick sensor platform allows you to get current meteorological data from a [TellStick](http://www.telldus.se/products/tellstick) device.
To use your TellStick device in your installation, add the following to your `configuration.yaml` file:
```yaml
# Example configuration.yaml entry
sensor:
platform: tellstick
135: Outside
21: Inside
only_named: True
temperature_scale: "°C"
datatype_mask: 1
```
Configuration variables:
- **ID: Name** *Optional*: Entry for a sensor with the name for it and its ID.
- **only_named** *Optional*: Only show the named sensors. Set to `True` to hide sensors.
- **temperature_scale** *Optional*: The scale of the temperature value.
- **datatype_mask** *Optional*: Mask to determine which sensor values to show based on. Please check the [TellCore tellcore.constants documentation](https://tellcore-py.readthedocs.org/en/v1.1.2/constants.html#module-tellcore.constants) for details.

21
source/_components/sensor.temper.markdown Normal file
View file

@ -0,0 +1,21 @@
---
layout: page
title: "TEMPer sensors support"
description: "Instructions how to integrate TEMPer sensors into Home Assistant."
date: 2015-08-06 19:00
sidebar: false
comments: false
sharing: true
footer: true
ha_category: Sensor
---
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:
```yaml
# Example configuration.yaml entry
sensor:
platform: temper
```

36
source/_components/sensor.time_date.markdown Normal file
View file

@ -0,0 +1,36 @@
---
layout: page
title: "Time & Date support"
description: "Instructions how to integrate the time and the date within Home Assistant."
date: 2015-05-08 17:15
sidebar: false
comments: false
sharing: true
footer: true
ha_category: Sensor
---
<img src='/images/supported_brands/clock.png' class='brand pull-right' />
The time and date 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:
```yaml
# Example configuration.yaml entry
sensor:
platform: time_date
display_options:
- 'time'
- 'date'
- 'date_time'
- 'time_date'
- 'time_utc'
- 'beat'
```
The types *date_time* and *time_date* shows the date and the time. The other types just the time or the date. *beat* shows the [Swatch Internet Time](http://www.swatch.com/en_us/internet-time).
<p class='img'>
<img src='{{site_root}}/images/screenshots/time_date.png' />
</p>

56
source/_components/sensor.transmission.markdown Normal file
View file

@ -0,0 +1,56 @@
---
layout: page
title: "Transmission support"
description: "Instructions how to integrate Transmission within Home Assistant."
date: 2015-04-25 9:06
sidebar: false
comments: false
sharing: true
footer: true
logo: transmission.png
ha_category: Sensor
---
<img src='/images/supported_brands/transmission.png' class='brand pull-right' />
The [Transmission](http://www.transmissionbt.com/) platform allows you to monitor your downloads from within Home Assistant and setup automation based on the information.
```yaml
# Example configuration.yaml entry
sensor:
platform: transmission
host: IP_ADDRESS
port: 9091
name: Transmission
username: YOUR_USERNAME
password: YOUR_PASSWORD
monitored_variables:
- 'current_status'
- 'download_speed'
- 'upload_speed'
```
Configuration variables:
- **host** (*Required*): This is the IP address of your Transmission daemon, eg. 192.168.1.32.
- **port** (*Optional*): The port your Transmission daemon uses, defaults to 9091.
- **name** (*Optional*): The name to use when displaying this Transmission instance.
- **username** (*Optional*): Your Transmission username, if you use authentication.
- **password** (*Optional*): Your Transmission password, if you use authentication.
- **display_variables** array: Conditions to display in the frontend.
- **current_status**: The status of your Transmission daemon.
- **download_speed**: The current download speed.
- **upload_speed**: The current upload speed.
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** -> **Perferences** and choose the tab **Remote**. Check **Allow remote access**, enter your username and your password, and uncheck the network restriction as needed.
<p class='img'>
<img src='{{site_root}}/images/screenshots/transmission_perf.png' />
</p>
If everthing is setup correctly, the details will show up in the frontend.
<p class='img'>
<img src='{{site_root}}/images/screenshots/transmission.png' />
</p>

37
source/_components/sensor.vera.markdown Normal file
View file

@ -0,0 +1,37 @@
---
layout: page
title: "Vera sensors support"
description: "Instructions how to integrate Vera sensors into Home Assistant."
date: 2015-10-20 21:00
sidebar: false
comments: false
sharing: true
footer: true
logo: vera.png
ha_category: Sensor
---
<img src='/images/supported_brands/vera.png' class='brand pull-right' />
This vera sensor platform allows you to get data from your [Vera](http://getvera.com/) sensors.
To use your Vera sensor in your installation, add the following to your `configuration.yaml` file:
```yaml
# Example configuration.yaml entry
sensor:
platform: vera
vera_controller_url: http://YOUR_VERA_IP:3480/
device_data:
12:
name: My awesome sensor
exclude: true
13:
name: Another sensor
```
Configuration variables:
- **vera_controller_url** (*Required*): This is the base URL of your vera controller including the port number if not running on 80, eg. http://192.168.1.21:3480/
- **device_data** array (*Optional*):This contains an array additional device information for your Vera devices. It is not required and if not specified all sensors configured in your Vera controller will be added with default values. You should use the id of your Vera device as the key for the device within `device_data`.
- **name** (*Optional*):This parameter allows you to override the name of your Vera device in the frontend, if not specified the value configured for the device in your Vera will be used.
- **exclude** (*Optional*): This parameter allows you to exclude the specified device, it should be set to "True" if you want this device excluded.

18
source/_components/sensor.wink.markdown Normal file
View file

@ -0,0 +1,18 @@
---
layout: page
title: "Wink sensors"
description: "Instructions how to setup the Wink sensors within Home Assistant."
date: 2015-01-20 22:36
sidebar: false
comments: false
sharing: true
footer: true
logo: wink.png
ha_category: Sensor
---
<img src='/images/supported_brands/wink.png' class='brand pull-right' />
The wink sensor platform allows you to get data from your [Wink](http://www.wink.com/) sensors.
The requirement is that you have setup your [Wink hub](/components/light.wink.html).

35
source/_components/sensor.worldclock.markdown Normal file
View file

@ -0,0 +1,35 @@
---
layout: page
title: "Worldclock support"
description: "Instructions how to integrate a Worldclock within Home Assistant."
date: 2015-10-02 11:15
sidebar: false
comments: false
sharing: true
footer: true
ha_category: Sensor
---
<img src='/images/supported_brands/clock.png' class='brand pull-right' />
The worldclock 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:
```yaml
# Example configuration.yaml entry
sensor:
platform: worldclock
time_zone: America/New_York
name: New York
```
Configuration variables:
- **time_zone** (*Required*): The resource or endpoint that contains the value.
- **name** (*Optional*): The name of the sensor, eg. the city.
For valid time zones check the **TZ** column in the [Wikipedia overview](https://en.wikipedia.org/wiki/List_of_tz_database_time_zones). Or get the full list from the [pytz](https://pypi.python.org/pypi/pytz) module.
```python
python3 -c "import pytz;print(pytz.all_timezones)"
```

25
source/_components/shell_command.markdown Normal file
View file

@ -0,0 +1,25 @@
---
layout: page
title: "Shell command component"
description: "Instructions how to integrate Shell commands into Home Assistant."
date: 2015-10-13 19:10
sidebar: false
comments: false
sharing: true
footer: true
ha_category: Other
---
<img src='/images/supported_brands/utilities-terminal.png' class='brand pull-right' />
This component can expose regular shell commands as services.
```yaml
# Example configuration.yaml entry
shell_command:
restart_pow: touch ~/.pow/restart.txt
```
Configuration variables:
- Alias for the command and the command itself.

30
source/_components/simple_alarm.markdown Normal file
View file

@ -0,0 +1,30 @@
---
layout: page
title: "Intruder Alerts"
description: "Instructions how to receive intruder alerts from Home Assistant."
date: 2015-01-20 22:36
sidebar: false
comments: false
sharing: true
footer: true
---
<img src='/images/supported_brands/emblem-important.png' class='brand pull-right' />
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]({{site_root}}/components/notify.html). It will also flash a specific light when a known person comes home.
This component depends on the components [device_tracker]({{site_root}}/components/device_tracker.html) and [light]({{site_root}}/components/light.html) being setup.
To set it up, add the following lines to your `configuration.yaml` file:
```yaml
simple_alarm:
# Example configuration.yaml entry
known_light: light.Bowl
unknown_light: group.living_room
```
Configuration variables:
- **known_light** (*Required*): Which light/light group has to flash when a known device comes home.
- **unknown_light** (*Required*): Which light/light group has to flash red when light turns on while no one home.

64
source/_components/sun.markdown Normal file
View file

@ -0,0 +1,64 @@
---
layout: page
title: "Tracking the Sun"
description: "Instructions how to track the sun within Home Assistant."
date: 2015-01-24 14:39
sidebar: false
comments: false
sharing: true
footer: true
ha_category: Weather
---
<img src='/images/supported_brands/weather-clear.png' class='brand pull-right' />
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][automation-trigger].
[automation-trigger]: /components/automation.html#sun-trigger
```yaml
# Example configuration.yaml entry
homeassistant:
latitude: 32.87336
longitude: -117.22743
sun:
elevation: 123
```
Configuration variables:
- **elevation** (*Optional*): The solar elevation angle is the altitude of the sun. If ommitted will be retrieved from Google Maps.
<p class='img'>
<img src='/images/screenshots/more-info-dialog-sun.png' />
</p>
### {% linkable_title Implementation Details %}
The suns 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.
```json
{
"type": "sun",
"service": "switch.turn_on",
"event": "sunset",
"offset": "-01:00:00"
}
```
#### {% linkable_title Maintains entity `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
| `next_setting` | Date and time of the next sun setting

39
source/_components/switch.arduino.markdown Normal file
View file

@ -0,0 +1,39 @@
---
layout: page
title: "Arduino switch support"
description: "Instructions how to integrate Arduino boards within Home Assistant."
date: 2015-09-14 18:28
sidebar: false
comments: false
sharing: true
footer: true
logo: arduino.png
ha_category: Switch
---
<img src='/images/supported_brands/arduino.png' class='brand pull-right' />
The arduino switch platform allows you to control the digital pins of your [Arduino](https://www.arduino.cc/) 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:
```yaml
# Example configuration.yaml entry
switch:
platform: arduino
pins:
11:
name: Fan Office
type: digital
12:
name: Light Desk
type: digital
```
Configuration variables:
- **pins** (*Required*): Array of pins to use. The number corresponds with the pin numbering schema of your board.
- **name**: Name that will be used in the frontend for the pin.
- **type**: The type of the pin. At the moment only 'digital' is supported.
The digital pins are numbered from 0 to 13. 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.

44
source/_components/switch.arest.markdown Normal file
View file

@ -0,0 +1,44 @@
---
layout: page
title: "aREST switch support"
description: "Instructions how to integrate aREST switches within Home Assistant."
date: 2015-09-11 23:15
sidebar: false
comments: false
sharing: true
footer: true
logo: arest.png
ha_category: Switch
---
<img src='/images/supported_brands/arest.png' class='brand pull-right' />
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](http://arest.io/) RESTful framework.
To use your aREST enabled device in your installation, add the following to your `configuration.yaml` file:
```yaml
# Example configuration.yaml entry
switch:
platform: arest
resource: http://IP_ADDRESS
name: Office
pins:
11:
name: Fan
12:
name: Light Desk
```
Configuration variables:
- **resource** (*Required*): IP address and schema of the device that is exposing an aREST API, eg. http://192.168.1.10.
- **name** (*Optional*): Let you overwrite the the name of the device. By default *name* from the device is used.
- **pins** (*Required*): An array with all used pins of your board.
- **name** (*Required*): The name of the pin you wish to toggle.
Accessing one of the endpoints (eg. http://192.168.1.10/analog/2/) will give you a JSON response. The interesting part is `return_value` which represents the sensor's data.
```json
{"return_value": 34, "id": "sensor02", "name": "livingroom", "connected": true}
```

Some files were not shown because too many files have changed in this diff Show more