Team Status Report for 2/21/2026

Most Significant Risks & Mitigation
The main risk this period is uneven bandwidth during the transition from Design Review to implementation. Mario was focused on exams and had limited deliverable output, while Cindy completed the Design Review and hardware prep.
Mitigation: we are dividing work clearly. Cindy is leading hardware bring-up and firmware deployment on the ESP32 nodes; Mario is owning CI pipeline coverage, MQTT evaluation, and Raspberry Pi familiarization. Spring break may push some of Mario’s deliverables into the following week but we’re still ahead of schedule overall, so we’re not adjusting milestones yet.

 

second risk is scope creep around the message broker. After a professor’s feedback that Redis may be overkill, we’re considering MQTT as a simpler alternative.
Mitigation: We will treat MQTT as an optional/alternate path rather than a full swap so that hardware integration and latency validation can proceed on the existing stack. Any MQTT adoption will be phased in so it does not block bring-up.

 

Design Changes
As mentioned, we are evaluating MQTT as an alternative to Redis for device-to-backend messaging. No other design or scope changes this week. The three-subsystem architecture (access control, environmental, lighting) and validation strategy remain as presented in the Design Review.

 

Schedule Updates
We completed the Design Review and received key hardware (Raspberry Pi 5, RFID modules, sensors). Parts are inventoried and stored in the designated lab storage. We remain ahead of schedule. The Gantt chart showed that we were in the backend/RPi/MQTT setup and early implementation; we instead had a full stack in place and have now finished the Design Review and hardware prep. The next two weeks are allocated to hardware bring-up (Cindy) and CI/MQTT/RPi work (Mario). Spring break may shift some of Mario’s deliverables (e.g., 50% coverage, MQTT exploration) by about a week; we will reassess after break if needed.

 

Progress & Technical Highlights
  • Design Review: Architecture was consolidated into clear presentation materials, including updated system block diagrams for all three subsystems (lighting, access control, environmental). Implementation, testing, and project management plans were formalized, and the task schedule was reorganized into a Gantt chart with clear firmware/hardware and backend/frontend division. Faculty and peer feedback from the proposal (scalability, safety, integration) was incorporated into the design narrative and validation approach.
  • Hardware readiness: Raspberry Pi 5, RFID reader modules, and sensors were received, inventoried, and secured in the Hamerschlag lab storage. Datasheets were reviewed, GPIO pin assignments confirmed, and wiring layouts planned for each node. Firmware structure was aligned with the physical hardware so that flashing and subsystem validation can start as soon as wiring is complete.
  • Technical positioning (no direct code deliverables): CI/CD approach was refined in line with coverage practices from another course, with the goal of applying that to the monorepo. Redis vs. MQTT was identified as a design trade-off to resolve in the coming weeks; MQTT will be explored as an alternate broker without blocking current integration work.
Planned next steps: Hardware bring-up and firmware deployment (wiring ESP32s to RFID, relay, and dimmer; validating sensor reads and actuator control; debugging firmware and ESP32–RPi communication). In parallel: push toward ~50% test coverage on the repo, evaluate MQTT integration path, and dedicate 2–3 hours to RPi 5 setup and CLI familiarization.

Mario’s Status Report for 2/21/2026

No deliverable contributions were made this week. Looking back on last week’s report, I severely over estimated what we could accomplish in 7 days; mostly because of upcoming exams I’ve been studying for. Even so, considerable progress was still made.

Key contributions included:
Much of what was “contributed” was just learning in preparation for certain modules of our project.

  • CI/CD: In my AI ML class we’ve spent a considerable amount of time discussing how to do complete test coverage of code we create. Now I feel extremely comfortable approaching and establishing a robust CI pipeline for our GitHub monorepo.
  • System Design: After having an extensive discussion with one of the lead capstone class professors, I’ve realized a key error in our tech stack for this project. Due to the nature by which I’ve learned system design up to this point, the software stack I created for the IoT has an overengineered message broker (Redis). I now realize this is overkill and we could potentially opt for a less intricate solution like MQTT.
  • Parts: Our requested RFID modules and the RPI 5 have arrived and are in our possession. I went ahead and locked these parts inside one of the red boxes provided to us at the Hamerschlag lab hall.

Is your progress on schedule or behind?
We’re still way ahead of schedule so I’m not worried that we went one week without a deliverable.

What deliverables do you hope to complete in the next week?
Here’s what I plan to hopefully get done by the end of next week; to be honest it’ll probably drag on to the week after since it’ll be spring break!

  • CI Pipeline: I’ll try and get at least 50% code coverage on the current GitHub repo we have. That way we’ll be certain there aren’t any vital tests gone awry.
  • Software Stack: I’ll figure out a way to use an MQTT instead of a Redis stream. Since it’s already implemented as such, the MQTT will most likely be a separate (alternate) to our message broker of choice.
  • RPI 5: We need to get accustomed to using the RPI software. At least 2-3 hours will be dedicated to familiarizing myself with the coding language and its CLI.

Cindy’s Status Report for 2/14/2026

This week focused on finalizing our Design Review materials and formalizing the firmware architecture for all three ESP32 subsystems (Access, Environmental, and Lighting). I rebuilt the full system specification diagram to clearly partition the Web Dashboard, Raspberry Pi backend, event/data layer, and House Model hardware nodes, explicitly showing sensing → compute → actuation flows and labeled interfaces (Wi-Fi, HTTPS/WSS, I2C, ADC, PWM, GPIO). I expanded our quantitative use-case and design requirements to include detailed latency targets for access control (<500 ms 95th percentile), permission revocation (<100 ms), dashboard updates (<1 s), manual dimmer response (<300 ms), and automatic daylight harvesting (<1 s), and mapped each to a corresponding validation method for the Design Review. I also refined Slide 9 and Slide 10 content to clearly separate buy/build/integrate responsibilities and define measurable pass/fail criteria without overcrowding the slides.

On the firmware side, I defined a consistent monorepo structure under with separate directories. I finalized GPIO assignments, clarified SPI/I2C/ADC/PWM boundaries, and incorporated a local control loop within the lighting node so daylight harvesting remains responsive even if backend latency fluctuates. I also updated the power budget to account for PWM dimming loads and relay-driven devices.

I am on schedule and slightly ahead in terms of architectural readiness. While hardware integration is the next major milestone, the system partitioning, validation strategy, and firmware structure are now clearly defined and review-ready. Next week I plan to flash firmware onto physical ESP32 boards, wire the RFID reader, BME280, TEMT6000, solenoid lock, and relay modules, validate secure WebSocket communication with the backend, generate TLS certificates for device authentication, and begin collecting baseline latency measurements for access control and lighting response.

Team Status Report for 2/14/2026

Most Significant Risks & Mitigation
The primary risk this week shifts from architectural uncertainty (now resolved) to hardware integration reliability. With the full software stack now implemented, the next phase requires all three ESP32 subsystems to communicate reliably with the backend over Wi-Fi via WebSocket. If any node experiences connectivity issues, dropped packets, or firmware crashes, it could delay our end-to-end validation timeline. Our mitigation plan is as follows: (1) the frontend dashboard already includes local fallback logic so the UI remains fully demonstrable even if a hardware node is offline, and (2) we will bring up one subsystem at a time (access control first, then environmental, then lighting) rather than attempting all three simultaneously, isolating integration failures to a single node.

A secondary risk is meeting our defined latency targets (<500 ms for access control, <300 ms for manual dimmer, <1 s for daylight harvesting) once real network hops and TLS overhead are introduced. We plan to start collecting baseline latency measurements immediately after firmware flashing to detect any performance gaps early, giving us time to optimize before the demo.

Design Changes
We expanded the project scope from two subsystems (access control + environmental sensing) to three by adding a full intelligent lighting control subsystem with daylight harvesting. This decision was made because the lighting hardware (TEMT6000, PWM dimmer, 4-channel relay) was affordable and the architectural pattern mirrors the existing subsystems closely, allowing us to demonstrate a more compelling “smart building” narrative at low additional risk. The backend, frontend, firmware structure, and documentation have all been updated to reflect this addition.

Schedule Updates
We are currently ahead of the original schedule. The Gantt chart called for backend environment initialization, MQTT schema definition, and initial Raspberry Pi setup this week. Instead, we delivered a nearly complete full-stack implementation. This puts us in a strong position to dedicate the coming weeks entirely to hardware integration, testing, and optimization rather than splitting time between software and hardware.

Progress & Technical Highlights
This was our most productive week to date. The repository went from a bare initial commit to a fully structured monorepo with 10 merged pull requests spanning every layer of the system. Highlights include:

  • A working FastAPI backend with 12+ REST/WebSocket endpoints for sensor ingestion, lighting control, and device management
  • A production-ready React dashboard with real-time analytics, access control management, lighting controls, and admin authentication
  • Three fully scaffolded PlatformIO firmware projects with defined GPIO assignments, communication protocols, and local control loops
  • Docker Compose infrastructure (TimescaleDB with hypertables + Redis) and a GitHub Actions CI pipeline
  • Comprehensive documentation: API reference, architecture guide, setup/troubleshooting guide, user guide, and testing strategy
  • AI-assisted development was used extensively (GitHub Copilot agent and Cursor) for code generation, with all output reviewed, bug-fixed, and integrated by Mario. Cindy independently finalized the firmware architecture, system specification diagram, and Design Review materials.

Part A (Mario): Public Health, Safety, and Welfare
Safety-wise, one of the main deliverables for this project is the access control subsystem (RFID + electromagnetic door lock). It’s supposed to mimic the entrance of a house and provides security for those within by ensuring that only authorized people can enter. Even if someone tampers with the ESP32 node, since it has a web-first architecture, the door can’t be actuated without server-side authorization. As for the fail-safe, I’m unsure of whether it should default to locked or unlocked in case of a fire or an attempted break-in.

From a health and welfare standpoint, the environmental monitoring subsystem (BME280 temperature/humidity/pressure sensor) provides real-time indoor climate data with ±0.5°C accuracy. This directly helps better an occupant’s comfort and can potentially detect HVAC failures. The lighting control subsystem with daylight harvesting automatically adjusts artificial lighting to maintain normalized (300 lux) light levels, which research has shown impacts occupant circadian rhythms and psychological well-being. Since the entire system is designed to be remotely operable via a web dashboard, if used for a massive building, this could support building managers in maintaining healthy indoor environments even when they’re away.

Part B (Mario): Social Factors
Our platform’s web-first design philosophy has meaningful social implications. By requiring that all building functions route through a centralized, authenticated web dashboard, we are creating a system that promotes transparency and accountability. Every door access event is logged with timestamps, user ID, and grant/deny reasons, creating an extensive auditable record. In a shared living environment, this could have the fallback of nurturing a feeling of overbearing security.

The dashboard’s policy management interface allows building administrators to define super specific access rules (time-of-day restrictions, per-user permissions), which empowers communities to collectively govern their shared spaces. However, we also realize that such systems can be used for surveillance or discriminatory access control. Our design mitigates this by making the audit log visible to all authorized users and making it use role-based access for the policy engine itself. Culturally, the project reflects a societal shift toward “smart” living environments; we have intentionally designed the UI to be accessible and intuitive (flat design, clear visual hierarchy, real-time feedback) so that it doesn’t create a digital divide between tech-savvy and laymen occupants.

Part C (Cindy): Economic Factors
The smart home system addresses economic factors primarily through energy cost reduction and scalable infrastructure design. The lighting control subsystem’s daylight harvesting feature automatically dims artificial lights when sufficient natural light is detected, directly reducing electricity consumption. Studies estimate that daylight-responsive dimming can reduce lighting energy use by 20-60%, which translates to meaningful cost savings for building operators — especially at commercial scale.

Our technology stack was selected with economic efficiency in mind: we use open-source software throughout (FastAPI, React, TimescaleDB, Redis, PlatformIO) with zero licensing costs, and commodity hardware (ESP32-S3 at ~$7/unit, BME280 at ~$3, TEMT6000 at ~$2). The total bill of materials for our prototype is under $80, demonstrating that intelligent building management is achievable at a fraction of the cost of proprietary commercial solutions (which can run $10,000+ for a single building). By publishing our system under the MIT License and documenting a reproducible architecture, we contribute to the broader ecosystem of affordable building automation, lowering the economic barrier for small property owners, educational institutions, and developing communities to implement professional-grade building controls.

Mario’s Status Report for 2/14/2026

This week marked a significant transition from planning and architecture into active implementation. My primary focus was building out the full software stack; initializing the repository scaffolding, implementing the backend API and lighting control subsystem, and making a semi-decent frontend dashboard. I managed the development workflow using AI-assisted tools, which I detail transparently below.

AI Tool Usage Disclosure: I used GitHub Copilot coding agent and Cursor (AI-powered IDE) as development accelerators throughout the week. Specifically:

  • GitHub Copilot coding agent was used to generate initial scaffolding code (PR #1), implement lighting control backend services and database schemas (PRs #2, #4), update README documentation (PR #3), and fix targeted bugs in the frontend utilities and WebSocket logic that surfaced during code review (PRs #6, #7, #8, #9). I authored every prompt, defined the scope and requirements for each PR, reviewed all generated code for correctness, and merged only after verifying the output met our system’s architectural standards.
  • Cursor Agent was used to generate the full dashboard frontend UI overhaul (PR #5), producing React components, page layouts, service integrations, and the theme system. I provided the design specification (dark flat aesthetic, Mosaic-inspired), directed the component structure, and made iterative refinements including a follow-up manual CSS overhaul to remove beveled corners (PR #10, authored entirely by me).
  • This status report itself was drafted with the assistance of GitHub Copilot Chat (Claude), which I prompted with my repository context and previous report format. I reviewed, edited, and verified all content for accuracy.

Key contributions included:

  • Repository Initialization & Project Scaffolding: Designed and prompted the complete project architecture; a monorepo folder structure spanning firmware/, backend/, frontend/, infrastructure/, docs/, certs/, hardware/, and scripts/. I authored the detailed specification that dictated every file, dependency, and configuration template (PR #1). This included defining all FastAPI entry points, PlatformIO project configs for three ESP32 nodes, the React app skeleton, Docker Compose files for TimescaleDB and Redis, CI/CD workflows, and comprehensive documentation stubs (ARCHITECTURE.md, API.md, SETUP.md, USER_GUIDE.md, TESTING.md, productReqDoc.md, projectDescription.md).
  • Lighting Control Subsystem: Architected and directed the implementation of our third subsystem (lighting control with daylight harvesting). This involved specifying the firmware structure for ESP32 #3 (TEMT6000 ambient light sensor, PWM dimmer via LEDC, 4-channel relay control), the backend API endpoints (/api/lighting/dimmer, /api/lighting/relay, /api/lighting/daylight-harvest), the TimescaleDB hypertables (lighting_sensor_data, relay_state, dimmer_state) with continuous aggregates and 90-day retention policies, and the Pydantic validation schemas (PRs #2, #4). I defined all hardware GPIO pin assignments, the BOM for the TEMT6000, IRF520/540 MOSFET dimmer, and SRD-05VDC relay module, and updated the power budget from 4.88W to 13.0W peak.
  • Backend API & Services Layer: Directed the implementation of the FastAPI backend with the WebSocket manager for bidirectional device/client communication, the database client with session management, sensor data endpoints with real-time broadcast, and the full lighting control API (12+ endpoints documented in API.md). I configured CORS, Pydantic Settings for environment management, and the startup/shutdown lifecycle hooks.
  • Frontend Dashboard – Design & Implementation: Specified and directed the build of the complete React dashboard (PR #5), replacing the minimal skeleton with a multi-page application featuring: real-time temperature and lighting graphs (Recharts), access control with RFID policy management, dimmer/relay controls, admin authentication, CSV export, and WebSocket live telemetry. I ripped the initial web page design from one of my previous TartanHacks Hackathon projects. I steered towards a dark-theme flat UI and then manually authored the CSS theme overhaul (PR #10) getting rid of all rounded corners/bevels and retuning the color palette to match our project’s aesthetic. This was the only PR where I wrote every line of code myself without AI assistance.
  • Code Review & Bug Resolution: Went through and reviewed every single AI-generated pull requests for correctness where I identified and filed issues for four specific bugs: toIsoTimestamp treating epoch-zero as falsy (PR #6), WebSocket URL fallback hardcoded to localhost (PR #7), createOrCheckAccessEvent returning raw unnormalized data (PR #8), and filterSeriesByRange breaking on epoch-zero timestamps (PR #9). I wrote the problem descriptions and directed the fixes.
  • Documentation: Updated the main README.md to show the new three-subsystem architecture (PR #3), which includes hardware wiring specs, data flow diagrams, and updated performance targets. I also authored and reviewed updates to SETUP.md (15+ troubleshooting scenarios), API.md (12 endpoint specs with request/response examples), and the file-architecture.md implementation status tracker.
  • Infrastructure: Configured the Docker Compose stack (TimescaleDB + Redis) with proper volume mounts, health checks, and networking. Set up the GitHub Actions CI pipeline for backend linting (flake8, black, mypy, bandit, safety).

Is your progress on schedule or behind?
I’m ahead of schedule. The original plan was to test for backend environment initialization and initial MQTT broker this week. I’ve delivered a nearly complete full-stack implementation with a working backend, 12+ API endpoints, a pretty good frontend dashboard, three firmware project structures, CI/CD, and comprehensive documentation. The lighting control subsystem that was supposed to be done later is basically complete.

What deliverables do you hope to complete in the next week?

  • Firmware Flashing & Hardware Integration: Flash the ESP32 firmware onto physical hardware, wire the RFID-RC522, BME280, TEMT6000, solenoid lock, and relay module, and validate end-to-end communication with the backend.
  • Access Control API Completion: Implement the remaining backend endpoints for RFID-based access control (/api/access, /api/policies) and remove the frontend’s local mock fallbacks.
  • TLS Certificate Infrastructure: Generate the CA and server/device certificates for the secure handshake protocol between ESP32 nodes and the backend.
  • WebSocket Real-Time Testing: Validate bidirectional WebSocket communication between the dashboard and physical ESP32 devices over the local network.

Mario’s Status Report for 2/7/2026

Following our initial consultations with the course staff, my primary focus was finalizing the architecture of the software stack for the proposal and making sure to define the system requirements. I moved away from a simple collection of sensors and more toward having an emphasis on a cohesive web infrastructure built to scale.

Key contributions included:

  • Requirement Specifications: Defined the quantitative targets for our system, including the 0.5°C deviation accuracy for temperature sensing and the <2s latency for remote door actuation.
  • System Architecture: Developed the high-level block diagram, specifically architecting the interaction between the ESP32 nodes (firmware), the Raspberry Pi Gateway, and the Web Application.
  • Software Stack Selection: Researched and selected our tech stack, choosing React.js for the frontend, Node.js/Express for the backend, and MQTT as our primary communication protocol to ensure low-latency data transmission.
  • Use Case Refinement: Worked with the team to narrow our focus to a web-first building control platform, ensuring our abstract and problem statement reflected a professional-grade solution rather than a simple hobbyist sensor kit.

Is your progress on schedule or behind?
I am currently on schedule. While my partner finalized the Gantt chart and labor division, I provided the technical milestones necessary to populate that schedule, ensuring the software development phases are realistically timed.

What deliverables do you hope to complete in the next week?
In the upcoming week, I plan to focus on the following software-specific tasks:

  • Subsystem Interfacing: Define the specific JSON schemas for MQTT messages passing between the sensors and the gateway.
  • Backend Environment: Initialize the Node.js server environment and set up the project’s GitHub repository.
  • Hardware Setup: Assist in the initial configuration of the Raspberry Pi to begin testing the local MQTT broker.

Team Status Report for 2/7/2026

Most Significant Risks & Mitigation
The most significant risks to the success of our project are meeting our latency targets for real-time control and monitoring, maintaining reliable concurrency, and ensuring that the secure device provisioning and the permission revocation pipeline does not introduce unacceptable delays. We defined concrete, quantitative stress, latency, and security tests so performance and failure modes can be detected early. Our contingency plan is to scale down the number of simultaneously active devices and features during the demo if performance becomes unstable, and to temporarily relax non-critical features so that real-time access control and monitoring remain within specification.

Design Changes
Since our early discussions, we made a deliberate design change to narrow the MVP scope and system focus to environmental sensing and access control (temperature sensor and door lock). This change was necessary to reduce technical risk and ensure we can reliably meet latency and security requirements within the semester schedule.

Schedule Updates
We have established a structured Gantt chart schedule that breaks the project into concrete, week-sized tasks. At this time, the team is on track with the initial schedule as we move from the proposal phase into early communication protocol definitions and hardware setup.

Progress & Technical Highlights
We have successfully transitioned the project from a collection of isolated sensors to a cohesive, web-first building control platform. We are particularly proud of our high-level block diagram, which clearly defines the interface boundaries between our ESP32 nodes, the Raspberry Pi gateway, and the web-based backend services. 

Cindy’s Status Report for 2/7/2026

For the past few weeks, after finalizing our project idea and speaking with our TA/FAC, I focused on developing the technical backbone of our proposal with my partner and helped refine the system scope and requirements.

Meeting – Refining Proposal and Discussing Abstract
Date: 1/26/2026

  • Focused on refining and narrowing the use-case requirements
  • Helped converge the project scope to four main high-level requirements
  • Coordinated division of proposal slide responsibilities among the team
  • Discussed how to better position our system as a web-first building control platform rather than a collection of isolated sensors

Meeting – With TA/Faculty
Date: 1/28/2026

  • Walked through the high level block diagram with course staff
  • Refined how we should frame quantitative targets for requirements
  • Received guidance to narrow feature focus for the MVP, especially on:
    • environmental sensing (temperature)
    • access-control functionality
  • Discussed early hardware planning and concerns regarding MVP component choices

For the proposal presentation, I specifically contributed to the tasks and division of labor, the identification of major component parts, and the construction of the Gantt chart schedule. I worked with my teammates to break the project into concrete, week-sized tasks, assign clear ownership for each task across the team, and ensure that all major technical areas (embedded firmware, backend/web infrastructure, hardware integration, and system integration/testing) were covered without overlap or gaps. I also helped decide between the major hardware and software component parts needed for the MVP (pros vs. cons), and organized these tasks into a structured Gantt chart.

For the upcoming week, I plan to complete the following:

  • Help convert the proposal level solution approach into a clearer subsystem-level block diagram
  • Assist with:
    • Defining interface boundaries between embedded nodes and backend services
    • Early communication protocol definitions
  • Set up initial hardware parts as soon as possible