Home automation is wonderful.  Up until recently, I used things like motion sensors and contact sensors to trigger various things.  While these devices still have their place, they are "dumb."  For example, I could have a motion sensor in my backyard that triggers lights, but any motion from squirrels or my dog unnecessarily triggers.

Recently, a youtube channel I came across detailed how to easily set something up that can determine objects in your camera and act accordingly.

The meat of this uses 3 pieces of software:

- Blue Iris https://blueirissoftware.com/

This is the only piece of software that requires cash money.  Also, it runs in Windows.  These might be deal breakers for some (it was almost for me), but after trying it out, I decided to go with it.  It turned out to be worth the price (around $60) and it's much easier to work with than ZoneMinder.  There are also efforts to make this work in Docker (more on that later).

- Deep Stack AI Server https://deepstack.cc/

This software is free and available as a Docker container.  https://hub.docker.com/r/deepquestai/deepstack

- AI Tool (Windows - https://github.com/gentlepumpkin/bi-aidetection) or node-deepstackai-trigger (Docker - https://github.com/danecreekphotography/node-deepstackai-trigger)

The AI Tool runs on windows while node-deepstackai-triggers runs in a Docker container.  This is the important piece of the puzzle and sits in-between Deep Stack AI Server and Blue Iris.  The basic flow is:

Blue Iris captures a still image into a folder – >AI Tool/node-deepstackai-trigger sees the image > image is sent to Deep Stack AI > results are returned to AI Tool/node-deepstackai-trigger > actions are taken based on results

Actions can be any type of home automation you have going on.  With node-deepstack-ai, you can send out a web request or a MQTT message.  In a particular set up, I set up my front door car to recognize people.  After everything happens, my front door records a high resolution video and makes a chime/announcment on select Alexa devices in my home.  Previously, I would get false alarms if any motion was detected on the camera.  Now, I have a "smarter" camera that gives me finer control on my home automation.  This is all very exciting stuff for home automation.  You can run all this processing locally and not depend on pay/Internet services.

Below is an example of another automation I have with a camera pointed at my pool.  When it notices a person, I trigger Blue Iris to record a high resolution video.  Blue Iris can also trigger other things as well so you can chain these things together (or, just add another trigger Uri to the array).

Example snippet of configuration for my pool camera:

    {
      "name": "poolsd",
      "watchPattern": "/aiinput/poolsd*.jpg",
      "cooldownTime": 5,
      "enabled": true,
      "threshold": {
        "minimum": 0,
        "maximum": 100
      },
      "handlers": {
        "webRequest": {
          "triggerUris": ["http://192.168.1.28:81/admin?camera=poolhd&trigger&user=user&pw=pass"]
        }
      },

To set this all up, I recommend watching The Hook Up youtube channel video on how to set this all up.  The wiki for node-deepstackai-trigger also has good detailed info:  https://github.com/danecreekphotography/node-deepstackai-trigger/wiki

Hopefully, we can have something set up to train the AI with our own personal faces.  We can get really creative with home automation then.  I would like my doors to open when my camera sees my ugly mug.

# Windows?

I prefer to use the node-deepstackai-trigger docker container since it is easy to keep running and configure.  It also pairs well in a docker-compose set up with Deep Stack AI server.  The final piece of the puzzle is getting Blue Iris running in Docker.  jshridha has created a container, but ther is a lot of work to be done.  It isn't stable for my tastes, but we are working to fix things.  I have already submitted some PRs to update things and I hope we can eventually get this working properly.   https://github.com/jshridha/docker-blueiris

Funny last note:  As I was writing this on my patio, I noticed some log entries from node-deepstackai-trigger:

2020-09-01T15:52:07-07:00 [Trigger patiodoorsd] /aiinput/patiodoorsd.20200901_155151275.jpg: Detected object laptop is not in the watch objects list [person, dog]
2020-09-01T15:52:07-07:00 [Trigger patiodoorsd] /aiinput/patiodoorsd.20200901_155151275.jpg: Not triggered by laptop (95.88411500000001)

lol - that's pretty cool.

I lost most of this original post due to datacenter outage at my cheap VPS provider (https://buyvm.net/ - they are pretty good cause they are pretty cheap).  Since I don't want to forget things and it may be useful to some, here is a link to the github project for this:

https://github.com/leonowski/go-shell-api-docker

Basically:  Build this thing, run it in Docker, and copy the binaries out.  Great for making small utilities that run in shell but called through HTTP.

Good usage example:  as a WOL interface that lives on your router.  Instead of having to remember how to send a WOL packet, just do something like a curl command.

So, for Independence Day, my family set out on a road trip to Lake Tahoe.  My wife and I take turns driving.  During one of my turns riding shotgun, something came up at the office that required my attention.  It should have been a quick task, but my particular carrier throttles my hotspot connection.  It's very frustrating because the same connections that go through my phone directly work quickly and are not throttled.  So, I did a little workaround to get past this restriction.

SSH has the ability to create a SOCKS proxy.  This is a general TCP proxy that can be used to forward traffic from your computer through another computer.  So, with an android app acting as an SSH server and any SSH client (I'm using MacOS), you can bypass any hotspot throttling using an application that can connect using a SOCKS proxy.  Your traffic will basically appear to come from your phone directly instead of a client behind a hotspot NAT connection.

My preferred SSH server on Android is SSHDroid.  The option to enable an SSH proxy is simply -D followed by the port you want the proxy server to listen on.  Here is the basic idea:

1 - Turn on hotspot tethering and confirm that your client can connect.
2 - Launch SSHDroid.  Hit the start button.  SSHDroid will report the IP and port that the SSH server is running on.

3.  Connect to the SSH server from your ssh client.  For example, I would connect to SSHdroid from my Mac with this command:

ssh admin@192.168.43.66 -D 9999

This will start the SSH connection to the SSHDroid server on my android phone and create a local SOCKS proxy on port 9999 on my laptop.

4.  Finally, configure your client to connect to the proxy server.  For Mac OS, that means configuring the network settings to connect to the proxy server at localhost:9999.  For some clients (like Firefox or git), they use their own proxy settings apart from the system wide proxy settings.

While this is connected, you should now have full speed from your carrier.  No more throttling.  Just freedom.

Things to note:

• You may want to check the TOS with your provider.  This stuff may violate the TOS.  But, in a pinch, it works well.  You shouldn't abuse it.
• You don't need root access to your phone!
• You may get better performance if you add the -C option in your ssh command.  This turns on compression.
• This method works well with any SSH client.  It should work with putty on Windows.  It works well on my Chromebook running in Crostini (you may need to forward ports) and with the wonderful Chromebook SSH app.
• Creating a SOCKS proxy is also a good way to encrypt your traffic without having to use VPN.  For example, during this roadtrip, I SSH into my home SSH servers to create the SOCKS proxy tunnel.  This protects me from the foreign network that I'm on with encryption and my point of presence for the Internet is my home.
• SSHdroid has a lot of options including the ability to use keys or passwords.

It turns out that my old blog post about making an August lock bridge device was popular https://www.thenoel.org/diy-august-l/

Unfortunately, some folks had problems getting things to run due to a combination of some vague instructions I put up and possibly a lack of experience working with things like nodejs.  So, I thought about making a Docker image that could do most of the nodejs stuff automagically.  It took some time as I had never worked with Docker on a Raspberry Pi before and I didn't know how to make bluetooth work in a container.

Fortunately, balena has all of this worked out already!  The other part of this is getting Docker to work properly on the Raspberry Pi Zero W.  As of this writing, there is a bug that causes a seg fault when running Docker on Raspbian.  There is a workaround if you install a particular version.  Instructions will be below.  First, a note:  You should know how to SSH into your Raspberry Pi Zero and work with Linux.  It is expected that you will run this bridge headless and hidden away somewhere (but close enough to connect via bluetooth to your lock).  The instructions below start with the assumption that you have installed Raspbian Stretch on your zero.

1.  Run these commands to get some required things and things up to date:

sudo apt-get update && sudo apt-get upgrade -y && sudo apt-get install bluetooth bluez libbluetooth-dev libudev-dev

2.  Run these commands to install the particular version of Docker that doesn't crash:

curl -fsSL https://get.docker.com -o get-docker.sh

chmod u+x get-docker.sh

VERSION=18.06.3~ce~3-0~raspbian ./get-docker.sh

Running the Docker Container

To run the Docker container, launch it with environment variables that specify the key, key offset, and port (default is 8080).  An example is below:

sudo docker run --restart always -d \
-e "OFFLINEKEY=ABCD1234" -e "OFFLINEKEYOFFSET=1" -e "PORT=8080" \
-v /run/dbus/system_bus_socket:/var/run/dbus/system_bus_socket \
--privileged --network host leonowski/august-server

Explanation of options:

--restart always -->  tells Docker to always restart this container

-d -->  tells Docker to run the container daemonized

-e --> specifies an environment variable pair.  3 are specified for the key, key offset, and port (if port is not set, 8080 is default).  Obviously, set it these env vars to your particular lock's keys.

-v /run/dbus/system_bus_socket:/var/run/dbus/system_bus_socket --> maps the dbus path to allow bluetooth to work.  :)

--privileged -->  the bluetooth stuff requires privileged container mode to be on

--network host -->  the bluetooth stuff also requires the container to be in network host mode.

One Final Thing

I was building the container on the raspi directly and then I found out you could cross compile on an x86 machine including Docker Hub!  That's why you can pull the image directly from Dockerhub at leonowski/august-server.  Check out the Dockerfile to see how the cross compile works.  It's really simple thanks to the folks at balena.

2019 is here.  That means it's time to update Ghost to 2.0.  Also, I put a new picture up as the cover for thenoel.org.  It's a picture of some hot sausage cooking up on a grill that I took in Prague.  The street food was amazing.

https://ngrok.com/

It lets you make a public, Internet accesible endpoint. It's great for doing quick tests.

It has been about 1 year since I got the Chevy Bolt. It's time to reflect on this revolutionary EV.

First, I have to say - this thing is still awesome. Instant torque, long range battery (60KWh), and the DC fast charger make this an awesome car. There is still no maintenance (other than tire rotations) and the battery hasn't shown any loss of performance/charge (probably due to the liquid cooling, unlike the air-cooled Leaf which has potential long-term battery issues). The odometer is at around 20k miles and the car still feels like it's brand new. I ride this car hard and run it in sport mode all the time. It's a tiny beast.

After driving a Leaf for 3 years, I was hesitant to jump ship - but Nissan didn't have the larger capacities available yet and I was really itching to get a long range EV. The Model 3 is still in mass production hell (still is) and I'm just an impatient nerd. Was it worth it? After 1 year, I say jumping ship was well worth it.

I do have the same gripes with the vehicle:

• It's tiny. I'm a small asian guy and it still feels a bit cramped inside.

• For something that is so technologically advanced, the in car sound system does have some strange problems that require me to reboot it from time to time (I have to stop the car, turn off the entire car, and then turn it back on - ugh!)

• There is little trunk space. My wife and I did manage to bring home a large heat lamp from Lowes once using very creative spacing techniques - but man, that trunk is TINY!

• Chevy's OnStar cellular system is slooowww. I don't subscribe to their major services, but the free basic connection that reports the car's status, allows door lock/unlock, and other related features is slow. It also times out a lot when it sits in my garage. It's very unreliable (perhaps, an AT&T problem?)

• This is a common gripe with all EV tires: No grip. I realize that EV cars are designed with efficiency in mind and as a result, the tires aren't the best for performance. I'm not asking for Z-rated tires here (although, that would be fun in a car like this), but I wish someone made a better tire for EVs. With all that torque, it's easy to lose control in sport mode if you're not careful. All that torque probably wears out the tires quickly too.

My family is now ready for a 2nd EV. There are lots of options now with bigger batteries. Maybe something will change my mind soon about how good the Bolt is - but for now, the Bolt is badass.

Euler Project problem 3 took me way longer than I expected. While I am not a real programmer, I thought I was good enough to script this in bash quickly. My life as an IT guy requires me to have some knowledge of scripting and I thought I was good enough to pound this out quickly. It took some time. In the end, I realized that there was a simple and elegant way to get the correct result. If you want to just skip to it, here it is: https://github.com/leonowski/euler-practice/blob/master/euler3.sh

My first approach was really like a brute force method. I made a function to check if something was a prime number and made another function to get the square root of a number (I checked if numbers 2 through the square root were evenly divisible). I then made an array of all numbers evenly divisible into the input number. It looked like this:

#lets make an array to get divisibles first
array=()
for x in $(eval echo "{1..$1}")
do
  if [[ $1%$x -eq 0 ]];
    then
    array+=("$x")
  fi
done

After I got that array, I would then pull out only the primes into a new array. I would use the function I made previously to verify if the number was prime. It looked like this:

#now lets filter out the divisible array and keep only primes
primearray=()
for z in "${array[@]}";
  do
    if [[ $(primecheck "$z") -eq 1 ]];
    then
      primearray+=("$z")
    fi
  done

Finally, I would just print out the last number in the new prime only array like this:

printf '%s\n' "${primearray[-1]}"

And that did work. But it was freakin slow. On top of that, it wouldn't take the input of the number that the Euler problem wanted me to use:600851475143.

I scratched my head during my free time. My next idea was to abandon the use of arrays. Why not just loop backwards from the input to 1 and stop when we find even divisibility AND have a prime number?! So, I dropped the whole array approach and just made 1 for loop like this:

for x in $(seq "$1" -1 1)
 do
   if [[ $1%$x -eq 0 && $(primecheck $x) -eq 1 ]];
   then
   printf '%s\n' "$x"
   break 2
  fi
done

Technically, this was better. I didn't have to go through a set of numbers twice. I was able to calculate prime factors a little faster, but it still wasn't that fast and I still couldn't use the actual number the problem wanted me to use. AARGH!

My next thought was to optimize the loop by immediately skipping the primecheck() function on numbers that were obviously not prime - numbers ending in 0,2,4,6, and 8. So, I added this check before the mod 0 and primecheck:

for x in $(seq "$1" -1 1)
 do
   lastdigit="${x: -1}"
   if [[ "$lastdigit" -eq "0" ]] || [[ "$lastdigit" -eq "2" ]] || [[ "$lastdigit" -eq "4" ]] || [[ "$lastdigit" -eq "6" ]] || [[ "$lastdigit" -eq "8" ]]; then
   continue

   elif [[ $1%$x -eq 0 && $(primecheck $x) -eq 1 ]]; then
   printf '%s\n' "$x"
   break 
  fi
done

This also gave a speedup again. But - you guessed it, still no luck with:600851475143.

I battled some flu symptoms while thinking about this in my head. I then thought about trying to figure out prime factors by hand. I had actually forgotten how to do this by hand - it's actually really simple. Starting at 2, see if you can evenly divide the input number by 2. If you can, great - write it down. Try 2 again against the answer of the previous try (the input divided by 2). If it still works, write it down again. Try 2 again against the answer of the previous try (the input divided by 2 divided by 2) - if it doesn't work, try 3 against the answer of the previous try. If 3 works, write that down. If it doesn't, continue to 4. Continue this until all the numbers you have written down multiplied by each other equal your input number.

Some examples:

Input: 12345
Factors: 3 x 5 x 823

Input: 123456
Factors: 2 x 2 x 2 x 2 x 2 x 2 x 3 x 643

Input: 22
Factors: 2 x 11

Input: 123
Factors: 3 x 41

A pattern began to show. The last number is always a prime! While in my medicated/woozy state, I wrote down my thought on a new loop (using arrays again) to get what I needed. It turns out being away from my computer really helped. Doing things by hand can really make things simple for the brain.

So, the script simply looked like this (no more prime checks):

factors=()
current=$1
for x in $(seq 2 1 "$1")
do
  if [[ $current%$x -eq 0 ]]; then
  factors+=("$x")
  current="$current"/"$x"
  x=$x
  fi
done

printf '%s\n' "${factors[-1]}"

This seemed to work really well! I was like "holy crap!" - but there was still a problem. I couldn't use the input number that the Euler project wanted me to use:600851475143. I was REALLY starting to hate that number. In fact large 6+ digit numbers all seemed slow.

After running through this in my head, I realized that the entire loop had to be run from 2 through the input number. So, the bigger the input number, the longer it would take. It shouldn't need to keep going once you have all the factors in place to equal the input number. So, I added something in the loop to keep track of it:

mul=1
  for i in "${factors[@]}"; do
    mul=$(( mul * i ))
    done
#    echo $mul #uncomment to see progress of check done before break
    if [[ $mul -eq $1 ]]; then
    break
  fi

What this did was print out the current state of the array if you multiplied all the values. Once it got to the input number, the loop could stop. Done - you have your prime at the end of the array. This improvement also worked well. I even had something in there to print the progress of the array multiplication. Things were now SUPER FAST! But - GUESS WHAT AGAIN!? I still couldn't use the 600851475143 number. I was almost ready to scream.

I tried to run it again with 600851475143 and realized that my "echo $mul" wasn't even showing any progress. Surely, it would have hit 1 number at some point that was evenly divisible. I suspected that the number 600851475143 was just way too big for what I was running this on and the for loop would never run on that big number (I was running this in Cygwin64 on Windows). Maybe this isn't a problem in a real linux environment? I then started experimenting with the main loop. I realized that if I changed the upper range of the for loop to a hard number (instead of the variable input like 600851475143), I could get my answer for 600851475143! The answer was 6857, so if I put 7000 as the last number in the loop, things worked! So, finally, I thought about doing a loop that didn't depend on a definite number range. The answer was to simply use a while loop! I could initialize the counter at 2 and count up indefinitely without specifying the upper number! So, the final work looked like this:

factors=()
current=$1
x=2
while [[ $x -gt 1 ]]
do
  if [[ $current%$x -eq 0 ]]; then
  factors+=("$x")
  current="$current"/"$x"
  x=$x
  mul=1
  for i in "${factors[@]}"; do
    mul=$(( mul * i ))
    done
#    echo $mul #uncomment to see progress of check done for break
    if [[ $mul -eq $1 ]]; then
    break
    fi
  fi
x=$((x+1))
done


#largest prime factor should be last element in the factors array
printf '%s\n' "${factors[-1]}"

YES! That worked! No more hard coding a for loop range! I'm sure this problem would be easy for a seasoned programmer, but it was actually fun for me to go through this and struggle.

UPDATE

OK, while the above did work for the project euler number, the script seemed to be broken for some other numbers. I took a closer look and I was incrementing the loop at the wrong time. I also made the break just print it out right there. Here is the final best version (I promise!):

factors=()
current=$1
x=2
while [[ $x -gt 1 ]]
do
  if [[ $current%$x -eq 0 ]]; then
  factors+=("$x")
  current="$current"/"$x"
  x=$x
  mul=1
  for i in "${factors[@]}"; do
    mul=$(( mul * i ))
  done
#    echo $mul #uncomment to see progress of check done for break
    if [[ $mul -eq $1 ]]; then
    printf '%s\n' "${factors[-1]}"
    exit
    fi
  continue
  fi
x=$((x+1))
done

Of course getting laid off sucks! Duh, right? It bruises the ego and makes you question your own abilities. I was laid off recently about a month ago. Ouch. I went through the usual range of emotions. I read multiple articles on how to dust yourself off and get back up on that horse. I've had setbacks before - this is nothing, right?

Well, this isn't a post about how things are different. The cliches and stories out there are true. Dust yourself off and get going again. No one is going to feel sorry for you. This lay off was a kick in the pants that I needed. At some point, a well-paying job where you aren't challenged isn't good. Things that are worth it are always hard.

So, with that in mind - I thought I would try to run through Project Euler problems using only Bash. Yikes! The goals being:

1. Refresh my shell scripting skills.
2. Improve my thinking skills.
3. Do something hard.

I actually skimmed through the problems quickly and thought to myself, "these should be easy!". Well, I'm writing this post after doing the first 2. While the idea of how to run through these things seemed easy in my head ("pseudocode"), getting the syntax right in Bash and remembering what is possible seems to be a challenge. Fortunately, I found a neat tool called ShellCheck:

https://github.com/koalaman/shellcheck

They also have a neat web-based version:

https://www.shellcheck.net/

This tool helps you format your shell scripts properly. It can even tell you if certain things will only work for certain shells (bash, zsh, etc.) and how to make them more generic so they work in all shells. Very neat stuff.

I'm going to keep a copy of the scripts in this repo:

https://github.com/leonowski/euler-practice

Feel free to mock my approach/style. Any criticism will help me in the long run. This is why getting laid off no longer sucks for me. Challenges are fun. Discovering new tools (to me anyway) is fun. Discussing opportunities with old co-workers, friends, and potential new employers is fun. It took getting laid off to remind me.

I ran across this neat idea on Random Nerd Tutorials that is basically a way to make your own Amazon Dash button with a customizable action. While you can certainly get your own Amazon Dash button and hack it for your needs, this solution uses a simple ESP8266 module and a small Arduino sketch.

The code is available here.

In most of my blog posts, I mention the use of Espurna - but with this, it's so simple and beautiful. You only need a small sketch to do this. The idea is:

1. Place the ESP8266 in DeepSleep mode all the time.
2. On a reset (waking up the device), connect to Wi-Fi and make an HTTP request.
3. Go back to DeepSleep.

I decided to give it a try. I took a look at the sketch first and saw that the setup function immediately put the device into sleep after connecting via wifi and making the HTTP request (the original post on Random Nerd Tutorials is how to make this run an IFTTT action).

void setup() {
  Serial.begin(115200); 

  initWifi();
  makeIFTTTRequest();

  // Deep sleep mode until RESET pin is connected to a LOW signal (pushbutton is pressed)
  ESP.deepSleep(0);
}

The main loop function does nothing.

void loop() {
  // sleeping so wont get here
}

And that's it. So, you simply wire up a button to the ESP8266 reset pin and every time the thing resets, it connects via Wi-Fi and does an HTTP request. Simple and brilliant. Usually, you would run something in the main loop - it never occurred to me to NOT run anything in there and use DeepSleep. The deep sleep feature in the 8266 makes running off a battery viable as it sips on a little juice at a time.

As you can see in the chart, only the RTC is running in this mode. So, it sips about only 20 microamps! I confirmed this on my little USB tester.

I actually thought something was wrong with my tester as I had expected to get some reading above 0. It wasn't until I read the specs saying it would draw around 20 microamps. So, "0.00" is about right. :)

So, I wanted to try this with something in my home. I set up a script to toggle my light and exposed it via vutil. I posted about vutil previously here. After exposing the light control via HTTP, I just needed to alter the sketch a bit.

In the makeIFTTTRequest() function is a simple HTTP GET. I need to change it to do an HTTP POST. So, the request now looks like this:

Serial.print("Request resource: "); 
  Serial.println(resource);
  client.print(String("POST ") + resource + 
                  " HTTP/1.1\r\n" +
                  "Host: " + server + "\r\n" + 
                  "Accept: */*\r\n" +
                  "Content-Length: " + content.length() + "\r\n" +
                  "Content-Type: application/x-www-form-urlencoded\r\n" +
                  "\r\n" +
                  content +
                  "Connection: close\r\n\r\n");

The sketch variables at the top need to be changed for webserver and resource. webserver should be the IP where you want the HTTP POST to hit and resource should be the REST API endpoint (for vutil, that's "/execute/command"). You also need a new variable for the content that will eventually get posted. I named it content. So it looks like this now:

// Replace with your unique URL resource
const char* resource = "/execute/command";

// the webserver
const char* server = "192.168.1.4";

//the POST content
String content = "command=sh toggle_light.sh 11";

And since we are now using String, we need to include the String library at the top:

#include <String.h>

After that, compile and upload to your ESP8266. I have a cheap setup to easily boot or reset my ESP8266 and power it from a 5V source. Please ignore the lousy soldering job.

Here's a video of me trying it out on my prototype board. I don't have an actual button wired up, but I just connect the wires connected to RESET and ground (pull low) to simulate a button press.

It works great! If I monitor the serial connection while doing this, I can see what's going on.

Connecting to: MYWIFISSID........
WiFi connected in: 2201, IP address: 192.168.1.129
Connecting to 192.168.1.4
Request resource: /execute/command
HTTP/1.1 200 OK
Content-Type: application/json
Content-Length: 51
Date: Tue, 13 Feb 2018 09:05:36 GMT
Connection: keep-alive

{"pid":17132,"output":"{\"ResponseValue\":\"OK\"}"}

So, it connects to Wi-fi, gets an IP, does the HTTP POST, gets a response, disconnects, and then it goes back to deep sleep (that's not reported in serial output, but you can print something out in the sketch if you really want to). You could expand this to practically anything via HTTP or something with the GPIO. The best part is you can run this off a battery since it sips so little juice in DeepSleep.

Thanks to the folks at Random Nerd Tutorials for teaching me something neat tonight.

HomeGenie is what I have been running for my Home Automation needs. It does a lot, but I mainly chose it for these features:

• Z-wave support.
• Multi-platform. It's an app coded in C# and packages are built for all flavors of servers/arches including Windows/Linux and x86/arm (running with mono).
• Support for generic IP cameras.
• API to interact with devices.
• A great Android interface app

The developer Gene is also pretty responsive to bug reports and feature requests.

With all of that said, I am in the middle of a transition to another home automation called Home Assistant I'll talk about this more in a minute, but let's take a look at HomeGenie first.

Since the server can run in mono, I run it on a Raspberry Pi. To control Z-Wave devices, I use a simple USB Z-wave stick like this. And with just those 2 pieces, this thing is already pretty powerful.

This is how the Raspberry Pi 3 looks with the Z-wave USB stick. The dust is not necessary.

A screenshot of the Android interface customized for a room in my house.

Once you get it going, it's a simple matter of configuring it via the web GUI. You can add new modules (switches, cameras, sensors, etc.) all via the GUI.

Screenshot of HomeGenie switches.

To get things to work with Alexa, I use the ha-bridge I mentioned in a previous post. HomeGenie provides a simple API to get the status of switches, turn them off/on, or even dim (if the device supports dimming). For example, I can turn a switch with Z-wave identifier 24 by doing an HTTP GET on this endpoint:

http://host:8080/api/HomeAutomation.ZWave/24/Control.On

You would simply plug that into ha-bridge under the "On Items" section. To dim, the endpoint would look like this:

http://host:8080/api/HomeAutomation.ZWave/24/Control.Level/${intensity.percent}

You would plug that in the "Dim Items" section of ha-bridge. "intensity.percent" is a variable that is determined by the number you tell Alexa. So, for example, you can say "Alexa, dim the lights to 30%" and the number 30 will be used by ha-bridge making the final endpoint:

http://host:8080/api/HomeAutomation.ZWave/24/Control.Level/30

Since you can control it via HTTP, you can also use curl to script some actions. Here is a simple script I use to toggle the state of any light:

#!/bin/bash

get_status() {
curl --silent http://host:8080/api/HomeAutomation.HomeGenie/Config/Modules.Get/HomeAutomation.ZWave/"$1" | jq '.Properties[] | select(.Name == "Status.Level") | .Value'
}

turn_off() {
curl --silent http://host:8080/api/HomeAutomation.ZWave/"$1"/Control.Off
}

turn_on() {
curl --silent http://host:8080/api/HomeAutomation.ZWave/"$1"/Control.On
}


get_status "$1" | grep 0 && turn_on "$1" || turn_off "$1"

Just use the Z-wave switch identity number as an input parameter. BTW, the script above uses jq to help me take the JSON output of the API and mangle it for my needs. I could probably post something later about how much I love to use jq. If you haven't used jq before, I encourage you to try it. It's neato burrito.

A New Challenger Has Entered the Ring

While I do love HomeGenie, I do plan on switching to something new and exciting called Home Assistant. Development is hot and heavy at Home Assistant and they support A TON OF devices. It seems like they have a release every week with more and more support for new and neat things. I had looked into Home Assistant some time back, but the end-user interface didn't seem as "nice" as HomeGenie's. That is quickly changing. I am able to run Home Assistant now in a docker container to test things out. One of the neat things that Home Assistant supports is the idea of a "Command Line Switch." This lets you control practically anything that is accessible from a command line. This allows me to control my existing HomeGenie setup from Home Assistant.

A screenshot of the Home Assistant user interface. This is probably old by now and they do have themes and a newer UI in the pipeline.

Home Assistant also has an Alexa/Hue Phillips emulator built-in so it negates the need for ha-bridge. If I had to pick a winner, I would say Home Assistant is starting to pull away.

One Last Thing - HomeKit Support

We have some Apple users in my household. There is no iOS app for the HomeGenie interface and the web interface is too slow to run on mobile well. I found this neat NodeJS server app that emulates the iOS HomeKit API called homebridge. Homebridge has a ton of plugins to integrate devices with HomeKit. A simple search on npmjs.com can list these plugins. There is one particular plugin that takes your configuration from home assistant and puts it nicely in homebridge. It's called homebridge-homeassistant.

A screenshot of HomeKit support for iOS users in my household.

It works well for my needs. Even voice control with Siri works. But, things are a bit "rube goldbergy" - I have 3 servers running just to do all of this:

HomeGenie <--> Home Assistant <--> Homebridge

Once I switch over to Home Assistant, that should make things a lot simpler. I hope. :p

Most of the motivation behind my projects comes from being cheap. There are usually easy solutions out there to problems I want to solve, but they are expensive. For this blog post, I want to talk about my pool pump. (and yes, Alexa will be mentioned in this post - again!)

Most pool pumps out there use a mechanical timer to start and stop the pump at a set period of time. The common one found in most equipment boxes is made by Intermatic.

That's a shot of my timer in my equipment box. It's a solid device. I have only had to replace 1 minor part in 10 years (the motor for the timer in the back). It uses a couple of metal trippers labeled as "on" and "off" to push that orange lever to the right and turn on the system. While it is solid, it's very basic. It turns off, it turns on, it keeps time. I can't do anything with it beyond that and it's not hooked up to my "smart home."

There are solutions out there like these:

https://www.amazon.com/Aeotec-Security-controller-electricity-consumption/dp/B00MBIRF5W

https://www.amazon.com/dp/B00YTCZZF0/ref=asc_df_B00YTCZZF05359821

But, they are way too expensive. I am a fan of Z-wave (in that picture above, I actually use a Z-wave switch to power my pool lights), but there is a cheaper way to do this. Just like my cheap wall sconces, we just need a few cheap items:

• ESP8266 powered device like my favorite, NodeMCU: https://www.amazon.com/Communication-Wireless-Interface-Internet-Development/dp/B01ISYTADW/ This is a great device as it has everything integrated: a serial to USB port, headers pre-soldered, reset/flash buttons, and a 5v/3v regulator. You can find them really cheap if you buy direct from China too at ~ $3.00 or so. A Raspberry Pi Zero W works well too, but ESP8266 devices are cheaper and smaller.

• A couple of solid state relays. These worked well for me: https://www.amazon.com/gp/product/B00RHBEDJE These are high amp (40) relays. I need 2 because my pool pump, chlorinator, and heater are powered from a 2-pole 30-amp breaker. So, each leg is split into 15-amps and each leg goes into 1 relay. The trigger for the relay can be as low as 3v, which is perfect for GPIO output signals.

• My favorite software to run ESP8266 devices, Espurna (FREE!)

This all works for under $30.

The wiring is simple. Feed one line from the breaker into the relay's switching terminal (the line). The other terminal outputs to your equipment (the load). When the relay is activated, the line will power the load. To trigger the relay, we attach the GPIO signal from the ESP8266 to (+) on the input. The common/ground is attached to the (-) side.

Here is an ugly shot of things wired up, but before I put it neatly in the box.

The software/firmware is configured just like how it's described in my cheap sconce post. The difference here is to configure 2 relays in the hardware.h header file. I chose to use GPIO 15 and 16, so the relay definitions look like this:

    // Relays
    #define RELAY1_PIN          16
    #define RELAY1_TYPE         RELAY_TYPE_NORMAL
    #define RELAY2_PIN          15
    #define RELAY2_TYPE         RELAY_TYPE_NORMAL

After configuring the basics, I set the Switches to all be synchronized. Both legs of power will always be turned on at the same time.

Before I slapped everything in the box neatly, I gave it a quick test. Forgive the blurry video and my use of the word "Alexa" - alexa isn't in play yet here.

Now, just slap the thing in neatly.

I had a concern about the nodemcu device getting a wi-fi signal in that metal box when closed. After I closed things up, there were no issues.

This solution provides:

• An easy way for my family to turn on the pool pump when they want to go swimming. Since it runs Espurna, I just have Alexa detect it and it can be turned on/off with a simple "Alexa, turn on the pool pump" command.

• I can have multiple schedules for the timer. Previously, I only had 1 set of off/on triggers.

• I don't have to go outside to change the schedule.

• Since it can be controlled via REST API, I could make this pump "smarter" and have it turn off when unnecessary or turn on when the temperatures are high (you need to circulate and chlorinate your water more as temps increase).

After putting this all together, I just realized that I should have wired up a button to toggle the relays at the box. This is if I don't have my phone near me and I want to activate the pump. This should be a simple fix - I just need to make a momentary pushbutton, wire it up, and update the Espurna to take that as an input that toggles the relays. When I get this done, I'll update this post.

So, since I'm trying to blog more, let me share some little neat thing I found tonight. It's called vutil. It does a few things, but the neat thing I found is being able to execute system commands via HTTP requests. So, you can then interface with your computer via simple HTTP POST commands remotely. This is very useful for things like home automation or to run simple commands on your computer remotely.

I tried it out on my Windows system in Cygwin with nodejs installed. It's a simple setup: Clone the repo, cd to the vutil dir, and then create a simple config.json file. If you just want to run the command line feature, the config looks like this:

{
  "activatedModules" : {
    "dbquery" : false,
    "command" : true,
    "csv2json" : false,
    "request" : false,
    "file" : false
  }
}

Finally, just run npm install while in the directory to get the pre-reqs installed. Run the command like this to run it on any port you want:

PORT=8677 node server.js

Now, all you have to do is POST to http://host/execute/command with a single body parameter named "command" and the value set to the shell command you want to run. I tested a shutdown in Windows like this:

curl -d "command=shutdown /s /t 7200" -X POST localhost:8677/execute/command &

And... it worked!

Since it's running in Cygwin, I can run Cygwin Bash in addition to Windows command-line. Here is me sending "pwd" and the JSON output:

curl -d "command=pwd" -X POST localhost:8677/execute/command
{"pid":6348,"output":"/home/thenoel/vutil\n"}

If you read my last few posts - I bet you know what I'm going to say next: ALEXA! (yes, I love her. yes, I would marry her if I could). I mentioned in the Control Practically Anything with Alexa post that the ha-bridge can output HTTP requests. Using vutil, you could have 1 consistent way of interacting with your machines at home (instead of some using SSH, some using EventGhost, some using xyz). For you Google Home users out there, I bet there is a way to configure it so that voice commands translate to HTTP requests. But again, I'm in love with Alexa - so who cares about Google Home? (just kidding - maybe....)

Oh - one other thought: Tasker on Android! Tasker lets you send HTTP requests that can be triggered by tons of events including voice. That would be neat to use with this.

With all this said, you probably don't want to run this anywhere important. It doesn't have any built-in security (it's only restricted by the user context that node is running with), but you could reverse-proxy it with ngnix and turn on authentication + SSL. If you want to expose this outside your home network, that's probably what you should do.