Dexter- go pi go

Mobile Robots Obstacle Avoidance Using Ultrasonic Sensors and Neural Control System
Name
Course
Tutor
University
Date
City

Abstract
This laboratory aims to familiarize oneself with the functioning of a mobile robot learning how to write the robot’s navigation program. The primary objective is to write a program to make the robot move forward until it detects an obstacle. On identifying barriers, it ought to turn either right or left depending on the available free space. Further investigation is carried out to compare the performance of the robot in the real environment as compared to the simulated one. Additionally, the student will get conversant with the communication protocol of the microcontroller used with the robot beside uploading programs to it ensuring that the applications execute. A detailed description of the different stages required interfacing and program a microcontroller is provided. The algorithm is combined with neural networks and fuzzy controls which express the rules difficult to describe using mathematical models. Finally, a relationship between the presented algorithms and those developed in the lab is carried out.

Keywords: Robots, Algorithm, Program, GoPiGo, DEXTER, System, Mobile, Controller, Microcontroller
Mobile Robots Obstacle Avoidance Using Ultrasonic Sensors and Neural Control System
Introduction
Robotics is the field of technology which is responsible for the design, application, operation, and construction of robots. Specifically, a robot is a machine with the capability of performing complex tasks in series automatically which is achieved by being pre-programmed by a computer.

There are a couple of functions which are assigned to the robots and ought to be performed. These tasks are attached to a couple of limitations which should be achieved irrespective of the restrictions being automatic or human controlled. The electro-mechanical machines can perform the work of a person autonomously or in a computer-controlled environment. According to the Oxford dictionary, a robot is defined as “a machine with the capability of performing complex series of actions automatically, especially one which is computer programmed.”
Today, the world has embraced automation which has given way to robotics. In one way or another, we find ourselves using robots in our day to day activities either knowingly or unknowingly. There is a need for students in the artificial intelligent field to understand the development and functioning of robots. In this report, experiments have been carried out with the mobile robot kit (DEXTER). This robot is a mobile robot which is differential wheeled with the capability of navigating in an environment which is objecting clustered.
The autonomous navigation of the robot vehicle is dependent on the ability of the robot to know its position to an appropriate degree of accuracy besides sensing its surrounding environment as required. Just like for the unmanned vehicles, autonomous robot’s guidance and navigation are vital issues of control. For a robot to decide concerning performing a task expected of it, it has first to know the state in the working environment and its where about first of all. A good example is how we humans use our eyes and brain to receive and process feedback from the surrounding to determine what to do next depending on the task to be performed. Nerves are responsible for creating the image on the retina of the eye after which it is sent to the brain for processing. The brain then makes the judgment on how to act in different situations sending commands to the necessary body parts via nerves.

Likewise, for a mobile robot to achieve a mission, it is vital for it to obtain feedback information from its environment. Due to the nature of the robots environ, the system is required to carry out navigation demand. The feedback data collected should include its velocity acceleration and position. During the process of determining the position, it is inaccurately, the robot first obtain the measurement from the real world after which it posts method this data to eliminate uncertainties which exist in measurement information. After these calculations, the robot is said to have gotten a reliable estimate of the current position it is situated. This position is now the basis on which it navigates.
An autonomous mobile robot is one which moves and changes its workspace with the aim of completing a given task with limitations of given rules or ones it develops itself. There exist four main differences for kinematic analysis of the manipulation of robots. Stationary manipulators form closed chain when in contact with fixed objects while wheeled mobile robots like DEXTER form many closed chains simultaneously. The robots mobility determines how freely they move around independently to accomplish their tasks.

Background
The thought of having versatile robotic systems which are autonomous and can perform their tasks with minimal or no supervision at all is standard and has been practiced in the last past years. This realization was marked by the release of small size computers which have large memories robust processing capabilities such as the Raspberry Pi, NUC among others. This has been pushed further too by the availability of open source libraries which has made the implementation of robotic systems easier.
There have been a variety of object detection algorithms which have been developed over the years. Dexter industries are among the players who design and manufacture accessories for the raspberry pi for robotics. GoPiGo is a robotic platform for the raspberry pi which is used in this project which is meant to be a standalone raspberry pi robotic package. This package contains a robotic body, robotic power supply, motors, and controls. It has been used to demonstrate the artificial intelligence of individual companies like Google and Amazon.
Due to the high rate of growth of the robotics field, learning institutions have begun to offer programs and classes in this field. They combine elements of computer science, mechanical and electrical engineering. The goal of learning and mastering the concepts, project-based knowledge is vital in this area as for the case in this report. Educational robots have been used as experimental platforms. These kinds of robots are built to perform basic tasks such as obstacle avoidance and line following. Programs ought to be written then uploaded to the microcontroller to achieve essential functions like collecting small balls and traveling from one area to another. The application of these skills obtained is like the robot that carries radioactive fuel rods among others.
Initially, the mobile robots used individual processors and operating systems which cannot satisfy the current requests of robot development. There have been new technologies which have been emerging, and one of the research focuses has been in the field of the mobile robot. With the presence of embedded systems and microcontrollers, it is possible to develop robots with intellectualization, economization, and miniaturization.
Attempts to achieve a safe trip of the robot, obstacle avoidance is a vital safeguard. Besides, it is among the most imperative subjects for research The ability of a robot to avoid obstacles or planning of its path is not only one of the critical directions of research in mobile robots, but also it is an essential and indispensable part of the navigation technology of the robot. In static scenes, robot path planning and obstacle avoidance is the primary concern of path planning globally in addition to the local one.
Programming and interfacing microcontrollers
Technology is becoming more and more common in addition to being advance in the evolving world of today. The inventions of smart products continue to advance on a daily basis, and they are revolutionizing the process of design of most of the almost all possible outcomes. Having shoes which contain chips with which they pair and communicate with smartphones for the essence of keeping track of their activities, to refrigeration units which can track the expiry of grocery products and now self-driving cars are just but few examples of inventions in the modern world, robotics; which utilizes microcontrollers to ease our lives.
A microcontroller is an integrated circuit (IC) which is programmable. It has the capability of carrying out multiple functionalities depending on how it is programmed. There exist a couple of microcontrollers which provide functionality in a wide range. The kinds of wide variety of applications that exist within microcontrollers make them tools which are dominant in the modern design. In a nutshell, we are to look at their basics and how they are programmed and interfaced.
It all begins with the selection of a microcontroller that suits the intended purpose. Different microcontrollers have different functionality and features which are unique to each model or brand. Before even programming the microcontroller, selection of a model that meets all the requirements of the design is crucial. The essential features which one looks for in microcontrollers include the number of input and output pins, the storage memory and the clock frequency. However, there are other numbers of specifications which are countless but exist. It would be pointless to write code which cannot interact with the hardware presented as required.
The microcontroller settled for in this project is a rasp berry pi microcontroller. It is the most commonly used microcontroller since it has open source software. Additionally, this microcontroller is a credit card sized computer which thus provides great processing power and storage. During its creation, the goal of the group was to create an easy to use hardware and software microcontroller to provide readily available processing power to everyone. The applications for this microcontroller have been wide and vast. It is being used for robots on land, quadcopter automation and the making of drone boats among others (Richardson, M. and Wallace, S., 2012, 6.).
Programming microcontrollers are typically done using high-level languages such as Java, Python or C++. The other essential tool required to program is an integrated development environment (IDE). It is in most cases a software developed by the microcontroller creator, and it contains vital tools which help in the programming of the microcontroller. The essential tools found in an integrated development environment include a code editor, a compiler and a debugger. However, depending on the microcontroller, additional features may be present. The rasp berry pi microcontroller has a couple of development environments which one has to choose from. For this specific lab, the preferred integrated development environment was ADA fruit web-ide.

To get started with the rasp berry pi microprocessor, there are a couple of hardware and software required which include:
Rasp Berry pi based hardware processing platform
A power supply compatible with the rasp berry pi
A development environment of choice.
Specifically, rasp berry pi model B+ is used and is pictured below (Barrett S., 2013, 23).

Figure 1: Rasp berry pi B+ model board (Upton, E. and Halfacree, G., 2014, 7).
The processor hosted in the rasp berry pi has a processor of 1.2 GHz besides an on-board memory of 1 GB random access memory. The architecture it uses is the RISC (reduced instruction set computer) concept, and thus it allows the processor to perform an approximate of sixteen million instructions per second (MIPS). When the operating system operates at 1.2 GHz. interfacing comes handy as it is the setup required to connect the different electronic parts, controllers, and chips to the microcontroller.
The sole purpose of the microcontroller is to control the dc motors and the servo motors which the robot is using. The robot has an autonomous arm which implies that it is to follow a given path. Changing the necessary way suggests that the program must be updated accordingly. The implementation requires four dc gear motors which are used alongside four servo motors. The motion gotten is provided by the dc motors which are attached to compatible wheels. The characteristic of avoiding obstacles is obtained from the ultrasonic sensors which are connected to the robot. These sensors enable the robot to prevent any obstruction detected in its path ensuring it navigates smoothly. For interfacing between the microcontroller and the motors, there is a set of two motor drivers which provide the interfacing. The motor is supplied with a power source which are dc batteries mounted on it. To ensure functionality achieved, a robotic arm with a gripper whose aim is to pick and place objects is put as an end effector.

To illustrate the logic flow, the block diagram below shows a visual representation of the logic.

Figure 2: Visual representation of the logic
The sensor is an ultrasonic sensor whose aim is to detect obstacles in the path. The sensor used in this project is an HC-SR04 ultrasonic sensor. This sensor provides non-contact distance measurement which is precise. It determines the distance by the help of sonar-like dolphins and bats do. It is the best choice as it offers excellent range accuracy and readings which are stable and secure to use accurately. The sensor operates by sending an ultrasonic burst which in return provides an output pulse which corresponds to the required time for the burst echo to return to the sensor. After this, calculation of the distance to the target can be easily calculated by measuring the pulse width of the repetition. The sensor is in the image below

Figure 3: sensor image (Barrett, 2013, 24)
The sensor’s features are:
Power Supply: 5V DC

Quiescent Current : <2mA
Effectual Angle: <15°
Ranging Distance : 2cm – 500 cm/1″ – 16ft
Resolution : 0.3 cm
 Echo Hold-off  750 μ s from fall of Trigger pulse
 Burst Frequency – 40 kHz for 200 μ s
 Burst Indicator LED shows sensor activity
Delay before next measurement – 200 μ s
 Size – 22 mm H x 46 mm W x 16 mm D (0.84 in x 1.8 in x 0.6 in)
The AT89S52 is an 8-bit complementary metal oxide (CMOS) microcontroller which contains 8K bytes of in-system flash memory which is programmable. This flash which is on-chip provides the capability of being re-programmed in-system or by a memory programmer that is conventionally non-volatile. The combination of the versatile 8-bit central processing unit together with the programmable Flash being in the system on a monolithic chip makes the Atmel AT89S52 a powerful microcontroller which is providing a cost-effective and highly flexible solution to embedded systems control operation.
The two DC motors are for the sake of moving the robotic chassis. The engines are interfaced with the microcontroller by the driver integrated circuit L293d. This integrated circuit consists of the course of an H-Bridge. The purpose of the bridge is to enable the voltage supplied to be applied in either direction across the load. The backward and forward movement of robotic structures is facilitated by the H bridge circuit, and their application is often in dc motors movement in either direction. The structure of the course is built with four switches which are in solid state or mechanical as shown in the figure below.
Figure 4: switches in solid state
Whenever the S1 and S4 switches (as illustrated in the figure above) are closed, and the other two switches are open (S2 and S3), there is a definite supply voltage across the motor which facilitates the forward movement. Reverting the operation is achieved by closing the S2 and S3 switches and simultaneously opening the S1 and S4 switches. The operation mode brings about the reverse operation of the motor hence enabling the backward movement of the robot. In addition to reversing the polarity of the engines, the bridge is used in breaking the motor. This is the situation where the motor comes to a sudden stop which is achieved by shorting the terminals of the motor or letting the motor run freely to a halt. This efficiently disconnects the motors from the circuit as they are summarized in the table below.

Table 1: Summary of motor disconnection
Obstacle avoidance
Since the development of the first practical robot more than the past half century, there has been a massive installation of robots on the floors of factories to perform a couple of tasks. The surrounding in which these robots, commonly called manipulators, are in is usually well controlled which is a guarantee of a safe working environment. However, there has been the rise in the application of mobile robots in the recent years. These robots have to navigate in in dynamic environments which are uncontrolled such as airports, museums, city halls among others. It implies that the safety of the objects in the surrounding, which is inclusive of human beings is paramount (Mutlu, L. and Uyar E., 2012, 17- 18).
There is the great literature which exists concerning the autonomous navigation of mobile robots which have the capability of sensing obstacles. Sensors are put in strategic positions of the robot to ensure its sensing capability is super. For the specific robot in the experiment, the ultrasonic transducers are placed at intervals at locations 7, 8 and 9 as shown in the figure below which is top view mechanical structure of the robot.

Figure 5: Ultrasonic transducers intervals
The other favorite arrangement that ensures that the obstacle avoidance is superb is arranging a circular array of ultrasonic sensors all around the body of the mobile robot. Incorporation of an ultrasonic rangefinder can also be employed at a low cost however it has a problem with the resolution of small angles (Mutlu, & Uyar, 2012, 47).
Neural networks provide an algorithm which consists primarily three neural design subnets. The responsibility of the first two is the most vital one since it depicts the behavior of an intelligent vehicle. The basics are primarily locating the target and avoiding obstacles. The first two sensors consists a controller and a classifier which are trained with supervised techniques of backpropagation. The neural network in the third position is in the capacity of a supervisor and is responsible for making the final decision which is from the first two networks’ feedback. The last neuron which acts as the driver as well as trained by the variant algorithm of the reward and penalty associative learning.
With the Rasp berry pi microcontroller, a simple obstacle avoidance code for the robot is shown below which begins by declaring some constants and input and output pins.
2381250import RPi.GPIO as GPIO import time import numpy as np
GPIO.setmode(GPIO.BOARD) GPIO.setwarnings(False)
class MotorControler(object):
def __init__(self, parent=None):
self._data = {‘name’: ‘MOTOR’, ‘delay’: 0.01, ‘LD’: 14 ‘LU’: 15, ‘RD’: 18, ‘RU’: 23}
self.init_pin()
def init_pin(self):
self.GPIO_LD_PIN = self._data.get(‘LD’, -1) self.GPIO_LU_PIN = self._data.get(‘LU’, -1)
self.GPIO_RD_PIN = self._data.get(‘RD’, -1) self.GPIO_RU_PIN = self._data.get(‘RU’, -1)
if self.GPIO_LD_PIN == -1 or self.GPIO_LU_PIN == -1 or self.GPIO_RD_PIN == -1 or self.GPIO_RU_PIN == -1:
print(‘message’, ‘FATAL ERROR : INVALID PIN ENCOUNTER # ‘ + str(self.GPIO_LD_PIN) + ‘, ‘ + + str(
self.GPIO_LU_PIN) + ‘, ‘ + + str(self.GPIO_RD_PIN) + ‘, ‘ + + str(self.GPIO_RU_PIN))
# pin setup
# set GPIO numbering mode and define output pins
GPIO.setup(self.GPIO_LD_PIN, GPIO.OUT) GPIO.setup(self.GPIO_LU_PIN, GPIO.OUT) GPIO.setup(self.GPIO_RD_PIN, GPIO.OUT) GPIO.setup(self.GPIO_RU_PIN, GPIO.OUT) time.sleep(0.5) # warmup time self.stop()
def stop(self):
GPIO.output(self.GPIO_LD_PIN, False) GPIO.output(self.GPIO_LU_PIN, False)
GPIO.output(self.GPIO_RD_PIN, False) GPIO.output(self.GPIO_RU_PIN, False)
def step_forward(self):
GPIO.output(self.GPIO_LD_PIN, False) GPIO.output(self.GPIO_LU_PIN, True)
GPIO.output(self.GPIO_RD_PIN, False) GPIO.output(self.GPIO_RU_PIN, True) print(‘Move Forward’)
def step_backward(self):
GPIO.output(self.GPIO_LD_PIN, True) GPIO.output(self.GPIO_LU_PIN, False)
GPIO.output(self.GPIO_RD_PIN, True) GPIO.output(self.GPIO_RU_PIN, False) print(‘Move Backward’)
def step_right(self):
GPIO.output(self.GPIO_LD_PIN, True) GPIO.output(self.GPIO_LU_PIN, False)
GPIO.output(self.GPIO_RD_PIN, False) GPIO.output(self.GPIO_RU_PIN, True) print(‘Move Right’)
def step_left(self):
GPIO.output(self.GPIO_LD_PIN, False) GPIO.output(self.GPIO_LU_PIN, True)
GPIO.output(self.GPIO_RD_PIN, True) GPIO.output(self.GPIO_RU_PIN, False) print(‘Move Left’)
def move_forward(self, count=15):
for i in range(count):
self.step_forward() self.stop()
def move_backward(self, count=15):
for i in range(count):
self.step_backward() self.stop()
def move_right(self, count=15):
for i in range(count):
self.step_right() self.stop()
def move_left(self, count=15): for i in range(count):
self.step_left() self.stop()
def readings():
IR_SENSOR_A = 2 IR_SENSOR_B = 3 IR_SENSOR_C = 6 IR_SENSOR_D = 4
GPIO.setup(IR_SENSOR_A, GPIO.IN) GPIO.setup(IR_SENSOR_B, GPIO.IN) GPIO.setup(IR_SENSOR_C, GPIO.IN) GPIO.setup(IR_SENSOR_D, GPIO.IN)
time.sleep(0.5) # warmup time
ir_measure_a = GPIO.input(IR_SENSOR_A) ir_measure_b = GPIO.input(IR_SENSOR_B) ir_measure_c = GPIO.input(IR_SENSOR_C) ir_measure_d = GPIO.input(IR_SENSOR_D)
print(ir_measure_a, ir_measure_b, ir_measure_c, ir_measure_d)
return [ir_measure_a, ir_measure_b, ir_measure_c, ir_measure_d]
# FOR DEMO def run():
motor = MotorControler()
while True:
sensor = readings()
if sensor[1] == 0 and sensor[2] == 0:
motor.move_forward(count=15) elif sensor[1] == 1 and sensor[2] == 1:
if np.random.ranf() > 0.5 :
motor.move_left(count=15) else:
motor.move_left(count=15) # provide more condotion for better maneuvering
run()
0

import RPi.GPIO as GPIO import time import numpy as np
GPIO.setmode(GPIO.BOARD) GPIO.setwarnings(False)
class MotorControler(object):
def __init__(self, parent=None):
self._data = {‘name’: ‘MOTOR’, ‘delay’: 0.01, ‘LD’: 14 ‘LU’: 15, ‘RD’: 18, ‘RU’: 23}
self.init_pin()
def init_pin(self):
self.GPIO_LD_PIN = self._data.get(‘LD’, -1) self.GPIO_LU_PIN = self._data.get(‘LU’, -1)
self.GPIO_RD_PIN = self._data.get(‘RD’, -1) self.GPIO_RU_PIN = self._data.get(‘RU’, -1)
if self.GPIO_LD_PIN == -1 or self.GPIO_LU_PIN == -1 or self.GPIO_RD_PIN == -1 or self.GPIO_RU_PIN == -1:
print(‘message’, ‘FATAL ERROR : INVALID PIN ENCOUNTER # ‘ + str(self.GPIO_LD_PIN) + ‘, ‘ + + str(
self.GPIO_LU_PIN) + ‘, ‘ + + str(self.GPIO_RD_PIN) + ‘, ‘ + + str(self.GPIO_RU_PIN))
# pin setup
# set GPIO numbering mode and define output pins
GPIO.setup(self.GPIO_LD_PIN, GPIO.OUT) GPIO.setup(self.GPIO_LU_PIN, GPIO.OUT) GPIO.setup(self.GPIO_RD_PIN, GPIO.OUT) GPIO.setup(self.GPIO_RU_PIN, GPIO.OUT) time.sleep(0.5) # warmup time self.stop()
def stop(self):
GPIO.output(self.GPIO_LD_PIN, False) GPIO.output(self.GPIO_LU_PIN, False)
GPIO.output(self.GPIO_RD_PIN, False) GPIO.output(self.GPIO_RU_PIN, False)
def step_forward(self):
GPIO.output(self.GPIO_LD_PIN, False) GPIO.output(self.GPIO_LU_PIN, True)
GPIO.output(self.GPIO_RD_PIN, False) GPIO.output(self.GPIO_RU_PIN, True) print(‘Move Forward’)
def step_backward(self):
GPIO.output(self.GPIO_LD_PIN, True) GPIO.output(self.GPIO_LU_PIN, False)
GPIO.output(self.GPIO_RD_PIN, True) GPIO.output(self.GPIO_RU_PIN, False) print(‘Move Backward’)
def step_right(self):
GPIO.output(self.GPIO_LD_PIN, True) GPIO.output(self.GPIO_LU_PIN, False)
GPIO.output(self.GPIO_RD_PIN, False) GPIO.output(self.GPIO_RU_PIN, True) print(‘Move Right’)
def step_left(self):
GPIO.output(self.GPIO_LD_PIN, False) GPIO.output(self.GPIO_LU_PIN, True)
GPIO.output(self.GPIO_RD_PIN, True) GPIO.output(self.GPIO_RU_PIN, False) print(‘Move Left’)
def move_forward(self, count=15):
for i in range(count):
self.step_forward() self.stop()
def move_backward(self, count=15):
for i in range(count):
self.step_backward() self.stop()
def move_right(self, count=15):
for i in range(count):
self.step_right() self.stop()
def move_left(self, count=15): for i in range(count):
self.step_left() self.stop()
def readings():
IR_SENSOR_A = 2 IR_SENSOR_B = 3 IR_SENSOR_C = 6 IR_SENSOR_D = 4
GPIO.setup(IR_SENSOR_A, GPIO.IN) GPIO.setup(IR_SENSOR_B, GPIO.IN) GPIO.setup(IR_SENSOR_C, GPIO.IN) GPIO.setup(IR_SENSOR_D, GPIO.IN)
time.sleep(0.5) # warmup time
ir_measure_a = GPIO.input(IR_SENSOR_A) ir_measure_b = GPIO.input(IR_SENSOR_B) ir_measure_c = GPIO.input(IR_SENSOR_C) ir_measure_d = GPIO.input(IR_SENSOR_D)
print(ir_measure_a, ir_measure_b, ir_measure_c, ir_measure_d)
return [ir_measure_a, ir_measure_b, ir_measure_c, ir_measure_d]
# FOR DEMO def run():
motor = MotorControler()
while True:
sensor = readings()
if sensor[1] == 0 and sensor[2] == 0:
motor.move_forward(count=15) elif sensor[1] == 1 and sensor[2] == 1:
if np.random.ranf() > 0.5 :
motor.move_left(count=15) else:
motor.move_left(count=15) # provide more condotion for better maneuvering
run()

Comparing the Rasp berry pi microcontroller with the go pi go robot microcontroller, the only difference evident is in the programming language used which is python. The program begins by scanning the surrounding at a 180-degree angle. This is followed by methods to control the robot based on the input gotten. Just like in the table above, the figure below shows a snippet of the code to control the robot.

Fig 6: go pi go turning algorithm.
With two microcontroller codes, the bottom line is to turn the chassis either left or right by a particular number of degrees. The process begins by scanning the environment which is done with the help of the sensors. Convenient function to simplify the coding task is supplied which ought to move the robot.
The difference between the two samples of codes provided above does not affect the functionality as they are meant to achieve the same task. For the later one, we begin by importing a couple of libraries after which the controls are provided. Despite the microcontroller in place, it is evident that there are functions which define either the right or left turns which the robot ought to take.
The input to the system is the information which the system obtained from the sensors placed on the left right and center as illustrated earlier. The activation of the sensors is from the proximity of an obstacle with which it occurs in the path. According to the post made, the algorithm will output accordingly ensuring the position of the robot is corrected avoiding obstacles. Since the output function of the network is in decimal numbers which are in the range of zero to one, we use the pi microcontroller to develop a feature for comparison so that these values are set to a value which could be in the range of one to two.
The vector’s output comprises of three elements which correspond to each other from the activities they control the robot. The value obtained from the parts is programmed so that the corresponding movement concerning the input is received. There are a couple of vector combinations which can be obtained to give the correct direction as summarized below.
( 1, 0, 0, 0 ) – This vector represent a control action to turn right.
( 0 1, 0, 0 ) – This vector represent a control action to turn left.
( 0, 0, 1, 0 ) – This vector represent a control action to turn advance without any change.
( 0, 0, 0, 1 ) – This vector represent a control action to turn back.
The algorithm corresponding to the above vectors is diagrammatically illustrated below. The process begins with the sensors reading which helps in determination of the robot’s position. The data from the sensors is then processed by the microcontroller after which the execution action is given. This process is looped through over and over again until the target is reached.

Figure 7: algorithm process
The robot developed in the lab is not designed for any specific task but is a general autonomous navigation vehicle. During its development, research on obstacle avoidance was carried out which helped identify certain limitations. Even though the navigation required was achieved, a couple of improvements can be made to improve the efficiency of the robot. Among the improvements noted are adding sensors on either side of the robot. For the sake of aerospace obstacle avoidance, sensors which are well suited could be used to gather accurate information.
In conclusion, the overall robot performance was commendable despite the small hitches during the development stages. The left sensor, for example, had a minor problem which was rectified by changing the onboard pin. A couple of adjustments accompanied the development stage before the final testing of the robot. The ultrasonic sensors, however, users have many limitations when they suffer from receiving unreliable sonar response from the surrounding environment besides angular uncertainty and specular reflection.
References
Mutlu, L. and Uyar E., 2012. Indoor Navigation and Guidance of an Autonomous Robot Vehicle with Static Obstacle Avoidance and Optimal Path finding Algorithm, CTS2012, Bulgaria
Richardson, M. and Wallace, S., 2012. Getting started with raspberry PI. “O’Reilly Media, Inc.”.Ismail,
R., Omar, Z. and Suaibun, S., 2016, October. Obstacle-avoiding robot with IR and PIR motion sensors. In IOP Conference Series: Materials Science and Engineering (Vol. 152, No. 1, p. 012064). IOP Publishing.
Upton, E. and Halfacree, G., 2014. Raspberry Pi user guide. John Wiley & Sons.