This is my undergrad capstone project. A quadrotor flight controller was designed from scratch on STM32 and ESP32. The second part of the project was to design pattern formation algorithm with obstacle avoidance. To aid in faster development, I designed tools such as swarm simulator and automatic PID tuner (based on dynamic model). The simulator helped in implementing different algorithms without risking hardware damage and was incredibly useful during covid-19 lockdown. I worked on the following tasks:

• State Estimation (Kalman, Complementary and Butterworth filter) for 12 states.
• Control Architechture for altitude, climbrate and position lock.
• Dynamic modelling, linearisation and implementing multiple control methods (LQR, PID)
• Implementing collaborative behaviour(pattern formation, rendezvous) through Multiagent theory based on graph networks.
• Analysing effect of connectivity on collaborative robots.
• [Just for fun] - Calculating NDVI index and image stiching from video captured from quadrotor.

As a part of Dynamics of Machines Course, our group developed an acrylic bending machine. My work was to design and develop the entire electronics and control stack. Initially, the machine was manually controlled by controlling the voltage but to make it easier to use, a temperature controller was added. Currently, it is in use at Ahmedabad University Mechanical Engineering Lab. My work on the project was:

• Decide which electronic components to purchase based on temperature requirements while constraining to the budget.
• Develop a system with feedback of thermocouple to control temperature (Algorithm used: PI control, Exponential Smoothing)
• Develop the algorithm of how the machine has to be operated (manual/autonomous/safety features)
• Design and fabricate the circuit board.

As a part of mechatronics course, we designed the window cleaning robot. This was my first ever exposure to electronics and microcontrollers. The project required us to go in depth with finding the solution to real problems in city. With the rise of skyhigh buildings, we decided to make a window cleaning robot which cleans the outer surface of window. The robot was attached to window using a ducted fan, which creates a suction. Using standard toy tyres, our robot travelled on the window. Our algorithm was extremely elementary which followed straight path and then turned in other direction when encountered any wall. The work done in project is as follows:

• Studying the problems and finding out the problem statement.
• Figuring out the design and mechanism of the robot.
• Deciding components based on air flow required to keep it on wall.
• Make few prototypes, interfacing with motor drivers, ESCs and other sensors.

Outcome: Suction to wall was successful, although it couldn't travel because of toy wheels and low torque motors. Moreover, the COG was not low enough, so it had tendency to fall.

This is one of my best personal projects. In Summer 2020, I was learning mobile robotics and wanted to implement the algorithms. However, I couldn't use ROS in my virtual machine due to resource consumption. Hence, I decided to make my own simulator. What started as a simple 2D point based animation became a full 3D simulator with swarm capabilities. The reason I like my simulator is because it is lightweight and I can modify it as per my requirements. The simulator has the following capabilities as of now (June 2021):

• Completely built using standard python libraries.
• Robots: Differential Drives and Quadrotors(2D and 3D)
• Both linear and non-linear dynamic models
• Inbuilt path tracer, blackbox and auto pid tuner.
• Swarm algorithms for patten formation using graph theory (Formation and Agreement protocols)
• Inbuilt controller as a sample to play with keyboard.
• Language: Python

Note:- I will have to say, this simulator is no way as sophesticated as ROS. It is just intended as a learning or demonstration platform for low resource computers. Its not public currently, I will work on documentation and make it a little more usable before making it available.

In this project, we(team size - 5) designed and manufactured the windtunnel. The windtunnel was subsonic, each section was manufactured by hand(even the thermocouples) except the testing chamber with laser cutter. Then, dimmerstat, thermocouples and datalogging was added. The size of windtunnel was around 2.3 meters in length. It was manufactured in modules using plywood and acrylic. Additionally the contraction section (entry of air) is curved and designed using a 5th degree polynomial which minimise boundary layer thickness and has minimal contraction to save space. It reduces the area of the contraction section smoothly so the forces on the supports is reduced. I worked in the following areas:

• Design windtunnel using CREO and MATLAB and make production drawings.
• Select Fan based on velocity required using fluid mechanics calculations.
• Selected heater by developing an automated script to calculate surface temperature using radiation, convection and conduction.
• Build mathematical model using circuit analysis of heat transfer to calculate the amount of heat transfer in individual modes.
• Designed and fabricated electronics board for controlling speed of fan, collecting thermocouple data and using Opamps to amplify the readings.

As a part of Fluid Machines course, we designed a protype of francis turbine. The turbine was designed to generate a power of 50 MW with a head of 100 m. Accordingly, the number of guide and runner vanes were calculated with appropirate angles. The design of vanes were done using NACA hydrofoils adjusted to calculated angles and the miniature design was 3D printed. A geared mechanism was created to adjust the opening of guide vanes, which allowed to vary the flow rate of incoming fluid. Unfortunately I couldn't find a picture of the 3D printed product :(

This was my first experience with robotics. Performed inverse kinematics on KUKA KR3 (6 DOF) using Peter Corke's toolbox. However, the inverse kinematics algorithm was misbehaving at singular points, so I worked out my own algorithm. My solution was partly based on geometric solution and then iterative solution at end effector. The algorithm successfully solved the problems encountered at singular positions, however it was slower compared to the toolbox algorithm. To cope up with the speed, I check forward kinematics for each solution output by the toolbox. Whenever there is an anomaly, I resolve at that point with my algorithm. The highlights to the project are:

• Forward and inverse kinematics on SCARA robot in python.
• DH parameterisation of Kuka KR3 from datasheet.
• Forward and Inverse Kinematics using DH parameters and simulating using Peter corke's toolbox
• Solution at singular positions using geometric and iterative solution.
• Trajectory generation with quintic polynmoial.

This was a two part project. In fractal visualisations, we made Mandelbrot, Multibrot, Julia Set, Barnsley Fern and Ikeda Map. The codes were written in C++ and Python for different sets. In the end, applications of fractals were researched.
Second part was chaotic analysis of inverse pendulum where dynamic model of double pendulum was derived using Lagranjian. An animation was made for the dynamic model and chaotic analyses was carried out. Then a binary fractal was generated following condition derived from Hamiltonian. TO further analyse this non-linear system, poincare map and phase plots were generated.

This project is closely related to my robotics simulator(Python) and my SCARA simulator(MATLAB). The project was to generate the plot of angles vs time for kinematic chains. The language required was strictly scilab, which was unknown to me at that time. At first glance, it is just figuring out the kinematic equations and solving for answers at each step. But I decided to add animations in the code. The following linkages were simulated:

• 4-bar crank rocker linkage
• Inline slider-crank linkage
• Offset slider-crank linkage
• Velocity Analysis of RSSR (R - revolute; S - spherical) linkage
• Acceleration Analysis of Sliding Contact Linkage