Smart Lighting: The Interface That’s All Around Us
--
A step-by-step guide to setting up programmable lights in an office — and why it improves your meeting culture.
The most useful and enduring technologies are ones that benefit us every day without asking us to make a conscious choice to use them. Components of our lives that we take for granted such as electricity, climate control in buildings, plumbing, and Internet protocols all work to improve our quality of life whether or not we acknowledge their existence at all. The majority of new technology products require our deliberate actions, such as typing on a phone or speaking to Alexa. Each decision to interact with technology requires the cognitive effort to identify that something needs to happen and then taking the steps to trigger the behavior of the technology.
Conscious use of technology has its place, but the best technology should enhance a user’s life without asking them to change their routine. With this goal in mind, we’re building smarter office technology to present employees with information the exact moment they need it — without them having to ask for it.
Who hasn’t had that moment at work when you realize you need a private space to have a quick conversation with a busy colleague who only has seven minutes before their next meeting? Typically what happens next is you’re desperately spinning around the office, craning your neck to peer into as many rooms as you can see, then scrambling to log onto your laptop, open up the office calendar, check each room’s calendar one by one until you find a genuinely available room, and finally schedule it for longer than you need it. By the time you’ve sorted out these logistics, the person whose time you were trying to steal has moved on to their next meeting.
With our first smarter office project, HelloRoom, we solved the issue of booking conference rooms only for the amount of time needed when you’re standing next to an open room. With HelloLights, we wanted to tackle the problem at an even earlier point in the flow — the awkward neck-craning search for an empty room. As hard as one may squint to see what’s on each of the eight HelloRoom tablets in our D.C. office, it’s usually not a fruitful exercise. Even looking to see if the room is occupied by people is not always an easy venture — what if someone’s having a secret huddle in the back corner you can’t see? What is immediately visible, however, is the light coming from each room. Light is a perfect interface to transfer the necessary information — it’s not too intrusive, its color can be varied to relay a change, and it’s visible at a distance.
Technology, research, and planning.
At Huge, we frequently experiment with new technologies and build prototypes to identify those technologies’ strengths, weaknesses, and capabilities. Once we know more about a particular technology, we open a discussion to a larger group for suggestions on how that technology can benefit us and our clients.
Last year, we ordered a smart light bulb just for fun. We went with a LIFX Color 1000 light bulb. These bulbs are a slightly less popular option than Philips Hue bulbs, but had several attractive characteristics:
- The lights work over wifi without any need for a hub/bridge or other wireless technology.
- A single bulb costs only $45.
- The bulbs can be triggered remotely to turn off and on, change colors, dim, and brighten.
- They have a great API, straightforward documentation, and good examples in multiple programming languages.
- There are multiple Node.js packages already written to control the lights.
- The LIFX website has very active forums and a robust help section.
- LIFX has feature-rich Android and iOS apps to group and control multiple lights.
With a bulb in hand, we began to write code to make sure we could invoke all of the features that LIFX advertised. This step is important because the advertising for new technology products is often not consistent with the realities that developers run into when working with them. We were pleased to discover that the LIFX bulbs worked exactly as described. When we were done testing the bulbs, we also had a robust library of code examples to control all of their features.
HelloLights featureset.
Now that we could control these lights programmatically, it was very quick work to write an application to communicate conference room status via light. We titled the application HelloLights, keeping in sync with HelloRoom, since both aim to make conference rooms easier to use. The current HelloLights feature set is focussed on non-intrusive changes to light color to assist employees in finding a free conference room and staying on schedule during their meeting.
- Free conference rooms shine a soft blue light that users can easily see from a distance. Occupied conference rooms show normal white lighting to let others know the room is taken. When scheduling a meeting, the creator can easily specify a custom light color for the duration of the meeting by adding a hex color code to the meeting description.
- When there are 5 minutes left in a meeting, the light softly pulses blue once to remind the attendees to wrap up their discussion.
- When only 1 minute remains in a meeting, the light pulses magenta strongly once to remind the attendees that someone else will likely want to use the room now and that the room is no longer officially booked.
Knowing that blue means free, employees can quickly glance around the office to see what rooms are free or occupied. The in-meeting light color transitions gently to remind employees of the end of a meeting without being too distracting.
Colors and lamps.
Adding colored lights to all eight of our conference rooms had a noticeable effect on the vibe of the office. First we tried bright saturated colors to connote open rooms, but the bright greens, reds, and magentas made it feel like we were in a bad underground ’90s Euro club. We settled on a more restrained color palette for long use periods (free and occupied), and saturated colors for alerts (five minute warning and meeting end alert).
Similarly, we needed a lamp style that’s consistent with the aesthetic of the office but clearly denotes a different function than normal lighting. We chose Vita Carmina Mini Table Lamps, which are available in both table and standing versions to fit the layouts of our different conference rooms. Our goal was to avoid a harsh spotlight effect. These lamps are stylish, and cast a diffuse light that can be seen easily from far away.
Technical architecture.
All of the code that powers HelloLights is available on the HugeInc Github account at https://github.com/hugeinc/HelloLights
We use Amazon Elastic Beanstalk (EB) for small- to medium-sized projects such as this one. The platform lets us get up and running quickly and customize our applications using the AWS stack if we need to go beyond the bounds of what Elastic Beanstalk provides.
HelloLights uses two EB servers. The application server handles the bulk of the application logic, which includes:
- Authenticating with Google to read calendar data for each of our conference rooms.
- Communicating to the LIFX API to control our light bulbs.
- Storing configuration about conference rooms, lights and light color settings.
- Handling logic to evaluate the status of a room based on meetings scheduled and changing the light color accordingly.
- Running an endpoint that forces all lights to update and outputs JSON with status information on all lights in the system.
- Outputting detailed custom logs for monitoring and troubleshooting any issues.
- Unit testing to make sure light colors are set properly based on meetings currently scheduled in the conference rooms.
The second server is an EB worker server used to handle regularly scheduled tasks. Our EB worker server asks our main EB application server to update every minute using an HTTP GET request to a URL the application server provides. This update then looks at the status of any meetings and changes the light color accordingly.
Since we pass data over HTTP, we need to encrypt it; AWS greatly simplifies this process. AWS Certificate Manager allowed us to easily create and renew an SSL certificate without paying a dime. We then configured our EB application to use this certificate and also enforce that any connections use HTTPS instead of HTTP.
We wrote the application using our favorite stacks for applications of this size: Node.js and Express. The application itself is completely composed of server-side code, without any HTML, CSS, or client-side Javascript. The only end-user interfaces are the light bulbs themselves.
Lessons learned.
Configuring (or “onboarding”) the LIFX light bulbs was the most difficult challenge in transforming our research into a finished product. Once we fully configured the bulbs, they worked well in most cases, but there were several pain points we had to work through before we had a reliable system.
Onboarding the bulbs took multiple attempts, and even a successful attempt wasn’t guaranteed to be repeatable. A LIFX bulb initially creates its own wifi network which you then connect to using your phone. You can then use the LIFX app to configure the bulbs to join your own wifi network. This process seemed to randomly fail without reason or meaningful error messages, but a few themes did emerge.
The LIFX app on an iOS devices worked much better than on Android devices. This shortcoming is not mentioned anywhere in their documentation, and we had to find a spare iOS device to make it work.
The bulbs we received also had outdated firmware, which is not uncommon for these types of devices, but the firmware couldn’t be updated without getting past the troublesome onboarding process. The fix in this case was to download a PC/Mac application which can update the firmware on the bulbs directly but also happens to output verbose logs explaining what’s going on. This logging helped us gain a better understanding of when bulbs were updating properly. The iOS/Android app provided only generic error messages rather than any useful information to help solve the problem. Once the bulbs had updated firmware, the onboarding process went much more smoothly.
The last issue we ran into was the most difficult to resolve. The lights would randomly drop offline and not respond to any color change requests. This issue would happen intermittently, and we eventually determined that it was due to our wifi network using auto channel switching. This is a very common network configuration that helps increase wifi performance and was something we didn’t want to turn off in our office because it would affect everyone’s normal wifi performance negatively.
We ended up creating a separate wifi network just for the LIFX bulbs with a set channel that never changed. We then joined all of the bulbs to this new wifi network and they consistently stayed online. We also added more logging to the light update logic in our application. This change let us construct reports detailing when a light dropped offline unexpectedly, and confirmed that our separate wifi network with a single wifi channel resolved the issue. One lesson we learned in this case was that many internet of things (IoT) devices are designed for home networks and are often difficult to successfully use on corporate networks without additional support.
Benefits and what’s next.
Typically we pride ourselves on identifying the unmet user need first, then laser focusing on solving that need. In the case of HelloLights, we were pleasantly surprised to find that not only did we solve the initial need of quickly seeing available rooms, but we ended up with a few ancillary benefits as well.
Once we got used to the “your meeting is almost over” light pulse feature, we found ourselves closing our laptops during meetings more often, knowing that we didn’t have to keep our eyes on the clock to stay on schedule. We began focusing more on the discussion in the room rather than drifting off to think about the next event.
Now that the lights are a permanent office fixture, we’re coming up with new ways to use them, whether it’s setting them to an incoming client’s brand colors, pulsing them when it’s time for an all-hands meeting, or setting them to rainbow party mode for a celebration.
—Written by Matt Toigo, Jenny Madorsky, Rich Bloom, and Richee Chang
