🦾 Iron Man Gauntlet

1. Introduction

The idea for this project came to me at the most unexpected moment—right before Neil started the randomizer in Week 2 of class. As I sat there, waiting for the selection process to begin, my mind drifted back to the first Marvel movie I ever watched: Iron Man 🎬.

That film wasn’t just entertainment; it was a spark. Seeing Tony Stark build his first suit in a cave with nothing but scrap 🔧⚙️ made me believe that technology could be magical ✨. That belief has stayed with me, and now, I finally have the skills to make a piece of that magic real.

This project is everything 12-year-old me wished for. I might not be able to fly yet (give me time, I’m working on it ✈️), but this gauntlet is my chance to turn childhood dreams into reality. This isn't just about making something cool—it's about proving to myself that the kid who sat wide-eyed watching Iron Man was right to dream big 🚀.

2. Project Concept

The goal of this project is to create a functional Iron Man gauntlet that doesn’t just look the part but feels like something Tony Stark himself would wear. It will have:

🛠️ A meticulously crafted outer shell, made via 3D printing and laser cutting.
🏗️ A hidden metal frame beneath the fairings, acting as a sturdy mounting socket for the electronics.
🖐️ Gesture-based controls (because if I can make it work with a flick of the wrist, it’s infinitely cooler).
🎙️ Voice activation as a backup, allowing me to say "Jarvis, let's light them up" to trigger lights, sound, and movement.
🔥 A (hopefully safe) flame-propelling mechanism, designed to knock over cans like a mini repulsor blast—without setting the FabLab on fire. (Maybe.) 😅

Sketches & Drawings

Processing and functions

3. Materials and Tools

Materials:

🧵 PLA filament for 3D printing
🔲 Acrylic or MDF sheets for laser cutting
🏗️ Aluminum or steel for the internal frame
🤖 Servo motors
💡 LEDs and sound modules
🔌 Microcontroller (ESP32 or Arduino)
🏃‍♂️ IMU sensor (for gesture control)
🎤 Microphone module (for voice commands)
🔥 Propane-based igniter (for the plasma gun test phase)

Tools:

🖨️ 3D printer
🔥 Laser cutter
🏗️ CNC milling machine (if needed for metalwork)
🔧 Soldering kit
🔍 Multimeter

4. Design and Planning

I want to craft every detail of this gauntlet with care—this isn’t just a prop, it’s a functioning piece of wearable technology 🦾. My plan is to start with a detailed 3D model 🖥️, ensuring that every electronic component fits seamlessly within the frame. The outer shell will be modular 🧩, so I can iterate and improve on the design without starting over every time.

For controls, I’m starting with gesture recognition ✋ because let’s be honest—what’s cooler than pointing at something and watching it light up? But if that proves too challenging, I’ll shift to voice commands 🎙️. I love the idea of calling out "Jarvis, let's light them up" and watching the gauntlet spring to life ⚡.

5. Fabrication Process

3D Modeling 🖥️ – Designing the gauntlet in Fusion 360, making sure every part is sleek and functional.
Prototyping the Shell 🔲 – Using materials like sunboard/foam board and laser cutting to build the first version.
Electronics Integration 🔧 – Mounting servos, LEDs, and sensors inside the frame.
Programming the Controls 💾 – Writing code for gesture and voice activation.
Final Assembly and Testing 🛠️ – Bringing everything together and running tests to see what works (and what explodes 💥).

6. Testing and Evaluation

I am planning to test the gauntlet in two phases:

Motion and Response Tests 🎭 – Checking how accurately the gesture or voice commands trigger the intended actions.
Plasma Gun Test 🔥 – Seeing if I can safely create a controlled flame burst that knocks over cans 🥫 from a distance without melting anything important.

7. Challenges and Solutions

Gesture Recognition Complexity 🤖 – If the motion tracking proves inconsistent, I’ll refine the input detection or switch to a more reliable voice command system.
Heat Management for the Plasma Gun 🔥🚒 – Safety is the priority here, so I’ll incorporate heat shields and ensure proper insulation.
Weight and Mobility ⚖️ – The gauntlet should feel comfortable to wear without sacrificing durability. Finding the right balance between strength and weight will be crucial.

8. Conclusion

This project is so much more than a FabLab assignment—it’s a tribute to the kid in me who dreamed of having his own Iron Man suit 🦾. It’s a test of everything I’ve learned and a challenge to push my skills even further.

By the end of this, I won’t just have a gauntlet—I’ll have proof that if you dream big enough, and work hard enough, even the most impossible ideas can take shape 🚀.

12-year-old me would be absolutely freaking out right now 🤯.

Week 9 progress!!!

I have tried the basic working of my plasma blast using butane gas. The apparatus is simple, clear tube, mini torch lighter and an empty soda bottle.

Week 14 progress!!!

Week 15

System integration

The Final Compilation

Might as well be as cinematic as the inspiration right?

Prologue

My final project has to be one of the most interesting things I have worked on in my life. It is rooted from a core memory from my childhood and has helped me exercise and learn so many skills during the course of its completeion. Right from initial sketches, hand picking the electronics and assembling everything together this has been a roller coaster. This piece has bits and pieces of it already, but I am compiling the complete journey here.

3D scanning

The human body has one of the most complicated forms in nature and if you factor in movement, the complexity goes to another level. One of the most challenging parts of my project was 3D modelling my forearm on CAD, I tried doing it in Fusion 360 but its was strictly parametric and its sculpting interface was new and restrictive too. Eventhough Blender offers more flexibility, I couldn't risk messing up the dimensions, or proportions being too out of scale.

Yes! I can scale whatever I create in Blender by inmporting it in Fusion, but the STL file will have millions of faces, and just make my laptop crash.
So I Thought of something I did in Week 5 3D scanning!. I used an app called 3D Scanner App. This app is native to IOS and uses the LiDAR scanner onboard.

It took around 15-20 mins and an extra set of hands, the app was set on auto-capture. It shot 110 Hi-Res photos, which it compiled on the cloud and gave a 3D scan of my upper body and majorly my forearm.
I imagined hours of work trying to scale it to actual dimensions but surprisingly it was almost completely accurate!

Editing the mesh

Like any other 3D scan it was not perfect. I still had to clean up the mesh before using it as a guide.

This is how the mesh looked when I first imported it to Blender. It had a lot extra information, my torso and fragments of my faces. These had to be cleaned. the simplest way is to go to Edit mode and selecting all the points and vertices that you dont want and deleting them. Now that I had isolated my forearm from the rest of the scan, it was time to smoothen the surface. The bumps in the surface might hinder the 3D modelling that I wanted to do on top of it later. I switched to sculpt mode and selected the smooth tool and worked on the 3D scan. You have to be careful to not overdo it or you can change the entire topology and have to start over again. After the smoothening, I added a Solidify modifyer to make sure the mesh is recognized even when I export it to Fusion 360, which has a tendency to act funny when working with complicated meshes. I simply exported the files as an obj file. I used an app called Instant Meshes To simply the faces of my mesh. This is the interface of the app. You can see how to use the app here

Adjusting tolerances

Now that I had the simplified mesh of my forearm ready to go, I could finally import it into Fusion 360. Thinking that now I could easily convert it into an editable object because I had simplified the mesh previously. I was wrong! It still had thousands of faces, even to make my laptop hot enough to cook an egg, and still fail. I was stuck, on the most integral part of this entire project and that is when I found a video that explained how to use meshes and create cross-section sketch objects from them so that I could get reference points to start 3D modelling. You can find that video here.

Firstly, I imported the mesh to Fusion 360, and for me it was at the correct scale at the Meter(probably because I edited it in Blender) I centered it to the origin and the ground plane- to keep life simple. Now it was time to learn to model around a 3D scan, so I went into the Mesh tab in fusion 360 and selected Create Mesh Section Sketch. You select your target body, and the tool plane that you want to use, and you can see the cross section of your 3D scan appear. Now that you have a Section Sketch, you will see a sketch tab in your Fusion timeline. You have to select and pick the edit sketch option. Once you are in click on Create>Fit Curves to Mesh Section. This is the menu you should see
Here, for our use case we have to select the 4th option which is the Closed Spline
& then select your cross-section. I now had an approximate sketch of an elipse that should (in theory) fit my hand. So, I repeated this process 3 more time. Now I could use the loft tool in the Surface tab of fusion to create a body around my hand. The body created was just a plane, so I used the Thicken option and added a 2mm width to the extrusion. And repeating this one more time, I had 2 rings modelled around my hand. Now to check if the sizing was right I 3D printed them. Its visible that the rings do fit my forearm, but they are not exactly where they are seen in CAD. This can be due to a lot of reasons like the printer's tolerance and the shrinking of the PLA after being extruded, whatever the case, I added a 2mm offset to all the sketches, to adjust for this.

CAD - The Final Sprint

Everything was in place, and now the final sprint for CAD was underway! I had planned on making an exo-skeleton on which I could place all the electronics and hide the wiring. Over this I could make the final fairings that could be mounted, and give the final look for this gauntlet.

Exo-Skeleton

This was the exoskeleton that I created. The slits at the bottom are to attach elastic straps taht I'll use to wear the gauntlet. The cyclindrical extrusions are 8 mm spacers, which will be used to mount the top fairing, using M3 screws.
The flat surface at the front, was to get a plabne surface to mount the electronics, and the circle and the triangle are for mounting the Missile Silo Mechanism (that I will talk about).

Missile Silo

When I realised that I couldn't do the plasma blast from my palm, because of very little space and safety conerns, I changed my idea, and thought of mounting the entire pulse on the top of my forearm.
This gave me more space to work and made it safe to play around with the flammable gas that I was using. This is what I came up with. I picked the 3D model for the MG90s servo motor online, this would be used to lift and drop the cover for this Missile Silo. You can see the 2 prongs holding the bottle which would be used for the blast. I wanted this to be a clip on system so that I could easily remove and store the glove after using it.
The cylindrical extrusions are for attaching the lever arms that control the movement of the cover that I made for concealing this mechanism. You can also see the circle and triangle that I made for aligning and attaching this mechanism to the exoskeleton.

This is how the housing for concelaing the mechanism looks. I made this using the sketch and loft workflow mentioned earlier. The basic working of this mechanism is that when the servo motor turns it lifts the cover up and sends it behind, exposing the blasting tube. I'll show the working in more detail in the electronics section.

Chest piece

The chest piece or the arc reactor in the movies, is what power that whole Ironman suit. I want to create this effect too. That's why I made and enclosure for the plasma igniter, so that one could see the pulse travelling from the chest the forearm. You can see the two holes on the side to let the pipe enter from the reservoir and exit from the other side to the forearm. There is also a small hole beneath that to allow for easy cable management. There are cuboidal standoffs that are extruded upwards to support the lasercut stencil, which I made for aesthics that becomes a silhouette when the neopixels inside lightup. The handle like structures outside are for attaching elastic bands so that I could put it on easily.

Gas Holder

Because I was designing a complete system, I made a holster for the gas can I was using for this project, it also has slots for the elastic bant to go through and be attached to my waist.

Gas Nozzle

I went through so many itterations of the gas nozzle.
The first one was just a snap fit, no room for movement which menat no gas was release. I made the second one more ergonomic,but still it was a little tall, so i cut it to the right size, and finally made the final one which worked perfectly. You press down on it and it releases the gas. Completely manual giving full control should anything go wrong. This nozzle presses down on the bottle such that it starts releasing butane, through a small hole I made in it.

Electronics

Flex sensor

My journey with the flex sensor began with getting it properly wired and responsive. Initially, I connected the flex sensor to the XIAO ESP32-S3 using a simple voltage divider circuit with a pull-down resistor.

VCC (3.3V)
  |
  |
 [Flex Sensor]
  |
  |--------> A0 (Analog input pin on ESP32-S3)
  |
 [10kΩ Resistor]
  |
 GND

This setup ensured I could detect resistance changes as the sensor was bent occassionally.

Flex Sensor Spiral #1

// Use the correct analog pin based on your ESP32-S3 board
const int flexPin = A0;  // Replace with actual analog pin if different

void setup() {
  Serial.begin(115200);
  delay(1000); // Give time for serial monitor to connect
  Serial.println("Flex Sensor Test Started");
}
void loop() {
  int flexValue = analogRead(flexPin);
  Serial.print("Flex Sensor Reading: ");
  Serial.println(flexValue);
  delay(100); // Read every 100 ms
}

Once I had the raw analog values flowing in, I proceeded to map these readings from their native range to a percentage scale of 0–100.

Flex sensor Spiral #2

const int flexPin = A0;  // Analog pin
int rawValue;
int mappedValue;

void setup() {
  Serial.begin(115200);
  delay(1000);
  Serial.println("Flex Sensor with 0–100 Mapping");
}

void loop() {
  rawValue = analogRead(flexPin);

  // Map raw value (example: 500–3000) to 0–100
  // You might need to calibrate these numbers to your actual sensor range
  mappedValue = map(rawValue, 500, 3000, 0, 100);

  // Optional: constrain the value to ensure it's within bounds
  mappedValue = constrain(mappedValue, 0, 100);

  Serial.print("Raw: ");
  Serial.print(rawValue);
  Serial.print(" | Mapped (0–100): ");
  Serial.println(mappedValue);

  delay(100);
}

This made it much easier to interpret the sensor's behavior and set meaningful thresholds for triggering actions.

With the sensor calibration in place, I moved on to integrating it with actuators. I first tried connecting an MG90S servo motor directly to the ESP32, which unfortunately led to the board blowing due to the current draw.

Flex+Servo

#include <ESP32Servo.h>

const int flexPin = A0;      // Analog pin for flex sensor
const int servoPin = D3;      // PWM-capable pin for servo

Servo myServo;

void setup() {
  Serial.begin(115200);
  myServo.attach(servoPin);  // Attach servo to GPIO pin
  myServo.write(0);          // Initial position
  delay(1000);
}

void loop() {
  int rawValue = analogRead(flexPin);
  int flexMapped = map(rawValue, 500, 3000, 0, 100);  // Adjust these values as per calibration
  flexMapped = constrain(flexMapped, 0, 100);

  Serial.print("Mapped Flex Value: ");
  Serial.println(flexMapped);

  if (flexMapped > 80) {
    myServo.write(90);  // Turn servo to 90°
  } else {
    myServo.write(0);   // Return to 0°
  }

  delay(100);
}

This failure prompted me to introduce a PCA9685 servo driver to ensure stable and isolated control of the motor. Using this setup, I aimed to create a gesture-triggered sequence: when the flex sensor was bent beyond a certain threshold, the servo would rotate 90 degrees.

This process involved a fair amount of logic refinement. I ran into issues with bouncing sensor values and servo jittering, which I resolved through smoothing techniques and carefully timed delays using millis() instead of blocking delay() calls.

Even with so many fail safes and work arounds I never got the flex sensor to work consistently. Keeping in mind the safety concerns that this would entail. I discarded this idea and moved on to using a simple push button as a counter.

Servo motors

As said earlier I to prevent the ESP32 from blowing up again, I switched to using a PCA9685. PCA This is the PCA9685 It is a PWM board that can handle upto 16 servo motors at once.

PCA9685 Pin	Connects To (ESP32-S3)	Description
`VCC`	`3.3V` or `5V`	Power supply (depends on your board, most PCA9685s work with both)
`GND`	`GND`	Common ground
`SCL`	`I2C Clock` (default is GPIO 9 or 22)	I2C clock line
`SDA`	`I2C Data` (default is GPIO 8 or 21)	I2C data line

This is how I connected to my PCA board. I used a spare Arduino Nano to provide a stable 5V external supply to the PCA9685. The servo motor was then to be simply plugged into the colour coded rails and it was ready to go!

PCA9685 working

#include <Wire.h>
#include <Adafruit_PWMServoDriver.h>

Adafruit_PWMServoDriver pwm = Adafruit_PWMServoDriver(); // Default address 0x40

void setup() {
  Wire.begin(8, 9); // SDA, SCL - adjust if using different pins
  pwm.begin();
  pwm.setPWMFreq(50); // Analog servos run at ~50 Hz
}

void loop() {
  pwm.setPWM(0, 0, 300); // Move servo on channel 0
  delay(1000);
  pwm.setPWM(0, 0, 500); // Move to another angle
  delay(1000);
}

Plasma Igniter

I was the most concerned for this component because for my project to work I needed something to reliably generate a spark or an electric arch, which I could control electronically. I found this plasma lighter in a stationery shop and sparks flew across my mind (pun intended). Taking the internal circuitry out, i figured the this worked on the AND logic, two type of switches must be ON for the arc to be generated. A 3.3V LiPo battery, a transformer and a custom circuit board. After discussing with my mentor Jesal Sir. We aggreed that I should de-solder the tact switch find which 2 points I need to bridge and then control it digitally with a MOSFET. And so I did just that! Now, with the multi-meter I isolated the 2 points that I could connect so that the circuit can be completed. This is me trying out the new terminals that I soldered onto the lighter and they work! You can see the purple plasma at the bottom right of the photo. Now it was time to connect these new leads to a MOSFET module, and try and control it digitally. I again used an Arduino Nano for providing a 5V supply. Which I later, realised was a little overkill, not that it damaged the circuit or the lighter in any way. To my advantage it didnt hinder with the power requirements of the PCA9685

MOSFET

#define MOSFET_PIN 10 // Use any GPIO you like

void setup() {
  pinMode(MOSFET_PIN, OUTPUT);
}

void loop() {
  digitalWrite(MOSFET_PIN, HIGH); // Turn device ON
  delay(1000);
  digitalWrite(MOSFET_PIN, LOW);  // Turn device OFF
  delay(1000);
}

I uploaded this code to the ESP32-S3, et voilà!

NeoPixel chain

I used individual neo pixels and soldered them into a chain, Each neopixel has 4 main connections 5V, GND, Din & Dout. I essentially made a chain of these for both the gauntlet and the Chest piece, I used the Adafruit Neopixel library and coded them to turn on as soon as they were connected to power. I created a custom PCB so that wiring doesn't become a mess when connecting the lights!

PCB milling

Realising that I need to exted the 5V,GND and data port of my ESP32, I thought the best way is to mill my compact & custom PCB. I used the workflow I learnt in Week 8.
I opened up EasyEDA and laid out the compnents I needed. Then I made all the necesarry connections to the header pins. I saved this design and entered the schematic view. I ran the auto-route function using preset rules for our machine which we found in Week 8. This is the 3D render of my PCB These are the milling and soldering results:

Lasercut Stand

Time was running out and I wanted to create a kick-ass video to culminate my final project, which is why I thought ahead and lasercut a stand out of clear acrylic. Not only does this look super fancy and futuristic, it is barely seen when shot in low light and gives a floating effect to the gauntlet. This is the RDworks software interface used to program the lasercutter in my lab. This is how it turned out.

3D prints

You can see that a lot of work has gone into CAD and here are the outputs of my 3D priniting: Exoskeleton + Missile Silo Test print for palm All functioning parts of my project Test fitting the blast chamnber as well as the servo motor Missile Silo cover Dry fit of the final output

Surface finishes

We are in the Endgame now. Surfaces finishes were something that both Neil and I were very excited about when we had our fist conversation on a random review.

Nail Paint?

My mentor sent me this video. It showed a lady using nail paint as a primer, then using something called as chrome powder, commonly used in nail art(nothing to do with chromium powder which is toxic), and then finishing with a clear coat. This is how it turn out, the nailpaint that I had used never lost its stickiness, but the matallic shimmer was pretty impressive, I will experiment with this in the future.

Resin

Because i had that Chrome powder lying around, I figured why not mix it with resin, and maybe coat the 3D prints with it. I got craft resin with a 2:1 resin to hardner ratio and mixed a pinch of chrome powder in it. It just looked like glitter particles suspended in a clear solution- Not a winner!

Spraypaint

Nothing beats the good old spray paint can. Sanded down the layer lines of a test print and spray a coat of metallic red followed by a clear laquer coat. This was very close to the colour we see in movies.

Electroplating

The original plan however was to electroplate all the exterior 3D prints and then colour them red, this was my attempt in Wildcard Week But I never got another whack at it. Also the time it would have took would have delayed the rest of the porcess by a lot.

These are all the explorations done, but the comic accuracy of the red color of the filament I used, was also not ignorable. Not to mention the end quality of all the prints were immaculate, not needing a surface finish- at the cost of risking it looking scratched up or having paint chip off in a few months.

Final Assembly

I printed out the final parts which I was going to use as fairings for my gauntlet, they included in the Missile Silo files that I have attached at the bottom of this page.
You have seen pictures of it by now, but here are some screenshots of Fusion360

All the holes I have made are made for M3 nuts and bolts, I have adjusted the size of these holes according to the tolerances of my 3D printer, these may vary for someone trying to use recreate my work.

Most of the attachments were screwed down, Some were snapfit like the missile mechanism, the bottle mounting, the arms of the missile mechanism.

Now, that my main target was complete and everything seemed to work, I found files for the Ironman palm and fingers online. Had I stuck to the original idea of blasting from my palm I would have to model them myself. But now they were part of the aesthetics. Here are the links to those files :Ironman palm Reference_1, Ironman MK85 full suit, Ironman palm Reference_2, Ironman MK6 suit.
I followed the lead of cosplayers and used elastic along with rubber cement, to attach different parts of the build together. Each finger is made up of 3 pieces, and the thumb is 2 pieces. I stuck elastic between 2 pieces such that it returns to a natural bent position, which is comfortable for wearing for long durations. Not to mention i had to scale down the STLs to fit my finger sizes, this took some experimentaion.

Now that my glove was assembled, I uploaded the final combined code that managed all functions of the glove. This included the lights, motor and the sparking mechanism. Connections

Component	ESP32 S3 Pin	Notes
Button	D4	Pulled down with `INPUT_PULLDOWN`
PCA9685 SDA	D6	I2C data
PCA9685 SCL	D7	I2C clock
MOSFET Gate	D10	Controls your igniter or other load
NeoPixel Strip 1	D0	2 LEDs
NeoPixel Strip 2	D1	3 LEDs
Servo on PCA9685	Channel 0	Connect your MG90S

One code to run them all

#include <Wire.h>
#include <Adafruit_PWMServoDriver.h>
#include <Adafruit_NeoPixel.h>

// === I2C PINS for PCA9685 ===
#define I2C_SDA        D6   // D6 (GPIO6)
#define I2C_SCL        D7   // D7 (GPIO7)

// === PINS ===
#define BUTTON_PIN     D4   // D4
#define MOSFET_PIN     D10  // D10
#define NEOPIXEL_PIN1  D0   // D0 - 2 NeoPixels
#define NEOPIXEL_PIN2  D1   // D1 - 3 NeoPixels

// === COUNTS ===
#define NUMPIXELS1     2
#define NUMPIXELS2     3

// === SERVO SETTINGS ===
#define SERVO_CHANNEL  0
#define SERVOMIN       102   // approx. 500 us
#define SERVOMAX       512   // approx. 2500 us

// === OBJECTS ===
Adafruit_PWMServoDriver pwm = Adafruit_PWMServoDriver();
Adafruit_NeoPixel strip1(NUMPIXELS1, NEOPIXEL_PIN1, NEO_GRB + NEO_KHZ800);
Adafruit_NeoPixel strip2(NUMPIXELS2, NEOPIXEL_PIN2, NEO_GRB + NEO_KHZ800);

// === STATE VARIABLES ===
int pressCounter = 0;
bool cooldownActive = false;
unsigned long cooldownStart = 0;

void setup() {
  Serial.begin(115200);

  // Setup I2C explicitly
  Wire.begin(I2C_SDA, I2C_SCL);
  pwm.begin();
  pwm.setPWMFreq(50);
  delay(10);

  // Setup Pins
  pinMode(BUTTON_PIN, INPUT_PULLDOWN);
  pinMode(MOSFET_PIN, OUTPUT);
  digitalWrite(MOSFET_PIN, LOW);

  // Setup NeoPixels
  strip1.begin();
  strip2.begin();
  pulsePixels(strip1);
  pulsePixels(strip2);
  setAllPixelsOn(strip1);
  setAllPixelsOn(strip2);
}

void loop() {
  static bool lastButtonState = false;
  bool currentButtonState = digitalRead(BUTTON_PIN);

  // Detect rising edge (button press)
  if (currentButtonState && !lastButtonState) {
    handleButtonPress();
  }

  lastButtonState = currentButtonState;

  // Check if cooldown is over
  if (cooldownActive && millis() - cooldownStart >= 15000) {
    cooldownActive = false;
    Serial.println("Cooldown ended.");
  }
}

void handleButtonPress() {
  if (cooldownActive) {
    Serial.println("Cooldown active. Please wait...");
    return;
  }

  pressCounter++;

  if (pressCounter == 1) {
    Serial.println("1st Press: Moving servo to 115°");
    moveServo(115);
  } else if (pressCounter == 2) {
    Serial.println("2nd Press: Triggering MOSFET");

    digitalWrite(MOSFET_PIN, HIGH);
    delay(1500);  // MOSFET ON for 1.5 seconds
    digitalWrite(MOSFET_PIN, LOW);

    Serial.println("MOSFET OFF. Cooldown starts. Resetting...");

    moveServo(0);  // Return servo to 0°
    cooldownStart = millis();
    cooldownActive = true;
    pressCounter = 0;
  }
}

void moveServo(int angle) {
  angle = constrain(angle, 0, 180);
  int pulse = map(angle, 0, 180, SERVOMIN, SERVOMAX);
  pwm.setPWM(SERVO_CHANNEL, 0, pulse);
}

void pulsePixels(Adafruit_NeoPixel &strip) {
  for (int b = 0; b <= 255; b += 5) {
    for (int i = 0; i < strip.numPixels(); i++) {
      strip.setPixelColor(i, strip.Color(b, b, b));
    }
    strip.show();
    delay(5);
  }
  for (int b = 255; b >= 0; b -= 5) {
    for (int i = 0; i < strip.numPixels(); i++) {
      strip.setPixelColor(i, strip.Color(b, b, b));
    }
    strip.show();
    delay(5);
  }
}

void setAllPixelsOn(Adafruit_NeoPixel &strip) {
  for (int i = 0; i < strip.numPixels(); i++) {
    strip.setPixelColor(i, strip.Color(255, 255, 255));
  }
  strip.show();
}

I decided that its better to test the plasma pulse before integrating it into the final model. This was to know and learn from any failures in the tubing and/or attaching individual components.
Each attachment was first covered in teflon tape and then fixed in place with rubberised electrical tape, to avoid any leaks and cause safety issues.

Amazing one would think now everything should be working right? Wrong!!!

Even when the tube was filled with flamable gas, the only ignition that took place was where the sparks were happening. I didn't realise this at first. But I had created a seal tube, that had flamables in it and an igniter, but the thing required to set it ablaze was missing- Oxygen.

After feeling like a complete idiot for 5 minutes, I knew what lied ahead of me... more CAD. This isn't as daunting as it seemed back then in retrospect but all I had to do was to add holes in the nozzle, that would pull oxygen everytime I pumped the gas in because of The syphon effect.

I added the holes and the new nozzle was ready!

Bill of Materials

Heroshots

This is what days of working on CAD, hours of debugging code, and a little camera magic looks like!

This is my very own Ironman gauntlet in action!

10th of June presenting my work to Neil.

My Takeaways

It’s still a little hard to believe how far we’ve come. It feels like just weeks ago, I logged into my first Fab class, clueless, curious—and maybe a little overwhelmed. Now, somehow, it's all coming to a close.

But like all good things, this too must end.

If you're someone reading this—wondering how to begin your final project, or maybe standing at the edge deciding whether to join—let me say this: the weekly assignments, as intense as they may seem, are just the surface. A pretext. A spark. A glimpse of what can be done. Yes, the possibilities are endless. Wild. Even mind-blowing at times. But still, after it all, you’re only scratching the surface.

These past few weeks, diving deep into my final project, have been some of the most revealing moments of my journey. I’ve sharpened my CAD skills, challenged materials and machines to their limits, and learned to bet on my own abilities-even when time was running out.

And yet, despite everything I’ve built, broken, remade, and pushed through… I didn’t end up feeling like some all-knowing expert. I didn’t become the encyclopedia of making that I once thought I would. Truth is, that’s not the point.

What I did learn—what Fab really taught me—is that this is just the beginning. A taste of the sea before the dive. And sure, one day I might just be The Master of the Sea, but today… today is just my first real swim.

Now, as I step away, I’m looking forward to what’s next. To the next idea. The next messy table. The next impossible sketch that somehow becomes real. I’m looking forward to making up for lost time with the people I love, and carrying forward every lesson, every challenge, every spark from this chapter.

And maybe the best part of it all—the part that makes me smile even now—is the quiet confidence I’ve found somewhere along the way. The kind that tells me, deep down…

I can make almost anything.

Acknowledgements

I like to thank my mentors Jesal Sir & Pranav Sir for their prompt feedback and help in ideation of my project. I also extend graditude to the people part of the RIIDL ecosystem who helped my and my fabmetes along the way.

Links to previous weeks

Week 2 I learnt alot about DFA and DFM
Week 4 Building upon the coding skills learnt
week 5 3D scanning and 3D printing
Week 6 Week 8 CUstom PCB making
Week 9 Week 10 Week 11 Working with sensors and output devices
Week 15 Week 17 Week 18The final run to project completion.

Desgin files

Full 3D scan
Arm isolated
Arm simplified
Missile Silo
Modelling over 3D scan in Fusion360
Chest piece
Gas tank holder
Gas Nozzle
Updated Gas Nozzle PCB GERBER