This project will attempt to address an immediate challenge my wife and I are facing - how to avoid yelling from room to room while we try to take care of our newborn baby and maintain some semblance of continuity in household upkeep. This means we want to build a working solution immediately, with available tools and a minimum amount of effort.

With this in mind, our strategy is to use (or misuse) widely available, well documented Internet-of-Things development tools to rapidly develop a non-internet Thing. Using these tools will have the added benefit of enabling more flexibility to A/B test variations on the basic user interaction, as well as remotely debug the system. Once the system operation is satisfactory, we can pursue a later design phase with more appropriately targeted hardware.

Here's a sketch of what we want:

- User A presses a button to get User B's attention

- User A's device lights up to indicate that the call has been sent, while User B's device lights up to show that a request has been made

- User B then presses the button to acknowledge the request

- Both devices show the acknowledgment

After initiating the initial call, User A can also press again to cancel the call. This whole sequence works from both devices so that either user can call the other.

While this system will likely end up using some sort of low power RF connection (such as a LoRa link) directly between the two devices, we will be implementing this on top of an ESP8266/MQTT stack. Here is a rough system diagram:

While this approach makes a number of concessions to unnecessary system overhead, during a rapid prototyping phase this extra firepower can be useful. In particular, the need for a wifi network and host server looks problematic at first glance, but will allow updates to be pushed seamlessly to each device, and message traffic to be monitored and debugged.

We hope by building the system in this manner we can arrive at something that works for our immediate needs very quickly (within days hopefully) and support an iterative design process to refine the product.