Joystick controlled Robotic Arm with Arduino: Wiring Diagram, Code, Interactive 3D Web Simulation

byee-diary • • 2 min read
0

In the world of robotics, combining hardware with software has never been more exciting or accessible. One particularly engaging project is building and controlling a 3-DOF (Degree of Freedom) robotic arm using Arduino Nano and servo motors. This guide will walk you through the process of building a robotic arm with servo motors for precise control, while simultaneously integrating it with Three.js, a powerful JavaScript library for 3D rendering, to simulate its movements in real-time on a web interface.

This project offers a hands-on learning experience in robotics, servo motor control, and real-time 3D visualization, making it an excellent opportunity for students, hobbyists, and professionals alike.

Why Build a Robotic Arm with Arduino Nano, Servo Motors, and Three.js?

This project is perfect for:

  • Students and Educators: Learn the principles of robotics, servo motor control, and 3D visualization in a fun, interactive way. Through this project, you’ll understand how servo motors control the arm's movements and how to display these movements in a 3D environment using Three.js.

  • Hobbyists and Makers: Build an affordable, customizable robotic arm at home. With Arduino Nano and servo motors, you can create a functional arm, and with Three.js, you can simulate its movements in 3D on the web. This project is both beginner-friendly and highly scalable for more advanced users.

  • Engineers and Researchers: Prototype and test robotic systems efficiently and affordably. The integration of servo motors with Arduino Nano allows for precise movement control, and Three.js offers real-time 3D visualization to test and improve robotic movements in a virtual space before applying them to physical models.

  • Web Developers: Explore the exciting combination of IoT and real-time 3D rendering. By using Arduino Nano to control the robotic arm and Three.js to simulate its movements, you’ll deepen your understanding of both hardware interfacing and 3D visualization for web applications.

Combining Arduino Nano for hardware control and servo motors for precise arm movement, alongside Three.js for 3D simulation, this project is an ideal introduction to robotics, programming, and real-time web development. If you're looking for a reliable way to control your servos and optimize their performance, check out our Servo Angle and Pulse Width Calculator.

Understanding the 3-DOF Robotic Arm with Servo Motors

A 3-DOF robotic arm has three key axes of movement:

  • Base: A servo motor at the base rotates the arm horizontally, allowing it to move left and right.
  • Shoulder: A servo motor controls the shoulder joint, moving the arm vertically to lift or lower it.
  • Elbow: The third servo motor controls the elbow, enabling the arm to extend and retract.

In this setup, the robotic arm’s movements are controlled by:

  • Potentiometer: Used to control the base rotation. The potentiometer provides analog input to adjust the servo motor’s position for smooth rotation.
  • Joystick: The joystick controls both the shoulder and elbow angles, allowing precise adjustments to the arm's posture.
  • Servo Motors: Three servo motors are used to move the base, shoulder, and elbow joints of the arm. These motors are controlled via Arduino Nano using PWM signals for precise positioning.

To build this robotic arm, you’ll need the following components:

  • 3 Servo Motors: These motors will control the base, shoulder, and elbow movements of the arm. Typically, SG90 or MG90S micro servos are used in such projects, providing enough torque and precision for small-scale robotic arms.
  • Arduino Nano: The brain of the system, controlling the servo motors based on the input from the potentiometer and joystick. It handles all the logic for movement control.
  • Joystick and Potentiometer: Used to provide user input for controlling the arm's position.

This project uses affordable components such as the Arduino Nano and servo motors, making it accessible for both beginners and experts. If you're looking to learn more about how to control servo motors efficiently with an Arduino, our guide on servo motor control using a motor shield will give you useful insights.

Wiring Diagram for Robotic Arm Control

Here’s how to connect the components to the Arduino:

Joystick controlled Robotic Arm with Arduino

Code Overview

This code controls a 3-DOF robotic arm using three servo motors (base, shoulder, and elbow) via an Arduino. The arm's movements are controlled using a potentiometer for base control and joystick axes for the shoulder and elbow. Additionally, the angles of the servos are sent via serial communication to update the 3D simulation of the robotic arm in a web interface (using Three.js).

Code Breakdown

  1. Library and Pin Definitions:

    • #include <Servo.h>: This imports the Servo library to control the servo motors.
    • Pin Definitions: The pins connected to the potentiometer, joystick, and servo motors are defined. For example, POT_PIN (A0) is for base control, and JOYSTICK_X (A1) and JOYSTICK_Y (A2) are for controlling the shoulder and elbow respectively.

  2. Servo Objects:

    • Three servo objects are created (baseServo, shoulderServo, and elbowServo) to control the corresponding parts of the robotic arm.

  3. Variables:

    • baseAngle, shoulderAngle, elbowAngle: These variables store the current angles of the three joints of the arm (base, shoulder, elbow).
    • Debounce Variables: Used for the joystick button to avoid multiple presses when resetting the arm's position.

  4. Setup Function:

    • Serial.begin(115200): Initializes the serial communication with the computer at a baud rate of 115200.
    • PinMode Setup: Configures the pins for input and joystick button with an internal pull-up resistor.
    • servo.attach(): The three servos are connected to pins 9, 10, and 11.

  5. Main Loop:

    • Reset Button: Checks if the joystick button is pressed to reset the arm's position. When pressed, it resets the angles of all joints to the initial values.
    • Reading Inputs:
      • Potentiometer: Reads the analog value from the potentiometer (connected to POT_PIN) to control the base servo angle.
      • Joystick: Reads the X and Y axes of the joystick and maps them to control the shoulder and elbow angles.
    • Servo Control: Uses the servo.write() function to move the servos to the desired angles for each joint (base, shoulder, elbow).
    • Serial Communication: Sends the current angles of the three joints (base, shoulder, and elbow) to the web interface via serial communication every 50 milliseconds (SEND_INTERVAL).

Arduino Code for Robotic Arm Control

The Arduino code reads inputs from the potentiometer and joystick, calculates the joint angles, and sends them to the serial port. Here’s the optimized code:

#define POT_PIN A0      // Base control potentiometer
#define JOYSTICK_X A1   // Joystick X-axis for shoulder
#define JOYSTICK_Y A2   // Joystick Y-axis for elbow
#define JOYSTICK_BTN 2  // Joystick push button pin

// Variables to store angles
int baseAngle = 120;     // Initial position 120 degrees
int shoulderAngle = 50;  // Initial position 50 degrees
int elbowAngle = 85;     // Initial position 85 degrees

// Button debounce variables
unsigned long lastButtonPress = 0;
const int debounceDelay = 50;

// Timing variables
unsigned long lastSend = 0;
const unsigned long SEND_INTERVAL = 50; // Send every 50ms

void setup() {
    Serial.begin(115200);  // Start USB Serial communication
    
    // Initialize pins
    pinMode(POT_PIN, INPUT);
    pinMode(JOYSTICK_X, INPUT);
    pinMode(JOYSTICK_Y, INPUT);
    pinMode(JOYSTICK_BTN, INPUT_PULLUP);  // Button uses internal pullup
}

void loop() {
    // Check reset button (active LOW because of INPUT_PULLUP)
    if (digitalRead(JOYSTICK_BTN) == LOW) {
        if ((millis() - lastButtonPress) > debounceDelay) {
            // Reset to initial positions
            baseAngle = 120;
            shoulderAngle = 50;
            elbowAngle = 85;
            lastButtonPress = millis();
        }
    }
    
    // Read potentiometer for base control (0-1023 to -180 to 180 degrees)
    int newBase = map(analogRead(POT_PIN), 0, 1023, -180, 180);
    baseAngle = newBase;  // Base movement can be direct
    
    // Read joystick values
    int joyX = map(analogRead(JOYSTICK_X), 0, 1023, -45, 135);
    shoulderAngle = constrain(joyX, -45, 135);  // Constrain shoulder angle within valid range
    
    int joyY = map(analogRead(JOYSTICK_Y), 0, 1023, 0, 135);
    elbowAngle = constrain(joyY, 0, 135);  // Constrain elbow angle within valid range
    
    // Send data at fixed interval
    if (millis() - lastSend >= SEND_INTERVAL) {
        Serial.print("DATA:");  // Prefix required by HTML code
        Serial.print(baseAngle);
        Serial.print(",");
        Serial.print(shoulderAngle);
        Serial.print(",");
        Serial.println(elbowAngle);
        lastSend = millis();
    }
}

Key Features of the Code:

  1. Pin Setup : The potentiometer is connected to POT_PIN (A0), and the joystick is connected to JOYSTICK_X (A1) for the shoulder and JOYSTICK_Y (A2) for the elbow.
  2. Button Reset : The reset button, connected to JOYSTICK_BTN (pin 2), allows the robotic arm to return to its default position.
  3. Constraining Angles : Ensures that the shoulder and elbow angles stay within their valid ranges (-45° to +135° for the shoulder and 0° to +135° for the elbow).
  4. Data Sending : Sends the base, shoulder, and elbow angles via serial communication every 50ms.

Integrating Arduino with Three.js for 3D Simulation

To visualize the robotic arm’s movements in real-time, we can use Three.js, a JavaScript library for 3D rendering. Here’s how:

  1. Receive Serial Data:

    • Use WebSerial API or WebSockets to communicate between the Arduino and a web-based interface.

    • Parse the incoming data (e.g., DATA:<baseAngle>,<shoulderAngle>,<elbowAngle>) in JavaScript.

  2. Update the 3D Model:

    • Use the received angles to rotate the joints of the 3D arm model in Three.js.

    • For example, update the rotation of the base, shoulder, and elbow meshes based on the parsed angles.

  3. Real-Time Feedback:

    • As the user moves the joystick and potentiometer, the arm's movement is reflected in the 3D simulation, providing real-time visual feedback.

Conclusion

Controlling a robotic arm with an Arduino and joystick is a fun and educational project that combines hardware and software skills. By integrating Three.js, you can take this project to the next level by visualizing the arm’s movements in 3D space. This setup not only teaches the fundamentals of robotics and control systems but also demonstrates how to use web technologies for real-time visualization.

With the power of Arduino, Three.js, and a few basic components, you can create your own 3-DOF robotic arm and simulate its movements in a web browser. Whether you're a beginner or an experienced maker, this project is sure to inspire creativity and innovation.

Further Reading and Resources

Start building your robotic arm today and bring your ideas to life!

4.94 / 169 rates

Post a Comment

Previous Post Next Post