Carnegie Mellon ECE Capstone, Spring 2026: David Gelody, Patrick Lucas, Aidan Lincke
This week I continued to survey people’s thoughts on the Dawggles, specifically for easiness and comfort. We have been receiving positive feedback for the most part and refining on suggestions to improve the user’s experience. This involves adding a foam pad at the front of the Dawggles and improving the connection between the Dawggles and the iOS app.
Our progress is on schedule.
Next week, I plan to continue working on the navigation feature of the app and finalize the UI with Aidan.
The most significant risk to the project is issues with the translation or navigation apps during the demo. To manage that risk, we’re rigorously testing the apps for debugging and reliability. Additionally, there’s a slight risk that the demo environment may be too bright causing people to have difficulty seeing the display, so we’ve adjusted the brightness and also taken steps to test in different lighting environments.
Changes weren’t made to the design of the system. Instead, we made a few final touches to the CAD of the goggles to make them as comfortable as possible.
There aren’t any changes to the schedule.
Tests:
By working through the semester and making thoughtful design choices, our final Dawggles product passes each of the requirements and tests that we specified at the beginning of the semester. We thus didn’t need to make any design changes.
This week, I continued to work on the software for Dawggles. Specifically, I improved the UI of the Dawggles and the iOS app, and I improved the reliability of the hotspot and web socket connection. I also added a demo mode view to the iOS app so that the app can mirror the display of the Dawggles, and other people can watch demos from the perspective of the person wearing the Dawggles.
Our progress is on schedule.
Next week, we’ll polish the translation and navigation apps so that Friday’s demo works great.
This week I worked mostly on testing and making minor adjustments to the Dawggles. One of the things I worked on was improving string comparison and confidence score in the translation feature. Beforehand, the Dawggles were accepting strings too frequently, causing some of the same translations to be repeatedly displayed. Now, they ignore text that is within a certain similarity and lower in confidence level in order to remove repeats.
This coming week I plan on continuing to fine tune the dawggles and work on preparing for the demo–including the poster.
Overall, progress is on schedule.
This week I spent a lot of time working on the translation on the iOS side. I was able to utilize VNRecognizeTextRequest in Apple’s Vision framework to who real time live translation from and to multiple languages. Furthermore I was able to show the translations and their respective bounding boxes over the live video for debugging purposes and to verify that it was working properly.
I had to do some additional research via google searches and Apple’s documentation to get this working to the desired performance level. One helpful parameter I discovered was the VNRecognizeTextRequest recognitionLevel. Changing from “fast” recognition to “accurate” significantly improved character recognition performance and hardly if at all increased latency of the model.
Overall, I’m really happy with the state of the translation, although there is still some work on handling text groupings and a large quantity of text. I think we’re definitely still on schedule to complete and survey the Dawggles this week.
The project is in its final stages; every risk that could have jeopardized the success of the project has been managed and mitigated.
No changes were made to the existing design of the system.
Our dawggles now smoothly pairs with an iPhone through an iOS app over bluetooth by matching codes. Moreover, we can take a picture with the dawggles, send it over to the phone, translate on the phone, and send the translation back to the dawggles with low latency, meeting the expectation and goals of the project.
Our progress is on schedule.
This week, I worked on the navigation part of our dawggles. Given the space on our display, I could only fit key details such as the estimated time until arrival, the next street to turn onto, and distance until that street. I continued to work with Pat on the translation app to cleanly translate text on images. Moreover, I reached out to several friends to survey for feedback regarding reading text off the dawggles.
Our progress is on schedule.
Next week, I plan to continue surveying for feedback on the dawggles and finalize the navigation app.
New tools and knowledge I had to acquire to work on this project involved learning Swift to work on the app and learning how the raspberry pi can interact with an iPhone. To acquire this knowledge I read documentation online and long discussions with AI tools.
This week, I completed the pairing flow between the Dawggles and iPhone. There’s a smooth and secure user experience where the user just needs to confirm that Bluetooth pairing codes match on both the goggles and the phone. After confirming those matching codes, there’s a secure channel between the goggles and the phone, and the user doesn’t need to interact with their phone anymore for their phone to automatically join the Dawggles Wi-Fi and web socket server. I also set up a bunch of infrastructure around the Dawggles, like the Home screen and the status bar. The Home screen shows all of the apps on the Dawggles that the user can open, and the status bar shows up to date indicators about the connection to the phone and the remaining battery on the goggles.
Progress is on schedule.
Next week, we hope to finish the software for the apps on the Dawggles that we discussed in our use case and requirements. We’ll complete the translation and navigation apps for our described use cases.
As we’ve designed, implemented, and debugged the Dawggles, we’ve learned a lot about optics. Achieving the transparent display effect was the most unknown and difficult part of the project. We also needed to learn a decent bit about CAD and 3D printing in order to create goggles that hold every part together and fit comfortably. We learned the most from online sources and AI tools.
This week, I worked with Pat on the RPi software. I reorganized the code into two main classes for each of the navigation and translation apps; this way it will be much easier to build on the codebase and maintain it, as well as readability of code. Furthermore, I did some testing of the two GPIO buttons to make sure it seamlessly switches between apps and functionality.
Our progress is on schedule.
Next week, I plan to continue assisting with the slight CAD modifications and the iOS app with Aidan. We hope to have basic functionality for the app to connect to the software on the RPi through bluetooth.
As for the verification, I plan to write unit tests for parts of the RPi software in how it stores information and sends data, as well as continue testing it by using it as we have been doing.
This week, I worked with Pat and David on getting everything ready for the demos. We worked on creating a demo that explains the Dawggles and its use cases, shows each feature, and fits with time for questions. After the demos, I also began the Xcode project for iOS and researched the specific entitlements the app needs to use the Bluetooth and Wi-Fi hotspot mechanism between iPhone and Raspberry Pi.
Our progress is on schedule.
Next week, I will continue with the iOS app. The goal deliverable will be a seamless end-to-end pairing experience for a user setting up the Dawggles with their phone.
For verification of our system, I’ve worked a lot on the CAD, so the most important verification test will be the test that measures how many words that the user can comfortably see while wearing the goggles. Another important verification test is the test that ensures that the pipeline from user pressing a button, photo being taken, photo sent to the iPhone, translation occurring, and translation being sent back to the Raspberry Pi occurs within the low latency requirement that we defined.