Hi, I am Adnaan

FPGA Digital Systems Workbook

A staged FPGA design workbook covering combinational logic, structural VHDL, datapath/FSM design, and DSP architectures — from truth-table logic through to low-complexity spectrum sensing.

• Tools: VHDL, Vivado, MATLAB/Simulink, HDL Coder, Artix-7 (Nexys)
• Targets:
  • Xilinx/AMD Vivado + Digilent Nexys (A7 / Artix-7 class boards)
  • Mix of handwritten VHDL and model-based HDL generation (MATLAB/Simulink)
• What I actually built:
  • Implemented purely combinational logic designs using truth table → K-map → dataflow VHDL (prime detector), verified with self-checking testbenches.
  • Designed modular BCD arithmetic systems, including validation logic, digit-wise correction, and ten’s-complement subtraction, reused across multiple designs.
  • Built a datapath + FSM-controlled GCD engine, separating control and data paths and validating correct state sequencing on hardware.
  • Developed a 16-tap FIR filter using model-based design, then optimised timing via pipelining and retiming, comparing resource usage and critical-path delay.
  • Implemented a low-complexity spectrum-sensing pipeline using an 8-point Approximate DFT, including fixed-point modelling, FPGA-in-the-loop verification, and architectural pipelining to improve Fmax.

Result: Built and validated a progressive FPGA portfolio demonstrating clean modular design, verification-first workflows, and scalable architectures from basic logic through to DSP/sensing pipelines.

Mini Piano Tiles

An embedded rhythm game system inspired by Piano Tiles / StepMania, built on an STM32 with LED matrix beat visualisation, SD card audio playback, and PC-based configuration software.

• Project Overview:
  • Plays music from an SD card while displaying upcoming beats on a 16×4 WS2812B LED matrix.
  • Users hit illuminated arcade buttons in time with the music; timing accuracy and score update in real time.
  • A PC application configures timing parameters and manages song/sequence files.
• Key Features:
  • STM32F429-based embedded system with USB communication to PC software.
  • SD card reading of WAV audio files and TSQ sequence files.
  • Button timing evaluation, combo tracking, and scoring logic.
  • Battery-powered operation with USB charging and power management.
• Hardware:
  • MCU: STM32F429
  • LED Matrix: WS2812B (16×4)
  • Audio DAC: PCM5102A
  • Storage: SD card
  • Power: LiPo battery with BQ24074 charging and load-sharing
  • Interfaces: UART, I2C, I2S + DMA
• Firmware:
  • WS2812B LED driver and beat visualisation pipeline.
  • SD card + filesystem handling, WAV audio parsing, and playback.
  • TSQ sequence parsing, beat timing, and keystroke evaluation.
  • FreeRTOS-based task scheduling and USB/UART communication.
• PC Software:
  • GUI for sequence/audio management and timing window configuration.
  • Communication layer for configuring and interacting with the embedded device.

Result: Delivered a full embedded rhythm-game system with audio-synchronised LED beat prompts, real-time scoring, and a configurable PC GUI workflow.

Data Muling for Disaster Relief Sensor Mapping

Contributed to embedded systems and communication development for a wireless sensor mapping system enabling real-time monitoring with blockchain-based tamper-proof logging.

• Embedded Systems & Sensor Integration:
  • Programmed NRF microcontrollers (Thingy:52, EFR32MG12) in C using Zephyr RTOS.
  • Developed custom drivers for temperature, humidity, gas, and motion sensors.
  • Ensured stable BLE advertising and reliable sensor polling.
• Wireless Communication & Protocols:
  • Implemented BLE communication with <2s connection time.
  • Implemented MQTT over Wi-Fi for reliable data transfer.
  • Enabled UART communication to the base node and ensured seamless protocol integration.
• Mobile Node & Location Integration:
  • Configured a mobile relay node to scan BLE sensor broadcasts.
  • Attached GPS coordinates (±3 m) received from a phone app via BLE.
  • Forwarded enriched sensor data over Wi-Fi to the PC node.
• PC Node & Blockchain Logging:
  • Enabled tamper-proof data logging to a local Ethereum blockchain.
  • Implemented USB redundancy, InfluxDB storage, and real-time Grafana visualisation.
• Visualisation & Dashboard:
  • Delivered a responsive dashboard with real-time environmental heatmap updates (within 5s).
  • Supported insights aggregated from multiple sensor nodes.

Outcome: Successfully deployed a real-time, multi-node environmental monitoring system with blockchain integrity, mobile location tagging, and live visualisation to assist disaster relief operations.

E-paper Portable Digital Watch

Developed a pocket-watch-style personal organizer integrating features like real-time timekeeping, weather display, alarms, accelerometer-based screen rotation, and optical communication for date and time transfer. The project adhered to TP standards and included low-power operation and persistent configuration storage.

• Hardware: Designed PCBs using Altium and integrated components like the LM66200 for load switching, MCP1700 for voltage regulation, and CD4075CN for pin optimization. Soldered and assembled all hardware components.
• Embedded Software:
  • Programmed in C to handle UART communication, optical data transfer, EEPROM storage, timekeeping, and alarms.
  • Used ISR for efficient data handling and strtok_r for parsing incoming data.
  • Integrated accelerometer-based display rotation and LED/buzzer notifications using PWM and delays.
  • Implemented binary encoding for optical communication via photodiode and ADC.
• PC Software: Designed a GUI for parameter configuration and data synchronization. Ensured data persistence across power cycles and seamless communication with the device over UART.
• Leadership & Management: Coordinated the team, managed the bill of materials, ensured TP standards compliance, and prepared the final documentation.

Result: Successfully developed a fully functional e-paper-based digital watch system with intuitive GUI configuration, reliable optical and USB communication, and efficient low-power operation. The final product met all specified requirements and demonstrated robust performance during testing and presentation.

Remote-Controlled Microscope (RCM) System

Developed a system to control a remote-controlled microscope (RCM), capable of precise movements in 3D, zooming, and rotating. The project incorporated radio communication, real-time data visualization, and user interaction through a console and VT100 display.

• Hardware Implementation:
  • Utilized the Nucleo-F429ZI board, NRF24L01+ radio module, and other peripherals like RGB LEDs and the MFS board.
  • Designed and implemented a finite state machine (FSM) for RCM control using FreeRTOS tasks.
  • Developed hamming-encoded packets for radio communication, supporting operations like JOIN, XYZ movement, rotation, and zoom.
• Software Development:
  • Programmed in C to handle console inputs, radio packet creation, and transmission.
  • Integrated VT100 escape sequences for real-time visualization of RCM head position and system status.
  • Implemented error handling and task synchronization using FreeRTOS queues, semaphores, and event bits.
  • Designed modular mylib drivers for system components and reusable code functionality.
• Advanced Features:
  • Created a console-based control system for moving the RCM head and adjusting zoom/rotation.
  • Added visual feedback through LED color changes and position updates on the VT100 display.
  • Extended the system to handle user-defined challenges, like task memory monitoring and seven-segment display integration.

Result: Successfully developed and demonstrated a fully functional RCM system that met all project requirements. The final product showcased reliable communication, real-time visualization, and precise control, highlighting strong integration of hardware and software components.

Remote Firefighting Vehicle Prototype

Designed and developed a proof-of-concept prototype for a remote-controlled firefighting vehicle aimed at enhancing safety in hazardous environments. The project involved integrating mechanical, electronic, and software components to create a functional and remotely operable system.

• Mechanical Design: Utilized Fusion 360 to design and fabricate a durable, water-resistant housing for all components, ensuring protection from environmental factors and proper assembly within the vehicle.
• Electronics Development: Assembled and soldered a custom PCB (green board visible in the prototype) to regulate voltage to the components and serve as an on-board controller for the water pump.
• Software Implementation: Programmed control logic for the wheel motors, arm servos, and water pump using Arduino with C, enabling seamless integration of the hardware and remote communication capabilities.
• Communication System: Implemented a radio communication module to enable remote operation of the vehicle using a smartphone.

Result: Successfully powered and remotely controlled all components of the vehicle via a smartphone, demonstrating a functional prototype capable of addressing remote firefighting challenges.

Firewall and Intrusion Detection System

Developed and implemented a network security system comprising firewall rules and an Intrusion Detection System (IDS) to monitor, detect, and mitigate network attacks across various protocols.

• Firewall: Configured iptables rules on a Linux-based system to manage traffic, including:
  • Restricting access to specific ports (e.g., SSH, HTTP, HTTPS).
  • Limiting ICMP traffic to prevent ping floods.
  • Allowing only established and related connections for secure communication.
  • Blocking unwanted traffic while ensuring DNS and web service functionality.
• Intrusion Detection System:
  • Designed a Python-based IDS using the Scapy library for packet inspection and analysis.
  • Applied detection rules to identify suspicious packets in .pcap files.
  • Detected anomalies like TCP SYN floods, malicious content, and mixed protocol attacks through:
  • Content-based filtering.
  • Packet flag analysis (e.g., SYN, ACK, RST).
  • Time-based thresholds (e.g., 10 packets in 2 seconds).
  • Logged alerts in real-time, including timestamps and violation details.

Result: Successfully implemented a firewall capable of fine-grained traffic control and an IDS that detected diverse attack scenarios, including protocol-specific and mixed-protocol threats. Delivered a robust network security solution validated with comprehensive testing scenarios.

Snakes and Ladders Game on AVR Microcontroller

Modified a basic program template to implement additional features for a 2-player Snakes and Ladders game using C in the Microchip Studio environment.

• Microcontroller: Used the AVR ATmega324A microcontroller to program the game, receiving input from multiple sources and displaying output on an LED matrix.
• Programming Environment: Developed and modified code in C using the Microchip Studio environment.
• Inputs and Outputs: Integrated serial input, joystick control, and sound output to create an interactive gaming experience.

Result: Successfully implemented a fully functional 2-player Snakes and Ladders game with responsive controls, sound effects, and a visual display on an LED matrix.

Filter design

Designed a circuit to reverse the effects of a black box containing unknown elements, adhering to specific constraints. The project involved detailed analysis, design, testing, and refinement to achieve the desired results.

• Frequency Analysis: Conducted frequency response analysis using an oscilloscope to understand the behavior and characteristics of the black box.
• Circuit Design: Performed calculations to design an inverse circuit tailored to counteract the black box's effects, incorporating a 2nd-order high-pass filter and amplifier.
• Testing and Refinement: Developed, tested, and iteratively modified the circuit to ensure accurate performance and compatibility with input signal requirements.

Result: Successfully designed a 2nd-order high-pass filter and amplifier that negated the effects of the black box. The output signal was amplified and matched the input in amplitude and frequency characteristics.

Image Reconstruction for Noise Reduction

Developed and implemented a digital image processing system to reconstruct and denoise images corrupted by high-frequency noise during transmission.

• Filter Design: Created a low-pass digital finite impulse response filter in MATLAB to target noise frequencies above a specified cutoff (e.g., 0.125 px⁻¹).
• Convolution Application: Applied the filter using convolution techniques to denoise the image while retaining critical details.
• Filter Configurations:
  • Experimented with varying cutoff frequencies to balance detail preservation and noise suppression.
  • Tested different filter window sizes (e.g., -10:10, -50:50) to analyze their impact on image sharpness and noise attenuation.
• Performance Analysis: Compared pixel intensities of rows in the original, noisy, and reconstructed images to evaluate reconstruction quality.

Result: Successfully reconstructed denoised images, reducing high-frequency noise while preserving critical details. Demonstrated the trade-offs between noise suppression and detail retention, optimizing filter parameters to achieve clarity and sharpness in the reconstructed image.

OpenBSD 7.7 Kernel Extensions & Device Driver Experiments

This repository documents a systems programming project focused on modifying and extending the OpenBSD 7.7 base operating system, imported directly from the upstream CVS source tree.

• Approach: Implemented and extended kernel subsystems in incremental phases, emphasising correctness, concurrency safety, and behaviour consistent with production UNIX kernels.
• Subsystem work:
  • Process isolation and zones: zone-aware process visibility, access control, and metadata management within the kernel.
  • Zone-level scheduling control: integrated zone priorities with process scheduling and extended priority-related system calls.
  • System call extensions: exposed new kernel functionality while preserving OpenBSD’s security and privilege model.
  • PCI device driver development: device attachment, DMA-backed descriptor rings, interrupt handling, and event-driven I/O via poll(2) and kqueue(2).
  • Virtual block device: vnode-backed disk abstraction with copy-on-write semantics supporting filesystem operations.
  • Sector caching and consistency: LRU cache with write-back behaviour and safe synchronisation under concurrent access.

Cloud Computing Systems

A collection of cloud-based projects focused on designing, deploying, and analysing scalable computing systems in production-like, pay-as-you-go environments.

• Overview: Explores on-demand infrastructure, containerised services, and distributed data processing across multiple small systems.
• Technologies: Docker, microservice architectures, Apache Spark analytics, vector databases/semantic search, and cloud storage.
• Approach: Built and tested on cloud-hosted virtual machines, prioritising scalability, efficiency, and operational realism.
• Focus Areas:
  • Cloud infrastructure and virtual machines (IaaS)
  • Containerisation and service orchestration
  • Scalable web and microservice architectures
  • Big data processing and analytics
  • Vector databases and semantic search

Functional Programming Projects

Optimised data structures and implemented graph algorithms (BFS/DFS/Dijkstra) using functional programming techniques like recursion, immutability, and higher-order functions.

Java - Production Factory Belt System Simulation

Developed classes and methods to support an application that simulates a Production Factory Belt System.

• Programming Language: Implemented the application in Java, utilizing classes, interfaces, and lambda functions to ensure efficient and modular code design.
• Testing: Created JUnit tests to validate functionality and ensure reliability of the application.
• Graphical User Interface: Designed and presented the system in a GUI format for ease of interaction and demonstration.

Result: Successfully developed and tested a fully functional Production Factory Belt System, showcasing modular design and robust performance.

Python - Tkinter-based GUI Game of Maze Runner

Developed a Maze Runner game featuring a responsive graphical user interface built with Python's Tkinter library, integrating interactive gameplay elements and dynamic UI updates.

• MVC Design Pattern: Applied the Model-View-Controller pattern to decouple game logic, user interface, and event handling, ensuring scalability and easy maintenance.
• Event-Driven Programming: Leveraged Tkinter's event-handling capabilities to deliver a smooth, responsive user experience with keyboard inputs and UI feedback.
• Object-Oriented Design: Utilized classes for modularity, enabling reusable components for game mechanics and UI functionality.

Result: Successfully created a feature-rich game with a clean and maintainable codebase, offering engaging gameplay and an intuitive user interface.

C - Real-Time Online Auction Platform

Developed two programs to implement a real-time, online auction platform, enabling clients to connect and interact with an auctioneer for selling and buying items.

• Programming Language: Implemented in C, utilizing networking and multithreaded programming techniques.
• Server-Client Architecture: Developed a network server to accept client connections, allowing clients to communicate with the auctioneer via a TCP-based newline-terminated text command protocol.
• Features: Included advanced functionalities such as connection limiting, signal handling, and statistics reporting to enhance robustness and reliability.

Result: Successfully created a fully functional auction platform with real-time communication between clients and the auctioneer over TCP, demonstrating efficient networking and multithreaded programming techniques.

Python-Based Chat Server

Developed a scalable Python-based chat server to handle communication between multiple clients over a network.

• Designed a multi-threaded server using Python's socket library to manage concurrent client connections.
• Implemented protocols for message broadcasting, direct messaging, and client disconnection handling.
• Integrated exception handling and timeout mechanisms to ensure reliability and prevent resource leaks.
• Tested for scalability and functionality in a virtualized network environment.

Result: Successfully created a robust chat server with efficient message handling and reliable performance under load.