Touch to Motion: Conductivity-Powered Robotic Arm

Can a simple touch trigger motion? This project explores how electrical conductivity can activate mechanical movement using Arduino.

Here, I use two copper tubes as conductive materials, but you can experiment with anything that conducts electricity: silver, gold, conductive fabric, or even paint. The collision between these materials sends a signal that activates servo motors, bringing a 3-DoF robotic arm to life.

In other words: what if a collision could trigger an action?

1. Arduino Uno (or compatible clone)
2. Breadboard
3. MB102 Breadboard Power Supply Module (3.3V / 5V)
4. 3x MS24 20kg High-Torque Servo Motors
5. Jumper Wires
6. 2x 1/16" Diameter Copper Tubes (or any other conductive material such as wire, foil, or conductive fabric/paint)
7. Tape or Heat-Shrink Tubing (depending on whether you have access to a soldering iron)
8. Wooden Platform (for mounting and stability)

Note:

I’m using 20kg high-torque servo motors because I plan to switch to heavier conductive materials later on. However, this setup and wiring will work with most standard servos, as long as their power requirements match your supply.

shopping links:

1. MS24 20kg Servo Motors on Amazon
2. Arduino Starter Kit

Since I don’t have much experience with 3D modeling, I adapted an existing design instead of creating one from scratch. The original model can be found here:

🔗 Thingiverse 5DoF Robotic Arm

I simplified the design from a 5 DoF arm to a 3 DoF version to make it easier to build and control.

Below are the specific parts I printed:

1. 1x bGTS.stl
2. 1x bSTS.stl
3. 2x mSTS.stl

Notes:

1. The original model is designed for high-torque servos, such as the popular MG995.
2. For assembly, use 3 mm nuts and bolts (or the screws that come with your servos).
3. Depending on your printer’s precision, you may need to gently drill or sand some holes to ensure a proper fit.

In this project, two copper tubes act as the main conductive elements. When they touch, they close an otherwise open electrical circuit, similar to flipping a switch. This moment of contact allows current to flow from one piece of copper to the other, which the Arduino reads as a digital signal (HIGH or LOW).

That signal then triggers an action, in this case, movement in the servo motors attached to the robotic arm. Essentially, the copper materials become a sensor, translating a physical event (collision or touch) into an electrical command.

In simpler words, you can think of it like this:

1. When the copper tubes are not touching, the circuit is open, meaning electricity can’t flow.
2. When they collide or make contact, the circuit closes, allowing current to flow and activating the programmed response.

To connect your conductive materials to the Arduino, you’ll need to wire them up! During the prototype stage, you can simply tape the metal tip of a jumper wire directly to the copper surface, it’s quick and works well for testing. However, for a more stable and long-term setup, it’s best to solder the wire onto the copper and secure the joint with heat-shrink tubing.

WIRE IT UP!

In this setup, one piece of copper is connected to an input pin, and the other is connected to ground (GND). Essentially, you’re turning a physical interaction into an electrical input, your own custom switch made out of metal.

For this project, I’m using the 5V external power supply that came with my Arduino starter kit. It’s strong enough to handle the pre-programmed motions of the servos. However, if you plan to:

1. add more than 3 degrees of freedom, or
2. use high-torque servos in a continuous motion setup (for example, controlled by a joystick),

then it’s best to upgrade to a larger power supply. Most high-torque servos perform better and more reliably when powered closer to their rated voltage range.

Once your circuit works consistently on the breadboard, you can move to a solderable board to make your wiring more permanent and stable.

For the code, I decided to keep it simple: the robotic arm stays still until the conductive materials touch, which then triggers the movement sequence.

You can copy and paste the code below into the Arduino IDE and upload it to your board. Make sure your servos are connected to pins 3, 5, and 11, and your conductivity sensor wire is on pin 2.

#include <Servo.h>

Servo servo1;

Servo servo2;

Servo servo3;

const int sensorPin = 2;

bool extended = false;

int lastReading = HIGH;

unsigned long lastDebounceTime = 0;

const unsigned long debounceDelay = 100; // more stable

unsigned long lastMoveTime = 0;

const unsigned long moveCooldown = 1000; // 1s between moves

void setup() {

servo1.attach(3);

servo2.attach(5);

servo3.attach(11);

pinMode(sensorPin, INPUT_PULLUP);

Serial.begin(9600);

restArm();

Serial.println("System ready. Waiting for contact...");

}

void loop() {

int reading = digitalRead(sensorPin);

if (reading != lastReading) {

lastDebounceTime = millis();

}

if ((millis() - lastDebounceTime) > debounceDelay &&

(millis() - lastMoveTime) > moveCooldown) {

if (reading == LOW && !extended) {

Serial.println(" Rods touching — straighten arm!");

straightenArm();

extended = true;

lastMoveTime = millis();

}

else if (reading == HIGH && extended) {

Serial.println("Rod contact lost — return to rest.");

restArm();

extended = false;

lastMoveTime = millis();

}

}

lastReading = reading;

}

// ---- Movement functions ----

void straightenArm() {

// First, raise/lift the arm

smoothMove(servo2, servo2.read(), 60, 5);

smoothMove(servo3, servo3.read(), 120, 5);

// Then, make the base sweep left-to-right

int leftPos = 70;

int rightPos = 110;

for (int i = 0; i < 2; i++) { // sweep twice

smoothMove(servo1, servo1.read(), leftPos, 8);

delay(250);

smoothMove(servo1, servo1.read(), rightPos, 8);

delay(250);

}

// Return base to center

smoothMove(servo1, servo1.read(), 90, 8);

}

void restArm() {

smoothMove(servo1, servo1.read(), 90, 5);

smoothMove(servo2, servo2.read(), 90, 5);

smoothMove(servo3, servo3.read(), 180, 5);

}

// ---- Smooth transition helper ----

void smoothMove(Servo &servo, int startPos, int endPos, int stepDelay) {

int step = (startPos < endPos) ? 1 : -1;

for (int pos = startPos; pos != endPos; pos += step) {

servo.write(pos);

delay(stepDelay);

}

servo.write(endPos);

}

It’s ALIVE!!

I mounted the base of the arm onto a wooden structure for stability and testing. Here, I’m exploring how the arm’s movement depends on composition and placement, how the conductive materials interact, and how their contact (or lack of it) controls the motion.

Thanks for following along!