Developed firmware on the STM32F1 using STM32CubeIDE with FreeRTOS to manage five identical accumulator segments. The firmware measures thermistor values and cell voltages using flexible PCBs attached to the segments and transmits the data over a CAN bus. The system was designed to replicate the functionality of the Orion Thermistor Expansion Module, sending CAN messages compatible with the Orion BMS 2.

Key transmitted data includes:

• Segment number
• Lowest, highest, and average cell voltages
• Lowest, highest, and average cell temperatures

Designed flexible PCBs to streamline the process of integrating thermistors and voltage taps into the accumulator segments. Each PCB includes two SMD thermistors and a voltage tap, connecting to the system via an FPC connector. This design eliminates the need for hand-soldering thermistors by wire, significantly reducing assembly time and improving reliability. The PCBs enable the STM32s to measure voltages and temperatures efficiently and transmit the data over CAN.

Designed and implemented a remote telemetry system to locally store and remotely visualize the car's CAN bus data.
The system includes a custom transmitter and receiver setup:

• Transmitter: Developed a custom PCB housing an ESP32, NRF24 module, IMU, GPS, and SD card reader. Wrote firmware to interface the ESP32 with these components and the car's general CAN bus. The transmitter logs CAN bus data to an SD card for offline viewing in case of connection issues and uses the NRF24 module to wirelessly transmit data to the receiver.

• Receiver: Configured the receiver to interface with a computer over serial. All received data is streamed to Foxglove, a visualization platform for creating custom dashboards and data modules.

The system achieved a data rate of 1 Mbps with a wireless range of up to 1 km, providing reliable real-time telemetry and a fallback for offline data analysis.

Assisted in wiring the car's dashboard, integrating the Remote Telemetry Unit and a Raspberry Pi for the HUD. The dashboard setup also included a drive button, e-stop, IMD/AMS indicator lights, and auxiliary switches. Connected the Raspberry Pi to the car's CAN bus to extract and process critical CAN messages.

Collaborated on designing a custom UI using C++ and Qt, which displayed essential real-time metrics, including:

• Speed
• Battery Level
• Accumulator, Motor, Coolant, and Oil Temperatures

This system provided a comprehensive and intuitive interface for monitoring the car's performance during operation.

Designed and assembled multiple ESP32-S3-based development boards to serve as the foundation for all embedded systems in our 2025 car. The ESP32-S3 was chosen for its dual-core architecture, enabling multi-core OS operations. The custom boards included several enhancements tailored to our specific needs:

• ADS1115 16-bit ADC Module: Added to address the noise issues of the ESP32's built-in ADCs, enabling more accurate analog readings.

• Dual CAN Transceivers: Integrated to interface with the car's two CAN buses; one for high-priority info and another for bulk data.

• SPI-based CAN Controller: Included to support the second CAN bus, compensating for the
  ESP32-S3's single built-in CAN controller.

• Vertical USB-C Port: Designed for easier debugging when the boards are enclosed in their housings.

These custom boards are deployed across the car’s control unit, data collection module, and remote telemetry unit, providing a robust and flexible platform for vehicle operations and data management.

Developed a real-time intruder detection system using an STM32F4 Discovery board, ArduCAM OV5642, and a PIR motion sensor. The firmware, written in STM32CubeIDE with FreeRTOS, implemented a responsive and efficient task structure:

• Motion Detection: The PIR motion sensor was connected to a GPIO pin, triggering interrupts upon motion detection. An interrupt handler released a motion semaphore to signal further actions.

• Image Capture and Display: The ArduCAM OV5642 was interfaced using I2C for configuration and SPI for data transfer. When motion was detected, the system captured an image and displayed it on the board’s built-in LCD.

• Alert Mechanism: An onboard LED was flashed as an alert to indicate an intruder.

The system remained idle until motion was detected. After an image was displayed and the LED flashed, a 30-second timeout returned the system to idle mode, ready for the next interrupt. This design ensured low power consumption during inactivity while providing real-time responsiveness to motion events.

Designed and assembled a wireless Battery Management System (BMS) for an existing electric longboard battery pack configured as three nodes, each in a 3S4P arrangement. The system was implemented using ESP32 microcontrollers for both the battery nodes and the master controller:

• Wireless Nodes: Each battery pack was equipped with an ESP32 to measure the voltages of the three series sections and the temperature using a thermistor, with all measurements handled by the ESP32's ADCs. The ESP32 acted as a BLE server, transmitting data packets every second. Each packet, formatted in CSV for easy decoding, included the pack number, three voltages, and temperature.

• Master Controller: The master controller, also based on an ESP32, operated as a BLE client to receive and decode data from the wireless nodes. It monitored the battery packs and made operational decisions, such as disconnecting relays if safety thresholds were exceeded.

• Cloud Integration: The master controller transmitted the decoded data over Wi-Fi using the MQTT protocol to a Home Assistant server, enabling real-time monitoring and visualization on a
  cloud-based dashboard.

This system provided a modular, wireless, and efficient BMS solution for the electric longboard, combining local monitoring with remote data access.

Developed a full-stack web application for a chess variant called Hostage Chess, incorporating a custom backend library, a web server, and an interactive user interface:

• Backend Development: Created a C library to manage the chessboard, moves, and the unique rules of Hostage Chess. Used SWIG to connect the C library to a Python-based web server. The server handled GET and POST requests to manage game resources and facilitate communication between clients.

• Frontend Development: Designed the frontend using HTML, CSS, and JavaScript with jQuery. Implemented key pages, including:
  • A landing page for users to join a game.
  • A player page to make moves.
  • An opponent page to wait for the player’s move, with roles switching every turn.

• Database Integration: Incorporated an SQLite database on the server to store game data, enabling shared access between clients. Added a game history feature for users to review completed games.

This project combined efficient backend logic with an intuitive frontend interface to deliver a seamless online multiplayer experience for Hostage Chess enthusiasts.