I happened upon a polar sun path chart a while back and really thought it was a great graphic. It shows where the sun goes each day as a function of the seasons. Behold:
The polar Sun path chart for Seattle, WA
For Seattle, you can see at the top that the sun rises in the SE, peaks at 20° above the horizon, and then sets at 4:30pm on the winter solstice. Ugh. But in the summer, it’s up from before 4am to after 8pm, and peaks above 60° . You can make one of these plots for your area over at the University of Oregon’s Solar Radiation Monitoring Lab.
I liked this plot so much that I wanted to take it to the next level and see where the sun is live. In my experience with Python, I’ve grown to expect there to be sweet libraries that can compute stuff like that. Sure enough, there are a few. First, I found pysolar, which is really straightforward, fast, and simple. A few lines of code and I was up and running.
My first polar solar plot
The code for this is nearly trivial:
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
import datetime
import math
import matplotlib.pyplot asplt
from pysolar import solar
LOC=(47.607,-122.33)
HOURS=1
DAYS=365
def plotAll():
start=datetime.datetime(2019,1,1,0,0,0,0)
delta=datetime.timedelta(hours=HOURS)
data=[]
forinterval inrange(DAYS*24//HOURS):
now=start+delta*interval
alt=90-solar.get_altitude(*LOC,now)
azi=solar.get_azimuth(*LOC,now)/180.0*math.pi
ifalt<=90:
print(now,alt,azi)
data.append((alt,azi))
fig=plt.figure()
ax=fig.add_subplot(111,projection='polar')
alts,azis=zip(*data)
c=ax.scatter(azis,alts,s=10,alpha=0.5)
ax.set_theta_zero_location('S',offset=0)
ax.set_rmax(90)
plt.show()
plotAll()
But then as I fiddled with it, I realized I really wanted something that was going to show the Moon as well. And while I was at it, maybe a few more planets. I found the skyfield library, which looked perfect.
Since I want it to be live, I figure the best place to put it is in my self-hosted home automation setup based on Home Assistant (which I’ve written about a lot), right in the weather section. This is basically just local weather information.
Dotted blue line is winter solstice. Green line is summer solstice. This was taken in December so the solid solar path is close to the winter solstice. Planets shown between the moon and sun are Saturn, Venus, and Jupiter. The objects update every 10 seconds in the web browser and tick along from E to W.
As I watched it one day, during the sunset, it looked like some planets were supposed to be out. In the figure above, Jupiter, Saturn, and Venus are closely following the sun into the sunset. The moon was right there to the south but I didn’t see the planets readily. I eventually noticed Venus in the sunset, and then scanned around with my binoculars and, sure enough, I found Jupiter and Saturn too! How about that!
(I realize I could pull up Google Sky Map or similar and do the same thing, but it’s somehow more fun to have a live local version alongside my weather sensors)
A few days later, I’ve gotten used to where the sun rises and sets at this time of year. Out on a jog, I noticed where the sun was. Since I have been paying attention to this plot, it was easy for me to intuit where on the path it is at that time. From this, I was able to immediately orient myself in terms of the cardinal directions. It felt like a revelation.
(I also realize anyone can do this just by thinking about it, but having the polar plot really helped drill it in somehow)
So, this thing is a pretty solid clock, calendar, planet map, and compass! Tons of fun.
For future development, it’d be nice to have an actual web/javascript frontend. Eventually, I’d really like to have this mounted on a wall.
I’ve got one of those hydronic home heating systems where hot water from the hot water heater gets pumped to radiators around the house in addition to heating up water for faucets. A few days ago it died on me and threw an error code indicating something was wrong with ignition. I took a look at the igniter and found that it was full of an oxide layer.
After sandpapering it, it worked great, but I ordered a spare for when this inevitably happens again. Along the way, it occurred to me that it’d be kind of fun to have instrumentation on my hot water heater. I just got it up and running.
Way back in my first post about hot tubs, I used OneWire sensors called Dallas 18B20s (datasheet) with an Arduino 2009. They worked great at hot water temperature, so I decided to try them out again. This time, rather than using an Arduino, I’m using a ESP8266 microcontroller. These are cheap and have Wi-Fi, so I can easily get the data into my home assistant setup, just like I did with my mom’s furnace, my doorbell, and other stuff.
Step one is to solder a bunch of sensors together. I wanted to get readings on all the different pipes going into and out of my hot water heater. I went down there and measured how much space I’d need between each sensor. Then I soldered them up. Notably 18B20s can work in “parasite mode” with just two wires, but there are problems with parasite mode on ESP8266’s, and in prototype testing I was unable to get that mode to work. So I just wired them up to 3 wires. This tutorial is a good one for wiring up these sensors.
One Dallas18B20 soldered into my wire-o-sensors. Black goes to GND on the ESP, red goes to +5V on the ESP, and clear goes to GPIO 2, which is also jumpered to +5V with a 4.7 kOhm resistorAll 5 of the sensors are wired identically and soldered together into the ESP8266 microcontroller. I need a good name for this because it could totally be productized!I am not proud of this particular solder job connecting the wire to the ESP8266.One of the sensors zip-tied to the hot water heater pipe. Since it’s not great thermal contact, we can expect measured temperatures to be biased low.The whole installed system
For software, I already have a MQTT server up and running from my home automation setups, so the easiest thing is to just transmit the data via Wi-Fi/MQTT to my server and then receive/process it with Home Assistant.
The ESP8266 code is pretty straightforward. It connects to Wi-Fi and MQTT and then just sits around for a pre-determine delay (60 seconds) after which it reads the sensors and transmits them. Here it is:
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
/*
Hot water heater temperature monitoring station.
This reads a few temperature sensors at various points
on a hot water heater (or whatever) and transmits
them back to some place where they can be read and
processed (like a Home Assistant system).
Temperature sensors used here are DS18B20's in non-parasite mode.
These have good temperature resolution up to hot water temperatures.
*/
#include <OneWire.h>
#include <DallasTemperature.h>
#include <ESP8266WiFi.h>
#include <ESP8266mDNS.h>
#include <PubSubClient.h>
#define wifi_ssid "Wifi SSID"
#define wifi_password "Actual password"
#define mqtt_server "dummy-mqtt-server.com"
#define mqtt_will_topic "home/status/garage"
#define mqtt_user "user"
#define mqtt_password "password"
#define ONE_WIRE_BUS D2
OneWire oneWire(ONE_WIRE_BUS);
DallasTemperature sensors(&oneWire);
WiFiClientSecure espClient;
PubSubClient client(espClient);
intnumDevices;
StringbaseTopic="home/garage/";
unsignedlongpreviousMillis=0;
constlongintervalMillis=60000;// how often to update
DeviceAddress tempDeviceAddress;
voidsetup(){
pinMode(D2,INPUT);
pinMode(D2,OUTPUT);
sensors.begin();
Serial.begin(9600);
Serial.print("Greetings from the water heater.");
setup_wifi();
setup_mqtt();
Serial.print("Initializing devices...");
numDevices=sensors.getDeviceCount();
Serial.print("Found ");
Serial.print(numDevices,DEC);
Serial.println(" devices.");
for(inti=0;i<numDevices;i++){
if(sensors.getAddress(tempDeviceAddress,i)){
Serial.print("Found device ");
Serial.print(i,DEC);
Serial.print(" @: ");
printAddress(tempDeviceAddress);
Serial.println();
}else{
Serial.print("Found phantom device at ");
Serial.print(i,DEC);
Serial.print(" but could not detect address. Check power and cabling");
Then the setup in Home Assistant configuration is just a few MQTT sensors. To figure out which sensor was which I had to put my finger on them individually to see which one heated up first.
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
# Hot water heater sensor order from esp is 3 2 1 0 4
-platform:mqtt
name:Heat outlet
state_topic:"home/garage/3"
device_class:temperature
unit_of_measurement:'°C'
-platform:mqtt
name:Heat inlet
state_topic:"home/garage/2"
device_class:temperature
unit_of_measurement:'°C'
-platform:mqtt
name:Faucet inlet
state_topic:"home/garage/1"
device_class:temperature
unit_of_measurement:'°C'
-platform:mqtt
name:Faucet outlet
state_topic:"home/garage/0"
device_class:temperature
unit_of_measurement:'°C'
-platform:mqtt
name:Garage ambient
state_topic:"home/garage/4"
device_class:temperature
unit_of_measurement:'°C'
With that configured, I went to the front end and added a new History Graph card from Lovelace and choose the new sensors by name. An hour later, the data looked like this:
Temperature data from the hot water heater sensor line. I turned off the circulation pump around 6:54 P.M. and you can nicely see the heating loop converge to a lower temperature. Beautiful!
I love it. And of course, I added an e-mail alert when the faucet outlet temperature drops below 30 °C so I’ll be able to swap out the igniters before the thing cools all the way down.
I live in tall and skinny house with a loft on the upper floor. I can’t hear the doorbell going off when I’m up there, especially if I have music playing. This post is about how I extended the range of my doorbell by hooking a sensor up to it that communicates over Wifi to my smart-home, which then plays a doorbell tone over my speakers throughout the house.
I already have a reasonably capable smart home based on Home Assistant, so I challenged myself to do this in the cheapest, least intrusive way possible. In the end, I did this with a $7 part and without changing any of the wiring in my existing doorbell (I just had to connect 2 extra wires to the existing transformer).
Here’s a preview of it working:
Here’s the demo of it working. The 2nd ring is through the stereo.
My existing doorbell chime. I didn’t need to touch it. I just recorded it to play over the stereo.
I used my favorite chip for this, the ESP8266 WiFi microcontroller. When it senses that the button was pressed, the ESP sends a signal to my smart home (via a MQTT message over the WiFi). Then, Home Assistant senses this and plays a recording of the doorbell noise. It can also e-mail me or something if I’m not home.
Doorbells are usually wired like this. The transformer is usually kicking out a good 16-24 VAC when nothing is happening. When the doorbell is pressed, electromagnets slap some metal to cause a chime. At this time, the voltage drops at the transformer because the circuit is temporarily interrupted. That’s a good place to put the ESP8266 to watch for action.
My transformer reads 18.75 VAC on my voltmeter under normal conditions. To experiment before installation, I’ll be using a 6 VAC test transformer, which reads 7.23 VAC on my meter, and which corresponds nicely with the 20.6 Vpp I see measured on the oscilloscope.
Test setup with voltage divider, diode, and test transformer
Testing on the production transformer. I wired these in with the screws for production. Careful: AC can kill you, even though on this side of the transformer it’s lower voltage. Turn off the mains.
The ESP8266 chip has a 10-bit analog-to-digital (ADC) converter on it that functions between 0-1 V, returning digital values between 0-1024. Many development boards, like my Wemos D1, have a voltage divider already in place that takes the max input up to 3.3 V. So I needed to convert my doorbell signal down to 3.3 Vpp. This is the job of a simple voltage divider, plus a diode to chop off the negative side of the AC wave.
We solve:
\(
V_{peak} = V_{RMS} \cdot \sqrt{2} \cdot x = 3.3V
\) for x
For fun, we can try simulating the circuit with Qucs.
A first simulation of my voltage divider in the Qucs circuit simulator
On my test transformer, I tried cutting the voltage by a factor of 10. A voltage divider with a top resistor 9x the bottom one will work. So 1 kΩ and 10 kΩ would be close. Measuring reality with the oscilloscope agrees:
The oscilloscope measurement shows that the output signal is 10x less than the input signal, and totally positive. Looks perfect for the ESP’s ADC The voltage divider soldered up.
On the production system, I need to drop 18.7 Vrms down to 3.3 V peak, so my voltage divider must cut voltage down to 0.124 the peak, so a ratio close to 1:8 is needed. Honestly, 1 kΩ and 10 kΩ, with a 1:11 ratio should work fine. Let’s simulate it. Theory says it should give 2.4 V. Simulation agrees. Reality will also.
Simulation of the production setup in QucsUnsurprisingly, the simulation results agree with theory, 2.4V peak
2.4V on a 10-bit 3.3 ADC will be \(1024 \cdot \frac{2.4}{3.3} = 744\). So let’s set the ESP ADC to consider anything above 720 to indicate BUTTON NOT PRESSED, and anything below 720 to be BUTTON PRESSED.
Signal Processing and Software
Originally I thought it’d be really easy to read the peaks and detect the drop in voltage. I got it going and hooked into MQTT and Home Assistant really quickly with some simple software.
Here I am playing around with the test setup
However, seeing the break in the circuit is not so easy. With some test runs on the real doorbell, I wasn’t able to reliably detect a quick/normal doorbell press. If I really held down on the doorbell button I could detect it, but it wasn’t good enough. So I had to fiddle around in software to find a good read of the ADC with these kinds of pulses.
Sidenote: If you were using MQTT over TLS before and now you have connection troubles, it’s probably because ESP switched to a more robust TLS library and you either need to explicitly allow insecure connections over TLS or load a certificate chain. This took me a while to figure out. More here.
The ESP8266’s ADC isn’t all that fast. In the ESP’s API guide, you can find a really nice sample program around the description of system_adc_read_fast. This is also discussed here with a very similar waveform to what I’m dealing with. I did some tests in the Appendix below.
In the USA, a 60 Hz sine wave will cycle once every 16.6 milliseconds. If I sample enough to capture at least 1 full cycle and save the max value from that window, I can watch for a reduction in max values and trigger off of that. From the appendix, one cycle looks like it will require about 2300 samples with clk_div = 16 to capture. Then, we’ll want to keep the past 20 cycles or so to check/respond in about a 5th of a second. That ought to be fast enough.
I set up two interrupts with two timers: A fast one to read nearly every peak from every AC cycle and a slower one to take a look at the past 20 peaks and see if any of those have dipped below the trigger threshold.
Both interrupts re-schedule themselves with their respective timers unless a button-press has been detected, at which point they suspend themselves until something else turns them back on. That something lives in my loop function:
That’s pretty much it. The WiFi and MQTT setups are all pretty traditional. I reset ADC results to HIGH on the ADC 1024 to avoid echo-triggers after one gets sensed.
This arrangement of the dual timers and windows and stuff is the result of a bit of trial and error. I’m pretty happy with its ability to sense short variations in the peak AC signal. I cannot press it fast enough to make it miss the read. Yay.
Automation setup in Home Assistant
Now that the doorbell status is just a MQTT topic that we will monitor, the configuration in Home Assistant is pretty straightforward. First we need a binary sensor based on the MQTT topic:
1
2
3
4
5
binary_sensor:
-platform:mqtt
state_topic:"home/doorbell"
name:"Doorbell"
device_class:opening
And of course the automation:
1
2
3
4
5
6
7
8
9
-alias:Actual doorbell
initial_state:on
trigger:
-platform:state
entity_id:binary_sensor.doorbell
from:'off'
to:'on'
action:
-service:shell_command.dingdong
That’s it! It works great and plays throughout the house thanks to my Snapcast setup. Total incremental parts cost for a smart doorbell: $7.
Appendix A: How fast is the ESP8266 ADC?
I figured I’d just do some experiments with the ADC to help me understand how fast it really is. In summary, I was able to read 16384 samples that captured 8 peaks of a 60 Hz signal, so the fastest sample rate is roughly 123,000 samples/second. Not great, not terrible. Totally sufficient for this kind of work though, for sure.
Clock division =16. This is as slow as we can go
Clock division =8. This is as fast as we can go
With Clock div=32, it malfunctions and just returns 1024 for everything.
Just for fun I tried clock division = 24. That was messed up.
Zooming in on some of the data in a peak to see the noise
Here’s what the real peak looks like on my oscilloscope
Zoomed in more on the scope
The code used to do these demos is below. I just copy/pasted the data from the serial monitor into a text file and wrote a quick plotter in Python to graph the data. (Interestingly I couldn’t copy/paste all from the console output b/c one of the garbage characters halted the paste, so I shift-clicked to copy the large block quickly).
The code uses a timer to call the system_adc_read_fast function once and then prints it out and then just sits forever. I triggered the software watchdog a few times so I put that wdtFeed call in there to prevent it from resetting me all the time.
It’s that spooky time of year again, but this time it can be extra spooky with the help of home automation.
Motion-activated jumpscare on TV
One classic spooky thing to do is have a TV do something scary when people walk by. This is easier than ever on any TV now that everyone has Raspberry Pi with HDMI output and z-wave (or other) motion sensors everywhere. Check this out:
NOTE/UPDATE: After an update this kind of stopped working and I struggled with it a lot. Now I actually recommend using snapcast instead of this solution. It works better!
I moved to a new place and it has more than one room. Naturally, I hooked up the stereo in the living room and tested it like my dad taught me: by playing “Money For Nothing” really loudly. It worked. But wait a minute, there’s an upstairs now… how will I get it playing up there? I could always use the wifi network and raspberry pis to beam audio around. Yeah, let’s do that!
If you have a digital video recorder (DVR) hooked up to some cameras and you want to access it remotely when something happens, you can set up remote access to review things from wherever. Here’s how to do it.
I got a few Amcrest Wifi security cameras for my mom’s house at her request. They’re pretty nice overall (My only complaint is that the web-interface doesn’t fully support Linux). I set one up to save a jpg snapshot to memory every minute and then flew across the country. When I wanted to access them, I couldn’t just put the SD-card in a computer or anything, and clicking all 14,000 of them seemed like a pain, so I decided to figure out how to get them with a Python script.
I got one of those RGB LED matrix things for my birthday and wasn’t sure what to do with it. Then I found this awesome library which has Python bindings and can control it nicely even from a Raspberry Pi. Conveniently I had a spare Raspberry Pi 1 B+ sitting around so I hooked it up. After playing around for a while, I got the demos working.
But I needed to connect it to home-assistant to really make it valuable to myself. So I wrote a little program called Infopanel (available for free on github) that lets you do some things:
Get data directly from a MQTT broker for getting live data (e.g. travel times in traffic, weather conditions) and for command and control. This allows me to connect the screen to my home-assistant home automation system.
Assemble various built-in elements like giraffes, animated text, rainbow text, pictures, animated gifs into various scenes that rotate through on the screen to display the information in various fun and/or useful ways.
There are Temperature and Duration sprites that you can define high and low values of so they’re red when they’re bad and green when they’re good, and anywhere in between.
You can set the scenes to be just random or you can control them through MQTT.
It’s intended to be very configurable but since it’s brand new some extra development is needed to make everything perfect. Send in your ideas and requests and code changes!
A relatively complete example configuration file is in the repo. That demonstrates using MQTT, connecting MQTT topics to various sprites, building your own frames of animation by hand, and adding in gifs and images from file paths. Note that you have to set an environmental variable or two to get the fonts right and whatnot.
I have a website or two and sometime wish I could get notifications whenever someone visited them, just for fun. Well I did it, and now I can get beeps in my home whenever anyone visits. It’s kind of cool to hear it go off, though normally it will be annoying, so we need a switch for it.
My mom has one of those on/off furnaces (EDIT: actually it’s a boiler) that heats up water and circulates it through pipes around the house that have little radiator fins. She wants it to turn on before she wakes up so it’s not so cold in the morning. In this post, I explain how to turn a normal furnace into a smart furnace controlled by Home Assistant for only a few bucks.
Oh this is exciting! I’ve been trying to figure out how to get motion events from my IP camera into my home-assistant instance running on my Raspberry Pi, and I just did a successful test! It works! Hooray. Briefly, I set up an email server on the Pi, have the camera email the Pi, have the email server trigger a script which parses the email for key words and sends MQTT signals as appropriate, at which point the home-assistant MQTT client sees them and triggers automations (like blinking a light to scare people off). Here’s how I did it.
I just configured a pretty slick burglar alarm with the open-source Home-Assistant platform running on my Raspberry Pi. It can be armed to trigger when a door is opened and/or when a motion sensor goes off.
Then, a sequence of events happens:
An IR LED turns on my stereo
A sound file I cobbled together starts playing. It starts with a computerized voice saying that yourentry been detected and recorded, then it beeps for a while (giving you time to disarm), and then it goes into a blaring siren noise. Quite the escalation!
A light blinks on and off a few times
A camera takes a series of snapshots of the area
An email is sent to my phone with the snapshots, showing me what’s going on
You may have seen my earlier post about my new home automation setup. Well I just upgraded it! I just finished testing out a new infrared remote control send and receive capability and it is pure awesome. Here’s what I can do now from within home-assistant:
Turn on and off my new DeLonghi portable air conditioner from Costco, and set the temperature to whatever
Turn on and off the TV and press any buttons from its remote control
Turn on and off the stereo and virtually press any buttons from its remote control (which I never even had!)
Use an old random blueray remote control to set scenes, turn lights on and off, etc. (basically do anything under home-assistant’s control)
This post is about how I did it on my Raspberry Pi.
I went over to my friend’s house last night to help get home-assistant on a Raspberry Pi working for his z-wave door sensors and siren. The Ecotech sensor showed up fine but the Aeotech recessed one (Recessed Door Sensor Gen5 , ZW089-A) did not show up by default. After poking around in the logs for a while, we realized that it was sending BASIC_SET command classes instead of BinarySensor commands. Apparently (I thought I had fixed this already), home-assistant doesn’t recognize the BASIC_SET commands just yet. But looking at the config file for this device, we discovered that config item 121 changes which kind of report this sensor sends: Continue reading Using an Aeotech recessed door sensor in home-assistant
I’ve always dreamed of having a “smart-home.” There’s just something cool about being able to flip switches and read sensors and have a program turn a light on when you open the door, but only if it’s dark. This post is about home automation.
