Da Post

Final Project - The Morning Routine

Thu, 12 Dec 2019 00:00:00 GMT

Objectives

The purposes of this lab are to:

Automate my morning using Alexa to have her do the following
- Start playing music
- Tell me my calendar for the day
- Turn on my living room light to help my house wake me up
Build a novel way to see what the weather is going to be like and have it also suggest what I should wear

Materials

The materials used for this lab were

Personal computer (For programming the Arduino)
Personal smart phone (For configuring Alexa)
Smart bulb of your choosing (As long as it integrates with Amazon Alexa)
Apple Music account
Kasa Account (or whatever account is required for your smart bulb)
1 x Echo Dot (or other Amazon Alexa capable device)
1 x ESP8266 Wemos D1 Mini (Microcontroller)
1 x Breadboard
1 x USB -> MicroUSB cable for power and flashing the microcontroller
3 x LED lights
10 x Female to male jumpers
4 x Male to mail jumpers
1 x OLED Arduino screen
1 x Cardboard box to store it all in

References

Procedures

Setting Up Alexa

Plug in your new Echo Dot (or other device)
Download the Alexa App (iOS or Android)
Select Devices on the lower right hand corner
Press the ➕ in the top right of the screen and select Add Device
Select Amazon Echo from the list
Select your model (in my case it is an Echo Dot)
- I then select 3rd generation because that’s the one I have. Feel free to select whichever version you purchased
Now follow the directions on the screen to pair your new device!

Setting Up a Routine

Here we are going to set up two different routines: one that starts the morning off and one that ends the morning. The one to start it needs to read you what is going on that day (according to the calendar that we will add), turn on the living room smart light, and start playing some music. The ending routine should stop the music and turn the living room light off in preparation of us leaving the house.

Before we can start adding routines, we need to make sure that we have all of the devices and skills we need added to the app
- Note: A skill is simply an integration with another app or service that Alexa can then use
First, we’ll set up our Apple Music
- Click on the hamburger menu in the top left of the screen and select Skills & Games
- Click the 🔍 icon in the top right hand corner and search for Apple Music
- Click on the Apple music skill and click on the Enable to use button
- Now it will prompt you to login with your AppleID. Do this and the skill is activated and ready to use!
- You can test this by saying “Alexa, play music form Apple Music”
- At this point, you can also make it so that whenever Alexa is asked to play music, she plays it from Apple music by default. You can do this by going to the left hand menu and selecting Settings and go to Music & Podcasts > Default Services. Here you can set what you would like your defaults to be.
Second, we’ll set up Google Calendar
- We are going to add this skill a little bit differently. This time, we want to go to Settings > Calendar & Email and select Add Account
- Select your account type
- Follow the on screen instructions to sign into your account and like your calendar to Alexa. You can also add your email at the same time
Lastly, we’ll add in our smart light
- Go to Devices in the bottom right hand corner
- Press the ➕ in the top right of the screen and select Add Device
- Select Light > [Your brand name]. I am adding a TP-LINK Kasa light
- You will then most likely be prompted to set up your device in the lights proprietary app. Do this and then come back to the Alexa app and click discover devices
- Your device should be found and you can click add. It will then give you some options on naming the light and such

Now, we’re ready to set up our routines! We’ll start with our morning start route

From the Alexa app, click on the hamburger menu on the top left of the screen and select Routines
Click the ➕ in the top right hand corner to add a new routine
Add a routine name (I just selected Morning Start)
Add a When this happens
- I chose Voice and said when Alexa hears: “Alexa, good morning”
Now it is time for the meat of the routine: the actions. First we will add an action to set the volume Alexa should speak at in the mornings
- Select Add Action > Device Settings > Volume and set the volume you want Alexa to be at in the morning
Next, we want Alexa respond to our good morning
- Select Add Action > Alexa Says > Customised. Here you can tell Alexa to say whatever you want her to in response to your “good morning”
Next, we want Alexa to turn on our smart light
- Select Add Action > Smart Home > [The name of your light] and click next
- Choose Power and make sure the switch is On and click next
- Done!
Next, we want Alexa to read us the calendar
- Select Add Action > Calendar > Today's Calendar
- Click next and you’re all set up!
Finally, we need to set up Alexa to play Apple Muxic
- Select Add Action > Music
- Fill out form and select what you want Alexa to play

Now, we will set up the Morning end routine that will run when we leave the house in the morning

From the Alexa app, click on the hamburger menu on the top left of the screen and select Routines
Click the ➕ in the top right hand corner to add a new routine
Add a routine name (I just selected Morning End)
Add When this happens
- I chose `Voice and said when Alexa hears: “Alexa, goodbye”
Now time for the actions! First we will add and action to have Alexa respond
- Select Add Action > Alexa Says > Customised. Here you can tell Alexa to say whatever you want her to in response to your “goodbye”
Next, we want Alexa to turn the music off
- Select Add Action > Device Settings > Stop Audio
- Select the device to stop
- Click next to confirm
Finally, we want Alexa to turn off the light
- Select Add Action > Smart Home > [The name of your light] and click next
- Choose Power and make sure the switch is Off and click next
Your Alexa and routines are all set up! Give it a test by saying “Alexa, Good Morning” and then, “Alexa, goodbye”

Setting up The Weather Caja™

The Weather Caja™ is a box that will help me know what I need to do in the mornings. It will read out the forecast for the day and let me know what the current temperature, low temperatures, and high temperatures for the day are. It will do this using and OLED screen and 3 LEDs all run by an ESP8266 microcontroller.

Wire up your OLED screen to your ESP8266 using the following diagram
- D1 is the I²C Clock Pin
- D2 is the I²C Data Pin
Wire up your 3 LEDs to D5, D6, D7 pins
Use the code from previous labs to connect the ESP8266 to the internet, specifically WiFi

Initialize the display using the following code

#include <SPI.h>
#include <Wire.h>
#include <Adafruit_GFX.h>
#include <Adafruit_SSD1306.h>
#define SCREEN_WIDTH 128
#define SCREEN_HEIGHT 64
#define OLED_RESET     -1
Adafruit_SSD1306 display(SCREEN_WIDTH, SCREEN_HEIGHT, &Wire, OLED_RESET);

After you have initialized the display begin communication in the setup() function with the following code

if (!display.begin(SSD1306_SWITCHCAPVCC, 0x3C)) {
  Serial.println("[OLED]\tSSD1306 allocation failed");
  for(;;);
}

Now you can write to the display using the following code

display.clearDisplay();
display.setTextSize(1);
display.setTextColor(WHITE);
display.setCursor(0,0);
// Display static text
display.println("[Your Text]");
display.display();

Now you can write to the screen.
Next, you should use the http client from ESP8266 to get the weather from any API you would like
Use the ArduinoJson library to parse the JSON payload.
Based on these values from the API, you are able to turn on and off certain lights if the clothes you need to wear need to be lit up
Now, you have everything set up for your very own Weather Caja™. You just need to put it all in a box and make it look nice!!

Certification of Work

I certify that the solution presented in this lab represents my own work. In the case where I have borrowed code or ideas from another person, I have provided a link to the author’s work in the references, and included a citation in the comments of my code.

— Matthew Robertson

Appendix

Appendix 1: DIAGRAMS

Alexa Logical Layout 1

Alexa Logical Layout 2

Appendix 2: Configs

Morning Start Routine

Morning End Routine

Appendix 3: Demo and Images

Weather Caja™ Image

Appendix 2: Code

Available on GitHub

Lab 5 - Home Assistant

Mon, 02 Dec 2019 00:00:00 GMT

Objectives

The purposes of this lab are to:

Install an open source home automation platform
Interface this platform via MQTT with your various devices
Use Home Assistant to monitor the state of the garage door, and whether the car is parked in the garage.

Materials

The materials used for this lab were

Personal computer (MacBook Pro)
3 x ESP8266 Wemos D1 Mini (Microcontroller)
3 x USB -> MicroUSB cable for connecting the Microcontroller to the computer
3 x Breadboard
1 x Stop light LED component with built in resistors
1 x Hypersonic distance detector
1 x Magnetic door sensor
9 x Male to male jumper cables
1 x Raspberry Pi 3

References

Procedures

Download Hassio Home Assistant onto the Raspberry pi using the following instructions:
- https://www.home-assistant.io/getting-started/
Next, you will need to make sure that you set up the network correctly. For me, I wasn’t able to get the suggested USB network configuration file to work. Instead I used the nmcli approach.
- First login to hassio with the command login after bootup (using root as the username)
- Use the following command to see if the ssid you’re going to try and connect to exists
```
nmcli con show
```
- Use the following command to delete that connection if it exists and make sure that you are starting from scratch
```
nmcli con delete <SSID>
```
- Use the following command to (re)add the new connection
```
nmcli dev wifi connect <SSID> password <password>
```
- Start up the new connection
```
nmcli con up <WiFi Name>
```
Now you can connect to your new Home Assistant instance at the IP address it has or if you have mDNS discovery on your network you can go to `http://hassio.local:8123
Once you are connected to Home Assistance, you need to install the MQTT Add On
- Go to the Hass.io Page and select the Add On tab
- Search for MQTT
- Click on the mosquitto broker and install it
- Go to Configuration > Users and add a new username and password for the user that will be used to connect all the ESP-8266
Rewrite all of the Arduino code to connect to the new Home Assistant MQTT broker. After you have done this, remove all the logic from the stop-light that decided on what light it should be set to. This logic is going to be moved into home assistant using automations. You will need to add the following line to each of the setup functions of each Arduino.
```
client.connect((char*) device_id.c_str(), "[username]", "[password]");
client.publish("homeassistant/sensor/garage/[dev_name]/config", "{\"name\": \"[Device Name]\", \"state_topic\": \"/[Publish Topic]\"}");
```
Now that you have all of your devices registering themselves with home assistant you are ready to create your dashboard. You can do this by going to the Overview and click the edit button (it is a pencil).
- You will then go to the add FAB at the bottom to add a card.
- Select sensor and select the 3 entities: door, distance-sensor, and stop-light
- Now you will be able to see the state of these three different entities.
Now it’s time to add the logic to actually make the stop light work again. As previously stated, this logic is now going to be in Home Assistant. That means that we are going to need to add a hand full of automations. You should put an automation that will trigger on the mqtt topic of the distance sensor but only if the door sensor is open.
Once you have these automations up and running, you’ll need to then set up some kind third party automation. I chose to use IFTTT to make it so that I would get a notification if the Garage Door was left open too long.
To set up IFTTT, you need to do the following
- Register with an IFTTT account on https://ifttt.com
- Add webhook Applet and configure it to send a notification on the webhook of the garage door being left open
- Then add an automation in Home Assistant that will hit that webhook on the trigger of the garage door being open for 10s and there is no change in the stoplight.
Now you have a home assistant client that is set up to correctly change a stoplight and will send you a notification if your garage door has been left open for too long.

Thought Questions

Which version of Home Assistant did you choose to install? (Docker-based Hass.io, Raspbian-based Hassbian, or install it yourself?) Why did you choose this particular version?

I used the Raspbian based Hass.io image. I used this because I was familiar with the installation process. I did try the .vhdx of hass.io but it was having some kernal issues when I was installing it with Hyper-V so I changed to the raspberry pi image.
How should you decide which logic to perform in Home Assistant versus coding the logic directly into the devices? What guiding principles would you establish for future devices?

In my mind it matters most about how quickly triggers need to cause things to happen in the system. In this case, where the stoplight needs to change super quickly as things change then the logic needs to be close to the stoplight. The stoplight should probably have the logic inside of it so it is the most repsonsive. However, if something doesn’t need to be super responsive the logic can be in Home Assistant or the like.
What features do you like the most about Home Assistant?

The feature I like most about home assistant is the automation part. I really like that you can just set arbitrary triggers and have them set something into motion. This seems like it is extremely extendible. I also really like how you can have conditional triggers as well. It makes it so that the integrations can be much larger.
Please estimate the total time you spent on this lab and report.

9 hrs

Certification of Work

— Matthew Robertson

Appendix

Appendix 1: DIAGRAMS

Logical Layout

Appendix 2: Code

Available on GitHub

Lab 4 - MQTT Event Hub – Garage Door Sensor

Tue, 29 Oct 2019 00:00:00 GMT

Objectives

The purposes of this lab are to:

Implement an Event Hub for publish/subscribe notifications between devices
Develop a communications protocol for devices across the event bus
Establish more complex conditions for the actuator involving multiple sensors

Materials

The materials used for this lab were

Personal computer (MacBook Pro)
3 x ESP8266 Wemos D1 Mini (Microcontroller)
3 x USB -> MicroUSB cable for connecting the Microcontroller to the computer
3 x Breadboard
1 x Stop light LED component with built in resistors
1 x Hypersonic distance detector
1 x Magnetic door sensor
9 x Male to male jumper cables

References

Procedures

Set up MQTT server/broker. This can be done by installing it on Linux or Mac using the following guides
- Linux
- MacOS
Set up your Arduino dev environment to work with the ESP8266 Wemos D1 Mini
- Go to Preferences and add the following URL to the Additional Boards Manager URLs field
```
http://arduino.esp8266.com/stable/package_esp8266com_index.json
```
- Go to Tools -> Board: [Some Board Name] -> Boards Manager
- Search for Wemos
- Install esp8266 by ESP8266 Community (Note: this tutorial was made using verions 2.5.2 and does not guarantee that everything will work the exact same in later versions)
- Go to Tools -> Board: [Some Board Name] again and select the following board
```
LOLIN(WEMOS) D1 R2 & Mini
```
- Go to Tools -> Port and select the port that your Arduino is plugged into. (If you have issues on this step, you can find help here)
- Go to Tools -> Erase Flash: and select All Flash Contents
- You are ready to start coding!

Implement WiFi on the 3 Arduinos for 3 different files: stoplight, distance sensor, and door sensor using the example WiFi setup by going to
File -> Examples -> ESP8266WiFi -> WiFiClientBasic

Here are the libraries you’ll need

#include <ESP8266WiFi.h>
#include <ESP8266WiFiMulti.h>

Here is the function to connect to wifi

void connectToWifi(){
WiFi.mode(WIFI_STA);
wifiMulti.addAP(ssid1, passwd1);
wifiMulti.addAP(ssid2, passwd2);

Serial.print("\nConnecting");

while (wifiMulti.run() != WL_CONNECTED){
delay(500);
Serial.print(".");
}
Serial.println();

Serial.print("Connected to ");
Serial.print(WiFi.SSID());
Serial.print(", IP Address: ");
Serial.println(WiFi.localIP());

if (wifiMulti.run() == WL_CONNECTED){
digitalWrite(BUILTIN_LED, LOW);
}
}

You should call the function above in the setup function
```
void setup(){
Serial.begin(115200);
connectToWifi();
}
```

After you have tested that you are able to connect to network, you are ready to start connecting all your devices to your HUB/broker

Use the following code exerpts to set up each device to talk on the event hub

Connect to the correct HUB by initializing a PubSubClient client and create a device name of your choosing

WiFiClient wifiClient;
PubSubClient client("broker-ip-addr", 1883, wifiClient);
String device_name = "esp8266-[whatever name you want]";

Actually run the client’s connection function

while (!client.connected()){
if (client.connect((char*) device_name.c_str())){
Serial.println("Connected to MQTT Hub");
String message = "Distance sensor (" + device_name + ") connected @ " + WiFi.localIP().toString();
client.publish("[topic name]", message.c_str());
client.subscribe("[topic name]"); // only if you are going to subscribe to any topic
} else {
Serial.println("Connection to MQTT failed, trying again...");
delay(3000);
}  
}

Check at the beginning of each loop to make sure that you’re still connected and try and reconnect if not. If we are connected, we will run the clients loop inside of our loop
```
void loop(){
if (!client.connected()){
reconnectToHub();
}
client.loop()
```

You can test no that each of your devices connect since they will all publish their IP to the hub. You can subscribe on the command line of the mosquitto broker to see all their connections come through with the following command
```
mosquitto_sub -t [topic-name] -v
```
Once you have confirmed that all of your devices are correctly talking to the HUB let’s get the door sensor, the simplest sensor, up and running
- Set up sensor by attaching one pin of the sensor to a pin, I used D6, on the Microcontroller. It doesn’t matter which one you connect as either one will work for the sensor’s circuitry. Connect the sensor’s other pin to ground. Now that the sensor is connected we’re ready to hook it up in the code
- To do this you will want to make the pin type INPUT_PULLUP. This should be done in the setup() function. You can initialize the pin, D6 in this case, using the following
```
pinMode(D6, INPUT_PULLUP);
```
- Now all you’ll want to do is watch to see if the pin changes from high to low of vice versa. Once it changes, you should publish this change onto the hub to tell everyone subscribed that the door status has changed. It is also worth while to send out a periodic status of the door in case any node connects in between state changes they can still get the current status.
Next we will want to set up the distance sensor. To do this, we will need to set up the same code as in Lab 3. This will send out a hypersonic frequency and determine how far something is away based on the frequency that comes back. To do this, we will need to do the following
- Initialize each pin in the setup function. The trig pin or trigger pin should be an OUTPUT pin and the echo pin should be an INPUT pin
```
pinMode(trigPin, OUTPUT);
pinMode(echoPin, INPUT);
```
- Next, on every loop we should send out a frequency and listen for the response. With this response, we can determine the distance the object in front of the sensor is using what we know about the speed of sound. This will look something like this
```
digitalWrite(trigPin, LOW);
delayMicroseconds(2);
digitalWrite(trigPin, HIGH);
delayMicroseconds(10);
digitalWrite(trigPin, LOW);
duration = pulseIn(echoPin, HIGH);
distance = duration * 0.034 / 2;
```
- Using this distance, we can publish the current distance away something is based on the sensor’s reading. To do this you should use the client.publish([topic], [message]); function. I chose to do this every second so that any given point anything subscribed to the distance should have a pretty accurate reading of the distance.
Now that we have our two sensors publishing to the event hub, we can consume that data to determine what color our stoplight should be. The basic idea is that a stoplight should be off if the garage door is closed (i.e. the door sensor reads closed) and on if the garage door is open (i.e. the door sensor reads open). The color of the stoplight should be determined by the distance sensor using the following ranges (NOTE: All numbers are computed using the above distance algorithm and are measured in cm)

RED: < 15 and >= 5

YELLOW: < 25 and >= 15

GREEN >= 25
- You’ll notice that there is a hole in these ranges of less than 5. This is because when the distance reader is less than 5, the stoplight should flash red indicating that the car has gone too far and should back up.
The stoplight should subscribe to the topic for the distance sensor and for the door sensor. This way, it will be able to know when there are changes and change accordingly.
That’s it! You now have a stoplight that will change colors based on an objects distance and only function when the garage door is open. It also functions without using any kind of web server architecture! How amazing right?!

Thought Questions

How does the communication between devices change with the shift to using an event hub? How does this facilitate greater scalability? What things did you do to learn to use MQTT?

Things no longer have to worry about staying up to date with everything via requests. Now, everything just listens to exactly the information they need and acts upon it accordingly. This infrastructure scales so much nicer. You are able to set up an infrastructure where things will publish and subscribe how you set up. Then, at a later date, there is no issue with adding something that will continue to consume the data that is already being published. Furthermore, if you add another sensor of some kind, the configuration can already be in all the devices to listen to that topic even before that sensor is put into place. I read a few posts about the idea of what MQTT was and why is was important. Most of my learning came from implementing the library PubSubClient into my devices. As well, I spent a little bit of time having 3 or 4 terminal windows open and publishing and subscribing from them. This helped me easily see in real time what was going on the event hub.
What are strengths and weaknesses of the direct communication between the sensor and actuator? What are strengths and weaknesses of the event hub? Which do you feel is better for this application?

I feel there are many strengths with this direct communication. I am able to easily know when something is updated for one or many devices. One weakness I found having to think differently about was the fact that requesting information isn’t where this direct communication shines. It was awkward at first when I was thinking of how to get some of the information because I kept thinking of it as a request/response system which is not how this should be architected. I do think that there are some cases where the request/response architecture still has its merit. I loved the event hub. I thought that being able to just spit information into the system and anyone can access it is absolutely incredible. It made connecting multiple devices a breeze. I feel that MQTT is hands-down the better solution for this application. I think that the ability to have the distance and door sensors information available to anyone who desires it makes this application run smoothly and be super scalable.
What was the biggest challenge you overcame in this lab?

The biggest challenge for me in this lab was learning how to respect the event hub as an event hub and not a different version of a web server. My mind kept reverting to the web server way of thinking for every little problem to solve and this was not the best way to go about things. Once I got into stride with thinking about the event hub for what it truly was, I was able to come up with much better and more practical solutions. I ran into a few other hiccups here and there with my logic in my stoplight. But overall, my biggest challenge was definitely figuring out how to holistically think differently.
Please estimate the total time you spent on this lab and report.

5 hours

Certification of Work

— Matthew Robertson

Appendix

Appendix 1: DIAGRAMS

State Diagram

Logical Layout

Appendix 3: Code

Available on GitHub

Lab 3 - Arduino Stop Light w/ Distance Detector 🚦

Tue, 15 Oct 2019 00:00:00 GMT

Objectives

The purposes of this lab are to:

Build an IoT sensor using GPIO pins for inputs
Establish a machine-to-machine (M2M) communication protocol
Design an IoT interaction between a sensor and an actuator.

Materials

The materials used for this lab were

Personal computer (MacBook Pro)
2 x ESP8266 Wemos D1 Mini (Microcontroller)
2 x USB -> MicroUSB cable for connecting the Microcontroller to the computer
2 x Breadboard
1 x Stop light LED component with built in resistors
1 x Hypersonic distance detector
9 x Male to male jumper cables

References

Procedures

Set up stoplight with web server by following Lab 2
Set up your Arduino dev environment to work with the ESP8266 Wemos D1 Mini
- Go to Preferences and add the following URL to the Additional Boards Manager URLs field
```
http://arduino.esp8266.com/stable/package_esp8266com_index.json
```
- Go to Tools -> Board: [Some Board Name] -> Boards Manager
- Search for Wemos
- Install esp8266 by ESP8266 Community (Note: this tutorial was made using verions 2.5.2 and does not guarantee that everything will work the exact same in later versions)
- Go to Tools -> Board: [Some Board Name] again and select the following board
```
LOLIN(WEMOS) D1 R2 & Mini
```
- Go to Tools -> Port and select the port that your Arduino is plugged into. (If you have issues on this step, you can find help here)
- Go to Tools -> Erase Flash: and select All Flash Contents
- You are ready to start coding!
Implement WiFi on the Arduino using the example WiFi setup by going to File -> Examples -> ESP8266WiFi -> WiFiClientBasic
After you have tested that you are able to connect to network, you are ready to start setting your client you will use to send requests to the stop light
Set up your client by first creating the client object by
```
WifiClient client;
HTTPClient http;
```
This will create the objects needed to make an HTTP request

You can make an HTTP request using the following format

if (http.begin(client, [url])){
  int httpCode = http.GET();

  if (httpCode > 0){
    if (httpCode == HTTP_CODE_OK){
      String payload = http.getString();
      Serial.println(payload);
    }
  } else {
    Serial.printf("[HTTP] GET Failed, error: %s\n", http.errorToString(httpCode).c_str());
  }
  http.end();
} else {
  Serial.println("[HTTP] Unable to connect");
}

After you have your function that will make your HTTP request to change the light, you will need to make sure that your pin setup is correct and all pins are set to the correct mode meaning
- Trig Pin => OUTPUT
- Echo Pin => INPUT
Once you have this set up, you will need to add the code to your loop() function to make it so that you can get the distance of an object at any point.
- You are going to do this by calculating the amount of time it takes for the sound to go out, bounce off the object you’re measuring, and come back to the other sensor.
- This can be accomplished using libraries, however, let’s do it from sratch, for fun.
- The way this works is the Trig Pin (Trigger) sends a frequency (of about 40kHz) out for 10 µs. The echo pin then takes this frequency back in and calculates the duration the frequency took to get from trigger to echo.
- After you have this duration you can figure out how many cm away the object is by the equation duration * 0.034 / 2.
- Here is all of that in code
```
  digitalWrite(trigPin, LOW);
  delayMicroseconds(2);
  digitalWrite(trigPin, HIGH);
  delayMicroseconds(10);
  digitalWrite(trigPin, LOW);
  duration = pulseIn(echoPin, HIGH);
  distance = duration * 0.034 / 2;
  Serial.println(distance);
```
Now you have the distance of he object, you can do some nice if statements to figure out which light you should turn on. Once you have done this you have a stoplight that responds to a distance sensor and tells you whether to pull forward or not!

Thought Questions

Think of the interaction between your devices. How well would this scale to multiple devices? Is it easy to add another sensor? Another actuator?

It wouldn’t be awful to scale out a few more devices. The part that seems like it would be a headache is managing all of the IP addresses for the actuators. Having to keep that in sync with the sensors would be painful. I definitely think an event hub will solve this issue wonderfully.
What are strengths and weaknesses of the tennis-ball-on-a-string system that Don had originally? What are strengths and weaknesses of the IoT system that he developed? What enhancements would you suggest?

Some strengths of the tennis-ball-on-a-string is that it is simple. You are able to set it up in a couple of minutes and, quite frankly, it gets the job done. Some weaknesses of it is that it is an annoyance whenever the car isn’t in the garage. There is just a tennis ball in the way of anything else you are trying to do in there. As well, there is a likelihood of the tennis ball falling off or getting knocked off. Some of the strengths of the IoT system is that it would be able to be a system that the driver would use every day. Drivers are very accustomed to stop lights and this would make it nice to be able to incorporate into a normal routine. Some weaknesses would be complexity and maintenance. This solution would need to be maintained in order for it to remain useful.
What was the biggest challenge you overcame in this lab?

When trying to get this lab up and running on BYU’s campus, I ran into the captive portal of BYU-WiFi. I didn’t know this was necessarily happening at first and so it caused me good amount of headache trying to debug. Once I realized that’s what it was, it wasn’t too bad to get my hotspot set up and all of my devices connected to it.
Please estimate the total time you spent on this lab and report.

3 hours

Certification of Work

— Matthew Robertson

Appendix

Appendix 1: System Interface - Web Page

State Diagram

Appendix 3: Code

Available on GitHub

Lab 2 - Arduino Stop Light 🚦

Tue, 01 Oct 2019 00:00:00 GMT

Objective

The purposes of this lab are to:

Reinforce enumerating requirements from use cases and user stories
Become familiar with the Arduino platform and its programming methodologies.
Program an Arduino-based microcontroller to use the GPIO pins to control LEDs.
Develop iteratively, beginning with a minimum viable product and add functionality until the requirements are met.

Materials

The materials used for this lab were

Personal computer (MacBook Pro)
1 x ESP8266 Wemos D1 Mini (Microcontroller)
1 x USB -> MicroUSB cable for connecting the Microcontroller to the computer
1 x Breadboard
1 x Stop light LED component with built in resistors
5 x Male to male jumper cables

References

Procedures

Install the Arduino IDE from here
Set up your environment to work with the ESP8266 Wemos D1 Mini
- Go to Preferences and add the following URL to the Additional Boards Manager URLs field
```
http://arduino.esp8266.com/stable/package_esp8266com_index.json
```
- Go to Tools -> Board: [Some Board Name] -> Boards Manager
- Search for Wemos
- Install esp8266 by ESP8266 Community (Note: this tutorial was made using verions 2.5.2 and does not guarantee that everything will work the exact same in later versions)
- Go to Tools -> Board: [Some Board Name] again and select the following board
```
LOLIN(WEMOS) D1 R2 & Mini
```
- Go to Tools -> Port and select the port that your Arduino is plugged into. (If you have issues on this step, you can find help here)
- Go to Tools -> Erase Flash: and select All Flash Contents
- You are ready to start coding!
Implement WiFi on the Arduino using the example WiFi setup by going to File -> Examples -> ESP8266WiFi -> WiFiClientBasic
After you have tested that you are able to connect to network, you are ready to start setting up your web server.
Using the docs found for the ESP8266WebServer Library, create a web server that will turn on and off the lights and set them to a cycle mode. For the cycle mode, I would suggest using the millis() library so that you don’t lock up your server by using delay()‘s.
Once you have all of your code written and you’re ready to test it, connect your Arduino to the computer and flash it by going to Sketch -> Upload.
Once it has been flashed, keep it connected and open up the serial monitor (Tools -> Serial Monitor) so that you can monitor the server’s output.
You have now implemented a stoplight using an Arduino! What else can you do using the same simple libraries??

Thought Questions

What are some key differences between developing this lab on a Raspberry Pi, and developing on Arduino?

Developing on a Pi has a lot of overhead. There are a lot of different steps needed to even get the Pi up and running and able to host a web server. A Pi has multiple uses other than running a program for you since it has an entire OS on it. An Arduino on the other hand has a single purpose: be given compiled code and run it whenever I have power. Because of the simplistic nature, I had to be more creative to do things that are pretty easily implemented on a Pi (such as timeouts).
What are the strengths and trade-offs of each of these platforms?

I think that a Pi can do more complicated things quicker. As well, a Pi is a bit easier to work with. An arduino on the other hand is much more straight forward. There are two functions that need to be implemented and then you have a working product. As well, there is no overhead with starting/stopping a server which I think is incredible. It either has power or it doesn’t and if it does have power, it runs.
How familiar were you with the Arduino platform prior to this lab?

I had never used the Arduino platform prior to this lab. However, I will definitely be using it going forward it is an incredibly easy platform to work with and very powerful.
What was the biggest challenge you overcame in this lab?

The biggest challenge I had to overcome was getting my Arduino on WiFi. For one reason or another, my Arduino really struggled to get connected. It wasn’t until I erased all settings on the Arduino when I flashed the code (instead of just the sketch) that it actually worked for me.
Please estimate the total time you spent on this lab and report.

I spent about 1.5 hours on this project as a whole. Most of that time was familiarizing myself with the Arduino architecture.

Certification of Work

— Matthew Robertson

Appendix

Appendix 1: System Interface - Web Page

State: Startup, /lights-out

State: RED on, during cycle or manual

State: YELLOW on, during cycle or manual

State: GREEN on, during cycle or manual

Appendix 2: Server Output (via Serial)

Appendix 3: Code

Available on GitHub

Lab 1 - Raspberry Pi Stop Light 🚦

Tue, 17 Sep 2019 00:00:00 GMT

Objective

The purposes of this lab are to:

Learn to enumerate requirements from use cases and user stories
Learn to utilize the general purpose input/output (GPIO) pins on the Raspberry Pi to control LEDs.
Learn to develop a minimum viable product, and deliver new functionality through subsequent updates until the requirements are met, and all of the deliverables are acceptable.
Learn to use Github for progressive code commits and version tracking.

Materials

The materials used for this lab were

Personal computer (MacBook Pro)
Monitor, keyboard, mouse, and necessary cables to develop on the pi
1 x Raspberry Pi 3 Model B+
1 x Breadboard
1 x Stop light LED component with built in resistors
4 x Female to male jumper cables

References

Installing Node on a Raspbery Pi - This site has a wonderful walk through on how to get NodeJS installed on a Raspberry Pi. Node is what runs the server for this project
Basic Blink Tutorial for NodeJS - This is a great tutorial and intro to manipulating GPIO pins on a Raspberry Pi through NodeJS.
NPM rpi-gpio - This is the package reference to a great library for manipulating GPIO pins on a Raspberry Pi.
Lucidchart - A wonderful piece of online software that all the state diagrams were made through
Create React App - A wonderful wrapper to quickly create a ReactJS frontend application
ExpressJS - The documentation for the library used to create the API in NodeJS
NPM express-promise-router - A useful package for having the Express API be asynchronous
NPM onoff - The package used in this lab to manipulate GPIO pins
NPM path - A necessary tool for grabbing relative paths to server up certain files from NodeJS

Procedures

Follow the guide in Reference 1 to install NodeJS onto a Raspberry Pi
- Ensure Node installed by running the following command
```
node --version
```
- Ensure npm installed by running the following command
```
npm --version
```
- If either of these don’t return a version number, run through the above tutorial again and try to install it again. Also try and check that npm and node were both successfully added to your PATH variable

Once that is installed follow the documentation on how to set up a simple NodeJS server here. The simple NodeJS + ExpressJS server they provide for you is

const express = require('express')
const app = express()
const port = 3000
app.get('/', (req, res) => res.send('Hello World!'))
app.listen(port, () => console.log(`Example app listening on port ${port}!`))

Once that is installed, it is time to create the frontend part of the application. Do this by using the following command
```
npx create-react-app ./
```
Once it has been installed in the directory you want, you are ready to start creating your server to serve up the React app and the API server that will manipulate the GPIO pins.
Follow the following logical state diagrams to model the data flow on the server side
- This diagram shows how the data will flow as far as turning the lights on and off through the API and in turn the front-end of the application.
- In this diagram we see the logic of the automatic timer function. This is what the logic should be when the light will act as a normal stoplight would; cycling through its lights on specified intervals.
- The way these two diagrams talk is that whenever the cycle-on signal is triggered, the lights are turned off and the start point of the cycle is triggered. Whenever any other action is taken, it will then transition back to that state. Here is what the diagrams together look like.
Once you have your server up and running, you are ready to get your GPIO pins wired up and ready to go. This can be done using the following diagrams (remember, the lights in these diagrams have resistors built into them and that is why they are not on the layout diagram but still show up on the logical one. For the sake of the diagram, the fancy 4-pronged light represents a component that has 3 resisted lights on it and a ground pin all on a integrated board.
Once you have your server and your interface to manipulate the lights, you are ready to start your server. You can do this using node. If you file name was server.js you would start it simply by running
```
node server.js
```
You can connect to the web page you created by going to http://[IP-ADDR]:[PORT]
You have now completed a simple stop light with some automation! Congratulations!!
If there are any questions or anything, feel free to go to the github repo up at the top of the page to reference the code or just reference the Appendix which will have more screenshots and code snippets.

Thought Questions

What language did you choose for implementing this project? Why?
I chose to do this project in JavaScript. I know this language very well and develop in it every day. Because of this, I felt that I could utilize this knowledge to focusing on learning about the GPIO pins and not nuances of learning a new language.
What is the purpose of the resistor in this simple circuit? What would happen if you omitted it?
The resistor takes the load for the circuit so the entire load doesn’t go into the LED’s. The LEDs could probably handle this load but it would shorten the lifespan of the bulb in a big way meaning that it would burn out quicker than if we included the resistors in the circuit.
What are some practical applications for a device similar to this? What enhancements do you think would make this more valuable?
The obvious would be a stoplight. Although there is much more logic that goes into them, this seemed like a good foundation to go off of. As well, this would be an interesting idea to see if you could have some kind of status or something along those lines where it told that something was happening based on a light being turned on. One I can think of is if at work, the API could hit some DB and see if someone is scheduled to be in or not at that time. If they are scheduled to be in at that time, their light would be lit up so everyone could know that they should be on the clock and working.
Estimate the time you spent on this lab (from start to finish)?
I spent about 45 minutes setting up my environment and everything. I spent probably 3 hours on the server itself and another hour on the frontend. The wiring of the pi took me under 5 minutes. Overall, I would say that this project took me about 5 hours to complete.

Certification of Work

— Matthew Robertson

Appendix

Appendix 1: System Interface - Web Page

State: Startup, /lights-out

State: RED on, during cycle or manual

State: YELLOW on, during cycle or manual

State: GREEN on, during cycle or manual

Appendix 2: Server Output

Appendix 3: Server Code

Available on GitHub

Appendix 4: Front-end Code

Available on GitHub

Da Post

Final Project - The Morning Routine

Objectives

Materials

References

Procedures

Setting Up Alexa

Setting Up a Routine

Setting up The Weather Caja™

Certification of Work

Appendix

Appendix 1: DIAGRAMS

Appendix 2: Configs

Appendix 3: Demo and Images

Appendix 2: Code

Lab 5 - Home Assistant

Objectives

Materials

References

Procedures

Thought Questions

Which version of Home Assistant did you choose to install? (Docker-based Hass.io, Raspbian-based Hassbian, or install it yourself?) Why did you choose this particular version?

How should you decide which logic to perform in Home Assistant versus coding the logic directly into the devices? What guiding principles would you establish for future devices?

What features do you like the most about Home Assistant?

Please estimate the total time you spent on this lab and report.

Certification of Work

Appendix

Appendix 1: DIAGRAMS

Appendix 2: Code

Lab 4 - MQTT Event Hub – Garage Door Sensor

Objectives

Materials

References

Procedures

Thought Questions

How does the communication between devices change with the shift to using an event hub? How does this facilitate greater scalability? What things did you do to learn to use MQTT?

What are strengths and weaknesses of the direct communication between the sensor and actuator? What are strengths and weaknesses of the event hub? Which do you feel is better for this application?

What was the biggest challenge you overcame in this lab?

Please estimate the total time you spent on this lab and report.

Certification of Work

Appendix

Appendix 1: DIAGRAMS

Appendix 3: Code

Lab 3 - Arduino Stop Light w/ Distance Detector 🚦

Objectives

Materials

References

Procedures

Thought Questions

Think of the interaction between your devices. How well would this scale to multiple devices? Is it easy to add another sensor? Another actuator?

What are strengths and weaknesses of the tennis-ball-on-a-string system that Don had originally? What are strengths and weaknesses of the IoT system that he developed? What enhancements would you suggest?

What was the biggest challenge you overcame in this lab?

Please estimate the total time you spent on this lab and report.

Certification of Work

Appendix

Appendix 1: System Interface - Web Page

Appendix 3: Code

Lab 2 - Arduino Stop Light 🚦

Objective

Materials

References

Procedures

Thought Questions

What are some key differences between developing this lab on a Raspberry Pi, and developing on Arduino?

What are the strengths and trade-offs of each of these platforms?

How familiar were you with the Arduino platform prior to this lab?

What was the biggest challenge you overcame in this lab?

Please estimate the total time you spent on this lab and report.

Certification of Work

Appendix

Appendix 1: System Interface - Web Page

Appendix 2: Server Output (via Serial)

Appendix 3: Code

Lab 1 - Raspberry Pi Stop Light 🚦

Objective

Materials

References

Procedures

Thought Questions

Certification of Work