PRISM (pH & Rehydration Intensity Sensor Module) is an innovative health monitoring system that analyzes color and pH levels of urine to provide real-time health insights. The system uses the TCS34725 color sensor and pH sensors connected to Arduino, with a Node.js backend for data processing and a Next.js frontend for visualization.

• Project Design Assistant: Sebastian Silva
• Software development: Nathan Tam
• Hardware/Electrical Engineering: Edmond Ter Pogosyan
• Technical Research & Analysis: Anchita Ganesh
• CAD Modeling & Prototyping: Ernesto Tellez Perez & Connor McVicker

• pH Levels: Monitor acidity/alkalinity (normal range: 4.5-8.5)
• Color Analysis: 10-point health scale (1=excellent, 10=critical)
• Hydration Status: Real-time dehydration detection
• Health Alerts: Automatic notifications for concerning readings

• Real-time Monitoring: Continuous sensor data collection
• Machine Learning: K-means clustering for color classification
• pH Averaging: 10-second rolling buffer for stable readings
• Health Scoring: 1-10 scale based on color analysis
• Alert System: Automatic health concern notifications

• Live Dashboard: Real-time data visualization
• Historical Analysis: Trend tracking and analytics
• WebSocket Updates: Instant data streaming
• Responsive Design: Mobile and desktop compatible
• Health Recommendations: Personalized advice based on readings

• TCS34725 Integration: 16-bit color sensor support
• Serial Communication: Arduino to backend data flow
• SQLite Database: Persistent data storage
• REST API: Comprehensive data access endpoints
• TypeScript: Type-safe development
• Docker Ready: Containerized deployment

┌─────────────────┐    ┌─────────────────┐    ┌─────────────────┐
│                 │    │                 │    │                 │
│    Hardware     │    │    Backend      │    │    Frontend     │
│                 │    │                 │    │                 │
│  Arduino Uno    │    │  Node.js API    │    │   Next.js Web   │
│  TCS34725       │───▶│  TypeScript     │───▶│   React App     │
│  pH Sensor      │    │  SQLite DB      │    │   Tailwind CSS  │
│                 │    │  WebSocket      │    │   Real-time UI  │
└─────────────────┘    └─────────────────┘    └─────────────────┘
       ↓                       ↓                       ↓
   Serial USB              Port 3001               Port 3000

1. Arduino reads TCS34725 color sensor and pH sensor
2. Serial Communication sends data to backend via USB
3. Backend Processing averages pH, classifies color, stores data
4. Machine Learning analyzes color using K-means clustering
5. WebSocket Streaming pushes real-time updates to frontend
6. Dashboard Display shows live health metrics and trends

• Node.js 18+ and npm/pnpm
• Arduino IDE for hardware programming
• TCS34725 Color Sensor and pH sensor (optional for development)

git clone https://github.com/your-username/PUMA.git
cd PUMA

# Install all dependencies
npm run install-all

# Start both backend and frontend simultaneously
npm run dev

This starts both servers with auto-recompilation:

• Backend: http://localhost:3001
• Frontend: http://localhost:3000

Backend Setup:

cd backend
npm install
npm run build
npm run dev    # Development with mock data

Frontend Setup:

cd ../frontend
npm install
npm run dev  # Development server

See TCS34725 Setup Guide for complete hardware integration.

PUMA/
├── README.md                    # This file
├── .gitignore                   # Git ignore rules
├── backend/                     # Node.js/TypeScript Backend
│   ├── src/
│   │   ├── services/
│   │   │   ├── SerialService.ts       # Arduino communication
│   │   │   ├── ColorClassificationService.ts  # ML color analysis
│   │   │   ├── DataProcessingService.ts       # pH averaging & alerts
│   │   │   └── DatabaseService.ts             # SQLite operations
│   │   ├── routes/              # REST API endpoints
│   │   ├── config/              # TCS34725 configuration
│   │   ├── types/               # TypeScript definitions
│   │   └── utils/               # Logging and utilities
│   ├── README.md                # Backend documentation
│   ├── TCS34725_SETUP.md        # Hardware setup guide
│   └── package.json
├── frontend/                    # Next.js React Frontend
│   ├── app/
│   │   ├── dashboard/           # Health monitoring dashboard
│   │   ├── ui/                  # Reusable components
│   │   └── layout.tsx
│   ├── public/                  # Static assets
│   └── package.json
└── hardware/                    # Arduino code (future)
    └── arduino_sensors/

TCS34725    Arduino    pH Sensor
--------    -------    ---------
VCC   →     3.3V       VCC → 5V
GND   →     GND        GND → GND
SDA   →     A4         OUT → A0
SCL   →     A5

Important: TCS34725 requires 3.3V power, NOT 5V!

1. Install Dependencies

   # Backend
   cd backend && npm install
   
   # Frontend
   cd ../frontend && npm install

2. Environment Configuration

   # Backend environment
   cp backend/.env.example backend/.env

3. Database Initialization

   cd backend
   npm run build
   # Database auto-initializes on first run

1. Build Applications

   # Backend
   cd backend && npm run build
   
   # Frontend
   cd ../frontend && npm run build

2. Start Services

   # Backend (production)
   cd backend && npm start
   
   # Frontend (production)
   cd ../frontend && npm start

Perfect for testing without hardware:

# Terminal 1: Backend with mock TCS34725 data
cd backend
npm run dev

# Terminal 2: Frontend development server
cd frontend
npm run dev

Visit http://localhost:3000 to see the dashboard with simulated health data.

With Arduino connected:

# Configure Arduino COM port
# Edit backend/.env:
ARDUINO_PORT=COM3                # Windows
# ARDUINO_PORT=/dev/ttyUSB0      # Linux
ARDUINO_AUTO_DETECT=true

# Start backend
cd backend && npm start

# Start frontend
cd frontend && npm start

1. Real-time Monitoring: View live pH and color readings
2. Health Trends: Analyze historical data patterns
3. Alert System: Receive notifications for health concerns
4. Recommendations: Get personalized hydration advice

GET /health                    # System health check
GET /api/status               # Detailed system status

GET /api/readings/latest      # Most recent reading
GET /api/readings             # Paginated readings (?limit=100&offset=0)
GET /api/readings/range       # Date range query (?start=2024-01-01&end=2024-01-02)

GET /api/analytics            # Weekly analytics (?days=7)
GET /api/ph/buffer           # Current pH buffer statistics
GET /api/clusters            # Color classification clusters

GET /api/recommendations/:score    # Health advice for score (1-10)

POST /api/simulate            # Simulate reading (development)
POST /api/clusters/retrain    # Retrain ML clusters

Client → Server:

• requestLatestData - Request latest reading

Server → Client:

• newReading - New processed reading with recommendations

• healthAlert - Health concern notifications

• clustersUpdated - Updated ML clusters

• Normal Range: 4.5-8.5

• Acidic: < 4.5 (may indicate UTI, ketosis)

• Alkaline: > 8.5 (may indicate infection)