In this chapter, you can learn what a robot actually is and where this term came from. We did our best to define a robot as an autonomous machine that exists in a physical world, can sense its environment, and can act on it to achieve some goals.

We also went through a brief history of the field of robotics and discovered that many interesting machines were built prior to the era of real robots(from our definition). Later on, we discussed the basic building blocks of a robot, that is effectors, sensors, and controllers, which can be combined in numerous ways.

In this chapter, you can learn about how to simulate a custom robot called Chefbot in detail. We discussed the design of the robot in the previous chapter. After the robot design, we moved on to simulate the robot in a virtual environment to test design of the robot, and check whether it meeting our specification. In this chapter, we can learn about simulation and various simulators using in industries, research and education in detail.

After that we can see how the ROS framework and Gazebo simulator was used to perform the simulation. We can see examples using ROS and Python. We can see how to install Turtlebot stack in ROS Indigo and how to reuse the turtlebot code for Chefbot.

Finally we are simulating the robot and performing gmapping and autonomous navigation in a hotel environment.

In this chapter we can seen some robotic sensors which are using in this robot. The sensors we are discussing are Ultrasonic distance sensors, IR proximity sensors, and IMU's. These three sensors help in the navigation of the robot.

We can also see the basic code to interface these sensors to Tiva C Launchpad.

The main aim of this chapter is to discuss about speech recognition and synthesis and how we can implement it on Chefbot. By adding speech functionalities in our robot, we can make the robot more interactive than before.

We can discuss what are the processes involved in the speech recognition and synthesis process and can see the block diagram of these processes and the functions of each block. After discussing the blocks, we will see some interesting speech recognition frameworks (such as Sphinx/Pocket Sphinx, Julius, and Windows Speech SDK and synthesis libraries such as eSpeak and Festival). After discussing about these libraries, we will discussed and work with the Python interfaces of each library.

Towards the end of this chapter, we will implement ROS packages that perform speech recognition and synthesis functionalities.

In this chapter, we can see how to add Artificial Intelligence to Chefbot in order to interact with people. This function is an add-on to Chefbot to increase the interactivity of the robot. We are using simple AI techniques such as pattern matching and searching in Chefbot. The pattern datasets are stored in special type of files called AIML. The Python interpreter module is called PyAIML.

We will use this to decode AIML files. The user can store the pattern data in an AIML format and PyAIML can interpret this pattern. This method is similar to a stimulus-response system. The user has to give a stimulus in the form of text data, and from the AIML pattern, the module will find the appropriate reply for the user input.

We will see the entire communication system of the robot and how the robot communicates with people. It includes speech recognition and synthesis along with AI.

We have discussed about speech processing in the previous chapter. We also saw useful tags used in AIML and the PyAIML installation, its working, and some examples. Finally, we will implement the entire code in ROS along with speech recognition and synthesis units.

In this chapter, we are discussing to create a GUI for ChefBot that can be used by an ordinary user who doesn't have any idea about the internal working of a robot. We used Python binding of Qt called PyQt to create this GUI. Before we go to the main GUI design, we will see a "Hello World" application to get an easier understanding of PyQt.

The UI design was done using the Qt Designer tool and the UI file was converted into its equivalent Python script using Python UI compiler. After designing the main GUI in Qt Designer, we will convert the UI file into Python script and inserted necessary slots in the generated script.

The ChefBot GUI can start the robot, select a table number, and command the robot to get into that position. The position of each table are getting from the generated map we hard coded the positions in this Python script for testing.

When a table is selected, we set a goal position on the map, and when we click on the Go button, the robot will move into the goal position. The user can cancel the operation at any time and command the robot to come to the home position. The GUI can also receive the real-time status of the robot and its battery status. After discussing the robot GUI, we saw the debugging GUI tool in ROS, called rqt. We will see some plugins used for debugging the data from the robot.