MY FAB PROJECT

THE MINI THOR

I am planning to build a mini desktop EDM. This was inspired by my days as an EDM operator in a small machine shop in Kerala. After that, I have always been intrigued that I needed a small machine that will help me cut metals and profile them. TADA, we have the mini EDM. The design was inspired by the Formlabs FORM 1 SLA 3D printer, and I really wanted to make it look the same.

inspiration

Having started my journey as an EDM operator at the age of 18, I was immediately captivated by the precision and intricacy with which EDM could cut through metals. The process seemed almost magical, as it involved using electrical discharges to erode material, enabling the creation of highly detailed and accurate parts. This experience ignited my curiosity and passion for machining, leading me to envision a mini desktop EDM system that could bring the capabilities of this technology to a wider audience. Inspired by the sleek design of the Formlabs FORM 1 SLA 3D printer, I aim to infuse aesthetics with functionality, creating a visually appealing and user-friendly machine for metal cutting and profiling.

my project plan

Week 1-2: Research and Requirements Gathering (2 weeks)

Week 3-4: Concept Development and Initial Design (2 weeks)

Week 5-6: Detailed Design and CAD Modeling (2 weeks)

Week 7-8: Simulation and Analysis (2 weeks)

Week 9-10: Material Sourcing and Prototyping (2 weeks)

Week 11-12: Assembly and Mechanical Integration (2 weeks)

Week 13: Electronics Design and Prototyping (1 week)

Week 13-14: Software Development and Interface Design (2 weeks)

Week 14-16: Testing, Optimization, and Documentation (3 weeks)

BASIC INSIGHTS AND REFERENCES

to i had some idea on the workings of an edm from a machinist perspective but i wanted to get more information on the power electronics part as i was having very little knowledge on it

so these are some of the reference that i was able to get

the most promising project that i was able to get was by a team called reck robotics and they have a dedicated power supply for a table top edm

then i also came across a MTM project by mr.Will Langford it is a wire cut edm

i also visited my workshop that i worked as a edm operator for checking their latest edm machines

i am yet to figure out the powersupply i am planning to conduct some testing based on few hypothesis i have

CAD DESIGN

I finished the CAD design of the project

THE WALL

As I was approaching the build, due to some unforeseen circumstances, I had to take a three-week leave of absence from the academy. Now, I am left with one week to finish the project, so I have abandoned this project for the time being. However, I definitely plan to revisit it in the future.

Robot Safety Guidelines

When working with robots, safety is paramount to protect yourself and others. Follow these safety guidelines at all times:

Personal Protective Equipment (PPE)

• Eye Protection: Always wear safety goggles or a face shield to protect against flying debris or sparks during testing and operation.
• Hearing Protection: Use ear protection such as earplugs or earmuffs, especially in loud environments or when testing powerful motors.
• Hand Protection: Wear gloves to safeguard against sharp edges, hot surfaces, or pinch points when handling the robot.
• Foot Protection: Use sturdy closed-toe shoes or boots to protect against accidental impact or crushing injuries.

Testing Environment

• Enclosed Arena: Always test the robot in a controlled, enclosed area designed for robotics testing or competitions. This minimizes the risk of bystanders and ensures that the robot remains within a safe containment area.
• Emergency Stop: Implement an emergency stop mechanism or a weapon arming pin. When the robot is not in use, always insert the weapon arming pin to prevent accidental activation.

Operational Safety

• Supervision: Ensure that testing and operation are supervised by qualified individuals who understand the robot's capabilities and safety protocols.
• Readiness Checks: Before each test or operation, perform readiness checks on the robot, including verifying battery levels, securing all components, and confirming proper functionality.
• Post-Operation: After testing, inspect the robot for any damage, loose parts, or signs of wear. Address any issues before the next use.

By adhering to these safety guidelines, you can mitigate risks and ensure a safe and productive environment when working with your robot.

PROJECT SHREDZILA

I have chosen to build a beetle weight battle bot as my project due to my passion for battle bots, especially my favorite bot, Tombstone. In our country, the concept of battle bots is still not widely recognized, and the robot design and fabrication techniques are quite rudimentary and outdated. As our lab is frequently visited by students, I aim to create a showcase robot that demonstrates the potential of our lab in constructing high-quality robots. This project will inspire students to build, document, and share their own work. Additionally, I hope to leverage the fab network to cultivate a top-class battle bots community in India, particularly in Kerala.

SHREDZILA

SHREDZILA is my beetle weight battle bot, weighing 3 pounds or less. It features a powerful horizontal spinner weapon, inspired by the famous Tombstone. Designed for agility and durability, SHREDZILA can deliver devastating blows in combat

CAD

SHREDZILA's Design

SHREDZILA's design consists of three main components: the top-bottom structure, the weapon assembly, and the shell.

Top-Bottom Structure:

The top-bottom structure forms the backbone of SHREDZILA, providing support and stability. These components extend from the shell, ensuring structural integrity and balance during combat. Carefully engineered for durability and weight distribution, the top-bottom structure serves as the foundation for mounting the weapon assembly and other essential components. At the end of each segment of this structure, the weapon pulley and weapon are securely mounted, enabling precise control and powerful strikes.

Weapon Assembly:

Positioned at the end of each top-bottom segment, the weapon assembly is the primary offensive component of SHREDZILA. Inspired by Tombstone, the horizontal spinner weapon is designed to deliver devastating blows to opponents. The weapon pulley, integrated into the top-bottom structure, provides rotational power to the weapon, enabling rapid spinning and maximum damage upon impact.

Shell:

The shell encompasses SHREDZILA's top-bottom structure and serves as its outer armor. Designed for aerodynamics and durability, the shell provides protection against enemy attacks while enhancing the robot's overall aesthetics. Integrated seamlessly with the top-bottom structure, the shell contributes to SHREDZILA's sleek appearance while maintaining its resilience in combat.

you can see and download the cad file from here

SHREDZILA Fusion 360 file

you can see and download the cad file from here

download the step file here
download weapon files here
download WATER JET FILES from here

SHREDZILA Bill of Materials (Mechanical)

PROTOTYPING

I successfully created a mock prototype of SHREDZILA using cardboard, leveraging the precision cutting capabilities of a Zund machine. This allowed me to translate my design from CAD software into tangible components with remarkable accuracy. By assembling these cardboard pieces, I gained valuable insights into the feasibility and functionality of my design, enabling me to iterate and refine before moving forward with more permanent materials. This iterative process not only saved time and resources but also ensured that the final product would meet my expectations and requirements.

3D PRINTING

3D Printing SHREDZILA's Shell From TPU(A95)

I 3D printed the shell of SHREDZILA using TPU filament to ensure flexibility and durability. TPU, being a flexible material, provides the necessary resilience to absorb impacts during battles while maintaining the integrity of the shell.

3D Printing Process and Settings

These settings were carefully chosen to balance strength and flexibility. The grid infill pattern at 40% density provides a robust internal structure, ensuring that the shell can withstand the rigors of combat without being too rigid. The parameter setting of 6 ensures adequate wall thickness, adding to the overall durability of the shell.

Key Considerations for Printing with TPU

• Extruder and Bed Temperature:
  • Extruder Temperature: Set at 220°C to ensure the TPU filament melts properly and extrudes smoothly.
  • Bed Temperature: Set at 60°C to improve bed adhesion and reduce the risk of warping during printing.
• Print Speed: A slower print speed of 30 mm/s was used to accommodate the flexible nature of TPU, reducing the risk of stringing and ensuring better print quality.
• Retraction Settings: Retraction distance was set to 1 mm and retraction speed to 20 mm/s to minimize stringing and oozing, which are common issues when printing with TPU.
• Cooling: The cooling fan was kept off for the first few layers to enhance bed adhesion and then set to 30% to gradually cool the print, preventing warping and improving layer bonding.
• Infill Pattern and Density: The grid infill pattern at 40% density provides a balanced internal structure, offering both flexibility and strength. This pattern helps distribute impact forces evenly across the shell.

The combination of these settings and the TPU material resulted in a shell that is both tough and resilient, capable of protecting SHREDZILA's internal components while contributing to its sleek and aerodynamic design. This approach allowed me to create a high-quality, functional prototype ready for battle.

WATER JETING weapon & Top-Bottom Structure

The weapon and top-bottom structure of SHREDZILA were manufactured using water jet cutting, a precise fabrication method that uses a high-pressure stream of water mixed with abrasive particles to cut through materials like aluminum. This process allows for intricate designs and precise cutting edges, ensuring that SHREDZILA's components are both strong and accurately shaped to meet the demands of competitive battle robot performance.

CNC MILLING

i used the protrak milling machine to mill a block as the showcase base i used a 100 *50 *15mm ms flat

this the part that i milled out

you can reffer my moulding a casting week to know more on milling parts on protrak

CNC LATHE

i used the cnc lathe to make the all impotent bearing shaft for the robot , this part is the one that the weapon will spin on an di has to be presice that was the reson that i used the cnc lathe that was available on the lab

Electronics

SHREDZILA's electronics are designed to ensure robust control and precise operation. The system is built around an ESP32 microcontroller, which is programmed via an FTDI breakout using the RX and TX pins. The ESP32 is chosen for its versatility and built-in Wi-Fi and Bluetooth capabilities, which facilitate wireless communication.

To control the robot's movement and weapon, three PWM pins from the ESP32 are utilized:

• Two PWM pins control the mobility motors.
• One PWM pin is dedicated to the weapon motor.

The printed circuit board (PCB) for SHREDZILA's electronics was designed using EasyEDA, an online EDA tool that simplifies the creation and management of complex electronic circuits. The PCB design was then milled using a Roland milling machine, which was operated through Fab Modules software. This process ensures precision and reliability in the PCB's construction.

Once the PCB was milled, the electronic components were meticulously assembled onto the board. The assembly process included soldering various SMD components, ensuring solid connections and optimal performance. This thorough approach to the electronics setup is critical for SHREDZILA's operational effectiveness and durability in the demanding environment of robot combat.

SHREDZILA Electronics Bill of Materials (BOM)

Component Breakdown

• ESP32 Microcontroller: Central processing unit, handling all control signals and communication.
• FTDI Breakout: Facilitates programming of the ESP32 via serial communication (RX and TX).
• PWM Pins: Three pins on the ESP32 used to control the motors.
• PS2 Controller: Provides user input for controlling the robot.
• PCB Design: Created in EasyEDA and milled using a Roland milling machine.

By carefully designing and assembling the electronics, SHREDZILA achieves precise control and reliable performance, showcasing the capabilities of modern fabrication and electronic design techniques.

BLDC PLANETARY GEAR MOTOR BUILD

In my quest to incorporate a brushless drive into my project, I encountered a challenge: the lack of affordable planetary gear motors. To overcome this, I decided to create a custom solution using a 2212 BLDC motor. Here is the detailed process I followed:

Firstly, I extended the shaft of the 2212 BLDC motor to the opposite side, ensuring it could accommodate the planetary gear mechanism. I carefully removed the gear from a DC motor, which I planned to use with the BLDC motor. To ensure a secure fit, I used a file to create a flat portion on the BLDC motor's shaft. This flat surface was crucial for preventing any slippage once the gear was pressed onto the shaft.

Next, I pressed the gear onto the modified shaft of the BLDC motor, ensuring it was firmly attached. To complete the assembly, I designed and 3D printed an interconnecting part. This part served as a crucial link, connecting the planetary gear assembly to the BLDC motor securely and precisely.

This custom-built planetary gear drive provided the necessary performance required for my project, while also keeping the costs within a manageable range. By using readily available components and a bit of ingenuity, I was able to create a robust and efficient drive system tailored to my specific needs.

System Integration at Assembly

System integration at the assembly stage involves combining various components and subsystems into a cohesive unit. This process ensures that all parts work together harmoniously to achieve the desired functionality and performance of the final product. Key aspects of system integration at the assembly stage include:

• Assemble hardware components such as the shell, structural arms, and weapon assembly.
• Ensure all mechanical parts fit together precisely and securely.

• Integrate the printed circuit boards (PCBs) that house the electronic components.
• There is a dedicated module for PCBs, ensuring proper installation and connection of all electronic systems.

• Connect wiring between different components, ensuring proper routing and secure connections.
• Implement communication protocols for data exchange between components.

• Install and configure software necessary for system operation, including firmware on microcontrollers and control software on the main processing unit.

CODE

This code is designed to control a robot using an ESP32 microcontroller and a PlayStation 3 (PS3) controller. The robot has three motors, each controlled by an Electronic Speed Controller (ESC). Below is a detailed explanation of the code:

#include <ESP32Servo.h>
#include <Ps3Controller.h>

#define ESC1_PIN 26
#define ESC2_PIN 27
#define ESC3_PIN 14  // Define pin for the third motor

Servo esc1;
Servo esc2;
Servo esc3;  // Define the third motor

void notify()
{
    int lx = Ps3.data.analog.stick.lx;
    int ly = Ps3.data.analog.stick.ly;

    // Forward speed based on vertical joystick movement
    int speed = map(ly, 0, 255, 1000, 2000);

    // Adjust ESC speeds for turning
    int esc1Speed = speed;
    int esc2Speed = speed;

    if (lx < 255) {  // Move left
        esc1Speed = map(lx, 0, 128, 1000, speed);
        esc2Speed = speed;
    } else if (lx > 255) {  // Move right
        esc1Speed = speed;
        esc2Speed = map(lx, 0, 255, speed, 1000);
    }

    // Set the ESC speeds
    esc1.writeMicroseconds(esc1Speed);
    esc2.writeMicroseconds(esc2Speed);

    // Control the third motor with the triangle button
    if (Ps3.data.button.triangle) {
        esc3.writeMicroseconds(2000);  // Full speed forward
    } else {
        esc3.writeMicroseconds(1000);  // Stop the motor
    }

    Serial.print("Left stick: x="); Serial.print(lx); Serial.print(" y="); Serial.println(ly);
    Serial.print("ESC1 speed: "); Serial.println(esc1Speed);
    Serial.print("ESC2 speed: "); Serial.println(esc2Speed);
    Serial.print("ESC3 speed: "); Serial.println(Ps3.data.button.triangle ? 2000 : 1000);
}

void onConnect(){
    Serial.println("Connected.");
}

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

    // Initialize ESCs
    esc1.attach(ESC1_PIN);
    esc2.attach(ESC2_PIN);
    esc3.attach(ESC3_PIN);  // Initialize the third motor

    // Set all ESCs to neutral (1000 microseconds)
    esc1.writeMicroseconds(1000);
    esc2.writeMicroseconds(10000);
    esc3.writeMicroseconds(1000);

    Ps3.attach(notify);
    Ps3.attachOnConnect(onConnect);
    Ps3.begin("");

    Serial.println("Ready.");
}

void loop() {
    if (!Ps3.isConnected())
        return;
}

Code Explanation

This code is designed to control a robot using an ESP32 microcontroller and a PlayStation 3 (PS3) controller. The robot has three motors, each controlled by an Electronic Speed Controller (ESC). Below is a detailed explanation of the code:

#include <ESP32Servo.h>
#include <Ps3Controller.h>

Next, the pins for the ESCs are defined:

#define ESC1_PIN 26
#define ESC2_PIN 27
#define ESC3_PIN 14  // Define pin for the third motor

Servo Initialization

Three servo objects are created to control the ESCs:

Servo esc1;
Servo esc2;
Servo esc3;  // Define the third motor

PS3 Controller Notification

The notify() function is used to handle the inputs from the PS3 controller. It reads the analog stick positions and adjusts the speeds of the motors accordingly:

void notify() {
    int lx = Ps3.data.analog.stick.lx;
    int ly = Ps3.data.analog.stick.ly;

    // Forward speed based on vertical joystick movement
    int speed = map(ly, 0, 255, 1000, 2000);

    // Adjust ESC speeds for turning
    int esc1Speed = speed;
    int esc2Speed = speed;

    if (lx < 255) {  // Move left
        esc1Speed = map(lx, 0, 128, 1000, speed);
        esc2Speed = speed;
    } else if (lx > 255) {  // Move right
        esc1Speed = speed;
        esc2Speed = map(lx, 0, 255, speed, 1000);
    }

    // Set the ESC speeds
    esc1.writeMicroseconds(esc1Speed);
    esc2.writeMicroseconds(esc2Speed);

    // Control the third motor with the triangle button
    if (Ps3.data.button.triangle) {
        esc3.writeMicroseconds(2000);  // Full speed forward
    } else {
        esc3.writeMicroseconds(1000);  // Stop the motor
    }

    Serial.print("Left stick: x="); Serial.print(lx); Serial.print(" y="); Serial.println(ly);
    Serial.print("ESC1 speed: "); Serial.println(esc1Speed);
    Serial.print("ESC2 speed: "); Serial.println(esc2Speed);
    Serial.print("ESC3 speed: "); Serial.println(Ps3.data.button.triangle ? 2000 : 1000);
}

PS3 Controller Connection

The onConnect() function is called when the PS3 controller successfully connects:

void onConnect(){
    Serial.println("Connected.");
}

Setup Function

The setup() function initializes the serial communication, attaches the ESCs to their respective pins, and sets them to a neutral state. It also sets up the PS3 controller:

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

    // Initialize ESCs
    esc1.attach(ESC1_PIN);
    esc2.attach(ESC2_PIN);
    esc3.attach(ESC3_PIN);  // Initialize the third motor

    // Set all ESCs to neutral (1000 microseconds)
    esc1.writeMicroseconds(1000);
    esc2.writeMicroseconds(1000);
    esc3.writeMicroseconds(1000);

    Ps3.attach(notify);
    Ps3.attachOnConnect(onConnect);
    Ps3.begin("");

    Serial.println("Ready.");
}

Loop Function

The loop() function continuously checks if the PS3 controller is connected. If it's not connected, it does nothing:

void loop() {
    if (!Ps3.isConnected())
        return;
}

TEST

Component Testing

Before full assembly, individual components are tested to verify their functionality:

• Motors and ESCs: Each motor and electronic speed controller (ESC) is tested for proper operation. This includes checking motor rotation, speed control, and response to PWM signals.
• PCB: The printed circuit board (PCB) is inspected for correct assembly and soldering. Continuity tests ensure that all connections are secure.
• Microcontroller: The ESP32 microcontroller is programmed with test code to check its ability to control the motors and receive inputs from the PS3 controller.

Integration Testing

Once individual components are verified, they are integrated into the robot for system-wide testing:

• Assembly Checks: Ensure that all mechanical parts fit together properly and that the electronics are securely mounted.
• Wiring Verification: Inspect all wiring for correct connections, secure fittings, and proper insulation.
• Initial Power-On: Power on the robot to check for any immediate issues, such as electrical shorts or component failures.

Functional Testing

With the robot fully assembled, functional tests are conducted to validate its performance:

• Mobility Tests: Verify that the robot can move forward, backward, and turn as expected. This involves using the PS3 controller to drive the motors via the ESP32.
• Weapon System Tests: Check the operation of the weapon assembly, ensuring it activates and functions correctly when commanded.
• Controller Response: Ensure that the PS3 controller inputs are accurately translated into motor actions, with no noticeable lag or misinterpretation of commands.

ASSEMBLY

Assembling the robot involves several steps, from preparing the mechanical components to integrating the electronics and ensuring everything works together smoothly. Below is a detailed description of the assembly process:

Mechanical Assembly

The first step is to assemble the mechanical components:

• Shell: The shell is 3D printed using TPU material for flexibility and durability. It provides the outer armor and protection for internal components.
• Aluminum Arms: These are machined using CNC milling for precision and strength. They are attached to the shell to form the robot's structural support.
• Weapon Assembly: The weapon, made from HCHCR steel, is cut using water jet cutting to achieve sharp and intricate shapes. It is then mounted onto the robot.

PCB Integration

The robot uses custom-designed PCBs to control its electronic components:

• Design: The PCB is designed using EasyEDA, a popular electronic design automation tool.
• Manufacturing: The PCB is milled using a Roland milling machine, guided by Fab Modules to ensure precision.
• Assembly: Electronic components are soldered onto the PCB, which is then securely mounted inside the robot's shell.

Wiring and Connectivity

Connecting the various electronic components is crucial for proper functionality:

• Wires are routed through the robot to connect the ESCs, motors, and other electronic components.
• Special attention is given to secure connections and proper insulation to prevent short circuits.
• Communication protocols are implemented to facilitate data exchange between the ESP32 microcontroller and other components.

Software Installation

The software setup involves programming the microcontroller and configuring the control systems:

• Microcontroller: An ESP32 microcontroller is programmed using the Arduino IDE. It controls the robot's movements and responds to commands from the PS3 controller.
• Communication: The PS3 controller is connected to the ESP32 via Bluetooth. The controller's inputs are used to drive the motors and control the weapon.
• Calibration: The ESCs are calibrated to ensure smooth operation and accurate response to commands.

Final Assembly and Testing

The final steps involve assembling all components into the robot and performing rigorous testing:

• All components are assembled into the shell, with care taken to ensure everything fits securely and is properly aligned.
• Initial tests are performed to check the functionality of each component, including the motors, ESCs, and weapon system.
• Software tests are conducted to verify that the PS3 controller inputs correctly translate into the desired movements and actions of the robot.
• Final adjustments are made based on testing results to ensure optimal performance and reliability.

The successful integration of mechanical, electronic, and software components ensures that the robot operates effectively in various combat situations, showcasing the capabilities of modern fabrication techniques and electronic control systems.

FINAL PRESENTATION

at last the project is finish this is my final project image and personation

FINAL VIDEO

DESIGNFILES