#01_06 Autonomous Firefighter Robot
Posted by Superadmin on November 28 2018 04:34:04

Autonomous Firefighter Robot

 

Robot development is one of the big challenges in science and technology. It involves multidisciplinary fields of science and technology. In this chapter, we'll learn and explore how to build an autonomous robot for firefighting, starting with exploring robot platforms and then extending robot capabilities to address firefighting.

We'll learn the following topics:

Let's explore!

 

Introducing autonomous firefighter robots

 

An autonomous robot is one that has its own decision-making capacity to perform tasks such as moving, stopping, pressing a button, or some other specific purpose. Autonomous robots consist of artificial intelligence programs to perform decision computing. Researchers are interested in building a new model for autonomous robots. The more general we make an autonomous robot model, the more attention and effort goes in its development. However, autonomous robot development still needs a specific purpose so it can execute its goals.

An autonomous firefighter robot is one autonomous robot model with the specific purpose of finding and putting out fires. In this chapter, we'll learn and explore how to build an autonomous robot for firefighting.

A sample firefighter robot implementation is Thermite 3.0. This robot has a water sprinkler to extinguish fires. You can explore this robot on the official website, http://www.firefightrobot.com. This is what it looks like:



 

Exploring robot platforms

 

In this section, we'll explore various existing robot platforms that can be applied to build autonomous robots. We will review robot platforms with Arduino and Raspberry capabilities as the robot computing core.

 

Zumo robot for Arduino

 

Pololu are an electronics manufacturer and online retailer. They provide various robot platforms. You can see a list of robot platforms at https://www.pololu.com/category/2/robot-kits. Some robot platforms are available as robot kits without soldering. This means you can get your robot up and running without performing soldering on the kit. You can see a list of solder-less robot kits at https://www.pololu.com/category/4/robot-kits-without-soldering.

One robot kit you can make without soldering is the Zumo robot for Arduino. This kit enables your Arduino-based Arduino UNO model to be attached to the board. If you are interested in this robot kit, you can check it out on https://www.pololu.com/product/2510. The Zumo robot for Arduino can be seen here:



 

MiniQ Discovery Arduino robot kit

 

The MiniQ Discovery Arduino robot kit is a robotic platform that is ready to use. This kit is manufactured by DFRobot. They have made custom a Arduino board, called the Romeo board, to manage the robot. This board has a built-in motor driver to manage motor movement.

If you are interested in this kit, you can visit https://www.dfrobot.com/product-1144.html. You can see the MiniQ Discovery Arduino robot kit the following image. In this book, I will use this robot kit for my implementation.



 

Turtle kit - a 2WD DIY Arduino robotics kit for beginners

 

Another robot kit from DFRobot is Turtle kit. This robot uses the Romeo BLE board, which consists of an Arduino UNO model with a BLE module. The Romeo BLE board can be controlled from a smartphone through a BLE network.

You can see the Turtle kit in the following figure. Its website is https://www.dfrobot.com/product-1225.html.



 

GoPiGo robot

 

GoPiGo is a robot platform-based Raspberry Pi that is manufactured by Dexter industries. They provide a basic kit that you can bring your own Raspberry Pi to. It's called the GoPiGo robot Base Kit: https://www.dexterindustries.com/shop/gopigo3-robot-base-kit/. You can see its form here:



 

Detecting a fire source

 

One of requirements of building an autonomous firefighter robot is to find a fire's source. Fire-detection sensors are available for Arduino and Raspberry Pi. In this section, we'll explore fire-detection sensors.

 

Grove - flame sensor

 

If you have a Grove shield from SeeedStudio, we can use the Grove flame sensor to detect a fire. Technically, this sensor uses the YG1006 sensor with high photosensitivity. This sensor is easy to use on Arduino and Raspberry Pi. If you are interested, you can visit the website to obtain further information: https://www.seeedstudio.com/Grove-Flame-Sensor-p-1450.html. You can see the Grove flame sensor here:



 

SainSmart flame detection sensor module

 

If you don't have a Grove shield for a flame sensor, you can use any flame sensor module, for instance, the flame sensor module from SainSmart. This sensor module enables the Arduino and Raspberry Pi to be attached to the board. This sensor module is cheap, and you can find it at https://www.sainsmart.com/ir-infrared-flame-detection-sensor-module-detect-fire-flame-sensor-for-arduino.html. This is how it looks:



Basically, a flame sensor is cheap and you can find it on Aliexpress, Banggood, or another online store. A flame sensor usually has three or four pins: GND, VCC, A0, and D0. Some flame sensors have the A0 pin or D0 pin or both.

 

Demo - fire detection

 

In this section, we'll develop a simple application to detect fire. In this case, we need two modules: flame sensor and buzzer. We will implement this demo using an Arduino board.

Our scenario is to read a fire-detection value from the flame sensor. If the sensor reading reaches a certain value, Arduino will turn on a buzzer device to generate a sound.

In general, the buzzer device has three pins: GND, VCC and Signal. We can connect the buzzer device to PWM pins on the Arduino. You can see the buzzer device here:



Let's start to implement the hardware wiring. Use the following connections:

You can see the wiring diagram here:



For example, you can see my wiring implementation on the Arduino Leonardo here:



To access the buzzer device and generate sound, we can use the Tone object. You can learn more about it from https://www.arduino.cc/en/Reference/Tone.

The algorithm implementation is easy. Firstly, we open the Arduino software and write the following sketch program:

int flameSensor = A0; 
int buzzer = 9; 
int val = 0; 

void setup() { 
pinMode(buzzer,OUTPUT); 
Serial.begin(9600); 


void loop() { 
val = analogRead(flameSensor); 
if(val > 50) { 
Serial.print("Sensor Value = "); 
Serial.print(val); 
Serial.println(". Fire detected!!"); 

tone(buzzer,1000); 

else 
noTone(buzzer); 

delay(500); 



Save this sketch as ArduinoFireDetection.

Now you build and upload your sketch program to your Arduino board. After it's uploaded, you can open the Serial Monitor tool from Arduino to see the program output.

Try to move your sensor next to a flame so you can see the sensor value on the Serial Monitor tool. You can see a sample program output here:



How it works

This program initializes all required pins in the setup() function.

int flameSensor = A0; 
int buzzer = 9; 
int val = 0; 

void setup() { 
pinMode(buzzer,OUTPUT); 
Serial.begin(9600); 



In loop() function, we read the flame sensor value by calling the analogRead() function. In this case, we set the threshold value to 50. If the reading is greater than 50, we turn on our buzzer device by calling the tone() function:

void loop() { 
val = analogRead(flameSensor); 
if(val > 50) { 
Serial.print("Sensor Value = "); 
Serial.print(val); 
Serial.println(". Fire detected!!"); 

tone(buzzer,1000); 

else 
noTone(buzzer); 

delay(500); 



You can change the threshold value based on the results of your experiment.

 

Basic remote robot navigation

 

A robot can be controlled remotely through radio communication. We can use an RF module, Wi-Fi, or Bluetooth to communicate between robot and another system.

In this section, we'll try to control a robot from a computer using Bluetooth. In general, a communication model between a robot and a computer can be described as follows:



There are some radio and wireless modules that you can use to integrate with your robot to communicate with a computer.

For testing, I use the MiniQ Discover Arduino for robot platform from DFRobot: https://www.dfrobot.com/product-1144.html. Since this robot platform uses the Romeo board (Arduino compatible) as the core robot board, it supports an RF/wireless module-based XBee shield. You can check it out at https://www.dfrobot.com/product-844.html. This is what it looks like:



I use Bluno Bee (https://www.dfrobot.com/product-1073.html) from DFRobot for the RF module on the Romeo board. This module has a serial BLE network stack. You can attach it to the board and listen for incoming messages from serial pins. Bluno Bee has the same pin model as the XBee module. You can see it here:



Put the Bluno Bee module into the MiniQ Discover Arduino robot on the Romeo board. You also need another Bluno Bee that is attached to your computer through a micro-USB cable. You can see my implementation of the robot kit here:



Now we'll continue to develop a program to enable our robot to be controlled from a computer. Make sure you've turned off the robot. Using a micro-USB cable attached to the Romeo board, you can write a sketch program.

Open the Arduino software and write the following complete program:

//Standard PWM DC control 
int E1 = 5; //M1 Speed Control 
int E2 = 6; //M2 Speed Control 
int M1 = 4; //M1 Direction Control 
int M2 = 7; //M1 Direction Control 

void stop(void) //Stop 

Serial.println("stop"); 
digitalWrite(E1,LOW); 
digitalWrite(E2,LOW); 

void advance(char a,char b) //Move forward 

Serial.println("advance"); 
analogWrite (E1,a); //PWM Speed Control 
digitalWrite(M1,HIGH); 
analogWrite (E2,b); 
digitalWrite(M2,HIGH); 

void back_off (char a,char b) //Move backward 

Serial.println("back_off"); 
analogWrite (E1,a); 
digitalWrite(M1,LOW); 
analogWrite (E2,b); 
digitalWrite(M2,LOW); 

void turn_L (char a,char b) //Turn Left 

Serial.println("turn_L"); 
analogWrite (E1,a); 
digitalWrite(M1,LOW); 
analogWrite (E2,b); 
digitalWrite(M2,HIGH); 

void turn_R (char a,char b) //Turn Right 

Serial.println("turn_R"); 
analogWrite (E1,a); 
digitalWrite(M1,HIGH); 
analogWrite (E2,b); 
digitalWrite(M2,LOW); 

void setup(void) 

int i; 
for(i=4;i<=7;i++) 
pinMode(i, OUTPUT); 
Serial.begin(115200); //Set Baud Rate 
Serial.println("Run keyboard control"); 

Serial1.begin(115200); //Set Baud Rate 

void loop(void) 


if(Serial1.available()){ 
char val = Serial1.read(); 
if(val != -1) 

switch(val) 

case 'w'://Move Forward 
Serial.println("Move Forward"); 
advance (100,100); //move forward 
break; 
case 's'://Move Backward 
Serial.println("Move Backward"); 
back_off (100,100); //move back 
break; 
case 'a'://Turn Left 
Serial.println("Turn Left"); 
turn_L (100,100); 
break; 
case 'd'://Turn Right 
Serial.println("Turn Right"); 
turn_R (100,100); 
break; 
case 'z': 
Serial.println("Hello"); 
break; 
case 'x': 
stop(); 
break; 


else stop(); 




Save this sketch as ArduinoRobotDemo. Now you can build and upload it to the Romeo board.

Now your robot should switch to battery power. Your robot should be ready to receive a command from the computer.

Since one Bluno Bee module is connected to a computer, you can use any serial tool to send messages to Bluno Bee. I use CoolTerm (http://freeware.the-meiers.org) for testing.

Connect the CoolTerm application to the serial port of Bluno Bee. By default, it uses a baud rate of 115200. Based on our sketch program, you can use these keys to move the robot:

You can see my CoolTerm application output here:



 

Detecting obstacles

 

To move properly, our robot shouldn't be hindered by obstacles. A common solution to detect obstacles is to use an ultrasonic sensor. A sample sensor implementation is HC-SR04. You can get it from SparkFun: https://www.sparkfun.com/products/13959. You can see it here:



The HC-SR04 sensor has four pins: VCC (Power), Trig (Trigger), Echo (Receive), and GND (Ground), which are easy to connect to Arduino and Raspberry Pi.

Another sensor is the IR distance sensor. A sample sensor implementation is the Sharp GP2Y0A21 IR Distance Sensor, https://www.dfrobot.com/product-328.html, from DFRobot. Since I'm using the MiniQ Discovery Arduino robot, this sensor can be attached directly to the robot shield. You can see this here:



The GP2Y0A21 sensor has three pins: VCC, GND, and Signal. The Signal pin of GP2Y0A21 can be connected to analog pins from the Arduino board.

We can also scan obstacles around the robot. In this case, we need a servo motor and attach our sensor to the servo motor. You can get it from DFRobot on this site: https://www.dfrobot.com/product-255.html. You can also can see this kit here:



In general, a servo has three wires with the following pinout information:

You can connect a servo to Arduino through PWM pins.

To attach the Sharp GP2Y0A21 IR distance sensor to a servo motor, you need a mounting bracket like this product (https://www.dfrobot.com/product-127.html):



DFRobot also provides a complete kit, which consists of a Sharp GP2Y0A21 sensor, servo motor, and mounting bracket. You can check it out on https://www.dfrobot.com/product-715.html.

For this demo, we will wire it as follows:

After you've attached the sensor, mounting, and servo motor to the robot, you can start developing your sketch program. You can see my implementation here:



In the sketch program, we can access the servo motor using the Servo library. For further information on the Servo library, I recommend you read https://www.arduino.cc/en/Reference/Servo.

We will develop a sketch program to scan the obstacle distance around a robot. We'll move our sensor from 0 to 180 degrees through the servo motor.

Now you can open the Arduino software and write this sketch program:

#include <Servo.h> 

Servo servo; 
#define Svo_Pin 9 
#define GP2Y0A21 A0 

void setup() { 
servo.attach(Svo_Pin); 
Serial.begin(9600); 


void loop() { 
for (int i=0;i<180;i++) 

servo.write(i); 
uint16_t value = analogRead(GP2Y0A21); 
uint16_t range = get_gp2d12(value); 
Serial.print("Distance. Value: "); 
Serial.print(value); 
Serial.print(". Range: "); 
Serial.print(range); 
Serial.println(" mm"); 

delay(200); 

delay(2000); 


uint16_t get_gp2d12 (uint16_t value) { 
if (value < 10) value = 10; 
return ((67870.0 / (value - 3.0)) - 40.0); 



Save this sketch program as ArduinoDisctanceScanner.

Build and upload the program to your Arduino board. You can open the Serial Monitor tool from Arduino to see the following program output:



 

How it works

 

First, we declare our sensor and servo. Then, we initialize our setup() function.

#include <Servo.h> 

Servo servo; 
#define Svo_Pin 9 
#define GP2Y0A21 A0 

void setup() { 
servo.attach(Svo_Pin); 
Serial.begin(9600); 



In the loop() function, we move our servo from degree 0 to 180. On each degree change, we read a distance value from the sensor. Then, we calculate the distance by calling the get_gp2d12() function, defined in this sketch. Lastly, we print the resulting measurement to the serial port.

void loop() { 
for (int i=0;i<180;i++) 

servo.write(i); 
uint16_t value = analogRead(GP2Y0A21); 
uint16_t range = get_gp2d12(value); 
Serial.print("Distance. Value: "); 
Serial.print(value); 
Serial.print(". Range: "); 
Serial.print(range); 
Serial.println(" mm"); 

delay(200); 

delay(2000); 



To calculate a distance, we can refer to the datasheet. We'll implement the get_gp2d12() function to obtain a distance value:

uint16_t get_gp2d12 (uint16_t value) { 
if (value < 10) value = 10; 
return ((67870.0 / (value - 3.0)) - 40.0); 



 

Designing an autonomous robot

 

Designing and implementing an autonomous robot needs a lot of work. The biggest challenge of an autonomous robot is being movement and navigation and how to achieve objectives.

An autonomous robot runs on its own accord. This is challenging because we need to make our robot decide how it moves. From an artificial intelligence perspective, we can classify two models: supervised and unsupervised.

A supervised autonomous robot requires some objectives or guidelines to achieve its goals. On the other hand, an unsupervised autonomous robot can learn from its experiences and then make own decision based on certain conditions.

To build an autonomous robot for movement and navigation, we can design our algorithm as follows:



Before starting, a robot will initialize all parameters included for its sensors and motors. Then, we'll start by moving it in a random direction. While moving, the robot may detect an obstacle. If one is found, the robot will change direction.

In this scenario, we aren't defining the the goal of the autonomous robot. An example goal could be if it finds a star sign, the robot should stop and power off. You can define your own decisions and goals.

 

Building an autonomous firefighter robot

 

An autonomous firefighter robot is basically an autonomous robot with an objective of sprinkling water on a fire. To achieve this goal, the robot will move around to find a fire source. While moving, a robot should handle obstacle problems.

A sample design of an autonomous firefighter robot can be seen here:



The robot should have a water sprinkler module and fire and obstacle detection sensors. The robot platform can be based in Arduino, Raspberry Pi, or other MCU boards.

The idea of an autonomous robot for firefighting is similar in behavior to a common autonomous robot, but with additional features to detect fires and sprinkle water on them.

We can modify our autonomous robot design from the previous section for a firefighter robot scenario. You can see the modified design here:



We've added fire detection and water sprinkling to our algorithm. When the robot is moving, it should detect obstacles and fire. If it finds a fire, it should sprinkle water on it to put it out.

 

Summary

 

We learned about robot platforms in this chapter. Then, we learned about firefighter robots that move and detect a fire source and obstacles. Lastly, we design an autonomous robot for firefighting.

In the next chapter, we will explore multi-robot cooperation using swarm intelligence.