A PROJECT REPORT
ON
THRUSTER MODELLING
Internship Project Report
By
Rohan Gaonkar
Department of Electronics and Communication
NIT-Goa
Farmagudi, Ponda, Goa - 403401
2018-2019
UNDER THE GUIDANCE OF
Prof. Pramod Maurya
Abstract:
This report talks about thruster modelling for Autonomous Underwater Vehicle.
In this report I determined the thrust as a function of voltage and also as a function
pulse width of a PWM. Thus it will enable to control the thrust of AUV using
these relation. Based on the current draw for a desired thrust battery life of a
vehicle can be calculated.
Introduction
A Thruster is an electromechanical device equipped with a motor and propeller
that generates Thrust to push an Underwater Vehicle. Thruster control and
modelling are important parts of underwater vehicle control and .This is because
it is the lowest control loop of the system; hence, the system would benefit from
accurate and practical modelling of The Thrusters.
This report describes two Thrusters namely BTD150 Thruster from sabotix and
T200 Thruster from blue robotics. In This project I focussed mainly on Thrust vs
Voltage and Thrust vs Current plots. These plots are very important in order To
determine the current draw from the battery for the desired thrust. Since these
Thrusters drive Autonomous Underwater vehicles these plots are important to
determine the battery life of the vehicle.
BTD150 Thruster
Figure 1 BTD150
This Thruster is driven by brushed dc motor which is housed in aluminium
housing.
Specifications:
Max voltage – 19V
Max power – 110W
Depth rating -150m
These Thrusters do come with their maximum thrust ratting but what is desired
is Thrust vs current and thrust vs voltage curve, in order To determine Thrust
from voltage value and battery life of a vehicle.
In order to control This BTD150 Thruster I used, 5 Amp dual dc Motor Driver
with current sense.
Figure 2 8V-28V, 5Amp dual DC motor driver
8V-28V, 5Amp Dual DC Motor Driver with current Sense can drive 2 DC motors
with current up to 5Amps. It can work between 8 to 28V DC and gives currents
sense output for each motor. Motor driver has built-in protection from over
temperature, over currents, short circuit. It also gives out fault indications for the
over/under voltage, over temperature, over currents / short circuit.
Specifications:
Dual DC Motor Driver
Operating voltage: 8V to 28V
Peak output current: 5Amps per channel
Maximum PWM Frequency: 11 KHz
current sense output: 0.648 V/Amp
Motor driver has 4 input pins for each channel namely PWM, INA1, INA2 and
Ground. For or testing BTD 150 I gave PWM of frequency 255Hz to the motor
driver using Arduino board.
Speed of motor can be controlled using pwm input and direction can be controlled
using following logic.
status Input condition output
PWM INA1 INA2 OUTA1 OUTA2
forward L H L H L
back L L H L H
Soft stop L L L L L
Hard stop L H H H H
Interfacing Arduino with motor driver
Arduino digital pins are used for PWM, INA1 and INA2 which are output pins
and analog pin A0 is used for current sense which is input pin and takes input
from motor driver.
You can connect 0.1uF to 1uF capacitor between CS (current Sense) pin and
ground to reduce ripples in the CS out for more accurate current sensing.
For this motor driver PWM with 0% duty cycle correspond to high power and
100% duty cycle correspond to zero power.
T200 Thruster
Figure 3 T200 Thruster
This Thruster is driven by brushless DC motor. It is made of high-strength, UV
resistant polycarbonate injection moulded plastic.
Specifications:
Operating voltage – 6 To 20V
Max current- 25 Amps
Max power- 350 W
In order to drive this Thruster we need an Electronic Speed Controller (ESC)
since this Thruster runs using brushless dc motor.
Figure 4 basic ESC R1
The electronic speed controller works by receiving a signal from the motor as to
where the rotor is, so That it can channel on which transistor to switch on next,
and the rate at which to do so. The Electronic speed controller uses the signals
given by the Throttle channel from the receiver to help determine how much
power is needed to go to the motor to adjust to the desired speed hat is being
sent from the handheld controller.
Specifications:
Voltage- 6-16V
current- 30 Amp
Pulse width signal
Signal Voltage – 3.3 -5V
Max update rate - 400Hz
Stopped – 1500microseconds
Max forward – 1900 microseconds
Max reverse – 1100 microseconds
This ESC controls the speed of The BLDC motors using pulse width of the
PWM signal for a PWM with pulse width 1500 microseconds motors is
stopped, for 1900 microseconds motor rotates with max power, and for 1100
motor rotates with max power in reverse direction.
Interfacing Arduino and ESC
I have given a PWM of frequency 50 Hz to the ESC using Arduino Board and a
supply voltage of 12 V. Output of ESC is a three phase AC (which is not
sinusoidal).
Figure 5 output of an ESC
This is the output of three pins of ESC at no load condition.
Experimental Setup
Figure 6 Setup for thrust measurement
In this setup thrusted is mounted in a tank in a vertical position and thrust value
calculated by load cell is then displayed on force indicator
Plots
Thrust vs Voltage plot for BTD150 Thruster
As can be seen from plot 0.86Kgf is the maximum thrust force obtained at 18V
in forward direction and 0.68Kgf is maximum reverse thrust.
Thrust vs Current plot for BTD150 Thruster
Maximum current draw is 3.5 Amp at a thrust force of 0.86Kgf in forward
direction and 3.8 Amp at 0.68Kgf in reverse direction.
Thrust vs Pulse width plot for T200 Thruster
Max thrust of 1.4Kgf is obtained at a pulse width of 1800 microseconds in
forward direction and thrust of 1Kgf is obtained at pulse width of 1200
microsecond in reverse direction
Thrust vs current plot for T200 Thruster
Maximum current draw of 6.6 Amp is obtained for thrust value of 1.4Kgf for
forward direction and current draw of 6.5Amp is obtained for thrust value of
1Kgf in reverse direction
Functional representation of thrust vs voltage for BTD150
1) Forward Thrust
Polynomial . Quadratic Regression
1
0.8
0.6
Thrust_Kgf
0.4
0.2
0
3.5 5.5 7.5 9.5 11.5 13.5 15.5 17.5
Voltage_V
Polynomial Quadratic Regression Calibrator
Approximate relation between thrust and voltage:
2) Reverse Thrust
Polynomial . Quadratic Regression
0
-18 -16 -14 -12 -10 -8 -6 -4
-0.1
-0.2
Thrust_Kgf
-0.3
-0.4
-0.5
-0.6
-0.7
-0.8
Voltage_V
Polynomial . Quadratic Regression Calibrator
Approximate relation between thrust and voltage:
Functional representation of thrust vs voltage for T200
1) Forward Thrust
Polynomial . Cubic Regression
1.6
1.4
1.2
Thrust_Kgf
1
0.8
0.6
0.4
0.2
0
1530 1580 1630 1680 1730 1780
pulse_width
Polynomial . Cubic Regression Calibrator
Approximate relation between thrust and Pulse width:
2) Reverse Thrust
Polynomial . Quadratic Regression
0.2
0
1200 1250 1300 1350 1400 1450
-0.2
-0.4
Y:
-0.6
-0.8
-1
-1.2
X:
Polynomial . Quadratic Regression Calibrator
Approximate relation between thrust and voltage:
Conclusion
It was found that maximum thrust value for both the thrusters to be less than what
was given in the datasheet. The reason for this could be testing environment. I
have tested these thrusters in a tank where movement of water is restricted by
tank walls. Tank depth is also less which further reduces the thrust produced by
the motor.
If the experiment is performed in a pond or a much larger tank then we can
approach the actual thrust values.
We can also mount the thrusters in horizontal position using a linkage for more
accurate thrust values.
Appendix
1) Code for driving motor driver
//*************************************************************************
/*Pin connection Arduino UNO to 8-28-5 Motor driver
Arduino Pin No Atmel328p Pin 8-28-5 Motor driver Pin
8 PB0 INA-1
9 PB1 PWM-A
10 PB2 PWM-B
11 PB3 INA-2
12 PB4 INB-1
13 PB5 INB-2
A0 PC0 CS-A
A1 PC1 CS-B
//************************************************************************
int current_sensor_A = A0; //Current sensor of motor A is connected at ADC pin A0
int current_sensor_B = A1; //Current sensor of motor B is connected at ADC pin A1
int valA = 0; // variable to store the value read
int valB = 0; // variable to store the value read
int rpm = 200;
Int i=0;
float cur_val=0;
float current =0;
double factor = 7.535;
void setup()
{
cli();
DDRB = 0x3F; //Arduino PIN 8 and 11 are used as INB-1 and INB-2, 9 and 10 are used
for PWM and 12 ,13 for INB-1 and INB-2
PORTB = 0x00;
Serial.begin(9600); // Serial setup
Serial.println("Hey i am good..");
timer1_init(); //Timer initialize
//TIMSK1=0x21;
velocity(rpm,rpm); //Set motors velocity here. Smaller the value lesser will be the velocity
sei();
}
//TIMER1 initialize - prescale:255
// WGM: 0) Normal, TOP=0xFFFF
// desired value: 255Hz
// actual value: 255.000Hz (0.0%)
//Inverting Fast PWM Mode
void timer1_init(void)
{
TCCR1A = 0xF1;
TCCR1B = 0x0C;
TCCR1C = 0x00;
}
void clockwise(void) //Move both motors are in clockwise direction
{
PORTB=0x11;
}
void anticlockwise(void) //Move both motors are in anticlockwise direction
{
PORTB=0x28;
}
void hardstop(void) //Move both motors are in anticlockwise direction
{
PORTB=0x39;
}
void softstop(void)
{
PORTB=0x00;
void velocity (unsigned char motor_A, unsigned char motor_B) // Function for motors velocity
{
OCR1AL = (unsigned char)motor_A;
OCR1BL = (unsigned char)motor_B;
}
void Analysemode(char mode)
{
switch(mode){
case 'C':
clockwise(); //Move both motors in clockwise direction
Serial.println("Running Clock Wise.");
break;
case 'A':
anticlockwise(); //Move both motors in clockwise direction
Serial.println("Running Anti - Clock Wise.");
break:
case 'H':
hardstop(); //Move both motors in clockwise direction
Serial.println("Stopping Motors.");
break;
case 'J':
softstop();
Serial.println("stopping slowly");
break;
case 43:
rpm = rpm + 2;
if(rpm>255)
rpm=255;
velocity(rpm,rpm); //Set motors velocity here.
Serial.println(rpm);
break;
case 45:
rpm = rpm - 2;
if(rpm<0)H
rpm=0;
velocity(rpm,rpm); //Set motors velocity here
Serial.println(rpm);
break;
default:
break;
}
}
void loop()
{
if (Serial.available()) {
char mode=Serial.read();
Analysemode(mode);
}
// clockwise(); //Move both motors in clockwise direction
valA = analogRead(current_sensor_A); //read the current sensing pin
current = valA*factor;
i=i+1;
cur_val=((cur_val*(i-1))+current)/i;
if(i==500){
Serial.print(", Cur="); //Print value on serial terminal
Serial.print(cur_val); //Print value on serial terminal
Serial.println("mA");
i=0;
cur_val=0;
}
}
2) Code for ESC
#include <Servo.h>
int signal = 1500;// should be between 1100 to 1900
byte servoPin = 12 ;
Servo servo;
void setup() {
servo.attach(servoPin);
Serial.begin(9600);
servo.writeMicroseconds(1500); // send "stop" signal to ESC.
delay(1000); // delay to allow the ESC to recognize the stopped signal
}
void clockwise(void){
int temp=signal;
if(temp<1500){
temp=2*1500-temp;
if(temp>1881)
{ signal=1880;
}
else{
signal=temp;}
}
else if(signal==1500){
signal=1600;
}
}
void anti_clockwise(void){
if(signal>1500){
signal=2*1500-signal;
}
else if(signal==1500){
signal=1400;
}
}
void hardstop(void){
signal=1500;
}
void increase(void){
if(signal<1871){
signal=signal+10;
}
}
void decrease(void){
if(signal>1119){
signal=signal-10;
}
}
void Analysemode(char mode)
{
switch(mode){
case 'C':
clockwise(); //Move both motors in clockwise direction
Serial.println("Running Clock Wise.");
break;
case 'A':
anti_clockwise(); //Move both motors in clockwise direction
Serial.println("Running Anti - Clock Wise.");
break;
case 'H':
hardstop(); //Move both motors in clockwise direction
Serial.println("Stopping Motor.");
break;
case '=':
increase();
Serial.println(signal);
break;
case 45:
decrease();
Serial.println(signal);
break;
}
}
void loop() {
if (Serial.available()) {
char mode=Serial.read();
Analysemode(mode);}
servo.writeMicroseconds(signal); // Send signal to ESC.
}
