Adding More Inputs

Now that we have our own voice-enabled device with a custom skill, let’s see how we can integrate additional inputs such as a motion sensor. In this example, by adding a simple motion sensor, we can detect when people walk by and trigger an event like having Alexa say “Hello” or simply turning on an LED light. To follow along, you will need a passive infrared (PIR) sensor, sometimes referred to as pyroelectric infrared, or simply PIR (Figure 6-1). These are typically found in home security motion sensors but can also be ordered online for less than $10.

At a high level, PIR works by detecting infrared radiation levels above absolute zero; because humans and other animals typically radiate infrared wave lengths at around 10–12 μm (microns), this is a great technology for sensing people as well as creatures and other objects that radiate a decent amount of infrared light. We’re not going to dive too deep into the science of a PIR sensor, so if you want to learn more, check out Adafruit’s “How PIRs Work”. While you’re there, feel free to order a few of the PIR (motion) sensors to play with.

Figure 6-1. PIR Sensor - Photo Creative Commons, Adafruit Learning Systems

Generally PIR sensors will have three pins: one for ground, one for power, and one for the signal. Power is generally 3V to 5V, but can be as a high as 12V in some cases. As for the particular model shown here, you can feed it anywhere between 5V and 12V. The signal output is 3.3V, and can detect from up to 20 feet away at a 120 degree cone. The sensitivity and signal firing can be adjusted to your liking; for example, in some cases you might want to adjust the sensitivity to “min” and time to “max” (around 4 seconds) to detect when a person is standing in front of your device for a set period of time instead of just walking by.

Alternatively, you can use a sonar sensor, which uses ultrasonic waves to detect objects, or if you need something more precise for your particular application, you can look into using ToF Distance Sensor. The Adafruit VL53LOX is an amazing little sensor smaller than a US quarter dollar coin; the VL53LOX can detect objects by sensing the reflection of a very narrow field of light, unlike PIR and Sonar that detect within a wide cone or Field of View (FoV). With the wide range of motion sensors available, it’s a good idea to test as many as possible in order to determine which ones work best with your device.

As we mentioned earlier, this example will use a PIR sensor, so let’s get to it. First thing we’ll want to do is take a look at the diagram in Figure 6-2, so we know how to wire up our motion sensor.

Figure 6-2. Raspberry Pi with PIR sensor wiring digram

As you can see in Figure 6-2, we have the ground (black wire) connected to the Pi’s ground and the power (red wire) connected to the Pi’s 5V power output. As for our PIR signal (yellow wire), we connected it to GPIO 23 but you can wire it up to another GPIO pin if 23 is taken. Once we have all our connections in place, next thing we will want to do is modify the AlexaPi code to listen for the PIR events. For this we will need to open the rpilikeplatform.py file we talked about earlier in “Working with a Button and LEDs”.

Additionally you can add a new key value to the configuration file; for instance, under the raspberrypi section, add the first line as follows:

raspberrypi:
  motion: 23
  button: 18
  plb_light: 24
  rec_light: 25

Next open up the rpilikeplatform.py file in the src/alexapi/device_platforms directory. Once the file is open, look for the definition function called setup. There, we will set up our GPIO pin to listen to inputs from the PIR motion sensor; for instance, in the following code, simply add the first line (bolded for clarity) under setup:

def setup(self):
  GPIO.setup(self._pconfig['motion'], GPIO.IN)
  GPIO.setup(self._pconfig['button'], GPIO.IN, pull_up_down=GPIO.PUD_UP) 
  GPIO.setup(self._pconfig['rec_light'], GPIO.OUT)
  GPIO.setup(self._pconfig['plb_light'], GPIO.OUT)
  GPIO.output(self._pconfig['rec_light'], GPIO.LOW)
  GPIO.output(self._pconfig['plb_light'], GPIO.LOW)

Now let’s look for the after_setup definition function. There, we’re going to add GPIO event detection so when the motion is sensed from the PIR sensor, a function is called. In the after_setup function, we add a new line to the bottom of the function that listens for a HIGH event on the motion pin specified in the config file:

def after_setup(self, trigger_callback=None):
  self._trigger_callback = trigger_callback
  if self._trigger_callback:
  # threaded detection of button press
  GPIO.add_event_detect(self._pconfig['button'], GPIO.FALLING,
                        callback=self.detect_button, bouncetime=100)
  GPIO.add_event_detect(self._pconfig['motion'], GPIO.HIGH,
                        callback=self.detect_motion, bouncetime=100)

Note that in the preceding code we set the callback to self.detect_motion, which doesn’t currently exist. No worries, we are going to add a new function that will handle what we want to handle, when motion is detected. To test, we’ll start with something easy like turning on and off one of the LED lights. Add the following code right before the detect_button function like so:

def detect_motion(self, channel=None):
  logger.debug("Motion detected!")
  GPIO.output(self._pconfig['plb_light'], GPIO.HIGH)
  time.sleep(5)
  GPIO.output(self._pconfig['plb_light'], GPIO.LOW)

def detect_button(self, channel=None):
  self._trigger_callback(self.force_recording)
  logger.debug("Button pressed!")
  time.sleep(.5)  # time for the button input to settle down
  while GPIO.input(self._pconfig['button']) == 0:
    time.sleep(.1)
  logger.debug("Button released.")
  self.button_pressed = False
  time.sleep(.5)  # more time for the button to settle down

One last piece of code we need to update is in the cleanup function. Here we will remove the GPIO event detection to free up those resources when we’re not using them. In cleanup we will add the first line specified here, where we’re simply passing in the pin specified in the config file to the GPIO.remove_event_detect function:

def cleanup(self):
  GPIO.remove_event_detect(self._pconfig['motion'])
  GPIO.remove_event_detect(self._pconfig['button'])
  GPIO.output(self._pconfig['rec_light'], GPIO.LOW)
  GPIO.output(self._pconfig['plb_light'], GPIO.LOW)

Now we test. Go ahead and reboot the Pi. When the Pi comes back online, you will be able to pass your hand in front of the motion sensor or walk past it and it will light up the LED. Once we know this works for certain and as expected, we can start to think about other events we can activate inside of the detect_motion function, such as play a sound or brighten a display in much the same way the Nest thermostat does when you walk past it.

Going to Production

We’ve gotten our feet wet with some fun prototypes, but if you’re looking to create a product to sell to the public, there’s a much longer road ahead that includes strategic planning around security, testing, assembly, procurement, logistics, support, and much more. Successful product development is a complex process that has to be carefully executed, or else the potential for failure is too high, no matter how “cool” your product is. When prototyping, we can plug in some jumpers, write some code, and it works great, but as soon as that gets into the hands of customers it will easily break.

The first step in going to production is trashing your current prototype! You want to make sure you have iterated enough times that you are satisfied with the minimal viable product (MVP) and it serves its purpose. This can’t be done on the first iteration; you’ll need to take some time with it, but it shouldn’t be a long, drawn-out process—it’s all about finding the right balance. Tony Fadell, who designed and helped launch popular products such as the iPod and Nest, was well known for saying, “Don’t take longer than a year to ship a product.” Whether you take six months or a year is up to you; just draw the line in the sand and stick to it. Basically, once those MVP requirements are met, it’s time to launch!

A good, value-driven MVP project plan is a great way to establish when it’s time to go to production, and it’s important to consider the overall production lifecycle as you draw up the project outline. By now you should have an MVP in mind, based on our design thinking discussion in Chapter 1. Once you have a solid prototype ready, taking your MVP prototype to production requires some additions to that MVP requirements list. Some key considerations include:

• Security
• Quality management
• Manufacturing
• Support
• Regulations

Additionally there’s logistics around warehousing and shipping, which really depends on where you are manufacturing your product. You could partner with a factory that can handle most of the product lifecycle for you or simply one aspect of it. In the beginning, however, your best option is to find a factory that can help with both PCB design, enclosure design, even specification and documentation all the way through possibly drop-shipping. The cost per unit might be much higher in the beginning, but overall costs could potentially be lower, thus reducing your risk level.

What’s Next?

So there you have it. You’ve successfully learned to rapidly prototype a voice-enabled device. Now what? Now you keep iterating and improving. To help you along your journey in getting you through to the next steps, the following are some additional resources you can reference:

Books

• Prototype to Product by Alan Cohen

• Designing Voice User Interfaces by Cathy Pearl

• Designing Connected Products by Claire Rowland, Elizabeth Goodman, Martin Charlier, Ann Light, and Alfred Lui

• Collaborative Product Design by Austin Govella

• Product Roadmapping by Michael Connors, C. Todd Lombardo, Evan Ryan, and Bruce McCarthy

Online Courses and Videos

• Designing for AVS

• Designing for Voice: Conversational UI

• Learning Path: Programming the Internet of Things