1

Manuela Beltrán University. Sebastian Balaguera.Tatiana Rocha Laboratory project (Design Applied to Biomedical Engineering)

MODELING AND CONTROLLER DESIGN OF INVERTED

PENDULUM
Sebastian Balaguera , Tatiana Rocha
{sebalaguera,tati961219}@gmail.com
Manuela Beltrán University
Bogotá, Colombia

Abstract—This project is based on development of a self
balanced two wheeled robot. In particular, the focus is on the
electro-mechanical mechanisms & control algorithms
required to enable the robot to perceive and act in real time.
This research is aimed to design and implement Proportional
Integral Derivative (PID) controller on Two-wheeled self-
balance robot. The PID is used for the purpose of balancing
the robot to stand still at upright position despite
disturbances to follow the desired trajectory smoothly.
This report discusses the theoretical considerations made at
the start of the project, the steps that were taken to
implement the self-balancing code including the
consideration for the PID gains were tuned until the optimum
values are achieved, the analysis of the final results, the
interpretation of the final results, Therefore the experimental
results show the effectiveness of the proposed controller for
stabilization.
The objective of this project is double, first put the creativity
and skill of the engineer in the development and
implementation of a circuit that allows to carry out
mechanical and digital system to control a self balance robot
to control the speed and balance controlled by a DC stepper
motor and a gyroscope. The second one is to consolidate and
apply the basic programming concepts for the creation and
implementation of a self-balancing code including the
consideration for the PID gains that allows the visualization of
effectiveness of the proposed controller for stabilization.
II. DEVELOPMENT
1. Flowchart (Self balancing Robot)

Keywords— Control Systems, proportional control.

I. INTRODUCTION
The real world surrounding the application of technology are
large systems that interact according to the type of power
supply, the variable parameter and according to the
magnitude of measurement.
In this branch of technology mixes multiple disciplines in this
case medicine and electronics can find the applied design;
which is to design, plan and develop systems with desired
behaviors in the implementation of control systems based on
mathematical modeling.
The control objective of the inverted pendulum is to swing up
the pendulum hinged on the moving cart by a motor from
stable position to the zero state and to keep the pendulum in
vertically state despite disturbances
If the base on which the robot stand is not stable or the
platform is not balanced, the robot tend to falling off from
the vertical axis. This time a gyro chip is needed to provide
the PID controller about the angular position of the base of
the self balancing robot. A self balancing algorithm is
programmed into the controller and the controller drives the
motors either clockwise or anticlockwise directions to
balance itself.
 2
Manuela Beltrán University. Sebastian Balaguera.Tatiana Rocha Laboratory project (Design Applied to Biomedical Engineering)

Image 3. PID control circuit Schematic

4. Frame parts (Inventor)

Image 1. PID control balance algorithm

2. Control System (Self balancing Robot)

Image 4. Frame parts for self balancing robot

III. RESULTS AND ANALYSIS

1. Components
The components chosen in this project were:
1. 1 x Arduino pro mini clone
2. 1 x FTDI USB to TTL programmer for the Arduino pro
mini
Image 2. Control System for the robot 3. 1 x Arduino Uno clone
4. 1 x MPU-6050 gyro and accelerometer
3. Electric scheme (Fritzing) 5. 2 x 2.4G wireless serial transceiver module
6. 2 x 26mm Stepper motor
7. 2 x DRV8825
8. 1 x Mini DC 7~28V to DC 5V step-down converter
9. 1 x 11.1V 2200mAh 30C Li-polymer Battery
10. 1 x B3AC 2S/3S Lipo balance charger
 3
Manuela Beltrán University. Sebastian Balaguera.Tatiana Rocha Laboratory project (Design Applied to Biomedical Engineering)
2. Frame parts construction (Physical assembly) of the transceiver is forced high or low. As a result,
This project was made and printed by laser with two sheets of the FTDI programmer cannot change this output
MDF. I used 3 mm and 9mm sheets. To begin with, there are anymore and you will get an upload error. By adding
certain considerations that must be taken into account when this resistor, the FTDI programmer can change the
carrying out the physical assembly: voltage on the RX-pin of the Arduino despite the
1. As previously established the self-balancing robot state the transceiver output and the program is
must be balanced on a pair of wheels with the uploaded without any problems.
required grip providing enough friction. 2. The other two resistors (“R2” and “R3”) form a
2. This robot implements stepper motors instead of voltage divider. Meaning that the 12.6 volt of the
regular DC motors. The main reason is that Stepper battery minus the 0.6-volt voltage drop over the
motors are precise and have no performance loss diode is divided by 2.5. Resulting in a 4.8 volt on the
when the battery voltage drops. The DC motors may analog input when the battery fully charged. This
cause electric and mechanical friction differences, can be be shown in the next image:
the steppers motors work with pulses and they are
always an exact amount of motion or speed
3. When the robot starts tilting over the motors will
move the lower part of the robot a little bit faster in
the same direction as a result the lower part is
forced back under the higher part of the robot in
order to know is that this could only work if the
higher part of the robot has enough inertia
(resistance to change). To create this inertia the
battery is mounted on top of the frame
4. For the creation of this robot in the image 3 can see
holes of size of 3 and 2.5 mm, these holes were
implemented in order to be able to use screws to
assemble the physical assembly . The wheels are 5 Image 6. Physical Assembly
cm in diameter with a 5 mm center of hole , this way
I compressed them into the stepper motors . MDF is 3. In the main program this analog input will be used to
a hard material , and without modifications the MDF protect the battery. This is because lipo batteries can
wheels don’t grip the surface on and the robot be damaged when the voltage drops below 3 volt
cannot balance itself . To give more traction I used per cell. This is visualized in the code in this way:
an old inner tube from a bicycle.
battery_voltage = (analogRead(0) * 1.222) + 85;
//If battery voltage is below 10.5V and higher than 8.0V
if(battery_voltage < 1050 && battery_voltage > 800){
//Turn on the led if battery voltage is to low
digitalWrite(13, HIGH);
//Set the low_bat variable to 1
low_bat = 1
}
4. The diode D1 protects all the electronics against
reversed polarity. So, if accidentally reverse the
connections of the battery the components won't
burn itself. The DC to DC converter must be
Image 5. Physical Assembly calibrated in order to convert from 12v to 5v
5. The orientation of the gyro is important. If it is not
3. Frame parts construction (Electrical Scheme) placed correctly the software cannot calculate the
correct angle and the robot will not work.
Now that the frame is finished it is time to make the
controller board, to build the controller board, I used a
universal prototyping board. then connect thin wire
according to electrical scheme. To begin with, there are
certain considerations that must be taken into account when
carrying out the electrical assembly:
1. The resistor “R1” on the schematic is needed for Image 7. MPU 6050 position differences
uploading a program to the Arduino. The TXD output
 4
Manuela Beltrán University. Sebastian Balaguera.Tatiana Rocha Laboratory project (Design Applied to Biomedical Engineering)

With everything in place it's time to connect the FTDI

programmer to the Arduino pro mini however , we are going
to work with the MPU6050 or the gyro, so we only need the
voltage from the Arduino mini Pro so don't connect the
battery yet.

The gyro only measures angular motion and is measure in

degrees per second . But there is always angular motion over
time , The MPU 6050 is a 6 DOF (Degrees of Freedom) or a six
axis IMU sensor, which means that it gives six values as
output. Three values from the accelerometer and three from
the gyroscope. Where:
1. The Accelerometer is used to measure the
acceleration relative to the free fall.
2. The Gyroscope is used to measure the rate of change
of angle around a given axis, with respect to the
orientation of world coordinate frame.
To check if the gyro is connected correctly and to check the
balancing point of the robot I upload the public "hardware-
check" program; prior to all of this it is necessary to test the
balancing angle of the robot and fix it in that position on a
stand as shown in the next image:
Image 8. Robot position to obtain balance Value
Image 9. Balance Value in serial monitor
Other important factor is to set the stepper controllers to the
correct drive current. If the motor current is set to high the
stepper controllers will heat up and they might get damaged.
To begin with, there are certain considerations that must be
considered when carrying out the Current limiting:
1. Examine the datasheet for the stepper motor. Write
down it’s rated current. In this case we are using
NEMA 17 4,83V 0,84A.
2. Do not leave the STEP input floating, connect it to 5V
3. Place the multimeter in series with one of the coils
on your stepper motor and measure the actual
current flowing.
4. Take a small screwdriver and adjust the current limit
potentiometer until you reach rated current.

The program will check if there is any I2C device is connected

and if this is an MPU-6050. If everything is working as
expected the program will output several raw gyro values on
the screen but the one that matters is the Balance value that
will display in the serial monitor ; this one will be used later
on in the main program.

Image 10. Current limiting potentiometer and setting current

limit for DRV8825 with multimeter
 5
Manuela Beltrán University. Sebastian Balaguera.Tatiana Rocha Laboratory project (Design Applied to Biomedical Engineering)
Following all these steps, a physical assembly was achieved float max_target_speed = 150;
and the final result is as follows:
//// Global settings
byte start, received_byte, low_bat;

int left_motor, throttle_left_motor,

throttle_counter_left_motor, throttle_left_motor_memory;
int right_motor, throttle_right_motor,
throttle_counter_right_motor,
throttle_right_motor_memory;
int battery_voltage;
int receive_counter;
int gyro_pitch_data_raw, gyro_yaw_data_raw,
accelerometer_data_raw;

long gyro_yaw_calibration_value,
gyro_pitch_calibration_value;

Image 11. Self balancing robot unsigned long loop_timer;

4. Self-balancing code (Arduino Programming) float angle_gyro, angle_acc, angle,

First of all , Like previously established the steppers motors
are pulse driven. What does this mean? . If one pulse is given
to the stepper controller the motor will rotate 0,45 degrees .
This is because the step angle for the stepper motor is 1,8
degrees and stepper controller is ¼ of the step as you can see
in the specifications. So 800 pulses are needed in order to
make the wheels spin a full 360 degrees .
self_balance_pid_setpoint;
float pid_error_temp, pid_i_mem, pid_setpoint, gyro_input,
pid_output, pid_last_d_error;
float pid_output_left, pid_output_right;
The register “TWBR” is set to 12 considering that the clock
speed is 400KHz according to the equation found in the
Arduino Pro mini datasheet.

The wheel diameter is 5,1mm , so with every pulse the wheel TWBR = 12;
is travelling 0,2mm , at 800 pulses the wheel has travelled
160.2mm . By changing the time between the pulses , the
number of pulses per second can be changed . As a result, to
travel distance per time can be changed.

.
Now that we know how a stepper motor properly works and
has some kind of “Linear” behavior we can adapt only one set
of PID values, we can now explain the code:
First we define the wire library to communicate with the
MPU6050 then the address must be loaded with the I2C
library as well. We begin by setting the variables for the PID
values , The balance Value given by the MPU 6050 and some
globar variables that will be used later on the code
The main objective here knowing that we are implementin a
stepper motor is to create a variable pulse for controlling the
stepper motors a timer is created that will execute a piece of
code (subroutine) every 20us; This subroutine is called
TIMER2_COMPA_vect. According to the datashhet this can
be done since the Arduino pro mini have an 8 bit has a
counter in which we can manipulate the timing , so if we use
the following table :

#include <Wire.h>
int gyro_address = 0x68;
int acc_calibration_value = 80;

//Various settings
float pid_p_gain = 15;
In which establishes that if the registers CS22, CS21 and
float pid_i_gain = 1.5;
CS200 are in 011 the output of this counter will set it as 8 . As
float pid_d_gain = 30;
a result the 16MHZ clock is divided by 8 and a clock pulse is
2MHz , and dividing 1 by 2 MHz we get a clock time of 0,5us.
float turning_speed = 30;
 6
Manuela Beltrán University. Sebastian Balaguera.Tatiana Rocha Laboratory project (Design Applied to Biomedical Engineering)
Now we can calculate the compare value to trigger the PORTD |= 0b00100000;
interrupt routine every 20 us by dividing 20us by 0,5us , the throttle_right_motor_memory *= -1;
result is 40 , Since the timer starts at 0 the compare value is }
39. else PORTD &= 0b11011111;
. }
else if(throttle_counter_right_motor == 1)PORTD |=
0b00010000; else if(throttle_counter_right_motor ==
2)PORTD &= 0b11101111; }

Now we are going to enter and manipulate the registers for

the Gyro or MPU 6050 , and the first thing we notice is that all
the registers are set to “0” by default. So we are going to
implemet the Wire library in order to set the registers to “1”.
And at last we determine that “Clear timer” register is Basically what we want to do here is just:
determined by the name of “TCCR2A” ; This can be 1. Start the communication with the adress fond during
visusalized in the code like this : search
2. Write the register we want to use and set register
TCCR2A = 0; bits as “0” in all 8 bits in order to activate the Gyro
TCCR2B = 0; 3. En the transmission with the Gyro
TIMSK2|=(1<< OCIE2A);
TCCR2B|= (1 << CS21); Wire.beginTransmission(gyro_address);
OCR2A = 39; Wire.write(0x6B);
TCCR2A|=(1<<WGM21); Wire.write(0x00);
Wire.endTransmission();
Then the interrupt routine is called , The name of the interrup Wire.beginTransmission(gyro_address);
routine can be found in the Datasheet and is called like an Wire.write(0x1B);
“INTERRUPT VECTOR ” with the name of Wire.write(0x00);
“TIMEW”_COMPA_Vect” , So this piece of code is excuted Wire.endTransmission();
every 20us . Wire.beginTransmission(gyro_address);
Wire.write(0x1C);
ISR(TIMER2_COMPA_vect){ Wire.write(0x08);
//Left motor pulse calculations Wire.endTransmission();
throttle_counter_left_motor ++; Wire.beginTransmission(gyro_address);
if(throttle_counter_left_motor > Wire.write(0x1A);
throttle_left_motor_memory){ Wire.write(0x03);
throttle_counter_left_motor = 0; Wire.endTransmission();
throttle_left_motor_memory =
throttle_left_motor; if(throttle_left_motor_memory < After all of this we are ready to set some outputs pins for the
0){ Arduino Pro Mini in order to calibrate the Gyro. The output of
PORTD &= 0b11110111; the Gyro is in degrees per second meaning that when is in
throttle_left_motor_memory *= -1; } rest the output will be “0”. Like we said before we establish
else PORTD |= 0b00001000; before in the public code to determine the balance value of
} the MPU 6050 we can see the balance value and some
else if(throttle_counter_left_motor == 1)PORTD |= outputs generated by the axis x , y and z . But according to
0b00000100; image 9 , those values are not “0” , and that is completely
else if(throttle_counter_left_motor == 2)PORTD &= normal considering that every MPU6050 have some offset.
0b11111011; So now we have to subtract the average offset , with the data
//right motor pulse calculations that we can see in image 9 , the result is almost “0”.
throttle_counter_right_motor ++;
if(throttle_counter_right_motor > for(receive_counter = 0; receive_counter < 500;
throttle_right_motor_memory){ receive_counter++){
throttle_counter_right_motor = 0; if(receive_counter % 15 == 0)digitalWrite(13, !
throttle_right_motor_memory = digitalRead(13));
throttle_right_motor; Wire.beginTransmission(gyro_address);
if(throttle_right_motor_memory < 0){ Wire.write(0x43);
Wire.endTransmission();

Manuela Beltrán University. Sebastian Balaguera.Tatiana Rocha Laboratory project (Design Applied to Biomedical Engineering)
Wire.requestFrom(gyro_address, 4);
gyro_yaw_calibration_value += Wire.read()<<8|Wire.read();
gyro_pitch_calibration_value += Wire.read()<<8|
Wire.read(); delayMicroseconds(3700);
}
gyro_pitch_calibration_value /= 500;
gyro_yaw_calibration_value /= 500;
loop_timer = micros() + 4000;
Now it is time to measure the angle , First the raw
accelerometer Data is pulled from the MPU 6050 , The
balance calibration value is added and the result is limited to
plus or minus 8200 to prevent a division by “0”.
//Angle calculations
Wire.beginTransmission(gyro_address);
Wire.write(0x3F);
Wire.endTransmission();
Wire.requestFrom(gyro_address, 2);
accelerometer_data_raw = Wire.read()<<8|Wire.read();
accelerometer_data_raw += acc_calibration_value;
if(accelerometer_data_raw > 8200)accelerometer_data_raw
= 8200;
if(accelerometer_data_raw < -8200)accelerometer_data_raw
= -8200;
Is now possible to calculate the angle of the robot when using
the “Asin” function, , The accelerometer value is incremented
and the funtion does when the angle of the robot is
increasing , With this function the angle of the robot can be
calculated.
The result is 57,296 is used becuase the asin function is in
radians and not in degrees . This part will be the responsible
to handle the start of the robot :
angle_acc = asin((float)accelerometer_data_raw/8200.0)*
57.296;
if(start == 0 && angle_acc > -0.5&& angle_acc < 0.5){
angle_gyro = angle_acc;
start = 1;
} .
Considering that the robot starts when slowly is put into an
upright position; every loop that is 255 times per second. The
angle of the robot is measured with only the acceloremeter .
And if it is between (-0,5,0,5) degrees of the balancing point .
The angle Gyro variable is set to the current angle and start
variable is set to 1 to indicate that the robot is activated.
Next, the yaw and pitch are variables from the MPU6050 ,
and the calibration of the offset is subtracted ; according to
the datasheet of the MPU6050 we can see if the value output
is 131 the gyro output is 1 degree per second however
according to the code , the output is set to ¼ degree per 4 ms
or 255 so the next equation is presented:
7
Wire.beginTransmission(gyro_address);
Wire.write(0x43);
Wire.endTransmission();
Wire.requestFrom(gyro_address, 4);
gyro_yaw_data_raw = Wire.read()<<8|Wire.read();
gyro_pitch_data_raw = Wire.read()<<8|Wire.read();
gyro_pitch_data_raw -= gyro_pitch_calibration_value;
angle_gyro += gyro_pitch_data_raw * 0.000031;
By adding this travelled angle by angle gyro variables the
actual angle is updated to the new position, in short ; in the
start moment of the angle gets updated to new position so at
the start the angle gyro variable is set to accelerometer
variable and according to that goes forward or backward with
the motors.
Basically for the PID Calculations , we have two inputs the
current actual angle for the robot and the desired angle .
When the robot is not moving the desired angle is at 0
degrees. By measuring the difference between the actual
angle of the robot and the desired angle the PID calculates an
output that is used for controlling the stepper motors
The balancing robot is angle driven. First the difference
between the desired angel (setpoint) and actual angle
(process value) is calculated. The self_balance_pid_setpoint
variable is automatically changed to make sure that the robot
stays balanced all the time, This is how the PID algorithm is
made and has comments on each line for self explanation.
//The (pid_setpoint - pid_output * 0.015) part functions as a
brake function.
pid_error_temp = angle_gyro - self_balance_pid_setpoint -
pid_setpoint;
if(pid_output > 10 || pid_output < -10)pid_error_temp +=
pid_output * 0.015 ;
//Calculate the I-controller value and add it to the
pid_i_mem variable
pid_i_mem += pid_i_gain * pid_error_temp;
//Limit the I-controller to the maximum controller output
if(pid_i_mem > 400)pid_i_mem = 400;
else if(pid_i_mem < -400)pid_i_mem = -400;
//Calculate the PID output value

Manuela Beltrán University. Sebastian Balaguera.Tatiana Rocha Laboratory project (Design Applied to Biomedical Engineering)
pid_output = pid_p_gain * pid_error_temp + pid_i_mem +
pid_d_gain * (pid_error_temp - pid_last_d_error);
//Limit the PI-controller to the maximum controller output
if(pid_output > 400)pid_output = 400;
else if(pid_output < -400)pid_output = -400;
//Store the error for the next loop
pid_last_d_error = pid_error_temp;
//Create a dead-band to stop the motors when the robot is
balanced
if(pid_output < 5 && pid_output > -5)pid_output = 0;
//If the robot tips over or the start variable is zero or the
battery is empty
if(angle_gyro > 30 || angle_gyro < -30 || start == 0 ||
low_bat == 1){
//Set the PID controller output to 0 so the motors stop
moving
pid_output = 0;
//Reset the I-controller memory
pid_i_mem = 0;
//Set the start variable to 0
start = 0;
//Reset the self_balance_pid_setpoint variable
self_balance_pid_setpoint = 0;
} robot will always find it's balancing point
Now we have to see the how control calculations are done,
all the lines of the code are commented in order to
understand what the code does :
//Control calculations
//Copy the controller output to the pid_output_left variable
for the left motor and right motor
pid_output_left = pid_output;
pid_output_right = pid_output;
//If the first bit of the receive byte is set change the left and
right variable to turn the robot to the left
if(received_byte & B00000001){
//Increase left / Decrease right
pid_output_left += turning_speed
pid_output_right -= turning_speed;
} //Motor pulse calculations
//If the second bit of the receive byte is set change the left
and right variable to turn the robot to the right
if(received_byte & B00000010){
//Increase right / Decrease left
pid_output_left -= turning_speed;
pid_output_right += turning_speed;
} else if(pid_output_left < 0)pid_output_left = -405 -
//If the third bit of the receive byte is set change the left and
right variable to turn the robot to the right
if(received_byte & B00000100){
//Slowly change the setpoint angle so the robot starts leaning
forewards
8
if(pid_setpoint > -2.5)pid_setpoint -= 0.05;
if(pid_output > max_target_speed * -1)pid_setpoint -= 0.005;
}
//If the forth bit of the receive byte is set change the left and
right variable to turn the robot to the right
if(received_byte & B00001000){
//Slowly change the setpoint angle so the robot starts leaning
backwards
if(pid_setpoint < 2.5)pid_setpoint += 0.05;
if(pid_output < max_target_speed)pid_setpoint += 0.005;
}
//Slowly reduce the setpoint to zero if no foreward or
backward command is given
//If the PID setpoint is larger then 0.5 reduce the
setpoint with 0.05 every loop
if(!(received_byte & B00001100)){
if(pid_setpoint > 0.5)pid_setpoint -=0.05;
else if(pid_setpoint < -0.5)pid_setpoint +=0.05;
else pid_setpoint = 0;
}
The self balancing point is adjusted when there is not forward
or backwards movement from the transmitter. This way the
//If the setpoint is zero degrees
//Increase the self_balance_pid_setpoint if the robot is still
moving forewards
if(pid_setpoint == 0){
if(pid_output < 0)self_balance_pid_setpoint += 0.0015;
//Decrease the self_balance_pid_setpoint if the robot is still
moving backwards
if(pid_output > 0)self_balance_pid_setpoint -= 0.0015;
}
To finish the last part of the algorithm , basically it calculates
the pause times for the stepper controller
//To compensate for the non-linear behaviour of the stepper
motors the following calculations are needed to get a linear
speed behaviour.
if(pid_output_left > 0)pid_output_left = 405 -
(1/(pid_output_left + 9)) * 5500;
(1/(pid_output_left - 9)) * 5500;
if(pid_output_right > 0)pid_output_right = 405 -
(1/(pid_output_right + 9)) * 5500;

Manuela Beltrán University. Sebastian Balaguera.Tatiana Rocha Laboratory project (Design Applied to Biomedical Engineering)
else if(pid_output_right < 0)pid_output_right = -405 -
(1/(pid_output_right - 9)) * 5500;
//Calculate the needed pulse time for the left and right
stepper motor controllers
if(pid_output_left > 0)left_motor = 400 - pid_output_left;
else if(pid_output_left < 0)left_motor = -400 -
pid_output_left;
else left_motor = 0;
if(pid_output_right > 0)right_motor = 400 -
pid_output_right;
else if(pid_output_right < 0)right_motor = -400 -
pid_output_right;
else right_motor = 0;
//Copy the pulse time to the throttle variables so the
interrupt subroutine can use them
throttle_left_motor = left_motor;
throttle_right_motor = right_motor;
9
https://www.instructables.com/id/Self-Balancing-Robot/.
[Accessed: 14- May- 2019].
[4] J. Brokking, "Brokking.net - Your Arduino Balancing Robot
(YABR) - Media files.", Brokking.net, 2019. [Online].
Available: http://www.brokking.net/yabr_media.html.
[Accessed: 14- May- 2019].
[5] M. Hamza, "odelling and Experimental Analysis Two-
Wheeled Self Balance Robot Using PID Controller", 2019.
[Online]. Available:
https://www.researchgate.net/publication/238008621_A
_PID_backstepping_controller_for_two-wheeled_self-
balancing_robot. [Accessed: 14- May- 2019].
[6] "In-Depth: Interface DRV8825 Stepper Motor Driver
Module with Arduino", Last Minute Engineers, 2019.
[Online]. Available:
https://lastminuteengineers.com/drv8825-stepper-
motor-driver-arduino-tutorial/. [Accessed: 14- May-
2019].

IV. CONCLUSIONS VI. ANNEXES

1. t was determined that the transfer function, if not 1. Math
developed correctly, can alter the response of a
system manifesting itself in response to speed,
revealing three ways which can show the output of a
system being slow, normal and fast will depend on
the peak of each of the graphic or the responses of
that system.
2. This project has presented a design and implement
Proportional Integral Derivative (PID) controller on
two wheels while it balances itself. It was illustrated
that the Self balancing robot is capable of balancing
on its two wheels and can resist disturbances . This
was done using Arduino, and other off-the-shelves
parts to make it affordable, easier for maintenance
and improvement. The mathematical model was
developed while the PID controller was designed and
developed in real-time. The importance of
manipulating the PID gains to the performance of
controller has been shown experimentally.

V. REFERENCIAS
[1] Anadigm, Inc., PID Control Customer Presentation,
PR080200-0004, Agosto 2002.
http://www.anadigm.com/_doc/FPAA Solutions for PID
ControlPID Control.pdf. [Citado en 2005]
[2] Ethesis.nitrkl.ac.in, 2019. [Online]. Available:
http://ethesis.nitrkl.ac.in/2213/1/Inverted_Pendulum.pd
f. [Accessed: 14- May- 2019].
[3] M. author:, "Self-Balancing Robot", Instructables, 2019.
[Online]. Available: 2. Program (Arduino)
a. (see Anexes in the Zip)