Matt LagarenneTo start, let me shed some light onto some of the problems that Juliet aims to solve:
- There is no simple, cheap, clean interface for showing information in a condensed fashion
- There is no cheap way to easily control simple home automation such as lights and music
- The interface must be responsive and able to highlight details of the information provided
- There are no fully modular and open to expansion solutions available
So with the problems outlined, here's what I intend the project to become:
- An interface for showing basic information that is useful for the current day (weather, news, stock tickers, interesting quotes, upcoming TV shows, traffic monitor, etc.)
- Be able to dive deep into these modules to get more information from them (weekly forecasts, temperature high/lows, wind speed, for a weather example)
- A controller for basic house functions (turning off/dimming lights when no motion on the camera is detected, thermostat control)
- An easy to install and build device that is configurable to the end user's specifications
- A cheap but nice looking panel which can be installed in under an hour or two
- And last of all, I really want this to be as modular as possible so that other users can fork and expand on the software to add their own modules
Ideally this device would be placed somewhere in the open that gets seen a lot, such as in a kitchen or a hallway to a bathroom or similar. This would be best as the user would constantly get updated with information as they live their lives normally.
Some things that I don't intend for this device to become (at the moment, who knows what the future holds :) )
- Voice command listening device - it seems like other products are already moving into this space... but perhaps adding inter-operability is an option. Right now the voice processing seems a little too complex, comparable to a news module which is simpler to implement and offers more information
- Complete home automation - I don't have any plans for integrating a smart toaster or whatever crazy IoT technology strikes your fancy... perhaps when the project is more mature you could add your own implementation! :)
- Security device - This one I'm on the fence on. Maybe there could be an implementation for quick locks (or some RFID door opening device), but I don't think that the main goal of the project is home security.
Here's the first prototype video of the weather module with the mirror mounted to the LCD screen:
So without further ado, here's the current software breakdown of the project (as of 3/18/16)!
The Python program can be broken up into multiple subsections. The three main parts are the graphics and main program code, importer, and modules. The program starts by having the importer look through the "modules" directory. The importer looks for every file named *.py recursively and imports them into their own, separate modules. The importer does this by using the imp library included with python. This allows the program to call on the submodule's functions by going through a python dictionary with the name of the file as the key. This layout allows ease of use of the modules.
The modules themselves all inherit from the main parent module, juliet_module. This module has the base variables mod_name, mod_id, and mod_rect. These attributes define the name of the module, the id at runtime, and the rectangle the module takes up on the screen. In addition to these, there is a changed variable which is used when updating modules to check if the module's rectangle needs to be updated. juliet_module also contains the functions draw and update, which get called every frame during the main program loop.
The graphics program is supposed to be a separate forked process which runs separate from the main program at this point, though this is currently not implemented and juliet_graphics is called from the start. In the final project, the code would be called by a juliet_control module, which handles importing and starting the graphics and other modules. In addition, this code can handle the user input and instantiating new modules on the fly. This part is still under consideration and may be changed as the project develops.