FlashStride: Train Faster, Run Smarter

This project began with a simple goal: to create a compact, self-contained device that could help runners become more aware of their form and movement. From concept to completion, it became a rich learning experience that combined electronics, design, and problem solving in a meaningful way.

The core idea was to build a device that could monitor motion and provide immediate feedback, without relying on a phone or external tools. This required integrating multiple components—microcontrollers, sensors, a display, and LEDs—into a single, organized system. Beyond just connecting wires and programming the microcontroller, the project demanded careful planning of the physical layout, designing an enclosure that could hold all components securely while remaining easy to assemble and aesthetically polished.

One of the most valuable parts of the project was the integration of design and engineering. Using Tinkercad, I was able to model the enclosure digitally, experiment with layouts, and ensure that all openings and spaces matched the electronics before printing. This digital planning made the physical assembly smoother and allowed me to iterate quickly without wasting materials.

The project also emphasized patience, precision, and iterative improvement. Every step—measuring, cutting, aligning components, and wiring—required careful attention to detail. Learning to troubleshoot problems, adjust placements, and refine the design was as much a part of the experience as assembling the final device.

In the end, this project represents more than a functional device. It reflects creativity, curiosity, and the satisfaction of turning an idea into something tangible. Through building it, I gained hands-on experience in electronics and design, strengthened problem-solving skills, and created a tool that can provide meaningful feedback to runners. This introduction sets the stage for the detailed steps that follow, showing how careful planning, iterative design, and practical assembly come together to create a complete, fully functioning device.

Tools

1. Hot glue gun and glue sticks
2. Craft knife or utility blade
3. Measuring tools (ruler, calipers, etc.)
4. Cutting surface or mat
5. Small clamps or hands for holding pieces while gluing

Materials

1. Arduino Nano
2. MPU6050 accelerometer and gyroscope sensor
3. SSD1306 OLED display
4. Mini potentiometer
5. RGB LED module
6. Rechargeable 9V battery
7. Breadboards (2 mini)
8. Jumper wires
9. Thin wood veneer with plastic backing
10. Foam pieces for mounting breadboards
11. PLA filament for 3D printing
12. Markers or pencils for tracing

Software

1. Tinkercad (for enclosure modeling)
2. PrusaSlicer or other slicing software for 3D printing
3. Cirkit Designer IDE

3D Models

1. Mini Breadboard by WandrModeling on Sketchfab
2. MPU 6050 free download by rom35076 on Sketchfab
3. Display OLED 128X64 by Robótica Paraná on Sketchfab

FlashStride is a simple idea built around a problem that almost every runner experiences: pacing. When you are trying to run faster, it can be surprisingly difficult to know if you are actually maintaining the speed you want. Many runners start too quickly and run out of energy, while others hold back too much and realize afterward that they could have pushed harder. Learning how to hold a steady pace is one of the most important parts of improving as a runner.

FlashStride was created to help solve that problem in a straightforward way. It is a device designed to give runners immediate feedback about how their pace compares to the speed they are trying to maintain. Instead of guessing how fast you are going or constantly checking a phone, the device gives you a quick and clear indication of whether you are on track or need to adjust your speed.

The goal of the project was to keep everything simple and focused on the experience of running. The device monitors motion while you run and estimates your pace in real time. A small dial lets you set the speed you want to aim for, and the display shows how your current pace compares to that goal. With a quick glance, you can tell if you are running at the right speed or if it is time to pick it up.

What makes this project interesting is that it approaches the idea of a running device from a maker perspective. Instead of relying on complicated systems or expensive hardware, FlashStride is built from a few accessible components that work together to provide useful feedback. The result is a device that captures the core purpose of many high-end running gadgets in a much simpler form.

The project is also about experimentation and learning. Building something like this involves combining hardware, sensors, and code to create a tool that interacts with the real world. Along the way it becomes a chance to explore how motion sensing works, how data can be interpreted, and how small devices can be designed to solve everyday problems.

FlashStride fits well with the idea of making things faster, not just in terms of the runner wearing it, but in the way it encourages immediate feedback and improvement. The project is meant to help runners push themselves a little more, stay focused on their goals, and gradually improve their speed over time. At its core, it is a small project built around a simple challenge: helping someone run just a little bit faster.

When you are running and trying to hit a specific pace, it is surprisingly hard to know whether you are actually running at the speed you think you are. Your body’s perception of speed changes constantly during a run. At the beginning, you might feel slow even though you are moving quickly, and later you might feel like you are pushing hard while your pace has actually dropped.

I ran into this problem myself while trying to run at a consistent pace. I would decide before a run that I wanted to hold a certain speed, but once I started moving, it became almost impossible to judge accurately.

For example, imagine trying to run a pretty fast mile. Early in the run, you might feel energetic and end up running much faster than that without realizing it. After a few minutes, you are suddenly out of breath and struggling to maintain the pace because you started too fast. Other times, the opposite happens. You feel comfortable and steady, but when you finish the run and check the time, you realize you were going slower than you intended the whole time.

Even when you try to estimate it manually, it is difficult. One way runners sometimes do this is by checking a clock at certain landmarks. For instance, you might pass a street corner and think, “I should reach the next block in about thirty seconds.” But while you are running, you are also focusing on breathing, watching the ground, avoiding people, and thinking about how your legs feel. Doing mental math while keeping track of time is not easy in the middle of a run.

Another common method is simply judging by effort. If it feels hard, you assume you are running fast. But effort is not always a reliable indicator of pace. Running uphill, into the wind, or at the end of a long workout can make a slower speed feel extremely difficult.

After running into this problem many times, I started thinking about a simpler way to get feedback while running. Instead of trying to constantly calculate pace in my head, it would be much easier if a small device could track my movement and tell me whether I was ahead of or behind the pace I wanted.

That idea became the starting point for FlashStride. The goal was to create something that could give quick, simple feedback during a run so you always know whether you are on track or need to speed up. Instead of guessing your pace, the device compares your movement to a target speed and shows you the result instantly.

After thinking about how difficult it is to judge pace while running, I started wondering what the simplest possible solution would look like. Most running watches and apps focus on giving you a lot of data—distance, heart rate, splits, maps, and more. While that information can be useful, it also means you often have to look down at a screen and interpret numbers while you are in the middle of a run.

I wanted something much simpler. Instead of giving a runner a lot of statistics, the device would focus on answering one question: am I running at the pace I want?

The idea was to create a small device that could track movement and estimate pace in real time. Before starting a run, you would set the pace you want to aim for using a dial. Once the run begins, the device will monitor your movement and continuously compare your current speed to that target pace.

The feedback would be quick and easy to understand. Instead of needing to read detailed numbers or analyze graphs, the device would simply show whether you were on pace or falling behind. With a glance, you could immediately know if you needed to push a little harder or if you were already ahead of your goal.

Another important part of the idea was keeping the hardware simple. The goal was not to build a complicated project, but a focused tool built from basic components. A small microcontroller could run the program, a motion sensor could detect running movement, and a display could show the information. Adding a dial to adjust the target pace would make the device easy to use without menus or buttons.

This concept eventually became FlashStride. The device is built around the idea that improving speed does not always require complicated technology. Sometimes all you need is a simple tool that tells you exactly what you need to know at the moment you need it.

Before physically wiring the components, I planned the entire circuit using Cirkit Designer IDE. This allowed me to visualize how each part would connect and function together, which helped prevent mistakes during assembly.

I began by placing virtual components in the IDE, including the microcontroller, motion sensor, OLED display, potentiometer, and RGB LED. Each component was positioned roughly where it would sit on the breadboard, giving a clear sense of the overall layout.

Next, I drew connections between the components according to the intended wiring. Power and ground lines were routed carefully to ensure every part received the correct voltage. The communication lines, such as the I²C connections for the sensor and display, were drawn to match the Arduino pins they would ultimately connect to. The potentiometer and RGB LED connections were also mapped out to the appropriate analog and digital pins.

Using the IDE made it easy to adjust and reorganize connections digitally before touching the physical components. This step helped identify potential conflicts, such as overlapping wires or crowded breadboard areas, and allowed me to plan a clean, efficient layout.

By the end of this process, I had a complete, virtual representation of the circuit that served as a reliable blueprint for wiring the real electronics. This planning step was crucial for ensuring that the physical assembly would be smooth and error-free.

Before starting any design or assembly work, I gathered all of the electronic components needed for the project. Having everything on hand at the beginning made it much easier to plan the layout and ensured that I could check how the parts would fit together inside the enclosure.

Once collected, I organized the components in a way that allowed me to see and access each piece easily. Grouping the parts by size and function helped keep the workspace tidy and made it faster to reference them while designing the enclosure in Tinkercad.

This preparation step also made it simple to visualize how the electronics would be arranged within the case and helped prevent mistakes later, such as placing components too close together or misaligning the openings for controls. By starting with a complete, organized set of electronics, the entire design and assembly process became smoother and more efficient.

Before positioning the electronics inside the enclosure, I prepared the two mini breadboards to make them easier to mount and more stable once installed. To do this, I placed the breadboards back-to-back, so their connection sides faced outward. This arrangement allowed for a compact setup and kept the wiring more organized.

Next, I cut two small pieces of foam, one for each side of the breadboards. These foam pieces acted as cushioning and support, helping to keep the breadboards securely in place inside the enclosure. I applied a thin layer of glue to each foam piece and pressed it onto the corresponding side of the breadboards.

Once the glue dried, the breadboards were firmly attached to the foam, which made them easier to handle during assembly and provided some shock absorption for the electronics when the device was in use. This preparation ensured that the breadboards would remain stable and properly aligned when inserted into the enclosure later.

After preparing the breadboards, the next step was connecting the OLED display to the circuit. I took the pins of the OLED module and carefully inserted them into one side of the breadboard, making sure each pin went into the correct row for its connection.

Positioning the OLED this way allowed it to sit securely on the breadboard while keeping the wiring organized. By inserting the pins firmly, the display maintained a stable connection and was ready to be linked to the other components in the circuit.

This setup also made it easy to align the OLED with the cutout in the enclosure later, since it could be moved slightly on the breadboard to match the opening while staying electrically connected.

After the OLED was in place, I added the MPU sensor to the breadboard as well. I inserted its pins on the same side of the breadboard as the OLED, but on the opposite section, leaving enough space between the two components for wiring and adjustments.

Placing the sensor on the same side kept all the main connections close together, which made the circuit more compact and easier to manage. By spacing it slightly apart from the OLED, I ensured that the wires wouldn’t overlap or tangle, and both components could be easily aligned with their respective openings in the enclosure later.

This layout also made it simple to connect the sensor to the rest of the circuit while maintaining a clean and organized breadboard arrangement.

With the OLED and MPU sensor in place on the breadboard, the next step was installing the mini potentiometer. I positioned it between the OLED and the MPU, placing it in the middle section of the same side of the breadboard.

This location kept the potentiometer within easy reach for adjustments, while keeping all three main components close together for a compact, organized layout. By carefully inserting its pins into the breadboard rows, the potentiometer was secured in place and ready to be connected to the rest of the circuit.

Placing it between the other components also ensured that it would align neatly with the enclosure opening later, making it easy to adjust once the device was assembled.

After arranging the OLED, MPU sensor, and potentiometer on the first breadboard, the next step was to prepare the Arduino Nano. I placed it onto the second mini breadboard, keeping it separate from the other components to make wiring and positioning easier.

By using a dedicated breadboard for the Arduino, I could organize the power and signal connections more cleanly, and it also helped balance the weight of the electronics inside the enclosure. I carefully inserted the Nano’s pins into the breadboard rows, making sure it sat flat and stable so it wouldn’t tilt or wobble.

This separation also allowed the first breadboard with the sensors and display to be positioned independently, while still being connected to the Arduino. Keeping the Nano on its own breadboard made the overall assembly neater and ensured that each part could be aligned properly when inserted into the enclosure later.

After placing the MPU sensor on the breadboard, the next step was connecting it to the Arduino Nano so it could send motion data to the program running on the device. The MPU communicates with the Arduino using the I²C communication protocol, which allows sensors to send data through two main signal lines.

I started by connecting the power wires for the sensor. The VCC pin on the MPU was connected to the 5V pin on the Arduino Nano, providing the sensor with the power it needs to operate. Then I connected the GND pin of the MPU to one of the GND pins on the Arduino. These two wires are essential because they supply power and complete the electrical circuit.

Next, I connected the communication wires that allow the sensor to transmit motion data. The SDA pin on the MPU was connected to A4 on the Arduino Nano, which is the Arduino’s data line for I²C communication. Then I connected the SCL pin on the MPU to A5 on the Arduino Nano, which is the clock line used to synchronize data being sent between the sensor and the microcontroller.

While making these connections, I tried to keep the jumper wires short and neatly arranged across the breadboard. This helps reduce clutter and makes the circuit easier to troubleshoot if something needs to be adjusted later. Organizing the wiring also makes it easier to fit everything inside the enclosure without wires getting in the way of the other components.

Once all four connections were made—5V, GND, A4 (SDA), and A5 (SCL)—the MPU sensor was fully connected to the Arduino Nano. With these wires in place, the Arduino can read acceleration and motion data from the sensor, which is the key information used by the device to analyze running movement and provide feedback to the user.

After connecting the motion sensor, the next step was wiring the OLED display so it could communicate with the Arduino Nano and show feedback messages to the user. Like the sensor, the OLED display uses I²C communication, which means it only requires four main connections to work.

First, I connected the power pins. The VCC pin on the OLED module was wired to the 5V pin on the Arduino Nano, providing power to the display. Then I connected the GND pin of the OLED to one of the GND pins on the Arduino. These two connections allow the display to receive power and complete the electrical circuit.

Next, I connected the communication pins. The SDA pin of the OLED was connected to A4 on the Arduino Nano, which is the data line used for I²C communication. Then I connected the SCL pin of the OLED to A5 on the Arduino Nano, which is the clock line that synchronizes data between the Arduino and the display.

Because both the OLED and the motion sensor use I²C, they can share the same A4 and A5 pins on the Arduino. This is one of the advantages of the I²C protocol—it allows multiple devices to communicate with the microcontroller using the same pair of signal lines.

While adding these wires, I arranged the jumper wires neatly across the breadboard so they would not interfere with the other components. Keeping the wiring organized also helped ensure that the display and sensor would fit properly inside the enclosure later.

Once the four wires—VCC, GND, SDA (A4), and SCL (A5)—were connected, the OLED display was ready to receive information from the Arduino and display messages during operation.

After connecting the display and sensor, the next component to wire was the potentiometer. The potentiometer acts as an adjustable input device that allows the Arduino to read a changing voltage depending on how the knob is turned. This can be used to adjust settings or tune how the device behaves.

I began by identifying the three pins on the potentiometer. Two of the pins provide power to the device, and the middle pin outputs a variable voltage based on the knob’s position.

First, I connected one of the outer pins of the potentiometer to VCC (5V) on the Arduino Nano. Then I connected the other outer pin to GND. These two wires supply power across the potentiometer so that it can create a variable voltage.

Next, I connected the center pin of the potentiometer to A6 on the Arduino Nano. This pin is an analog input, which allows the Arduino to read a range of voltage values instead of just simple on/off signals. As the knob on the potentiometer is turned, the voltage on the center pin changes, and the Arduino reads this value through the A6 pin.

While making these connections, I kept the wires short and organized on the breadboard to avoid clutter and make the circuit easier to manage inside the enclosure. Once the three wires—VCC, GND, and A6—were connected, the potentiometer was fully integrated into the circuit and ready to send adjustable input values to the Arduino.

I began by wiring the power connections. The VCC pin of the RGB LED module was connected to the 5V pin on the Arduino Nano, providing power to the module. Then I connected the GND pin of the module to one of the GND pins on the Arduino to complete the circuit.

Next, I connected the control pins that allow the Arduino to turn specific colors on and off. The green control pin from the RGB module was connected to digital pin D4 on the Arduino Nano. Then I connected the red control pin from the module to digital pin D3. These digital pins allow the Arduino program to control when each color lights up.

While connecting the wires, I kept them neatly routed across the breadboard so they would not interfere with the other components already installed. Keeping the wiring organized helps prevent accidental disconnections and makes it easier to fit the electronics inside the enclosure.

Once these wires were connected—5V, GND, D4 for green, and D3 for red—the RGB LED module was fully integrated into the circuit. The Arduino can now control the LED colors to provide quick visual feedback while the device is running.

The MPU6050 outputs acceleration values on three axes, which constantly change as the device moves. At first the numbers looked like noise, but once I started printing them to the serial monitor I noticed patterns. When I shook the device or simulated running motion, the magnitude of the acceleration would spike repeatedly.

To simplify things, I calculated the total acceleration magnitude using the three axes. This combines the x, y, and z values into a single number that represents how much motion is happening overall. That made it much easier to work with, because instead of tracking three constantly changing signals, I only had to monitor one.

The next step was figuring out what counts as a step. Running creates a very distinct motion pattern: acceleration rises as the foot strikes and the arm swings, then it drops again. I wrote a small piece of logic that looks for these peaks in the motion magnitude. If the acceleration rises and then falls past a certain threshold, the code counts that as a step.

Of course, random movement can also cause spikes, so I added some limits to filter out unrealistic step timing. For example, if two detected steps happen too quickly, they are ignored because they are probably noise. Real running cadence tends to fall within a predictable range, so this simple timing check works surprisingly well.

Once a step is detected, the program records the time between the current step and the previous one. This interval becomes the key measurement that allows the device to estimate running pace.

Detecting steps was only part of the challenge. The real goal of the device is to estimate running pace and compare it to a target pace set by the user. To do this, I needed to convert the timing between steps into an estimate of speed.

The idea is fairly straightforward. When someone runs, each step covers a small distance called stride length. By measuring how frequently steps occur, it’s possible to estimate how fast the runner is moving. If the device detects a step every half second, that corresponds to a cadence of 120 steps per minute. From there, the program multiplies cadence by an estimated stride length to approximate speed.

I used a typical stride length value as a starting point. This obviously varies from person to person, but it gives a reasonable approximation for demonstrating the concept. Once the speed is estimated, the program converts it into a pace measurement expressed in minutes per mile.

One thing I noticed early on was that calculating pace from a single step interval produced unstable results. The pace value would jump around constantly because every step is slightly different. To solve this, I averaged the timing from several recent steps. This smoothing process makes the displayed pace feel much more realistic and stable.

Finally, I added a condition so that if no steps are detected for several seconds, the device assumes the runner has stopped and clears the pace display. This prevents the device from showing misleading values when it is sitting on a table or when the runner pauses.

With pace detection working, the next feature I wanted was a way to compare the runner’s current pace against a target. This is where the potentiometer comes in. The potentiometer acts like a dial that lets the runner quickly choose a goal pace before starting a run.

In the code, the potentiometer value is read using an analog input. This value ranges from 0 to 1023, so I mapped that range to a realistic set of running paces between four minutes per mile and twelve minutes per mile. Turning the knob clockwise or counterclockwise instantly changes the target pace.

The device constantly compares the measured pace to this target value. If the runner is moving faster than the target pace, the green LED turns on to indicate they are ahead of schedule. If the runner is slower than the target, the red LED lights up to signal that they need to speed up.

This simple feedback system is one of the parts I like most about the project. Instead of constantly checking numbers on the screen, the runner can glance down or even just notice the LED color to know whether they are on track. It makes the device feel more like a training tool rather than just a sensor readout.

At this point the device could read motion, detect steps, estimate pace, and provide visual feedback based on the runner’s goal. The remaining work mostly involved refining the display and making sure the system behaved reliably during different types of movement.

After testing different ideas and gradually refining the logic, I eventually arrived at the final version of the code that runs on the device. This version ties together all the pieces of the project: the accelerometer, the OLED display, the potentiometer, and the pacing LEDs. The main goal was to make the system simple enough to run reliably on an Arduino while still giving useful feedback during a run.

The program starts by initializing the I²C devices, since both the OLED display and the MPU6050 accelerometer share the same communication bus. Once the devices are connected, the code performs a short one-second calibration period. During this time, the device measures the accelerometer values while it is sitting still. These readings are averaged and stored as offsets, which allows the program to subtract the constant gravity component from future measurements. This step is important because it ensures that the motion detection logic only reacts to actual movement instead of the static acceleration caused by gravity.

After calibration, the main loop runs continuously. Each cycle reads the latest acceleration data from the MPU6050 and calculates a single motion magnitude value from the three axes. Using a combined magnitude instead of individual axes simplifies the step detection process, since the orientation of a wrist can change constantly while running.

The program then checks for step events by looking for peaks in this motion signal. When a peak is detected and the timing matches a realistic running cadence, the code records the time since the previous step. Instead of using just one step interval, the program stores several recent intervals and averages them. This smoothing step helps keep the displayed pace stable rather than jumping around with every stride.

With the averaged step timing available, the program estimates cadence and converts it into a pace measurement. This value represents the estimated time required to run one mile at the current speed. If no steps have been detected for several seconds, the code assumes the runner has stopped and clears the pace value so the display does not show misleading information.

At the same time, the potentiometer is read to determine the user’s target pace. The raw analog value is mapped into a range from four minutes per mile to twelve minutes per mile, which covers most typical running speeds. The program compares the measured pace with this target and updates the LEDs accordingly. When the runner is moving faster than the target pace, the green LED lights up. If they are slower than the target pace, the red LED turns on instead.

Finally, the OLED display is updated to show the current pace and the selected target pace. Keeping the display layout simple makes it easy to read at a glance while running. The screen refreshes continuously, giving the runner near real-time feedback on how their pace compares to their goal.

Before designing the enclosure and mounting structure for my project, I needed to make sure everything was accurately scaled. When designing something that will hold electronics, guessing the size of components almost always leads to problems. If the model is even a few millimeters off, parts may not fit, connectors may collide, or the device might not close properly after printing. To prevent this, I used reference parts in Tinkercad so that my design matched the real-world dimensions of the electronics I planned to use.

The first component I placed into the workspace was the Arduino board, since it acts as the main controller for the device. Fortunately, Tinkercad already includes a model of the Arduino Nano in its Electronics components library. I dragged this component directly into the workspace and used it as the central reference for the rest of the design. Having the Arduino Nano model available made it much easier to determine where the enclosure walls, mounting space, and wiring channels needed to go.

Next, I needed a reference for the potentiometer that would be used in the project. Unlike the Arduino Nano, there was not a perfect match available in the Tinkercad electronics library. Instead of searching endlessly for an exact model, I decided to design a simplified reference version myself. Using basic shapes like cylinders and boxes, I recreated the approximate dimensions of the potentiometer body and shaft. This approach worked well because the purpose of the reference part was simply to reserve space and ensure correct alignment, not to perfectly replicate every tiny detail of the real component.

For several other components in the project, I used 3D models from online sources. Many hardware parts have already been modeled by other makers and uploaded to online model repositories. I searched for models of the remaining components and downloaded them in a format compatible with Tinkercad. After downloading the files, I imported them into my design using the Import tool. Tinkercad allows STL and OBJ files to be imported directly, which makes it very easy to bring external models into the workspace.

After importing the models, I carefully checked their scale and orientation. Sometimes models downloaded from the internet are exported in different units, so they may appear too large or too small at first. If necessary, I adjusted the scale so that the model matched the real-world dimensions of the component. Once scaled correctly, these models became additional reference parts that I could design around.

With all the reference parts in place, I arranged them inside the workspace to simulate how the real electronics would be positioned inside the device. This allowed me to verify several important design factors, such as:

1. Ensuring enough space for each component
2. Leaving room for wiring and connectors
3. Making sure the Arduino Nano could be easily inserted or removed
4. Aligning openings in the enclosure with the correct hardware locations

By building the design around these reference components, I was able to avoid one of the most common problems in 3D printed electronics projects: parts not fitting together after printing. Instead of relying on estimates, I used real dimensions and models to guide the design process.

Taking the time to gather and place reference parts ultimately made the design much more reliable. It allowed me to confidently scale the entire project and ensured that when the parts were finally printed, the electronics would fit exactly as intended.

Once I had gathered all of my reference parts and confirmed the correct scale, I began designing the first side of the enclosure in Tinkercad. This side of the device was especially important because it contains several of the key components used in the project. In my physical prototype, this side holds the display and sensors that interact with the user, so I carefully modeled the layout to match how the real electronics would be positioned.

To begin, I placed the reference models for the main components into the workspace. These included the OLED display module, the accelerometer sensor, and the potentiometer. By arranging these parts first, I could design the enclosure around the actual hardware, rather than trying to fit the hardware into a finished design later.

The display I used for the project was a small I²C OLED module, which I represented in the model using a reference part for the SSD1306 OLED Display. I positioned this near the outer face of the enclosure so that the screen would be visible once the device was assembled. To accommodate it, I created a rectangular cutout in the front wall of the enclosure using a hole shape. This opening was carefully sized so the screen would sit flush with the outside surface while still being supported by the surrounding structure.

Next, I positioned the accelerometer module. For motion sensing, the project uses an MPU6050, which detects the movement of the shoe while running. Because this sensor needs to accurately detect motion, I placed it near the center of the enclosure so it would experience consistent movement along with the rest of the device. I also made sure that it was oriented correctly so that the axis directions would align with the direction the shoe moves while running.

The potentiometer was the third component placed on this side of the design. Since this part needs to be accessible for adjustment, I positioned it so that the rotating shaft would extend toward the outside of the enclosure. To make space for it, I created a circular opening in the wall of the case where the shaft could pass through. This ensures that once the device is assembled, the knob can be easily turned without needing to open the enclosure.

With the main components placed in their approximate positions, I began constructing the structural parts of the enclosure. I used basic Tinkercad shapes such as boxes and cylinders to form the outer wall and internal supports. The reference models for the electronics acted as guides, allowing me to adjust the walls and mounting areas until everything fit comfortably without overlapping. I also left extra space around the parts to allow room for wiring and connectors, which are often overlooked during the early design stages.

To keep everything aligned properly, I used the Align tool and the Ruler tool in Tinkercad. These tools helped me ensure that components were centered, spaced evenly, and positioned at the correct distances from the enclosure walls. This step was important because it ensured that the physical version of the device would be both functional and visually organized.

By the end of this stage, the first side of the enclosure was fully assembled in the digital model. It included the display window, sensor placement, and potentiometer opening, all positioned according to the layout of my real prototype. Designing this section first allowed me to establish the overall structure of the device and ensured that the most important components had the space and alignment they needed to function correctly.

After completing the first side of the enclosure that held the display, accelerometer, and potentiometer, I moved on to building the second side of the device in Tinkercad. This side of the design needed to hold the main controller and the wiring connections for the rest of the electronics.

From the previous step where I gathered reference parts, I had already imported a model of a small breadboard from an online source. I used this same breadboard model to represent how the wiring would actually be arranged in my physical prototype. I placed the breadboard on the opposite side of the enclosure from the display and sensors so that the internal layout of the device would be more organized.

Next, I added the Arduino Nano to the workspace and positioned it directly on top of the breadboard model. This mirrors how the electronics are assembled in the real build, where the Arduino Nano plugs into the breadboard to make wiring connections easier. By placing the Arduino on the breadboard in the model, I could clearly see how much space the board would take up and how the pins would be arranged.

Once both parts were positioned, I adjusted their placement so they were centered within the enclosure and left enough room around them for jumper wires. Since the OLED display, accelerometer, and potentiometer on the other side of the device all connect back to the Arduino, it was important to leave space where wires could pass between the two sections.

Modeling this second side after the real electronics layout helped ensure the enclosure would fit all of the components properly. It also made the design much easier to understand, since the internal structure of the model closely matches how the device will actually be assembled in real life.

After positioning the Arduino and breadboard on the second side of the enclosure, I added the RGB LED module that would be used for visual feedback. This component is used to display different colors depending on how the device interprets the running data, so it needed to be placed somewhere visible while still fitting cleanly within the internal layout of the device.

In my digital model inside Tinkercad, I placed a reference model for the RGB LED Module near the breadboard where the rest of the electronics were located. Instead of placing it directly in the center of the breadboard, I attached it along the outer edge. This placement closely matches how the module would be used in the real build, where components often sit near the edges of breadboards so that wires can be routed more easily.

Positioning the LED module along the edge had a few advantages. First, it allowed the LED itself to be closer to the outer wall of the enclosure so that its light could be easily seen from the outside. Second, it prevented the LED module from blocking the Arduino Nano or interfering with other wiring connections that run through the breadboard. Finally, placing it at the edge created more open space in the middle of the breadboard for jumper wires and other components.

To attach the module in the model, I aligned it carefully with the rows of the breadboard reference model and adjusted its height so that the pins would appear to insert into the breadboard surface. I also made sure it was positioned in a way that would leave enough clearance between the LED module and the enclosure walls. This ensured that when the real device is assembled, the LED will have enough room to fit comfortably without being squeezed or blocked.

By adding the RGB LED module at the edge of the breadboard, I was able to keep the internal layout organized while still making sure the LED would remain visible and functional in the final build. This small design choice helps improve both the usability and the appearance of the finished device.

After positioning the Arduino and breadboard on the second side of the enclosure, I added the RGB LED module that would be used for visual feedback. This component is used to display different colors depending on how the device interprets the running data, so it needed to be placed somewhere visible while still fitting cleanly within the internal layout of the device.

In my digital model inside Tinkercad, I placed a reference model for the RGB LED Module near the breadboard where the rest of the electronics were located. Instead of placing it directly in the center of the breadboard, I attached it along the outer edge. This placement closely matches how the module would be used in the real build, where components often sit near the edges of breadboards so that wires can be routed more easily.

Positioning the LED module along the edge had a few advantages. First, it allowed the LED itself to be closer to the outer wall of the enclosure so that its light could be easily seen from the outside. Second, it prevented the LED module from blocking the Arduino Nano or interfering with other wiring connections that run through the breadboard. Finally, placing it at the edge created more open space in the middle of the breadboard for jumper wires and other components.

To attach the module in the model, I aligned it carefully with the rows of the breadboard reference model and adjusted its height so that the pins would appear to insert into the breadboard surface. I also made sure it was positioned in a way that would leave enough clearance between the LED module and the enclosure walls. This ensured that when the real device is assembled, the LED will have enough room to fit comfortably without being squeezed or blocked.

By adding the RGB LED module at the edge of the breadboard, I was able to keep the internal layout organized while still making sure the LED would remain visible and functional in the final build. This small design choice helps improve both the usability and the appearance of the finished device.

After blocking out the enclosure using a rounded rectangular prism, the next step was to refine the overall shape so it would better fit the electronics and be easier to use. While the rounded shape looked good, the top and bottom surfaces were still slightly curved from the original rounded prism. This made it harder to create stable mounting surfaces for the electronics and would also make the device more difficult to open or access if adjustments were needed later.

To solve this, I modified the shape in Tinkercad by flattening the top and bottom surfaces of the enclosure. I did this by placing rectangular hole shapes over the curved sections and grouping them with the enclosure block. When grouped, these hole shapes remove material from the model, effectively trimming the curved sections and leaving flat surfaces behind.

Flattening these areas served two important purposes. First, it created flat mounting surfaces inside the enclosure where components such as the Arduino Nano and breadboard could sit securely. Flat surfaces make it much easier to position electronics accurately and prevent them from shifting around inside the case.

Second, having flat top and bottom surfaces makes the enclosure much more practical when it comes to assembly and access. A flat top allows for the possibility of creating a removable lid or access panel later in the design. This is useful if the electronics ever need to be repaired, adjusted, or reprogrammed. It also makes the device easier to place on a surface during testing, since it will sit level rather than rocking on curved edges.

When designing an enclosure for electronics, one of the most important steps is creating space inside the model so the components can actually fit. In Tinkercad, this process is simple thanks to the Hole feature, which allows shapes to subtract material from other shapes.

I started with the outer shell of the enclosure, which was originally a solid rounded rectangular block. While this shape worked well for the exterior design, it obviously needed to be hollowed out so that the Arduino Nano, breadboards, wiring, and other components could be placed inside.

To create the hollow interior, I first duplicated the exact same shape that was used for the outer shell. Using the same base shape ensured that the internal cavity would perfectly match the overall form of the enclosure. After duplicating it, I converted the copied shape into a Hole object in Tinkercad.

Next, I slightly shrunk the hole shape on all sides. This step is important because it leaves a thin wall around the enclosure instead of removing the entire interior. The amount the shape was reduced determines the thickness of the walls, so I adjusted the size carefully to make sure the enclosure would be strong enough while still leaving plenty of internal space for the electronics.

Once the hole object was properly resized, I aligned it with the original solid shape so that it sat perfectly centered inside the enclosure. Proper alignment is important because even a small offset could result in uneven wall thickness or parts of the enclosure being accidentally removed.

Finally, I grouped the two shapes together. In Tinkercad, grouping a solid object with a hole subtracts the hole from the solid. As soon as the shapes were grouped, the interior of the enclosure was cut away, leaving a hollow shell that could hold the electronics.

This technique is one of the easiest ways to hollow out an enclosure in Tinkercad because it maintains the exact outer shape while quickly creating an interior cavity. By shrinking the duplicate hole shape slightly before subtracting it, I was able to control the wall thickness and ensure the enclosure remained both lightweight and strong enough to hold the components securely.

Once the enclosure was hollowed out, the next step was planning where openings would be needed so the electronic components could be accessed from the outside. Since the device includes a display and adjustable parts, the enclosure needed carefully placed cutouts that line up with the hardware inside.

I continued designing the enclosure in Tinkercad. To make sure the openings would be placed correctly, I first positioned the 3D models of the electronic components inside the enclosure. This included the display and other parts that would need to be visible or reachable once the device was assembled. Placing the components inside the model helped me clearly see where the openings needed to be located.

Next, I created new shapes that would act as the openings. In Tinkercad, these shapes can be set as Hole objects. For example, the display required a rectangular opening so the screen could be seen from the outside of the enclosure. I resized a rectangular hole shape so it matched the visible area of the screen and then moved it directly over the display model.

I repeated this same process for any other parts that required access, such as areas where controls or connectors needed to reach the outside of the enclosure. Each hole shape was resized and moved until it lined up with the correct component.

To help position everything accurately, I used the Align tool in Tinkercad. This made it easier to center the hole shapes with the components and keep the layout neat and organized. Using alignment tools also helped ensure the openings would be placed evenly and in the correct position relative to the enclosure walls.

By the end of this step, the enclosure model contained all of the planned hole shapes positioned over the components that needed access. This allowed the design to be carefully checked and adjusted before moving on to the next stage of refining the enclosure.

Once the openings were planned and the components were arranged relative to each other, the next step was moving the entire electronics layout into the enclosure. Doing this made it possible to check that everything would actually fit inside the case and line up with the openings that were created earlier.

Working in Tinkercad, I first selected all of the electronic component models that represented the internal hardware. This included parts such as the Arduino Nano, breadboards, display, sensor, and any other reference components used in the layout. By selecting them all together, the entire electronics assembly could be treated as one group of objects while positioning it.

After selecting the components, I moved the entire electronics layout so that it sat inside the hollow enclosure. This step involved carefully adjusting the position in all directions to make sure the components were centered within the internal cavity and not intersecting with the walls of the case.

Placing the electronics inside the enclosure allowed me to visually confirm that the spacing worked properly. I could easily see if a component was too close to a wall, too tall for the enclosure, or not aligned with one of the planned openings. If something looked off, it was easy to move the components slightly until everything fit comfortably within the available space.

This step essentially treated the enclosure as a container and the electronics as a single assembly that needed to fit inside it. By positioning the entire electronics layout within the case at this stage, it became much easier to verify the overall design and ensure that all components would be located in the correct place when the enclosure design was finalized.

After confirming that the electronics were positioned correctly inside the case, the next step was to actually create the openings in the enclosure. Since the hole shapes had already been placed over the areas that needed access, this step was mainly about applying those shapes to the enclosure itself.

Still working in Tinkercad, I first selected the enclosure along with all of the hole shapes that were positioned on it. In Tinkercad, hole objects are used to remove material from solid shapes when they are grouped together.

Once these shapes were selected, I used the Group function. Grouping combines the objects into a single model and applies the hole shapes to the enclosure. This process creates the cutouts exactly where the hole objects were placed earlier, forming the openings for the display and other accessible components.

After the grouping step was complete, the enclosure contained all of the necessary openings. At this point, the electronic components that had been temporarily placed inside the enclosure were no longer needed for editing the case itself.

To keep the workspace organized, I selected the internal component models and moved them back out of the enclosure area. These components were only used as reference models to help position the openings and check the internal spacing. With the enclosure now finalized, moving them aside made it easier to focus on the finished case model and prepare it for exporting or further adjustments if needed.

By the end of this step, the enclosure had been transformed from a simple hollow shell into a functional case with properly placed openings for the electronics.

Once the enclosure design was finalized, the next step was preparing it for 3D printing. Because the electronics need to be installed inside the case, the enclosure had to be split into two separate halves so it could be opened and assembled later.

I performed this step in Tinkercad. First, I created a flat cutting shape that would divide the enclosure into two parts. This shape was positioned so it passed through the middle of the enclosure, creating a clear top half and bottom half.

Using this shape, I separated the enclosure so that the internal cavity would be accessible after printing. Splitting the case into two pieces makes it much easier to place the electronics inside, route the wiring, and secure the components before closing the enclosure.

After the enclosure was divided, each half became its own individual object in the design workspace. This allowed me to check that both pieces looked correct and that the internal cavity remained accessible for the electronics.

With the enclosure successfully separated into two halves, the final step was exporting the models for 3D printing. Tinkercad allows designs to be downloaded in several formats, so I selected each half of the enclosure and exported them as STL files, which is the standard format used for most 3D printers.

Exporting the files prepared the enclosure for the next stage of the project: slicing and printing the parts. Once printed, the two halves of the case can be assembled around the electronics to create the finished wearable device.

After exporting the enclosure halves from Tinkercad, the next step was preparing the files for 3D printing by slicing them in PrusaSlicer. Slicing converts the 3D model into instructions that a printer can follow, including layer height, infill, supports, and print orientation.

I started by opening PrusaSlicer and importing the STL files for the top and bottom halves of the enclosure. Once imported, I positioned each half on the virtual print bed to maximize stability and ensure a successful print. Orientation is critical—flat sides were placed against the print bed to reduce the need for supports and improve layer adhesion.

Next, I adjusted the print settings based on the enclosure’s requirements. Because the walls needed to be strong enough to protect the electronics, I chose a slightly thicker wall and a moderate infill percentage. I also checked that any openings, such as the display cutout and control holes, were fully supported during printing. For areas that overhang, I enabled minimal supports so the printer could build these sections cleanly.

I then previewed the sliced layers in PrusaSlicer to verify that everything looked correct. The layer view helped me confirm that the walls were consistent, the openings were preserved, and there were no floating parts or potential printing issues.

Finally, once I was satisfied with the settings and the layer preview, I exported the sliced files as G-code. This file contains the printer instructions for each layer, which can be sent directly to the 3D printer to start producing the enclosure halves. By slicing carefully in PrusaSlicer, I ensured that the printed parts would fit together properly and provide a solid, functional case for the electronics.

Once the enclosure models were sliced and the G-code was ready, the next step was 3D printing the two halves. I used a standard FDM 3D printer to produce the parts from PLA filament, which is easy to print and strong enough for this wearable device.

First, I prepared the printer by loading the filament and leveling the print bed. Proper bed leveling is important to ensure the first layer adheres correctly, which is critical for printing flat surfaces like the top and bottom of the enclosure.

Next, I transferred the sliced G-code files for the top and bottom halves to the printer. I started with one half at a time, making sure each part was correctly oriented on the bed. The flat sides of the enclosure were placed down to provide a stable base and reduce the need for supports.

During printing, I monitored the first few layers to ensure they were sticking well and that the extrusion was consistent. Once the first layers looked solid, I let the printer complete the remaining layers. Printing each half took some time, depending on the wall thickness, infill, and layer height that had been chosen in PrusaSlicer.

After each half finished printing, I carefully removed it from the print bed and cleaned up any small imperfections, such as minor stringing or support remnants. This preparation ensures that the two halves will fit together smoothly when the electronics are installed.

By printing the enclosure in two halves, I created a case that is easy to assemble and strong enough to protect the internal components, while still allowing access to the electronics for adjustments or maintenance.

To create a clean, finished panel for the control area, I used a thin wood veneer with a plastic backing. First, I placed the veneer over the area of the enclosure that it needed to cover and used it as a guide to trace the shape directly onto the surface of the veneer. Accurate tracing ensured that the veneer would match the panel dimensions exactly, including any openings for buttons or the display.

After tracing, I carefully cut along the lines using a sharp craft knife. I scored the veneer lightly at first, then went over the lines more firmly to complete the cut. The plastic backing helped keep the veneer rigid while cutting, preventing it from bending or tearing.

This method produced a panel that perfectly matched the control area, ready to be attached for a neat and polished finish.

Once the wood veneer panel was cut to the correct shape, the next step was attaching it to the enclosure. I used a hot glue gun for this because it bonds quickly, holds securely, and works well with both plastic and veneer surfaces.

I first positioned the veneer over the control panel area to make sure it fit perfectly. Then, I applied small dabs of hot glue along the edges and a few spots in the center of the veneer. Working carefully, I pressed the veneer down onto the enclosure so it adhered evenly, making sure it was flush with the surrounding surface.

After a few seconds, the glue cooled and hardened, holding the veneer firmly in place. This created a smooth, finished appearance over the control panel while keeping the openings for buttons and the display fully accessible. The hot glue also allowed for slight adjustments during placement, ensuring the veneer sat perfectly on the enclosure.

To connect the top and bottom halves of the enclosure neatly, I used another piece of thin wood veneer. This piece would wrap around the edge of the enclosure and act as a decorative wall between the two halves.

First, I measured the perimeter of the enclosure where the strip would sit. I then transferred these measurements onto the wood veneer and marked the cutting lines carefully. Accurate marking was important to make sure the strip would fit snugly all the way around the case.

Next, I cut the veneer strip using a sharp craft knife. I scored lightly at first to create a clean guide, then cut fully through along the lines. For corners or curves, I made careful adjustments, cutting small sections at a time to ensure the strip could bend or wrap smoothly without cracking.

This cutting process produced a long, even veneer strip that could later be glued around the enclosure edge, serving as both a visual wall and a way to connect the two halves cleanly.

With the enclosure halves and decorative veneer ready, the next step was placing the electronics inside the top half of the case. I began by carefully inserting the components into the internal cavity of the top enclosure, making sure each part lined up with its corresponding opening.

The potentiometer was pushed gently through its designated hole, allowing the knob to sit flush with the exterior so it could be easily adjusted. At the same time, I aligned the OLED display with its cutout, ensuring that the screen was fully visible and seated neatly behind the opening. Proper alignment was important so that the display could be read clearly and the controls remained accessible.

After positioning the main components, I added a rechargeable 9V battery to power the device. The battery was placed inside the enclosure where it fit comfortably, and the leads were connected directly to the VIN and GND pins of the Arduino Nano. This provided stable power to the microcontroller and all connected components.

Once everything was inserted and aligned, I double-checked that the potentiometer, display, and battery were seated properly and that there was enough clearance inside the top half of the enclosure for the other electronics. This careful installation ensured the device was ready to be assembled fully with the bottom half.

After the electronics were installed in the top half, the next step was to apply the side wood veneer strip around the edges. This strip not only created a clean, finished look but also acted as a wall to help align the top and bottom halves of the enclosure.

I started by measuring and cutting a small slot in the veneer for the charging port. This slot needed to line up exactly with where the rechargeable 9V battery would be connected to the Arduino’s charging input. Carefully marking and cutting the slot ensured that the charger could be plugged in without interfering with the wood veneer or the enclosure’s fit.

Next, I positioned the veneer strip along the top half of the enclosure. Working slowly, I applied small dabs of hot glue along the edge and pressed the veneer into place. The plastic-backed wood allowed the strip to bend slightly around corners while keeping its shape, so it hugged the edges smoothly. I continued along the entire perimeter, making sure the veneer stayed flush and the charging slot remained clear and unobstructed.

Once the veneer was applied all the way around, I double-checked the alignment of the slot and the overall fit. The strip created a polished edge that not only enhanced the visual finish but also provided a guide for attaching the bottom half of the enclosure. The charging port slot ensured the device could be powered easily without needing to remove the side veneer, combining functionality with a clean, professional appearance.

With the top half of the enclosure prepared, electronics installed, and edges wrapped with veneer, the next step was connecting the bottom half of the enclosure to complete the case. This step required careful alignment to ensure the two halves fit together neatly and securely.

First, I took the 3D-printed bottom half and checked its fit against the top half. The veneer strip around the top half acted as a guiding wall, so the bottom half could slide snugly into place. I held the top half steady and gently lowered the bottom half over the edges, making sure that it aligned evenly along the entire perimeter. This process involved moving slowly and adjusting the angle slightly to ensure the veneer wasn’t bent or damaged and that the halves met flush with each other.

Once the bottom half was properly seated, I pressed the edges together lightly to make sure there were no gaps. I checked all sides visually and with my fingers, making sure the veneer strip stayed in place and acted as a tight guide for the fit. The snug fit is important because it keeps the electronics secure inside and gives the enclosure a clean, professional look.

After confirming that the bottom half fit correctly, I applied small amounts of hot glue along the interior edges where the two halves met. Working carefully in sections, I pressed the halves together while the glue cooled, ensuring a strong bond without misalignment. The glue reinforced the connection, keeping the top and bottom halves firmly attached while maintaining the smooth edge created by the veneer.

By taking the time to carefully slide the bottom half into the veneer and then gluing it in place, the enclosure became a sturdy, complete case. The electronics were fully enclosed, the veneer provided a polished finish around the edges, and the device was ready for testing and use.

With the side veneer applied and the charging slot cut, the next step was setting up the charging connection for the rechargeable 9V battery inside the enclosure. The slot in the veneer allowed access to the charging port without removing the wood or the electronics.

I took the charging cable and carefully threaded it through the slot in the veneer, making sure it passed smoothly without bending sharply or catching on the edges. Once the cable was in position, I guided the connector to the battery compartment inside the top half of the enclosure.

Next, I plugged the charger directly into the 9V rechargeable battery, connecting it securely to the terminals. I made sure the connection was firm but not forced, so that the battery could charge safely. The slot in the veneer allowed the cable to remain accessible from the outside while keeping the enclosure looking clean and uninterrupted.

After the charger was connected, I verified that the cable had enough slack to avoid strain and that the battery was seated properly. This setup ensured that the device could be recharged easily without needing to disassemble the enclosure, maintaining both functionality and a neat finish.

Using the device is straightforward and user-friendly. Before starting, ensure the rechargeable battery is fully charged by inserting the charging cable into the slot on the side of the enclosure. The slot is designed to make charging easy and convenient without needing to open the device, so you can quickly prepare it for use at any time.

The device can be placed in a pocket, clipped to a belt, or attached in another way that keeps it secure while running. Adding a clip is optional, depending on your preference, but it helps keep the device stable and easily accessible. The main goal is to position it so that you can quickly glance at the display and see the feedback while you move.

During use, the OLED display shows your current running pace and compares it to your target pace, providing real-time feedback on how well you are maintaining your desired speed. The RGB LED acts as a quick visual guide: green indicates that you are on pace and meeting your goal, while red signals that you are off pace and may need to adjust your speed. Together, the display and LED allow you to monitor your performance without needing to constantly focus on the device, giving you both immediate and easily interpretable feedback.

The potentiometer on the device lets you adjust the target pace while running. Turning the knob changes the pace goal, allowing you to increase or decrease your target as needed. This feature makes the device flexible for different workouts or running conditions, giving you control over the feedback it provides without stopping or removing it from your pocket or clip.

After finishing a run, the device can be removed and recharged through the side slot. Its compact design, simple controls, and clear feedback system make it easy to use repeatedly. By providing both visual cues and numeric feedback, the device helps you stay aware of your pace and encourages more consistent and effective running over time.

The final product is a fully assembled device that combines all the components into a compact, functional unit. The enclosure houses the electronics securely, with openings for the OLED display, potentiometer, and charging slot. The edges are wrapped with thin wood veneer, giving the device a smooth, finished look while keeping everything sturdy.

The OLED display shows the current pace and compares it to the target pace, while the RGB LED provides a clear visual indication—green when on pace and red when off pace. The potentiometer allows easy adjustment of the target pace, making the device adaptable to different running goals.

The device is small and portable. It can be carried in a pocket, clipped to a belt, or attached in another convenient way, allowing it to remain stable during movement. The components are carefully arranged to keep the device balanced and durable.

In the end, the final product is a practical, self-contained tool that delivers immediate pace feedback, is easy to use, and combines electronics, design, and assembly into a polished, functional device.

Creating this project was a meaningful and rewarding experience. It was an opportunity not only to build something functional, but also to learn through experimentation, problem solving, and creativity. Projects like this remind me how powerful it can be to take an idea and slowly turn it into something real through patience and persistence.

Throughout the process, I learned the value of designing, testing, adjusting, and trying again. Not everything works perfectly on the first attempt, and that is part of what makes building projects so valuable. Each challenge becomes an opportunity to learn something new, whether it is about electronics, design, or simply thinking through a problem from a different perspective.

More than anything, this project reinforced how enjoyable it is to create things with your own hands. From the earliest idea to the finished device, every step involved exploration and discovery. Seeing a concept gradually take shape is incredibly satisfying and inspiring.

I hope this project encourages others to experiment, build, and try new ideas of their own. You do not need perfect tools or perfect knowledge to start creating something interesting. Curiosity, creativity, and a willingness to learn are often the most important ingredients.

In the end, this project represents much more than just a device—it represents the process of learning, building, and growing through making. And that, to me, is the most valuable outcome of all.

I would like to take a moment to sincerely thank the people and organizations who supported me throughout the process of creating this project. Building something like this takes time, experimentation, and patience, and I am very grateful for the encouragement and resources that made it possible.

First, I would like to thank Autodesk for developing Tinkercad. Tinkercad played a major role in the design of this project, especially when creating the enclosure for the electronics. Being able to quickly model shapes, test ideas, and visualize how the components would fit together made the design process much more accessible. The platform allowed me to experiment freely and refine the design step by step until the enclosure was ready to be printed. Tools like this make it possible for students and makers to turn ideas into real physical objects, and I am very thankful that such resources are available.

I would also like to give a heartfelt thank you to my parents. Their support, encouragement, and patience helped make this project possible from beginning to end. They supported my interest in building things and experimenting with electronics, and they provided the time, space, and resources needed to work on the project. Their encouragement helped me stay motivated even when parts of the project required troubleshooting or redesigning. Having people who believe in what you are working on makes a huge difference, and I am extremely grateful for their support.

I would also like to thank my friends, who showed interest in the project and encouraged me throughout the process. Even simple conversations about the idea, seeing the progress, or offering feedback helped keep me motivated while building and refining the device. Working on projects like this is always more enjoyable when you have people around you who are excited to see what you are creating.

Finally, I am thankful for everyone who encourages curiosity, creativity, and hands-on learning. Projects like this are a great way to explore engineering, electronics, and design, and they would not be possible without supportive people and accessible tools. I am deeply grateful for the encouragement and inspiration that helped turn this idea into a finished project.