May’s Status Report for 11/15/25

This week I worked with Rhea to finish the first board. We finalized the button-board to LED-board connection and assembled them. Together we ran modular tests—LED and indexing, the button board, and both together—to check mapping and behavior. I also helped prep for the interim demo and updated the Gantt chart with Rhea.

For the second board, I laser-cut the LED board and two iterations of the button board. I worked with Tanisha to restructure the LEDs and run quick checks (LED pattern and switch-matrix tests). I helped assemble the button and LED boards, setting the dowel height so the buttons press reliably. With Tanisha, I updated Rhea’s mapping code for the second board and tested the full system to confirm it works end-to-end.

Verification of Board Design and Peer to Peer Connection Subsystems:

  • LED board tile fit: Place tiles and lightly tilt/tap the board. Pass if tiles don’t slide, are held by the engraved divot, and still lift off easily.
  • LED cutout alignment: Check that each cutout lines up with its LED centerline. Pass if alignment error ≤0.5 mm and no LED is occluded.
  • P2P connection: Peers connect and stay connected without errors.
  • P2P state match: After each action, both peers compute the same state (hash or event log matches).
  • P2P ordering/duplicates: Out-of-order or repeated messages are handled once only.

Tanisha’s Status Report for 11/15/25

This week, I focused on completing the assembly of our second Catan board so that we can transition into synchronization and software integration over the next few weeks. I spent most of my time in TechSpark working on the hardware components. I finished wiring and soldering the entire switch matrix, and May and I worked together to solder and restructure all of the LEDs. I also laser-cut the remaining token and button pieces we needed for the board. Rhea and I assembled the LED board and cut the dowels used for the button-press mechanisms. As a team, we merged the two boards and finalized the LED-to-button mapping. By the end of the day on Friday, we were able to get the second board fully working, which positions us well for the upcoming software work.

I also spent time redesigning the dice-plate algorithm. I reframed the problem so that the algorithm detects the result of each die roll and lights up the corresponding tile, running directly on the Raspberry Pi. A key requirement is identifying when the roll begins and ends so that the board updates only once per roll rather than continuously. To reduce noise, the algorithm focuses only on the visible dice-plate region and filters for black pips on a white face. I experimented with bounding boxes to restrict the detection area and thought about ways to improve reliability, including using a custom die with colored faces so the system requires both the pip pattern and face color to match. I also considered replacing the physical dice entirely with a spinner wheel if it yields cleaner signal detection. I plan to test these ideas next week and begin integrating the algorithm with our tile-lighting logic. Below, I also listed my subsystem verifications:

Verification:

  • Switch matrix (multimeter + press tests):
    Check continuity across all rows/columns with a multimeter and verify each button press registers correctly with no ghosting.
  • LED–button mapping:
    Press each button and confirm the correct LED lights up.
  • Dice detection accuracy:
    Run repeated rolls to confirm correct pip detection under different lighting conditions.
  • Roll start/end detection:
    Verify the algorithm triggers tile lighting only once per roll.
  • ROI filtering:
    Confirm bounding boxes correctly isolate the dice plate and ignore external pips.

We are currently on schedule. With the second board fully assembled, the major hardware tasks are complete, and the dice-detection work is progressing. Next week, I hope to prototype the revised dice-detection strategies, begin setting up the peer-to-peer communication system with Rhea and May, and connect the dice output to the board-lighting logic. I will also document the algorithm’s structure and gather photos and videos demonstrating my progress to support the next status update.

May’s Status Report for 11/08/25

This week, I worked with Rhea on building and testing the switch matrix. We ran into a few minor connection issues, which we resolved through testing and soldering. I also helped soldered the LEDs to fit the Catan board cutout, working modularly and testing as we went. We verified the switch matrix by testing each button individually and checked LED connectivity every few strips.

We encountered more soldering issues than expected when securing the LEDs, so to make debugging easier, we split the LEDs into two separate strips. Our original plan to minimize soldered segments made sense at first, but bending the LED strips to fit the settlement and city layout (three LEDs in a peace-sign shape) caused problems, so I resoldered the broken connections and replacement LEDs. For future builds, we plan to solder those connections separately to avoid bending the strips altogether.

Since both the hardware and software components, switch matrix and LED wiring, now work independently, we’re ready to connect the two boards and start testing how they interact. While assembling the board, we realized we need to add a frosted acrylic layer above the tokens (to mark robbers) and leave more space between the LEDs and buttons. We also decided to fill the engraved numbers with black ink for better visibility.

In addition, I laser-cut the second LED board cutout and the switch matrix. We tested alternate buttons with a higher height, but they proved unstable and sometimes got stuck when pressed. Through this week’s testing and design adjustments, we’re confident we can build the second board more efficiently with these improvements.

Next week, I’ll help finish assembling and testing the second board.

Tanisha’s Status Report for 11/08/25

This week was midterm-heavy, so most of my project work took place later in the week. After exams, May and I focused on completing all soldering for the LED connections and repairing previously broken ones. While we secured the joints with electrical tape, several connections still came loose during testing, so we plan to explore more stable soldering or wire management methods next week.

In parallel, I continued developing the dice detection algorithm. I continue experimenting with multiple approaches, such as background subtraction, bounding box isolation, and DBSCAN clustering, to improve pip recognition accuracy. I successfully integrated the algorithm with the external Etron camera, enabling proper real-time testing. However, differentiating the dice from the surrounding background remains a challenge. Background removal often makes the dice less visible against the plate, reducing detection accuracy below our stated use-case requirement. A sample image of my current progress is below. I also placed orders for extra parts for our new design and second board.

After researching more effective techniques, I realized that pretrained models may not generalize well for our setup. Instead, I plan to train a custom YOLO model using images captured from our specific camera and lighting conditions. I will begin collecting training data once one board is fully assembled, which should be within the next two weeks. With midterms over, I also expect to help complete the second board next week and further refine the dice detection accuracy.

Team Status Report for 11/08/25

This week, we focused on getting one full board to a usable, testable state. That meant rebuilding the switch matrix with sturdier parts, reshaping and mounting the LEDs to match the hex layout, and writing the software path from “button press detected” to “specific LEDs light up.” The goal was to complete a reliable build for the interim demo.

1. Switch Matrix

We rebuilt the matrix with new buttons mounted in a rigid base and used thicker copper wire. This setup reduces flex on solder joints, which was our biggest reliability issue before. The new assembly is a lot stronger, and I think the second board’s matrix will go a lot smoother.

2. LEDs

Because the board requires LEDs to be placed in a hex shape, we had to cut and re-solder the straight LED strip at every turn to wrap each game tile. We also left physical clearance for the dowel attached to each house piece so it can press the button underneath. This step was definitely one of the most time-consuming parts of building the game board.

We initially used duct tape to keep the LEDs attached to the game board, but it didn’t end up being strong enough, so we decided to hot glue each section of the LED strip to the board. Additionally, we wanted to use a single GPIO pin for the entire strip; however, the joints kept breaking, so we ended up splitting the strips and using two GPIO pins. 

3. Software

On the software side, we now have a script that reliably detects button presses and another that can address specific LED indices. We’ve verified that all buttons can be detected and all LEDs light up as expected. We also have a script that will take the button press and light up the corresponding LED index. The only thing that is missing is the mapping table from button press to LED index. Once we assemble the boards on top of each other, we will be able to record the correct mapping and test the code.

4. Dice Plate

The dice plate currently reads faces on a black-and-white die using our computer vision pipeline. It works, but it isn’t consistent due to noise and lighting variation. We believe we need to train a small, task-specific model (or at least collect a dataset under our exact conditions) to improve robustness. This is currently our biggest technical challenge. Once we assemble the boards with the camera, we will collect images and label them, so we can train the model on the actual conditions of our game board.

 

Plan for next week:

  • Align the game board (with the LEDs) with the buttons below it
    • Record which button maps to which LEDs
    • Ensure that pressing a piece on the game board accurates presses the button on the switch matrix
  • Begin working on the second game board
    • Finish the switch matrix
    • Finish restructuring the LEDs
  • Start working on training a new model for the dice plate

Rhea’s Status Report for 11/08/25

This week, I focused on completing the switch matrix and writing core software for button detection and LED response.

May and I built the full switch matrix from start. We started by gluing all the tactile buttons to the baseboard, then soldered copper wire across each column. We had to solder a diode to the other leg of each button, and then another copper wire connecting all the rows. We used electrical tape along every connection to strengthen joints and prevent short circuits between adjacent rows and columns. After finishing the matrix, I worked on the Python code for button press detection. I implemented software debouncing to make sure a singular button press didn’t register as multiple presses. This took most of Tuesday, and by the end, we had a working, stable 11×11 switch matrix that could detect multiple presses simultaneously.

May and Tanisha handled most of the LED re-soldering (I mostly just held wires down for them). I took the strips they finished soldering and taped them in the correct positions around the board to form hex shapes. This took most of our Wednesday work session. The duct tape I used initially wasn’t strong enough, as the joints kept flexing. We decided to switch to hot glue for all sections. On Thursday, May and I secured all the LEDs in place and thoroughly tested them to make sure the connections were strong enough to withstand normal gameplay and movement.

I also wrote the main LED control script, which links button presses to specific LED indices. The program continuously scans the switch matrix, and (1) lights up “house” LEDs when a single button is pressed, (2) lights up “road” LEDs when two adjacent buttons are pressed, and (3) moves the “robber” light when a specific tile button is pressed again. Right now, the code framework is complete: we just need the final mapping between buttons and LED indices once the boards are physically aligned. After that, I’ll test and tune the system for full responsiveness.

We are slightly behind schedule on finishing the second board because the LED re-soldering and mounting took longer than expected. Before the interim demo, we hope to have the first board assembled completely and the mapping between buttons to LED indices recorded. For next week, I plan to work on tuning the software components, as I am out of town for half the week. Once I am back, I plan to help finish the second board and start working on synchronizing the two boards together.

May’s Status Report for 11/01/25

This week I iterated on several CAD versions and made quick laser-cut prototypes to check size and fit. I created CAD for the base board, hex tiles, dice plate and walls, and tokens, and then used the laser cutter to cut and engrave those parts. For the dice plate, I made versions with different wall heights and different wall designs. With the team, I measured spacing between LEDs and cities/settlements and accounted for kerf and a bit of wiggle room so parts place easily – the board cutouts are slightly larger than the pieces. The prototypes confirmed fit and engraving depth and helped me find the best power, speed, resolution, and number of cycles settings for the Epilog machine. The new board has LED-only holes to hide wiring and a shallow divot so tiles don’t move. The dice plate has a locking rim and a smaller hex cutout so the camera can see through the clear plate from underneath.  I ran into issues separating engraving and vector layers because the part was 3D but the DXF export is 2D. I fixed this by redrawing some shapes in CorelDRAW and adding extra sketch outlines in SolidWorks before exporting. Additionally, each full board run takes about three hours, and TechSpark hours sometimes pushed cuts to the next day.

Next week I plan to finish the CAD and cut the middle board that holds the buttons so soldering is stable and aligned with the LEDs. We’re a bit behind because making the cutouts exact took time and we had a setback with the buttons, but we’ve ordered new parts. Now that we know the build, we can move faster and make a second board in parallel. After the middle board CAD and cutting are done, I’ll help with the switch matrix build.

Number Tokens

SolidWorks Board

CorrelDraw Board


The acrylic in the middle is clear, but above has a blue plastic cover on it.

Tanisha’s Status Report for 11/01/25

This week, Rhea and I focused on setting up SSH access for the Raspberry Pi. We initially encountered some connection issues because we needed to complete a head setup before enabling headless access. This was necessary to retrieve the Pi’s MAC address and register the device properly. After troubleshooting, we successfully configured SSH on both Raspberry Pis.

Rhea and I concentrated on building the switch matrix. This required soldering each button in sequence for input connections, followed by soldering diodes and completing all wiring. Although we checked connectivity throughout the process, we found several broken connections at the end. Because each button’s circuit is dependent on the others, fixing the broken ones would have required significant rework. Additionally, the current buttons are difficult to press, and the solder joints aren’t very secure.

To address these issues, we ordered new buttons and asked May to design a new board that will allow for a cleaner and more stable wiring setup. While we’ll need to rebuild the switch matrix, this iteration provided valuable insight into the design and wiring process and helped us identify key improvements for the next version.

In parallel, I worked on assembling the dice plate using the pieces May designed and laser-cut. While May primarily handled the CAD and laser-cutting process, I helped troubleshoot issues with engraving and cutting.  After assembling the dice plate (temporarily held together with hot glue for testing), we found that the angled wall version obstructed the view of the roads and houses on the board. We’ll move forward with a straight-walled design instead.

Because much of my time this week was spent soldering and waiting for laser-cutting jobs to finish, I wasn’t able to thoroughly test the dice algorithm with the new camera.

Once the new buttons arrive, I plan to finish assembling the revised switch matrix and fully test the dice algorithm with the camera in preparation for the interim demo.

Rhea’s Status Report for 11/01/25

I worked with Tanisha to finish setting up the Raspberry Pi with SSH so we could control the board remotely. I also tested the LED strips with the Pi and played with different brightness levels to see what would be most visible on the board and what would work best for roads, cities, and settlements.

I worked with May on the baseboard layout. I took measurements on the actual LED strip and cube pieces to figure out spacing/tolerances, and May translated that into the SolidWorks design so that all the components would line up.

I also set up the switch matrix and did the initial wiring. Tanisha helped with the soldering so everything was secured. While we did connectivity checks at each step, we believe some connections broke as we transported the components or as we continued building upon each piece, as there were still a few flaky connections once we finished. We will be switching to sturdier and bigger buttons and laser cutting a layer for the buttons to prevent all the pieces from moving around next week.

Team Status Report for 11/01/25

This week, we focused on refining the physical layout of the board and integrating all the pieces of the board.

1. Dice tray plate

We laser-cut multiple versions of the dice roll plate to test wall height (short vs. tall walls, and outward-tapered walls). After testing with actual dice, we decided to use tall, straight walls since they keep the dice contained better and look cleaner when integrated into the board.

2. Revised house vs. city indicator design

We changed how we represent houses vs. cities on each tile. To make our game board look cleaner and symmetric, we decided to have three LEDs at each corner. We will light up one for a house and all three for a city. This also works better with the LED strip spacing, as it is easier to route and gives a clearer visual distinction for the player.

3. Base board laser cutting

Our biggest accomplishment this week was finalizing the design we would laser cut for the baseboard. It took multiple iterations to get the dimensions for the cutout for each LED correct so that the wiring is hidden underneath. We are now ready to restructure the individually addressable LEDs to match this layout.

4. Switch matrix wiring

We also finished wiring and soldering the switch matrix. However, during continuity testing, we found intermittent connectivity issues on some rows/columns. The pinouts for the push buttons are very weak, so a few of them broke during soldering. We fixed those and then fortified the connections with electrical tape. Unfortunately, we think there were more issues with the soldering and maintaining connectivity. Rather than continuing to work with the small weak buttons, we decided to just order bigger and sturdier buttons. We also plan to laser cut a dedicated base plate with holes for each button so they are constrained, and hopefully, the solder joints don’t break.

Plan for next week:

  • Rebuild the switch matrix with the new buttons.
  • Laser-cut the switch base board to mechanically support the matrix.
  • Restructure the LED strip to match the board
  • Integrating LEDs + switches (so a button press leads to an LED lighting up)