arnav.upadhyay40

We built a Polar Graph Plotter using an Arduino microcontroller. The machine uses stepper motors to move a pen in polar coordinates — controlling both the angle and distance from a center point — to draw intricate geometric patterns on paper. We programmed the Arduino to translate mathematical equations into precise motor movements, allowing it to produce beautiful, spirograph-like designs automatically. It was a hands-on project that combined electronics, coding, and mathematics to create something visually stunning.

The specific project that I was working on before is Arjuna, and this is a hand tracking Nerf turret which uses the webcam of the computer in order to track your hand in 3D and then targets a pan tilt Nerf gun all by itself. For the script portion in this case, the procedure will include inputting through the webcam, MediaPipe hand tracking in cvzone, calculation of depth based on distance between knuckles of fingers, converting into servo angles based on coordinates, and calibration with the difference in distance between the webcam and the Nerf gun. In terms of the Arduino portion of this project, it includes the control program of the turret through serial communication in order to receive data of angles for the servos, and printing design of the turret.

I built a robot that follows a line using a kind of control called PID. It is based on the ESP32 DevKit V1. The robot uses an array of sensors a motor driver and Bluetooth to adjust its settings in real time.

Features:
The PID control makes the robot follow the line smoothly and accurately
The robot has a 5-channel infrared sensor array to detect the line
You can adjust the robots settings using Bluetooth
If the robot loses the line it will spin around until it finds it again
The robot has a custom circuit board with a voltage regulator

Hardware:
The brain of the robot is the ESP32 DevKit V1
The motor driver is a TB6612FNG
The robot uses 5 analog sensors
The voltage regulator is an LM7805
The robot has capacitors and connectors for the power and sensors

Built a 4-legged Arduino-based spider robot with 12 servos and full 3D inverse kinematics. The robot supports two modes — Bluetooth remote control with OLED face expressions, and autonomous obstacle avoidance using an ultrasonic sensor. Wrote all the firmware, designed the wiring, and documented the full project including circuit diagrams and a GitHub README.

Honestly, this project taught me more than I expected. I finally understood why you can’t just plug motors straight into an Arduino — the motor shield thing clicked once I saw what happens to the voltage without it. I got way more comfortable reading circuit diagrams, working with libraries I’d never touched before, and understanding how tiny things like a 40ms delay can completely change how a robot behaves. Writing the logic that makes the car actually “decide” which way to turn felt really rewarding — it’s simple code, but seeing a physical machine react to its environment because of something you wrote is a different kind of cool.

I did a bit more work to the arm by reducing the the latency between the commands send and the commands received by it this lead to a smoother control in the arm. I also resolved the inconsistent supply of 5v by adding a small Lithium ion battery to it. Now the arm can easily lift any object given it its weight limit.

Working on this project provided hands-on experience across several domains. On the hardware side, I learned how to correctly wire multiple servo motors to a shared 5V rail and how the 1000 µF decoupling capacitor is critical for preventing voltage brownouts when servos draw surge current simultaneously. I gained a solid understanding of how the HC-05 module bridges Bluetooth SPP communication to the Arduino’s UART, and why TX/RX lines must be disconnected during firmware upload. On the firmware side, I developed a deeper appreciation for custom serial protocol parsing — handling raw byte streams character by character, stripping ASCII offsets, and using delimiter/terminator bytes to frame multi-value packets. I also learned the value of smooth motion control: stepping the servo 1 degree every 10 ms dramatically reduces mechanical stress and produces far more natural movement than jumping directly to a target angle.

A 3-axis self-stabilizing gimbal built with Arduino Nano and MPU-6050 IMU. Uses DMP-processed quaternion data to control three servo motors across yaw, pitch, and roll axes in real time. Powered by a 3.7V LiPo battery, it automatically corrects orientation to keep the payload stable against motion and vibration.

I worked on an RFID-based Attendance System that automates the process of tracking and recording attendance. The system uses RFID technology to scan and identify individuals, instantly logging their attendance data into an Excel sheet for easy access and record-keeping. This project streamlined the attendance process by eliminating manual entry, reducing errors, and providing a structured, organized dataset that can be easily reviewed or exported for further analysis.

Today I built a gesture-based video controller using Arduino and ultrasonic sensors. I wrote the code to detect hand movements with two HC-SR04 sensors and tied it together with a Python script that translates those gestures into media controls on my computer. I also put together a full README for the project documenting how it works, the wiring, and how to get it running.

Building this RFID door lock gave me a deep practical understanding of the SPI communication protocol — specifically how the Arduino communicates with the MFRC522 module using dedicated SPI pins (MOSI on 11, MISO on 12, SCK on 13) alongside a configurable SS pin on 10 and RST on 9. I learned how every RFID card carries a unique UID and how to read it as a byte array, then compare it byte by byte using a loop to authenticate access. Working with the Servo library taught me how PWM signals precisely control motor angles — in this project rotating to exactly 130° to physically open the lock mechanism and returning to 0° to close it. I also learned the importance of initializing hardware state in setup() — using lockServo.write(0) at startup ensures the door always begins in a locked position regardless of where the servo was left. Using Serial.begin(9600) and print statements throughout the code helped me understand how serial monitoring is essential for debugging embedded systems in real time.

I worked upon serial communication a lot it was a real headache

I built a custom Arduino-based controller for racing games 🎮

Instead of using a normal controller, this setup uses a single joystick with dual modes:
Tap once → Steering mode
Tap again → Camera (look around) mode

The system is powered by Arduino and Python, where Arduino handles inputs and Python converts them into keyboard controls in real time. This is a simple prototype, but it shows how custom controllers can be built for games using basic electronics.

Started with the vision of creating Vyom OS as an AI-powered system to simplify user interaction through automation. Set up the project structure and began working on basic command handling. Implemented initial logic for processing user inputs and generating responses. Improved performance through testing and debugging. Planning to add voice interaction and smarter automation next.

This project is a custom drone that uses an Arduino as a cheap flight controller. It shows how to get stable flight with cheap parts and good engineering instead of using expensive commercial systems. The MPU6050 gyroscope and accelerometer work with the drone’s custom PID control system to keep track of its orientation in real time. After many test flights and careful tuning, the drone flies steadily, smoothly, and balanced. By working on this project, I learned a lot about PID tuning, sensor integration, flight dynamics, and debugging in the real world. The main point is to show that with the right logic and optimization, even a simple Arduino can work as a good flight controller.

Using OpenCV + MediaPipe for hand tracking and Arduino + servo motors for execution, I made a robotic arm that copies real-time hand movements. We started by finding hand landmarks, then we mapped gestures to servo angles and added serial communication to control the arm. We had to deal with problems like jitter, calibration, and latency, but we made the system work better so that motion was smoother and more responsive. The current prototype can successfully copy basic hand gestures in real time.

I’m working on my first project! This is so exciting. I can’t wait to share more updates as I build.