rajdanala / homeassistant-presentation Goto Github PK

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_probability

Each 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_usd

Adding 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_porch

Send 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: on

I 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 1

An 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

Customizing

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

Device Tracking

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
  • hass - command line control over Hass.io (reload, start/stop services, check config)
  • hassctl add-on for controlling hassbian
  • Can also control through GUI

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_alarm

Script 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_night

script.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.

• Python API
• Websocket API
• REST API
• Python REST API

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

Templating

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_update

Templating 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'

Themes

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!