Overview

Developed a web-based CAN bus monitoring and diagnostics platform for embedded systems. The application connects to multiple devices over serial interfaces, captures CAN frames in real time, automatically discovers nodes on the network, visualizes the network topology as an interactive graph, and tracks active peer-to-peer communication. It also includes a messaging interface for compatible hybrid nodes, along with automated connection health monitoring that detects and removes inactive links, making it a comprehensive debugging and diagnostics solution for CAN-based embedded networks.

Problem Statement

Provide developers and embedded engineers with a centralized platform for observing, debugging, and diagnosing CAN bus communication across multiple connected devices without relying on low-level serial tools or manual network inspection.

Solution

Designed a real-time monitoring dashboard that continuously reads CAN traffic from multiple serial-connected devices, automatically builds the network topology, visualizes communication links, logs CAN messages, and provides live diagnostics and communication tools for connected nodes.

Key Highlights

• Real-time CAN frame monitoring
• Multi-device serial communication
• Automatic CAN node discovery
• Interactive network topology visualization
• Peer-to-peer connection tracking
• Hybrid node chat interface
• Automatic connection health monitoring
• Embedded diagnostics dashboard

Features

• Real-time CAN frame capture
• Live CAN traffic logging
• Support for multiple serial devices
• Automatic node discovery
• Interactive network graph visualization
• Live node status monitoring
• Detailed node information panel
• Peer-to-peer connection tracking
• Hybrid node messaging interface
• Automatic inactive connection detection
• Dynamic topology updates
• Embedded network diagnostics

Technical Highlights

1. Real-Time CAN Monitoring: Continuously captures and processes CAN frames from multiple serial-connected devices with minimal latency.
2. Automatic Network Discovery: Discovers CAN nodes dynamically and maintains an up-to-date representation of the network topology.
3. Interactive Graph Visualization: Visualizes devices and communication links as an interactive graph that updates in real time as the network changes.
4. Connection Health Monitoring: Tracks peer-to-peer communication, automatically detecting inactive or disconnected nodes and removing stale links.
5. Serial Communication Layer: Supports simultaneous communication with multiple embedded devices connected through serial ports.
6. Hybrid Node Communication: Implements an integrated messaging interface enabling communication between compatible embedded nodes.

Architecture

The platform is built from five core components:

• Frontend: React, Next.js — provides the interactive monitoring dashboard and network visualization.
• Serial Communication Layer: Web Serial / Node Serial Communication — interfaces with multiple embedded devices over serial connections.
• CAN Processing Engine: JavaScript/TypeScript — parses CAN frames, manages node discovery, and processes network events.
• Topology Engine: Graph-based data model — maintains real-time network topology and peer relationships.
• Visualization Layer: Interactive Graph Rendering — displays devices and communication links with live updates.

Key Achievements

• Built a real-time CAN diagnostics platform for embedded systems
• Implemented automatic discovery of CAN network nodes
• Visualized dynamic network topology with live graph updates
• Enabled monitoring of peer-to-peer communication between embedded devices
• Integrated hybrid node messaging into the diagnostics dashboard
• Implemented automatic detection and cleanup of inactive network connections

Engineering Concepts

CAN Bus Communication, Serial Protocols, Embedded Diagnostics, Real-Time Event Processing, Network Topology Discovery, Graph Algorithms, State Synchronization, Connection Health Monitoring, Interactive Data Visualization, Distributed Embedded Systems.

Overview

AgentDB9 is a production-oriented development environment designed for building and running AI coding agents. The platform combines a browser-based VS Code experience with multiple LLM providers, semantic code search, real-time communication, and a modular microservices architecture. The system leverages Docker containers to orchestrate isolated services including the frontend, backend, AI inference layer, Model Context Protocol (MCP) server, vector database, and supporting infrastructure.

Problem Statement

Create a scalable development platform that enables AI-powered coding assistants with real-time communication, IDE integration, semantic code understanding, and support for multiple large language model providers.

Solution

Designed a Docker-based microservices architecture integrating a Next.js frontend, Node.js backend, browser-based VS Code environment, MCP server, vector database, Redis caching, PostgreSQL storage, and configurable LLM providers to deliver an extensible AI coding workspace.

Key Highlights

• Containerized microservices architecture
• Browser-based VS Code IDE
• Multi-provider LLM integration
• Model Context Protocol (MCP) server
• Semantic code search with vector embeddings
• Real-time communication using Socket.IO
• Scalable backend services
• GPU-accelerated local LLM support

Features

• Browser-based VS Code development environment
• Support for OpenAI, Anthropic, Ollama, and Cohere
• Real-time communication via WebSockets
• Semantic code search using vector embeddings
• Model Context Protocol (MCP) integration
• Containerized deployment with Docker
• Redis-based caching and session management
• PostgreSQL-backed persistent storage
• Shared TypeScript packages across services
• Extensible AI provider architecture

Technical Highlights

1. Microservices Architecture: Separated frontend, backend, AI services, IDE, databases, and infrastructure into independently deployable Docker containers.
2. Multi-LLM Integration: Designed a provider abstraction layer supporting OpenAI, Anthropic, Ollama, and Cohere with interchangeable AI backends.
3. MCP Server: Integrated a Model Context Protocol server enabling AI agents to interact with development tools and the browser-based IDE.
4. Semantic Search: Implemented vector-based code indexing using Qdrant to enable semantic retrieval of source code and project context.
5. Real-Time Communication: Used Socket.IO and Redis to synchronize IDE events, AI responses, and backend services with low latency.
6. Containerized Development: Built a reproducible development environment using Docker Compose for consistent local and cloud deployments.

Architecture

The system is composed of eight independently deployable services:

• Frontend: Next.js 14, TypeScript, Tailwind CSS — provides the user interface and browser-based development experience.
• Backend API: Node.js, Express, Socket.IO — handles API requests, real-time communication, and orchestration.
• LLM Service: OpenAI, Anthropic, Ollama, Cohere — routes AI requests across multiple language model providers.
• MCP Server: Model Context Protocol — enables AI agents to securely interact with IDE tools and project resources.
• VS Code Container: code-server — provides a complete browser-based Visual Studio Code environment.
• Vector Database: Qdrant — stores code embeddings for semantic search and retrieval.
• Database: PostgreSQL — stores metadata, configuration, and persistent application data.
• Cache Layer: Redis — manages caching, sessions, and pub/sub messaging.

Key Achievements

• Built a modular microservices architecture for AI-powered development
• Integrated multiple commercial and local LLM providers through a unified interface
• Implemented browser-based VS Code development using code-server
• Added semantic code search with vector embeddings and Qdrant
• Enabled real-time communication using Socket.IO and Redis
• Designed a scalable infrastructure suitable for AI coding assistants

Engineering Concepts

Distributed Systems, Microservices, Container Orchestration, Retrieval-Augmented Generation (RAG), Vector Search, Model Context Protocol (MCP), WebSocket Communication, AI Agent Infrastructure, Scalable Backend Architecture, Service-Oriented Design.

Repository Type: Monorepo. Language: TypeScript. Difficulty: Advanced.

Overview

Developed and customized a quadcopter flight controller using the open-source YMFC-AL (Your Multicopter Flight Controller - Auto-Level) framework. The project focuses on embedded flight control, IMU sensor processing, ESC calibration, and real-time stabilization algorithms. The controller is implemented entirely in Arduino and consists of separate modules for setup, ESC calibration, and the primary flight loop.

Additional improvements were made to increase stability, improve compatibility with modern Arduino IDE compiler optimizations, and prevent numerical instability during aggressive flight maneuvers.

Problem Statement

Create a reliable embedded flight controller capable of maintaining stable quadcopter flight using IMU sensor fusion while handling real-world flight conditions and hardware limitations. The challenge involves processing noisy sensor data in real time, calibrating motor controllers accurately, and ensuring the firmware remains robust under aggressive flight maneuvers that can push sensor readings outside expected bounds.

Solution

Implemented and customized the YMFC-AL flight controller with auto-level stabilization, ESC calibration utilities, complementary filtering for orientation estimation, and mathematical safeguards against runtime errors caused by sensor anomalies. The firmware was further refined for compatibility with newer Arduino IDE compiler versions and tuned for smoother motor initialization.

Key Highlights

• Arduino-based real-time flight controller
• Auto-level stabilization
• IMU sensor fusion using complementary filter
• ESC calibration utility
• Real-time pitch and roll estimation
• Optimized for newer Arduino IDE compiler versions
• Patched NaN instability during aggressive flight maneuvers
• Reduced motor startup speed to improve control reliability

Features

• Auto-level flight stabilization
• Electronic Speed Controller (ESC) calibration
• Real-time IMU data processing
• Pitch and roll angle estimation
• Complementary filter implementation
• Motor control through PWM outputs
• Flight controller setup and diagnostics
• Improved numerical stability

Technical Highlights

1. Complementary Filter: Implemented combining gyroscope and accelerometer data for stable orientation estimation. The filter blends high-frequency gyroscope data with low-frequency accelerometer corrections to produce smooth, drift-free angle estimates.
2. IMU Processing: Processed accelerometer vectors to calculate pitch and roll while maintaining real-time performance within the flight control loop timing constraints.
3. Numerical Stability: Fixed a NaN issue caused by asin() receiving values outside its valid domain during aggressive flight conditions by safeguarding accelerometer vector calculations with domain clamping.
4. Arduino Compatibility: Updated the firmware for compatibility with newer Arduino IDE compiler optimizations that introduced breaking changes in variable scoping and loop unrolling behavior.
5. Motor Control: Reduced motor startup speed to 1100µs for smoother and more reliable initialization, preventing abrupt motor spin-up that could destabilize the frame at launch.

Architecture

The firmware is organized into three distinct modules, each responsible for a specific phase of the flight controller lifecycle:

• YMFC-AL_setup.ino — Initial quadcopter configuration, hardware setup, and testing. Used to verify sensor readings, motor directions, and receiver input before flight.
• YMFC-AL_esc_calibrate.ino — Electronic Speed Controller calibration routine. Ensures all four ESCs respond uniformly to throttle commands for balanced motor output.
• YMFC-AL_Flight_controller.ino — Main flight control loop responsible for sensor processing, complementary filter execution, stabilization calculations, and PWM motor output.

Key Achievements

• Implemented stable auto-level flight control on real hardware
• Improved compatibility with modern Arduino IDE versions
• Resolved NaN runtime issue during aggressive flight maneuvers
• Enhanced motor startup behavior for safer and more predictable initialization
• Built modular firmware cleanly separating setup, calibration, and flight control concerns

Engineering Concepts

This project draws on a broad set of embedded systems and control engineering disciplines:

• Real-time control systems
• Sensor fusion (complementary filter)
• Embedded firmware development
• PID-ready flight control architecture
• PWM motor control
• IMU orientation estimation
• Numerical stability in floating-point arithmetic
• Low-level hardware programming

Technologies: Arduino (C++), Embedded Systems, IMU, Accelerometer, Gyroscope, PWM, ESC, Sensor Fusion, Complementary Filter, Control Systems. Version: 1.3 · Difficulty: Advanced · License: Open Source (YMFC-AL based)