Adrian’s Status Report for 2/21/2026

This week, I translated the UI requirements and data schema outlined last week into a functional interactive prototype with the use of Cursor.

The four operator questions from last week drove every design decision:

1. Where exactly have we searched?
The “spheres” concept from last week became a 2D sparse occupancy grid overlaid as a color heatmap directly on the map canvas. The map is divided into 2m × 2m cells, and every time a bot passes through a cell its visit count increments. The heatmap shades from dark green (lightly visited) through yellow-green to amber (heavily covered), giving the operator an immediate sense of search thoroughness and gap areas without any SLAM computation. This is purely positional history — lightweight and fast exactly as intended.

2. Where do we suspect the target is?
The global map view centers on the operator’s position as the origin. All bots are rendered relative to that anchor with live position updates. Target detections appear as pulsing red markers directly on the map at their reported (x, y) coordinates. I also added proximity halos around each bot — a color gradient ring (red when far from any known target, shifting to green when nearby) that gives the operator an at-a-glance sense of which bots are closing in on a detection.

3. Are the bots healthy and coordinated?
Rather than a hover tooltip, I implemented a persistent fleet status sidebar that keeps all bot health data visible at all times without requiring interaction. Bots are grouped into named clusters (Alpha and Beta) in collapsible accordions. Each bot card shows its ID, status badge (Searching / Returning / STUCK? / Idle / Lost), a color-coded battery bar with percentage, its assigned role (Scout / Anchor / Line / Relay), and its live coordinates. If a bot enters a STUCK? state the card highlights in red and a blinking indicator appears. The cluster accordion header also shows average battery and flags the cluster immediately if any bot is stuck, so the operator can triage quickly.

4. What should be done next?
The target alert payload schema from last week is fully implemented. Each alert carries a map location (x, y), confidence score rendered as HIGH / MEDIUM / LOW with color coding, and a sensor rationale string (e.g. “RF/UWB reflection detected”). When the operator clicks a target marker on the map, a popover appears with the full payload — location, confidence meter, rationale, and timestamp — along with an ACKNOWLEDGE action to clear it from the active alert queue. Unacknowledged targets accumulate a badge count in the top bar, so nothing is missed even if the operator is focused elsewhere on the UI.

 

At the beginning of the mission, all 7 bots have just entered the search corridor, and the occupancy heatmap is starting to form as a small green cluster in the right portion of the map. The sidebar shows all bots are healthy at 70–83% battery. No targets have been detected yet, and the top bar target counter reads zero; the operator controls are fully available.

Few minutes later, the bots have covered over 800 cells and have triggered 9 unacknowledged target alerts. The operator has clicked a target marker on the map, opening the TARGET DETECTED popover. It displays a MEDIUM confidence score of 77%, the precise map coordinates (X: 58.4m, Y: 21.0m), the sensor rationale (“Audio Anomaly Detected”), and the timestamp of the detection. The operator can ACKNOWLEDGE to log and dismiss it or Dismiss to close without recording. This directly demonstrates the actionable intelligence payload defined in last week’s schema.

Later on, the heatmap has grown to cover the majority of both the base room and the search corridor, with warm amber tones indicating areas of dense revisitation and the characteristic green-to-amber gradient showing thoroughness at a glance. Nineteen target markers (all unacknowledged) are distributed across the map as pulsing red rings. Bot trail lines are visible as faint white streaks showing each bot’s recent path.

On the performance side, the simulator and rendering pipeline run at approximately 3 Hz (333 ms tick), sitting comfortably within the 1–5 Hz target refresh rate defined last week.

Progress is on schedule. The mockup and initial implementation milestones are both complete.

For next week, the priorities are to begin the process of replacing the mock simulator with a live WebSocket or ROS bridge to ingest real bot telemetry, implement the SET BOUNDARY geofence drawing tool on the map, and begin stress-testing the refresh pipeline with the actual number of bots and update frequency we expect from hardware.

Team Status Report for 2/21/2026

Risks:

Right now, our biggest risk is whether our power distribution plan actually works the way we expect. If it turns out our current approach isn’t sufficient, we’d need to revise the design and order new components, which could slow down full prototype integration. That said, this isn’t immediately blocking us. Most subsystems (UWB comms, microcontroller setup, UI work, etc.) can still be developed over USB power. Power becomes critical once we start integrating locomotion and running the full search stack, so we have some buffer before it affects system-level progress.

Design and Schedule Changes ?

No changes were made to the system design this week. All major revisions to our use case and corresponding design updates were completed last week, so we’re continuing forward with that finalized architecture.

Since there were no new design changes, our schedule remains the same heading into this week.

On the implementation side, we made solid progress. We got the ESP32-S3 devkit fully up and running in the ESP-IDF VSCode environment with clean build/flash/monitor workflows.  Also, we figured out how to debug directly on the board using GDB, which will help a lot once we start diving into programming our robots. On the hardware side, we secured access to 2S LiPo batteries and selected voltage regulators for distributing power to different subsystems.

Brooks’s Status Report for 2/21/2026

Accomplishments:
This week my main accomplishments were determining the components needed to power both the microcontroller and the UWB SoC, as well as getting started with programming on the ESP32-S3 devkit we got a hold of.

Regarding power, our team decided to use a 2S LiPo battery which will give us a supply voltage of around 7.2V. Since both the ESP32-S3 devkit and the UWB devkit either run on USB or 5V supply, I picked out a suitable buck regulator from spark fun that is rated to supply up to 3.5A continuously which will be plenty to handle brief current spikes due to RF transmission.

As for programming on the devkit, I first made sure I was able to use the ESP-IDF for building, flashing, and monitoring serial output straight through my terminal:

Running Hello World from terminal

I chose to start with this so that if I encountered problems using the VSCode extension (the recommended way), I would have a better understanding of what was going on behind the scenes. I then moved to setting up and using the VSCode extension for set up so that I would have a proper development environment, as the extension makes the process of setting up your serial ports, setting the target, etc much easier or automatic:

Running Hello World using ESP-IDF VSCode Extension

Lastly, I made sure I knew how to properly debug and spent time figuring out how to use the extension to launch an OpenOCD server and begin debugging with JTAG and GDB. This step had some minor issues I had to sort through regarding which compiler was getting automatically selected by pressing the run and debug button, but after getting it all sorted I was able to set breakpoints and single step in GDB:

Debugging Hello World with GDB and ESP-IDF VSCode extension

Scheduling:

After the hiccups from the previous week, we are doing okay scheduling wise. We have finalized our BOM as a group and worked out the details of how all of our components are going to hook up (e.g. power) and which regulators or breakout boards we’d need. Also, I had planned on getting the development environment set up, which is mostly complete now with getting all the ESP-IDF things set up so I can now interact directly with the board. However, I was unable to get microROS set up. I tried using the micro-ROS component for the ESP-IDF but was having trouble flashing an example to the board this way and was unable to get this method to work and will need to continue troubleshooting or determine another way of running a micro-ROS agent on the board.

Next Week’s Deliverables:

In the next week I want to first get a micro-ROS agent publishing from the board first over serial, and then over WiFi UDP. In order to do this, I’m going to step away from trying the microROS component for the ESP-IDF and will instead be trying to get a normal ROS2 setup going on my laptop first, as I believe this may fix the issues I’ve been having with the component for the IDF.  I will need to create an Ubuntu partition on my Windows laptop as ROS2 requires a Linux environment, and then I can see if that fixes things. I know that other people have managed to get a microROS agent running on the board we are using, so I just need to figure out what method will work for us. Lastly, since we are partially limited by the work we can do until our components have arrived, my goal is to get a micro-ROS agent fully running on the devkit as a publisher with my laptop set up as a subscriber. Once we are able to publish data and read it on the laptop, I can start working with Adrian on how to connect the data we are getting from ROS to the boiler-plate UI he is working on.

Brooks’s Status Report for 2/14/2026

Accomplishments:
This week, after our team narrowed the project scope from general search and rescue to urban search and rescue on a single building floor, we split responsibilities by subsystem. My role was to evaluate the viability of ultra-wideband (UWB) as a localization method to correct accumulated error from dead reckoning and to choose a UWB hardware path that we can realistically prototype within our timeline. I researched how UWB behaves in indoor, floor-level environments (multi-room layouts, reflections/multipath, and possible non-line-of-sight), compared integration options with a focus on practical bring-up and documentation quality, and ultimately decided on the DWM3001 as the module direction. While working, I made some rough illustrations regarding our communications stack and how it will work to explain my thoughts to the rest of my group.

Progress:
Overall, we are slightly behind schedule, primarily due to constructive feedback after our proposal presentation that required a meaningful restructure of the project goal. We shifted from a broad “general search and rescue” framing to a more concrete demonstration of the value of multi-robot search in an urban environment, specifically, a single building floor, so some of this week’s effort went into revising scope and re-planning deliverables. To catch up, we are locking the narrowed scope so we stop burning time on requirements, pushing to complete the BOM and place orders immediately to avoid delays in purchases, and parallelizing integration work using the development hardware we already have so software progress isn’t blocked while we wait for parts. My time this week reflects that split: roughly 4 hours on UWB research, 4 hours in group planning meetings, 2 hours on module comparison and selection, and 2 hours reading general communications/distributed systems/networking papers to inform our coordination assumptions.

Scheduling:
Next week, our team’s goal is to complete our BOM and have all parts ordered so the build phase can begin without further slowing our schedule. As for me, I plan to start hands-on work with the borrowed ESP32-S3 devkit to begin bringing up the core software environment and laying the groundwork for integrating our stack (including micro-ROS on top of FreeRTOS), and I will convert the DWM3001 decision into a practical integration direction—how we’ll interface the module, what data we expect to use, and how those updates will be used to correct dead-reckoning drift during our floor-level demo. I’ll also keep the communications graphic updated as the architecture solidifies so we have a clear, consistent reference for how robot-to-robot and robot-to-base interactions are supposed to work.

Adrian’s Status Report for 02/14/2026

This week, I focused on formalizing the user interface requirements and metadata needed to support our refined use case as discussed in the team status report. I established four main questions that the UI must address for the operator in real-time:

1. Where exactly have we searched? Instead of using a complex SLAM map, the UI should render past positional data as “spheres,” which would create a lightweight visual history of where the bots have been. We use a 2D density heatmap that will overlay these trails to indicate search thoroughness in order to highlight gaps in coverage.

2. Where do we suspect the target is? The UI should only focus on the global view of the map with all the bots, which includes the operator’s position as the origin. This would provide immediate context for the operator to understand where the bots are relative to themselves.

3. Are the bots healthy and coordinated? The operator should hover over each bot and see its battery level, comms status, and cluster formation.

4. What should be done next? The target alert payload should likely include that map location (x, y), confidence score (0-1), and sensor rationale (e.g. RF/UWB reflection) to give the operator some actional intelligence rather than pure raw data.

I also thought highly of the data constraints and refresh rate the UI needs to satisfy to ensure smooth performance for the operator. The target UI refresh rate should be 1-5 Hz, which should be sufficient for our “dead reckoning” approach and reduce the computational overhead compared to the 30 FPS required for full visual SLAM, aligning with our low-cost and low-power constraints.

I have successfully translated our updated use case into specific UI requirements and potential data schemas. The design specifications are fairly detailed enough to begin designing the frontend mockups. For next week, I should be able to create a visual mockup of the dashboard layout/wireframe and start thinking further about the data schema that should be present to the operator for communication between the bots and the base station laptop.

Team Status Report for 2/14

Refined Use Case: Urban disaster area search for a single operator

(Definition of Search: reducing the area a Search and Rescue Team believes there will be a survivor)

Our team has finished our requirements and our design that satisfies those requirements to fit this newly refined use-case. It looks very similar to what we displayed in previous posts, but with key considerations noted below:

We are keeping the two motor per arm implementation. While our emphasis is not on being agile anymore, it is still more desirable to get over rubble that will be very likely present than to be limited to what our wheels can get over.

We have moved away from needing to care as much about size, as our use case does not necessitate it to be that small anymore. However, we still need to be mindful of cost. But, this gives us room to have a larger battery, and overall better equipment.

We are not doing fancy things like having the robots attach or jump anymore, as cool as that would be, it is not feasible for our MVP (and Josh is not a MechE)

We are using UWB as our primary method of localization / sensing, and for that to function it needs anchors. Anchors need to be stationary, and you typically need at least 3 to have readings at cm accuracy (which we want as all error accrues over time). Therefore, a working system will need at least 4 functional robots (3 that stay still while the other moves). In initial testing and our MVP we only need two to move and prove the distributed system effective, the rest can be stationary.

Our UI will be visualizing the paths that our robots have followed, and give color to those lines based on their proximity to a person (our MVP will be using a stationary anchor not ascribed to a bot). We will not be doing complicated SLAM things.

Joshua’s Status Report for 2/14/2026

I don’t have much to show for it again (well, I at least have the image below), but I have largely focused on learning how to use FreeCAD. Our design considerations are finished (see team post for details, also my personal relevant points are rehashed below), so now I want to port at least something over to CAD to have for our presentation this week.

We are keeping the two motor per arm implementation. While our emphasis is not on being agile anymore, it is still more desirable to get over rubble that will be very likely present than to be limited to what our wheels can get over.

We have moved away from needing to care as much about size, as our use case does not necessitate it to be that small anymore. However, we still need to be mindful of cost. But, this gives us room to have a larger battery, and overall better equipment.

We are not doing fancy things like having the robots attach or jump anymore, as cool as that would be, it is not feasible for our MVP (and I’m not a MechE)

Brooks’s Status Report for 2/07/2026

Accomplishments:

This week, we all spent time nailing down our use-case and requirements, and the MVP which would meet these. Our group has been meeting after class this last week to talk about our design plans and potential changes we might need to make, especially after getting feedback from our proposal presentation. I also spent time familiarizing myself with the ESP-IDF and microROS. Overall, this week was mostly spent researching microcontroller options and how to use RF reflection for target identification.

Since we’ve narrowed down our project’s requirements and have decided to use microROS, Zigbee, and WiFi, I spent time looking at microprocessors which would enable us to use these.

Notes on microprocessors and DevKits for our requirements:

Microprocessor + DevKit Consideration Notes (1)
Microprocessor + DevKit Consideration Notes (2)

Progress and Schedule:

The project is on schedule so far, but to stay on track we have to finalize our design by the end of next week, earlier better than later. This will allow us to spend the remaining days in the week, or weekend, finishing our presentation slides for the design presentation. I feel like I am in a good spot regarding my portion of the design and am on schedule.

Hopes for Next Week’s Deliverables:

For next week, I want us all to work together to finish the design for a single bot. For myself, I want to finalize decisions on microcontroller devkits, and whether or not we need an additional antenna on board for signal transmission + reception. I’d also like to merge this with the rest of my group mates so we know where all of these components will sit inside the bot, in order to finish the CAD design.

Adrian’s Status Report for 02/07/2026

  1. What did you personally accomplish this week on the project? Give files or photos that demonstrate your progress. Prove to the reader that you put sufficient effort into the project over the course of the week (12+ hours).
    • I’ve started designing the solution approach for CatomBots search and rescue that focuses on multi-robot search, pathfinding, and cluster-based collaboration
    • Jotted down thoughts on annotated visualization for user interface:
      • Coverage heatmaps for global, cluster, and individual bot views to visualize exploration efficiency
      • Target confidence regions to show detection certainty and prioritize search areas
      • Robot clustering behavior to visualize how bots group and share tasks dynamically
    • Defined some UI requirements and performance targets for global/cluster/robot views, latency, FPS, etc. Those metrics will guide both frontend design and backend data handling
  2. Is your progress on schedule or behind? If you are behind, what actions will be taken to catch up to the project schedule?
    • Currently, I am on schedule.  I plan to continue refining the UI structure and system logic over the coming days. By the end of next week, I expect to have the core UI concepts and layout solidified, ensuring that the team can begin implementation without delays.
  3. What deliverables do you hope to complete in the next week?
    • Translate UI requirements into a concrete frontend mock or data schema
    • Formalize cluster formation and task allocation logic, including defining how robots will decide when to form or dissolve clusters based on mission context and sensor data

Team Status Report for 2/07/2026

Risks:

At the moment, we are working on the design of our robots and what sensors, actuators, and microcontroller we will need to make our system work. The biggest risk in jeopardizing the success of the project at this stage would be making poor design choices, as our ability to implement the movement, communication, and searching of our robots highly depends on the choices we make now. In order to ensure that our design includes the components needed for implementation, we’ve divided subsections of the system among the three of us which we are responsible for.  Josh is focusing on linkages, body, and locomotion. Adrian is responsible for ensuring we have the proper sensors for obstacle detection and SLAM. Brooks is responsible for the RF communications components, microcontroller, and target detection.

Design State:

Thus far, we haven’t had to make any changes to our requirements nor design, but we expect the possibility minor tweaks or adjustments to the design in the coming week as we begin to finalize our parts list.

Schedule Changes?

We have made no changes to our schedule. We are still planning to finish our design this week so we can begin ordering parts, and to prepare for the upcoming design presentation.

Photos:

Initial Drawing of CatomBot Exterior: