Home Assistant is an open-source home automation platform written in Python (Github) on the backend, and Polymer on the frontend. When combined with hardware it makes an open hub for managing the state of home automation devices and triggering automations.
Presented on February 13, 2018 @ Code & Supply, Pittsburgh
Documentation
Installation
Components
Demo
- Speed of development - updates generally released bi-weekly
- Over 1,000 integrations
- Runs on Raspberry Pi, Synology NAS, or any computer running python
- Not dependent on cloud services (many components), all data stored locally in sqllite DB
- Ability to use disparate hardware
- Can work in conjunction with hubs from other manufacturers. Add HA in front of Smartthings
- Integrates with Amazon Echo, Google Assistant, and HomeKit for voice
- Helpful community - active Discord channel and Forum
- iOS app, or easily accessible through a responsive web interface
In many cases, the adoption of the technology [IoT] is being driven by businesses eager to gain valuable data from citizens, with little concern for their privacy or the protection of that data.
All of the analysts consulted pointed out that personal data from the connected home will often be bought and sold with consumers largely remaining oblivious to potential implications.
Internet of Things: Pinning down the IoT
Blink disables support for Smartthings in preparation for sale to Amazon
Hacker News
Overall, my takeaway is that the smart home is going to create a new stream of information about our daily lives that will be used to further profile and target us. The number of devices alone that are detected chattering away will be used to determine our socioeconomic status. Our homes could become like internet browsers, with unique digital fingerprints, that will be mined for profit just like our daily Web surfing is. If you have a smart home, it’s open house on your data.
The House that Spied on Me
- Samsung Smartthings
- Wink 2
- Apple Homepod
- Belkin Wemo
- Amazon Echo
- Google Home
- OpenSource: OpenHAB, Domoticz
Mesh networking with master-slave model
Up to 232 devices
Range up to 100m, 200m when meshed (adding more devices helps with communication)
Supports AES encryption
Low-latency transmission, up to 100 kbit/s
Nodes can be up to 30m apart, transmissions can hop nodes up to 4 times (adds delay)
Operates on 908MHz band, no interference from 2.4GHz (ISM) devices
Has interoperability layer to ensure all Z-Wave hardware and software work together
Z-Wave Plus - Fifth gen Z-Wave, improved battery life(~50%), range(167m instead of 100m), bandwidth(250%), OTA firmware updates. Need primary controller to be Z-Wave plus for full benefits
In HA, Z-Wave support is provided by python-openzwave
Additional hints on optimizing a Z-Wave network
Also a mesh network topology
No guaranteed interoperability between devices of different manufacturers
Data transmission at max 250 kbit/s
10m to 20m range
Operates in 2.4 GHz ISM band
Generally cheaper than Z-Wave
Good for transmitting one way - doorbells, fans, weather stations
Sonoff switches are available in RF versions
Broadlink RM Pro - controller
Easiest to configure
Consumes a lot of power relative to other protocols
Can control anything that accepts a signal from a remote (tv, amplifier, etc)
Broadlink RM Mini3
Good up to 10m
Installation of Home Assistant on a Raspberry Pi is accomplished by flashing the micro SD card with a downloaded image.
After first boot an installer will download the latest HA build and install in the background.
Home Assistant is not installed by flashing the SD card. On first boot make sure your device has an active Internet connection otherwise the download and installation of HA will fail. Either plug in an ethernet cable or configure wireless settings before booting. It takes around 15 minutes to complete the installation, and afterwards the Home Assistant interface will be available at http://<RasPI_IP>:8123
Install HomeAssistant core on a full Debian OS. No add-on packages available natively, but includes a tool called hassbian-config to aid with the installation of some common packages.
Has the benefit and/or drawback of running a full OS. This is beneficial if you want to run additional programs on the machine which are not integrated into the HA ecosystem.
Upgrades are accomplished through a pip3 package update.
$ sudo su -s /bin/bash homeassistant
$ source /srv/homeassistant/bin/activate
$ pip3 install --upgrade homeassistant
HomeAssistant running in a Docker container on ResinOS (soon to be replaced by a custom buildroot OS )
- Simple built-in updater
- No need to manage underlying OS
- Integrated app store for simple add-on installation and updating
- Ability to integrate community add-ons (web terminal, homebridge, pi-hole) and third-party repositories
Home Assistant organizes all the components that comprise your home automation network. This includes information pulled from the Internet (weather forecast, traffic cam image, bitcoin price), the state of a switch or light (on/off), presence detection (home/away), and more.
For each component that you want to use in Home Assistant, you add an entry to your configuration.yaml file and specify its settings.
The configuration file is written in YAML. YAML is a markup language that utilizes block collections of key:value pairs. It is heavily dependant on indentation and if there is an error in your configuration file it is likely due to incorrect indentation. You can check your config with an online YAML parser.
It is possible to edit YAML files from within Home Assistant using the HASS Configuration UI
homeassistant:
name: Pittsburgh
unit_system: imperial
time_zone: America/New_York
latitude: !secret latitude
longitude: !secret longitude
elevation: 330
frontend:
logbook:
exclude:
entities:
- sensor.dark_sky_summary
- sensor.dark_sky_daily_high_temperature
- sensor.dark_sky_daily_low_temperature
discovery:
updater:
sun:
map:
config:
history:
recorder:
purge_interval: 2
purge_keep_days: 7
logger:
default: warning
http:
api_password: my_password
light:
- platform: osramlightify
host: 192.168.1.5
sensor:
- platform: darksky
api_key: !secret darksky_api
units: auto
monitored_conditions:
- summary
- temperature
- temperature_max
- temperature_min
- precip_type
- precip_probabilityEach of these items is an entity with a state value and can be seen on the States page in Developer Tools in its raw form
and displayed on the frontend for easy viewing.
Additional sensors can be added by defining the new component in your configuration.yaml file. The bitcoin price sensor can be added with the following:
- platform: bitcoin
display_options:
- market_price_usdAdding a switch component like a power plug or light will automatically cause an entity with a toggle switch to be defined in the frontend, allowing you to turn the switch on or off manually.
Automations in Home Assistant are defined as trigger, condition, action.
(trigger) When I arrive home
(condition) and it is after sunset
(action) Turn the lights in the living room on
With trigger and action being mandatory and condition being optional.
A trigger will look at events happening in 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 currently on or off.
An example automation to turn on a porch light at sunset.
The id attribute is necessary only if you manage automations from within Home Assistant using the Automation Editor, which I don't recommend.
- id: '0001'
alias: 'Outside light ON at sunset'
hide_entity: true
trigger:
- platform: state
entity_id: sun.sun
from: above_horizon
to: below_horizon
action:
- service: light.turn_on
entity_id: light.front_porchSend me a text message (using the twilio component) if the water detector by my hot water tank registers water.
- id: '0002'
alias: 'Notify of water heater leak'
hide_entity: true
trigger:
- platform: state
entity_id: sensor.everspring_st812_flood_detector_flood
from: '0'
to: '255'
action:
service: notify.twilio
data:
message: 'Water detected by water heater!'
target:
- +1412xxxxxxx
My security alarm. If my hall motion detector registers motion, and nobody is home, and I have security enabled, then send me a text.
- id: '0003'
alias: 'Security - Motion detected'
hide_entity: true
trigger:
- platform: state
entity_id: binary_sensor.ecolink_motion_sensor_sensor
from: 'off'
to: 'on'
condition:
- condition: state
entity_id: group.all_devices
state: 'not_home'
- condition: state
entity_id: input_boolean.enable_security
state: 'on'
action:
service: notify.twilio
data:
message: 'Movement detected!'
target:
- +1412xxxxxxx
In the above example I check the state of an input_boolean named enable_security and only execute the action if the state is ON
This is a toggle switch on the frontend that I can manually set, or set through a different automation.
How do I get this toggle switch? I create it.
input_boolean:
enable_security:
name: Alarm Enabled
icon: mdi:shield-outline
initial: onI define different input_boolean and use them as conditionals to ensure my automations only fire exactly when I want them to.
If the action you wish your automation to perform is simple, like turning on a light, then you can call the service light.turn_on directly and pass the entity_id. If, however, you wish to trigger a more complex action then it may be necessary for your action to call script.turn_on or scene.turn_on with the entity_id being the name of the script or scene to execute.
Scripts are a sequence of actions that Home Assistant will execute.
script:
example_script:
sequence:
- service: light.turn_on
entity_id: light.kitchen
- service: light.turn_on
entity_id: light.bedroom
- service: notify.notify
data:
message: 'Lights are on!'Scenes capture the states you want certain entities to be.
scene:
- name: Romantic
entities:
light.tv_back_light: on
light.ceiling:
state: on
xy_color: [0.33, 0.66]
brightness: 200
- name: Movies
entities:
light.tv_back_light:
state: on
brightness: 100
light.ceiling: off
media_player.sony_bravia_tv:
source: HDMI 1An add-on project named scenegen can be used to create scenes by reading the current state of devices and outputting a corresponding scene.
Splitting up the configuration
You can move sections of your configuration.yaml to separate files and import them like so:
group: !include groups.yaml
automation: !include automations.yaml
scene: !include scenes.yaml
input_boolean: !include input_boolean.yaml
script: !include scripts.yaml
Grouping devices
Devices can be members of multiple groups. Some groups will be used to display devices together on the frontend. Other groups can be hidden (so they're not displayed on the frontend) and called within automations and scripts.
Lights:
- light.front_door
- light.hallupper
- light.halllower
- light.living_room
- light.bedroom
Inside_Lights:
- light.halllower
- light.hallupper
- light.living_room
- light.bedroom
Downstairs_Lights:
- light.halllower
- light.living_room
Upstairs_Lights:
- light.bedroom
- light.hallupper
Rename entities, hide entities, add icons, and more.
sensor.dark_sky_summary:
friendly_name: Conditions
sensor.dark_sky_temperature:
friendly_name: Temp
sensor.dark_sky_daily_high_temperature:
friendly_name: Daily High
sensor.dark_sky_daily_low_temperature:
friendly_name: Daily Low
sensor.dark_sky_precip:
friendly_name: Precipitation
sensor.market_price:
friendly_name: BTC
icon: mdi:currency-btc
binary_sensor.ecolink_doorwindow_sensor_sensor:
hidden: true
binary_sensor.ecolink_doorwindow_sensor_sensor_2:
hidden: true
binary_sensor.ecolink_motion_sensor_sensor:
hidden: true
Home Assistant can trigger automations based on your location and show your location on its map.
Location tracking can be done in many different ways, with varying precision:
- iOS App
- iCloud
- Owntracks
- NMap scan
- Many others
Once the first device is discovered HA will create a file named known_devices.yaml where it will track all the devices it knows about. If you want to rename a device, add a picture, or stop tracking a device, make the change in this file. For each tracked device HA will create a device_tracker.device_name entity which can be displayed on the frontend.
You can also define zones such that events will trigger when you enter or leave the zone.
Define a zone like so:
- name: Code_&_Supply
latitude: 40.46001
longitude: -79.93072
radius: 150
icon: mdi:desktop-classic
You even have the option of triggering events based on the direction of travel with the proximity component. You can have the thermostat raise the temperature as you approach home.
For more precise location detection Owntracks supports the use of iBeacons. You can turn your Raspberry Pi into an iBeacon with a large radius to trigger automations reliably when arriving in your home zone, or place iBeacons in each room of your house to trigger presence based actions at the room level.
Add-ons for updating configurations:
- Samba - Manage Home Assistant files exposed over an SMB share
- Git - Load and update configuration files for Home Assistant from a Git repository
- SSH - Enables easy ssh access for controlling the host
Dynamic DNS to access Home Assistant on the Internet.
Secure your installation if it is publicly exposed!
Consider not publicly exposing your Home Assistant installation to the world and instead keeping it secure inside your network. Various access methods such as OpenVPN, TOR, or ZeroTier exist which allow for more secure access. Setup instructions for ZeroTier on Raspberry Pi can be found here.
Easily and automatically add a free SSL certificate
Enables a local MQTT broker.
MQTT is a machine-to-machine or “Internet of Things” connectivity protocol on top of TCP/IP. It allows extremely lightweight publish/subscribe messaging transport.
Network devices can either publish simple information to an MQTT topic or subscribe to a topic to consume the data published there by another device.
The main advantage of MQTT is that it is a common protocol in the IoT space and allows easy sharing of information across devices that would otherwise be unable to communicate with each other.
Example: I can build a simple temperature and humidity sensor utilizing cheap microcontrollers like an ESP8266 or a Wemos D1 mini. These controllers will read the temperature from an attached sensor and have the ability to communicate over Wi-Fi. But how do we get these values into Home Assistant? MQTT. There are MQTT libraries available for many platforms, including Arduino. You configure your sensor with the IP of your MQTT broker as well as the topic you wish to publish to. Topics and sub-topics can be created on the fly. So for instance, if I place my new sensor in my bedroom I can tell it to publish to the home/temp/bedroom/master/ topic or if I wish to organize it differently I could instead publish to /home/bedroom/master/temp/.
Then, after I add the MQTT component to my configuration,
mqtt:
broker: 127.0.0.1
port: 1883
client_id: home-assistant-1
keepalive: 60
username: !secret mqtt_user
password: !secret mqtt_pass
I define a sensor to read that particular value.
- platform: mqtt
name: "Bedroom Temp"
state_topic: "home/bedroom/master/temp"
unit_of_measurement: "ºF"And now inside Home Assistant I have a component named sensor.bedroom_temp with a value being updated as the MQTT topic gets updated.
Pro tip: Home Assistant just pulls data from the MQTT topics you tell it to. If the information HA is disaplying seems incorrect or inconsistent it could be that the data being sent to Mosquitto is incorrect and not that it's an issue with HA. To troubleshoot these issues it can be beneficial to see the data being fed into Mosquitto from your sensors in real-time. To accomplish this I use the mosquitto_sub command with verbose output to subscribe to the # (all) topic. Omit --cafile if not using certificates.
mosquitto_sub -t "#" -v --cafile /etc/mosquitto/certs/ca.crt -p 8883 -u <user> -P <password>
The ability to access your frontend through an onion address on the TOR network. With this enabled, you do not need to open your firewall ports or setup HTTPS to enable secure remote access.
Additional security automations.
- id: '0005'
alias: 'Security - Sliding Door opened while in bed'
hide_entity: true
trigger:
- platform: state
entity_id: sensor.ecolink_binary
from: 'Closed'
to: 'Open'
condition:
- condition: state
entity_id: input_boolean.in_bed
state: 'on'
- condition: state
entity_id: input_boolean.enable_security
state: 'on'
action:
service: script.turn_on
entity_id: script.sound_the_alarmScript to sound the alarm.
sound_the_alarm:
alias: Alarm Activated
sequence:
- service: light.turn_on
entity_id: group.inside_lights
- service: notify.twilio
data:
message: "Alarm activated!!"
target:
- +1412xxxxxxx
- service: tts.google_say
entity_id: media_player.chromecast
data:
message: "Alarm alarm alarm alarm alarm alarm"Dasher is a simple way to bridge your Amazon Dash buttons to HTTP services. It is a Node application that listens on the network for Amazon Dash button presses and sends a post command to the Home Assistant REST API. I have one by my bed that I press when I get up in the morning and when I go to bed at night.
UPDATE: Dasher appears to have fallen out of date and no longer correctly runs on a Raspberry Pi. The Amazon-Dash project appears to be a working implementation.
Amazon Dash buttons can be good, cheap, battery powered buttons. You need to be an Amazon Prime member however to configure it.
Only one of the following automations will kick off depending on the time of day I press the button.
- id: '0006'
alias: 'Bedroom Dash Button - Good Morning'
hide_entity: true
trigger:
- platform: state
entity_id: input_boolean.dash_bedroom
from: 'off'
to: 'on'
condition:
- condition: time
after: '05:00:00'
before: '12:00:00'
action:
service: script.turn_on
entity_id: script.good_morning
- id: '0007'
alias: 'Bedroom Dash Button - Good Night'
hide_entity: True
trigger:
- platform: state
entity_id: input_boolean.dash_bedroom
from: 'off'
to: 'on'
condition:
- condition: time
after: '17:00:00'
before: '04:00:00'
action:
service: script.turn_on
entity_id: script.good_nightscript.good_morning
good_morning:
alias: "Trigger Morning routine"
sequence:
- service: scene.turn_on
entity_id: scene.good_morning
- service: input_boolean.turn_off
entity_id: input_boolean.dash_bedroom
- service: input_boolean.turn_off
entity_id: input_boolean.in_bed
scene.good_morning
- name: Good Morning
entities:
light.bedroom:
state: on
brightness_pct: 70
color_temp: 400
transition: 30
light.living_room:
state: on
light.halllower:
state: on
ESP8266, Arduino based devices, and many others can communicate via MQTT
There exists an HA component for The Things Network to tie in to a global IoT network based on LoRaWAN. LoRaWAN hubs cover an area 5 - 15 km to provide wide-area network coverage for low-bandwidth sensors and allow querying of these sensors world-wide. Home Assistant could, for example, read from all the LoRaWAN sensors connected to a private hub monitoring a 30 acre farm.
Graphing with Grafana and InfluxDB - display graphs and dashboards of time series data
And APIs to integrate with everything.
I replaced a mechanical controller on my whole house wood burner with an Arduino using a thermocouple to read the temperatures in the plenum.
Community member ericleejoe
I have an electric water heater, so I control the time when it’s on/off optimizing the cost based on my habits (including different pricing for the electricity during the day).
Community member ardeus
Early on Home Assistant introduced templating which allows variables in scripts and automations. This makes it possible to create conditions or actions based on variables.
- id: '0008'
alias: 'Daily Update'
hide_entity: true
trigger:
- platform: state
entity_id: input_boolean.daily_update
from: 'off'
to: 'on'
action:
- service: tts.google_say
entity_id: media_player.chromecast
data_template:
message: >
The temperature is currently {{states ('sensor.dark_sky_temperature') | round(0) }} degrees and bitcoin is trading at {{states ('sensor.market_price') | round(0) }} dollars
- service: input_boolean.turn_off
entity_id: input_boolean.daily_updateTemplating can be a great way to ensure the robustness and accuracy of your automations. For example, if you rely heavily on presence detection to trigger automations it can be problematic if your phone GPS glitches and places you 200m away from your actual location for a brief period of time. Now your "Away from home" automations kick-off and the lights turn off.
In this case you can track your presence using multiple sensors (Owntracks, nmap scan, iCloud) and use a template to define the state of a new input_boolean. The template reads the state of all 3 device trackers and only if 2 out of 3 report you as not_home does it set the state of input_boolean.User_home to OFF. Now use this component in your automations instead of the individual device trackers.
An example of a more complex template:
- platform: template
sensors:
status_smoke_co_alarm:
value_template: '{%- if is_state("sensor.first_alert_zcombo_smoke_and_carbon_monoxide_detector_alarm_level", "0") %}
Idle
{%else%}
{%- if is_state("sensor.first_alert_zcombo_smoke_and_carbon_monoxide_detector_alarm_type", "1") %}
Fire
{%- elif is_state("sensor.first_alert_zcombo_smoke_and_carbon_monoxide_detector_alarm_type", "2") %}
CO
{%- elif is_state("sensor.first_alert_zcombo_smoke_and_carbon_monoxide_detector_alarm_type", "12") %}
Testing
{%- elif is_state("sensor.first_alert_zcombo_smoke_and_carbon_monoxide_detector_alarm_type", "13") %}
Idle
{% else %}
Unknown
{%- endif %}
{%endif%}'
friendly_name: 'Smoke/CO Alarm'
It is possible to extensively customize Home Assistant's look from within your configuration.yaml
themes:
dark_theme:
# Main colors
primary-color: '#5294E2' # Header
accent-color: '#E45E65' # Accent color
dark-primary-color: 'var(--accent-color)' # Hyperlinks
light-primary-color: 'var(--accent-color)' # Horizontal line in about
# Text colors
primary-text-color: '#FFFFFF' # Primary text colour, here is referencing dark-primary-color
text-primary-color: 'var(--primary-text-color)' # Primary text colour
secondary-text-color: '#5294E2' # For secondary titles in more info boxes etc.
disabled-text-color: '#7F848E' # Disabled text colour
label-badge-border-color: 'green' # Label badge border, just a reference value
# Background colors
primary-background-color: '#383C45' # Settings background
secondary-background-color: '#383C45' # Main card UI background
divider-color: 'rgba(0, 0, 0, .12)' # Divider
# Table rows
table-row-background-color: '#353840' # Table row
table-row-alternative-background-color: '#3E424B' # Table row alternative
# Nav Menu
paper-listbox-color: '#5294E2' # Navigation menu selection hoover
paper-listbox-background-color: '#2E333A' # Navigation menu background
paper-grey-50: 'var(--primary-text-color)'
paper-grey-200: '#414A59' # Navigation menu selection
AppDaemon is a loosely coupled, multithreaded, sandboxed python execution environment for writing automation apps for Home Assistant. AppDaemon allows for writing more complex automations but is still based on state changes monitored by Home Assistant.
For example I have a script checking my commute time to work in the morning and back home in the afternoon. This is possible because I use Owntracks to track my location. Essentially my current coordinates and the coordinates of my destination are passed to Google Maps via an API to determine travel time. This is done continuously in the background by the Google Travel Time component.
- platform: google_travel_time
name: Time to Home
api_key: xxxxxxxxxxxxx
origin: device_tracker.my_iphone
destination: zone.home
options:
mode: driving
This script merely checks that component's state value at a specific time, and if it is greater than my defined threshold then it sends me a text.
First I define my apps in apps.yaml
Defining apps this way allows me to reuse my code to trigger both alerts with different variables.
commute_work:
module: commute
class: Commute
time: "8:00:00"
limit: 30
sensor: sensor.time_to_work
tracker: device_tracker.my_iphone
commute_home:
module: commute
class: Commute
time: "16:50:00"
limit: 30
sensor: sensor.time_to_home
tracker: device_tracker.my_iphone
And now I write my commute.py app.
import appdaemon.appapi as appapi
class Commute(appapi.AppDaemon):
def initialize(self):
time = self.parse_time(self.args["time"])
self.run_daily(self.check_travel, time)
def check_travel(self, kwargs):
commute = int(self.get_state(self.args["sensor"]))
currentLocation = str(self.get_state(self.args["tracker"]))
self.log(commute)
self.log(currentLocation)
if commute > int(self.args["limit"]):
if currentLocation == 'Work':
message = "Current travel time from work to home is {} minutes".format(commute)
self.log(message)
self.call_service("notify/twilio", title="Commute Warning", message = message, target="+1412xxxxxxx")
elif currentLocation == 'home':
message = "Current travel time from home to work is {} minutes".format(commute)
self.log(message)
self.call_service("notify/twilio", title="Commute Warning", message = message, target="+1412xxxxxxx")
else:
message = "Location unknown so no message sent"
self.log(message)HA Dashboard is a modular, skinnable dashboard for Home Assistant that is intended to be wall mounted, and is optimized for distance viewing. Perfect for displaying on a cheap Android tablet or Kindle Fire.
Floorplan is a custom integration which allows you to show a floorplan of your home and overlay device control over top. It is very customizable.
iOS app to create a floorpan template - magicplan
Node Red is a visual workflow development tool, allowing the creation of complex workflows to control Home Assistant devices.
3-part series on using Node Red to create Home Assistant automations.
Part 1,
Part 2,
Part 3
Hass.io running on a Raspberry Pi 3 - $50 with power and case.
Many people start with automating lights. Many lights are either wifi controlled or come with their own hub with a proprietary zigbee radio inside. You also should decide if you want white-only bulbs or color. I've found I prefer white bulbs that can display a range of white from cool to warm. I find the white color projected from color bulbs to be unpleasant. Color LED strips work well for adding a splash of color and effects.
Yeelight Wi-Fi color bulb - $35
IKEA Tradfri gateway kit with hub and two white bulbs - $80
Hue starter kit with hub and four white bulbs - $140
Osram Lightify - Hub $30, White bulb $19
Adding door/window sensors, motion detectors, fire alarms, water leak detectors, etc. requires investment in either Zigbee or Z-Wave.
A cheap, popular, Zigbee based starter kit is the Xiaomi Security Kit for $60 which includes a Zigbee hub, two door/window sensors, and a push button. The trade-off is that it's meant for Chinese use only. This means the kit is shipped from China, you must purchase a power adapter, and run through the setup process in Chinese. Having done this myself it's actually pretty simple.
Sonoff switches ($5 - $10) are a good option for automating power on/off. You can splice one to the cable of any lamp or to any extension cord to make it controllable. They are available in either Wi-Fi or RF versions. Amazon link
Flash the Sonoff with Tasmota or ESPurna third-party firmware. These firmware provide OTA updates and MQTT support.
There is a large ecosystem of Z-Wave enabled devices and sensors, and some sensors may only be available in Z-Wave versions. To proceed with Z-Wave you need a Z-Wave hub and the Aeotec Z-Stick (Z-Wave plus version) is a popular option for the Raspberry Pi.
Aeotec Z-Stick Gen5 - $45
Happy Automating!