If you are clumsy like me, you might have forgotten a few important events here and there. To combat this, I've decided to build a complete product that makes sure you never lose track of time! My system promises to make you a productivity guru!

Using a stunningly beautiful web application, you can customize your day/week/month by setting events. These events might be repeatable or just one-offs; they might take a fixed amount of time to complete or they might need to remain in the back of your head for the whole day (e.g. your aunt's birthday).

Finally, a dedicated device will remind you both visually and aurally of these tasks before they need to be ticked off. If you plan your day correctly, there is no way you miss anything!

For this complex system to work without revoking its upgradeability (meaning, in the future, one could expand the system to allow for multiple devices that remind you of upcoming events), there is a need for separation:

• A central server, which should contain details about all the upcoming events. The server should also provide a way to create new events or to modify existing ones.
• A device (perhaps, in the future, multiple devices) that will periodically ask the server for upcoming events.

The server will store details about future and past events using a relational database (specifically, PostgreSQL). The web interface will be written from scratch in HTML, JavaScript (enhanced with jQuery) and Sass. These two components are glued together by a backend custom written in Go.

To provide high reproducibility, everything will be self-contained in a Docker container.

The device that will remind the user of their tasks will need to connect to the server (meaning it requires network access) and will ping it at fixed time intervals to gain knowledge about upcoming events. A screen will provide the user with visual feedback, and, in case the user misses it, a buzzer will trigger as well. The reminder can be postponed (or silenced).

To accomplish this, I figured an ESP32 is best suited.

Everything I've just described can be seen in the following figure:

This is a software-heavy project! With this being said, I would like to point out the exact concepts I've used that were taught during this class:

1. GPIO - the GPIO pins are used to enable communication between the IoT device and the end user;
2. Interrupts - when pressing a button, an interrupt will occur;
3. Timers - to notify the user before a certain task is due, timers are needed; they are also used to communicate with the server;
4. I2C - the device's display is controlled via the I2C protocol;
5. ADC - since you are eager to deduct points, I am required to make bad decisions regarding my project - in this case, the buttons will use fewer GPIO pins for no reason other than to use ADC.

The server can be a repurposed old computer or, to simplify the process, a Raspberry Pi 4 Model B that I've had laying around :)

The IoT device will be an ESP32 module connected to a bunch of buttons, a small display and a buzzer.

• 1 x ESP32 module
• 1 x LCD display
• 1 x Buzzer
• ~4 x Buttons

As you can tell, there are plenty of external devices managed by the ESP32.

• [1] GitHub