Pipeline systems deteriorate progressively over time through various means. Pipeline inspection robot are designed to remove the human factor from labour intensive or dangerous work environments and also to act in inaccessible environment. However, if you take a look at the prices of those robots you will find that they are way too expensive.

This project aims to create another kind of pipeline inspection robot. Because we think that It is beneficial to have a robot with an adaptable structure to the pipe diameter, and cheaper at the same time.

Our challenge is to make this robot adaptable to diameters varying from 260mm to 390mm based on two sliding mechanisms.

Bruface MechatronicsProject VUB/ULB/ERASMUS

Team Members:

Dushimyimana Christophe

Houban Houda

Khoulali Soumia

Martin Simon

Zhao Ziao

Step 1: Design

We started out by creating a basic design in CATIA V5. The robot consists of two separated sliding mechanisms fitted onto a PVC central tube. Each sliding mechanism has three legs fixed to a cylindrical collar and linked to the sliding cylinder by a small link.

To slide, a spring makes the extension and the compression movement possible. So if the legs are compressed, the robot's diameter decreases. Once this compression force is released, the robot extends automatically. In between the two mechanisms, there is a holder of the electronic components which is in the shape of a long collar.

In our design (shown in the images above), two front legs are controlled by two highly geared dc motors. the rear legs are without motors because the front ones are powerful enough to drive the whole mechanism.

Step 2: Tools and Materials

Microcontroller

1xArduino Uno (any will work)

Motor Controller

1x H-Bridge (L298N)
22AWG Solid core wire
220V SMD Rework Soldering Station

Power

4x 9V Battery ( 1 to power the Arduino and 2 for the motors)

Other Electronics

2x 12VDC motors
DPDT Toggle switch (Power switch)
SPDT Slide switch (User input)
Heat Shrink Tubing

Hardware

6x laser cutted links (the motor links are slightly different from the other links)
6x PLA small links (printed)
2x Collars (printed)
2x Translational elements(printed)
1x Electronic parts holder (printed)
2x Strong rectangular springs (printed)
2x Motor-wheel pin (printed)
4x Link-wheel pin (printed)
2x bushing for motors (printed)
4x 7mm bearings
18x 3mm bolts
7x 2.5mm bolts
7x Zip ties
6x robot tire plastic wheels
1x end blocker
14x 2.5mm pgp-fasteners
36x 3mm nuts
14x 2.5mm nuts
50x 3mm shims
1x 40mm PVC tube

Tools

Electric Drill / Drill press (As well as a lot of bits)
Laser cutter
3D printer
Hacksaw
Soldering Iron
Pliers
Allen wrench
Assorted screwdrivers
Wire Strippers
C Clamp
Ruler
Multimeter

Step 3: Motor Controller

The motor controller that we built for this robot is based on an H-Bridge chip (L298N). With this chip, each motor requires two inputs to work (if one of the two pins of the H-bridge is HIGH and the other is LOW, then the motor will turn, but if it's inversed, the motor will turn in the opposite direction ! ).

Now you need to control the exact velocity of these motors. You can do this by putting a lower voltage on the "HIGH" pin of the Arduino knowing that any voltage higher than 5V will give the same motor velocity.

After fixing all the electronic components in the holder, we solder them in place and make connections using 22AWG solid core wires.

Step 4: Power

To power the Arduino, a 9V stack is used. It has a common ground with the three in series 9V stacks.

To power the H-bridge and the motors, 3x 9V stacks are used in series which provide a source of 27V.

Step 5: Legs

The legs are some of the most important parts of this robot because their design determines whether or not they can support the weight of the motor and the pressure due to the pipe. We decided to have 2 legs out of 6 controlled by one motor each, and the other 4 legs use roller bearings to have low friction.

To make the legs we laser cut a 6 mm width wood plate. As you can notice from the above images, there are two different cuts for the legs, this is due to the fact that one cut is for the motor-driven legs and the other is for the normal legs.

Step 6: Building Frame

With the legs finished, the next step is to build a frame to hold the motors and legs in place. We start the frame by making a suitable pin/bushing(in white) to hold the motor, the leg and the wheel together.

In order to fix the motor to the leg, we use 2 screws that enter from the whole of the leg through the holes of the motor, also we use a zip tie to fix it even more.

In addition to that, we use a pin to connect the motor shaft to the wheel. To reduce the friction between the wood and plastic, we fix a bushing in the leg central hole. After that, we make a pin (in black) for linking the normal leg to the wheel.

In order to ensure free rotation of the wheel, we put a roller bearing inside the leg so that the pin can rotate freely with the wheel. Then we bolt the legs through the collar with washers and locknut to hold them in place and let them spin freely on the bolt. we do the same thing for the fixation of the small link (in white connected to the legs) with the translational element and the leg. Finally, we bolt the collars to make sure that they are fixed to the central tube.

Step 7: Electronic Platform

We have designed the holder in order to fix all the electronic components easier. there is a place for Arduino ship and also in the opposite sides a place for H-briges, baterries and switches.

Finally, we screwed the Arduino and motor controller into the holder and we use the zip ties to fix the switches and the batteries.

Step 8: Wiring the Robot

The next step is to wire all the electrical components of the robot together. We start out by soldering long wires to the contacts on the motors. Next, wire together the pots on the legs. This is done by using segments of ribbon cable from an old IDE cable. The pots are wired so that they all have a common ground and input voltage. The input voltage is connected to the +9V pin on the Arduino, and the two signal wires are soldered to headers and then connected to analog inputs A0 - A1 on the Arduino.

Next, we wire the digital output pins on the Arduino to the inputs on the motor controller.

Finally, we drill a hole in the central tube so that we can enter the cables into the tube until the open end of the tube, where we fixed the front legs. This is done to connect the motors easier. Then we connect each motor voltage terminal to the 9V battery pack, via a toggle switch.

Step 9: Programming

<p>//This program is a simple program who will use motor drives (L298N) only to make the motor going straight forward than wait and then backward.<br>//Note that no regu-lation is used and the motor will just go at full speed (in the case of the pipe ro- bot, due to the degrees of freedom of the project this kind of method can be applied.
 
int mot1plus = 2; //initialisation of the motor pin
int mot1moins= 3;
int mot2plus = 4;
int mot2moins= 5;
int mot3plus = 6;
int mot3moins= 7;
float t_init , t_now , t; //initialisation of the time variables
float t_forward =8;
float t_back = 10;
float t_waiting = 1;
 
int motorSpeed=0;
 
void setup() 
{
  Serial.begin(9600);//give the values of the variables if mantioned inn the code (can be delete)
 pinMode(mot1plus,OUTPUT);//initialisation of the pins as output
 pinMode(mot1moins,OUTPUT);
 pinMode(mot2plus,OUTPUT);
 pinMode(mot2moins,OUTPUT);
 pinMode(mot3plus,OUTPUT);
 pinMode(mot3moins,OUTPUT);
  t_init=millis(); //initialisation of the time as variable and start to count 
  t_forward *=1000;//transformation of the time in seconds
  t_back*=1000;
  t_waiting *=1000;
  
}
 
</p><p>void loop()<br>{t_now=millis();
t=t_now-t_init;// use to calcul the time in the loop
 
if (t<=t_forward){ //first loop the robot goes forward
  digitalWrite(mot1moins,LOW);
 digitalWrite(mot1plus,HIGH);
 digitalWrite(mot2moins,LOW);
 digitalWrite(mot2plus,HIGH);
  digitalWrite(mot3moins,LOW);
 digitalWrite(mot3plus,HIGH);
  }</p><p>if (t>t_forward) { if (t<=t_forward+t_wait){
 digitalWrite(mot1moins,LOW);
 digitalWrite(mot1plus,LOW);
 digitalWrite(mot2moins,LOW);
 digitalWrite(mot2plus,LOW);
 digitalWrite(mot3moins,LOW);
 digitalWrite(mot3plus,LOW);}
  }</p><p>if (t_forward+t_waiting<=t){//third loop the robot come back<br>  digitalWrite(mot1moins,HIGH);
 digitalWrite(mot1plus,LOW);
 digitalWrite(mot2moins,HIGH);
 digitalWrite(mot2plus,LOW);
  digitalWrite(mot3moins,HIGH);
 digitalWrite(mot3plus,LOW);
  }  
 while(t>=t_forward+t_waiting+t_back){ // the code is block in this loop and the robot stop
  digitalWrite(mot1moins,LOW);
 digitalWrite(mot1plus,LOW);
 digitalWrite(mot2moins,LOW);
 digitalWrite(mot2plus,LOW);
 digitalWrite(mot3moins,LOW);
 digitalWrite(mot3plus,LOW);
  }
 
}</p><p><br></p><p><br></p><p><br></p><p><br></p><p><br></p><p><br></p>

Step 10: Tests and Results

Finally, it's time to test it.

We tested our robot in different diameters. The first test was in a pipe with a diameter less than 260mm but it was too compressed to be able to move forward, it moved hardly inside this pipe.

However, it performed quite good for other diameters (300mm,320mm). Also, it proved capable of working in larger diameters but as a car (without compression).

This robot is designed to work in horizontal cylindrical pipes or slightly tilted ones. Nevertheless, further improvements are possible for lager inclination angles or for uneven surfaces.

If you like this project don't forget to vote for us in the ''FIRST TIME AUTHOR" contest :)

Introduction: Pipeline Inspection Robot