The Medication Reminder Alarm is designed to help individuals, especially the elderly or those with busy schedules, take their medications on time through simple auditory and visual alerts. Inspired by my parents' struggles with remembering their medications, this project offers a physical, tech-free solution that ensures timely reminders, addressing the common issue of missed doses that can lead to serious health complications. Unlike mobile apps like Medisafe or MyTherapy, which require smartphones and can be challenging for less tech-savvy users, this device provides a straightforward, reliable reminder system. Similar projects like PillDrill and MedMinder combine medication storage with reminder systems, but this project focuses on ease of use and accessibility without needing a digital interface.
Start a New Design: Open fusion 360 software and begin a new design project.
Save File: Immediately save the file with a relevant name "Final Project".
Create a New Component (Base): Make a new component named "Base."
Base Sketch: Create a 140 mm diameter circle for the base and add three holes for mounting the Arduino Uno.
Extrude the Base: Extrude the base sketch by 3 mm (the thickness of plywood).
Edit Appearance: Apply a plywood texture or material to the base to give it a realistic look.
Insert Arduino Uno: Import the Arduino Uno model from the external library and align it on the base using joints.
Insert Breadboard: Import a breadboard model from the external library.
Create a New Component (Outer Shell 1): Create a new component and name it "Outer Shell 1."
Outer Shell Sketch: Sketch a 140 mm diameter circle for the outer shell with a 2 mm wall thickness. The inner diameter should be 138 mm.
Design 4 Holders: Design four internal holders to attach to the base.
Extrude the Shell and Holders: Extrude the shell to 40 mm in height and extrude the holders to 3 mm.
Sketch for USB and Plug Holes: Create sketches for the Arduino USB and plug openings and perform an extrude cut on the outer shell.
Create a New Component (Middle Base Joints): Make a new component named "Middle Base Joints."
Middle Base Joints Sketch: Sketch three joints with holes on one side.
Extrude One Side: Extrude one side of the joints by 4 mm.
Sketch the Opposite Side: Sketch the holes on the opposite side of the joints.
Extrude the Other Side: Extrude the other side by 8 mm.
Create a New Component (Outer Shell 2): Make a new component named "Outer Shell 2."
Outer Shell 2 Sketch: Sketch a 140 mm diameter outer shell with a 2 mm wall thickness (same as "Outer Shell 1").
Extrude Outer Shell 2: Extrude the shell to 18.5 mm and the holders to 3 mm.
Forgotten Holder Holes: Go back and add the missing holes for the shell holders.
Create a New Component (Middle Base): Create a component named "Middle Base."
Middle Base Sketch: Sketch three joints with holes, aligned with the "Middle Base Joints."
Project Joints Holes: Project the holes from the middle base joints to the middle base.
Extrude Middle Base: Extrude the middle base by 3 mm.
Combine Shells: Combine "Outer Shell 1" and "Outer Shell 2" into a single shell.
Create a New Component (Inner Shell): Create a new component and name it "Inner Shell."
Inner Shell Sketch: Sketch a 103 mm diameter circle for the inner shell with a 6 mm thickness.
Extrude Inner Shell: Extrude the inner shell to 12.5 mm.
Create a New Component (User Panel): Make a new component and name it "User Panel."
User Panel Sketch: Sketch spaces for the LCD, LEDs, buzzer, push buttons, rotary encoder, and mounting holes for bolts.
Extrude User Panel: Extrude the user panel by 3 mm (plywood thickness).
Insert LCD I2C Model: Insert the LCD I2C model from the library and align it with the user panel using joints.
Forgotten Joints Holes: Add the missing holes for the middle base joints in the shell.
Create a New Component (Slots): Make a new component named "Slots."
Slot Sketch: Create a sketch for the slots.
Extrude Slots: Extrude the slots by 3 mm (plywood thickness).
Circular Pattern for Holes: Create a circular pattern for the holes on the middle base.
Circular Pattern for Slots: Create a circular pattern for seven slots and attach them to the middle base.
Insert Push Buttons: Insert the push buttons from the library and align them on the user panel.
Insert Rotary Encoder: Insert the rotary encoder model from the library and align it on the user panel.
Create a New Component (Cover Plate): Make a new component named "Cover Plate."
Cover Plate Sketch: Sketch the cover plate, including a hole for a finger pull.
Combine Middle Base and Inner Shell: Combine the middle base with the inner shell to print as a single piece.
Create a New Component (Table): Make a new component and name it "Table."
Table Sketch: Sketch the table with dimensions of 500x500 mm.
Check Design Integrity: Review the entire design for any issues, ensuring all components fit correctly and all holes, joints, and alignments are accurate.
Render Photo: Set up the design for rendering, adjust lighting, camera angle, and materials, then take a high-quality rendering photo of the assembled design.
Save Final File: Save the completed design file with a final version name for future reference and exporting.
Rendering shot
File Export: I exported the design as a .dxf and .stl file from Fusion 360 to ensure compatibility with the laser cutting machine and 3D printing machine.
Software Used: Laser cutter control software RDWorks to prepare the design for cutting.
Settings: set the laser kerf to 0.1 mm to account for material removal during the cutting process. 45 for power and 40 for speed for cutting
Cutting Process: The laser cutter was used to cut out the base, slots, and user panel. Plywood was placed on the laser bed, and the machine cut the parts according to the design file.
Software Used: Cura to convert the 3D model into a format compatible with the 3D printer.
Settings: The outer shell, inner shell, and middle base were prepared for 3D printing. I set the material to PLA (or another filament), adjusted the layer height for a balance between quality and print time, and ensured proper infill for strength. was resolution 0.3 mm
Printing Process: After slicing the model, the file was sent to the 3D printer. The shells and middle base were printed layer by layer to the exact specifications, with the necessary holes and joints already incorporated into the design.
Material Used: PLA filament
Materials Used: The cut plywood parts, and 3D printed parts.
Tools Used:
Screwdrivers for assembly.
Glue for fixing parts where necessary.
Screws for securing parts to the base, middle base and user panel.
Process: After cutting, I assembled the parts by following the design. The holders attached the shells to the base.
fabricated parts
Final assembly without electronics
Plywood fabricated
Push Buttons:
Function: Used as input devices to trigger specific actions like confirming user input or snoozing or rejecting action.
Integration: Connected to the Arduino’s digital input pins. When pressed, they send a HIGH signal to the microcontroller, which then processes the input.
Rotary Encoder:
Function: Used to adjust settings such as selecting between options or changing the duration of alarms.
Integration: Connected to both digital and interrupt pins on the Arduino to detect rotation and clicks, allowing fine-tuned control over the system.
RTC (Real-Time Clock) Module:
Function: Keeps track of the current time, even when the system is powered off. This ensures that time-based operations as our case setting alarms, are accurate.
Integration: Connected to the Arduino via I2C (SDA and SCL pins), the RTC provides real-time data that the microcontroller can use to trigger events, such as activating a buzzer or updating the display based on a specific time.
LCD Display (I2C):
Function: Displays system information, such as time from the RTC, and message for user interactions.
Integration: The LCD is connected to the Arduino via I2C communication (SDA and SCL pins). The microcontroller sends commands to display relevant information, such as the status of inputs and system notifications.
Buzzer:
Function: Produces sound notifications or alarms. It’s used to alert the user when specific events occur, like an alarm going off at a set time (with the help of the RTC).
Integration: Connected to a digital output pin on the Arduino. The microcontroller controls it by sending HIGH signals, triggering the buzzer to emit sound.
RGB LED:
Function: Provides visual feedback by changing colors based on the state of the system or user interactions. The color changes with each push of a button.
Integration: Connected to three PWM pins on the Arduino (one for each color channel: Red, Green, Blue). The microcontroller controls the color by adjusting the PWM signals, enabling the RGB LED to display different colors in response to button presses.
Arduino Uno:
Function: The brain of the system. It processes the inputs from the buttons, sensors, rotary encoder, and RTC, and controls the outputs to the buzzer, LCD, and RGB LED.
Integration: All input and output components are connected to the Arduino’s pins (both digital and analog). It receives input data, processes it according to the program, and sends appropriate signals to output components.
555 IC as RTC and OpAmp as Rotary Encoder
Voltage Requirements: The Arduino Uno requires an input voltage between 7-12V, and the 9V DC adapter falls within this range, providing enough voltage to power both the Arduino and all connected components.
Current Requirements: The current demand of the connected components (LCD, push buttons, LEDs, rotary encoder, buzzer) is relatively low, and the 9V adapter can easily supply the necessary current without overloading the system.
Reliability and Stability: A DC adapter provides a steady power supply, making it ideal for prolonged use, testing, and development. Unlike batteries, it doesn’t require recharging or replacement, ensuring continuous operation.
The 9V DC adapter connects to the Arduino Uno via its barrel jack, which then regulates the voltage down to 5V to power the connected components. This method ensures a reliable and continuous power supply for the entire system during testing and operation.
A clock that displays time and date while triggering alarms, handling button presses, and controlling an RGB LED.
Alarm One triggers every minute (60 seconds), printing "Alarm One Rings" and "Simulated as 8 hours" on the LCD, while activating a buzzer and a red blinking LED.
Alarm Two triggers every 1.5 minutes (90 seconds), displaying "Alarm Two Rings" and "Simulated as 12 hours" with the same buzzer and LED behavior.
Alarms are implemented using time checks in the handleAlarms() function. Each alarm checks if enough time has passed (currentMillis - lastAlarmMillis) since it last rang.
Button 1 and Button 2 control specific actions. When pressed:
Button 1 turns off the buzzer, lights up the green LED for 3 seconds, and prints "Pills taken!" on the LCD.
Button 2 displays "Don't skip meds!" and turns on the red LED.
The handleButtonPress() function handles the debouncing and actions for these buttons. Debouncing ensures that only one press is registered even if the button is pressed quickly multiple times.
A snooze button is provided to silence the alarm for 10 seconds while turning the RGB LED yellow. After 10 seconds, the snoozed alarm is reactivated.
This is handled in the handleSnoozeButton() function, which sets the alarm back on after the snooze duration ends.
The buzzer is triggered by the alarms and is turned off when a button is pressed or snooze is activated.
The red LED blinks when an alarm is active, using the blinkRedLED() function that toggles the LED on and off at a 500 ms interval.
Green LED lights up for 3 seconds when Button 1 is pressed, and the red LED lights up for Button 2.
The LCD constantly updates to show the current time and date (displayTimeAndDate() function).
Different screens are displayed depending on the state of the system: alarm screens, button press messages, or snooze status. The updateLCD() function manages these states.
To avoid multiple button presses being registered too quickly, a debounce mechanism is implemented. It checks if enough time (50 ms) has passed since the last button press to accept another.
Functions such as handleAlarms(), handleButtonPress(), and updateLCD() help modularize and simplify the code. Each function focuses on a single task, making the program easier to manage and extend.
There were issues with the LCD library and RTC library versions, requiring adjustments in the initialization and handling of alarms.
Button debouncing and preventing multiple buzzer deactivations were also tackled.
The project involves several interconnected modules, including:
Arduino (Main Controller): Handles all inputs, outputs, and communication.
RGB LED: Provides visual feedback through different color lighting.
Buzzer: Provides audible alerts.
LCD Display: Shows real-time temperature and humidity data, along with system status messages.
Push Buttons: Trigger actions such as turning off the buzzer or confirming an alert.
Power Supply: The Arduino is powered by a 9V DC adapter. The Bluetooth module, RGB LED, DHT11 sensor, and buzzer are powered via the Arduino's 5V and GND pins.
RGB LED: Connected to PWM pins (Pin 9, 10, and 11). The color is changed based on input commands from the Bluetooth module.
Buzzer: Connected to a digital pin (Pin 2). It is triggered by the Arduino based on alarm conditions and can be turned off using the push button.
LCD Display: Uses I2C communication (SDA to A5, SCL to A4) to display data. The LCD displays the current temperature and humidity, as well as status messages when actions are performed (e.g., alerts)
Wiring Connections:
Bluetooth Module: VCC to 5V, GND to GND, RX to Pin 0, TX to Pin 1.
RGB LED: Red to Pin 9, Green to Pin 10, Blue to Pin 11, GND to GND.
Buzzer: Positive to Pin 2, Negative to GND.
DHT11: VCC to 5V, GND to GND, Signal to Pin 4.
LCD Display: SDA to A3, SCL to A2.
After integrating the modules, I performed several tests to verify the functionality:
RGB LED Test: The LED changed colors based on commands sent via Bluetooth. For example, sending the command 'Red' turned the LED red, and so on for green and blue. All colors displayed as expected.
Buzzer Test: The buzzer rang for 3 seconds when triggered. Pressing the push button successfully turned off the buzzer.
The demo video will showcase the following:
Real-time display of time and date data on the LCD.
Buzzer activation and deactivation using the push button.
1. Seeking Feedback
I actively sought feedback from colleagues, Instructors, and my friends during the development process. This feedback was critical in refining the project's functionality and design.
Instructors Feedback: My Instructor, Ahmed Sami, provided valuable ideas in design some I took as holders of the shell to base and some as bigger designs I didn't take, Abdelrahman Orabi also for the cover plate design to make it only for protection for the pills only not for the user panel and pills.
2. How I Helped My Peers
Code Optimization Advice: I helped my peers optimize their Arduino code,
Circuit Troubleshooting: During group discussions, I assisted others by troubleshooting wiring issues related to push-button debouncing and incorrect LCD addressing, which were causing their displays to malfunction.
Throughout the project, I encountered various challenges in different aspects like design, coding, and especially fabrication.
Mentor Support: When I struggled with fabrication, I go to Abdelrahman Orabi and here is a photo of how we try again and again to get the final fabricational parts.
Rotary Encoder: When adding the rotary encoder, I had to stop and research how to properly implement it for changing alarm durations. I watched tutorials and read Arduino guides to understand how to debounce and read the encoder correctly, preventing erratic behavior when turning it. the references and videos was provided by Omnia Anas.
Middle Base & Slots: Initially, the middle base had too many slots, which affected UX. I reduced the number of slots for better structure and space efficiency.
User Panel: The original panel layout was cluttered. I spaced out the buttons and LCD for improved usability and visibility.
Hinge Design: I initially included a hinge mechanism, but it added complexity and bulk. I removed it in favor of a simpler cover design for easier assembly.
Improper Timing Logic: One of the pitfalls I faced was not properly managing timing intervals for the alarms, which caused them to overlap and malfunction. When programming alarms, make sure to account for precise intervals and avoid overlapping conditions by using timers like millis() instead of delay(), which blocks other processes.
Ignoring Debouncing: When working with push buttons, I initially faced issues with false triggering due to button bouncing. To prevent this, implement debouncing in both hardware (using capacitors or resistors) and software (by writing code to ignore rapid state changes).
Ignoring Tolerances: A common mistake during 3D printing and laser cutting is failing to account for material thickness and tolerance. In 3D printing, leaving tight fits without proper tolerance may cause the parts to not fit together correctly. Similarly, for laser cutting.
Plan your wiring and layout carefully to avoid messy connections.
Research before implementing unfamiliar components like rotary encoders or Bluetooth modules.
Account for tolerances in both 3D printing and laser cutting to ensure smooth assembly.
Use timers like millis() in Arduino instead of delay() to keep your system responsive.
Sleep
If I had more time, I would focus on refining the user interface by integrating a bluetooth app for easier control and navigation. This would replace physical buttons and make the system more intuitive. Additionally, I would enhance the aesthetic design by incorporating sleeker, more ergonomic 3D-printed parts, improving both the device’s functionality and user experience.