• Abstract:

Penalty kick procedure is one of the most challenging tasks in the robotic soccer games. This study was aimed to solve the problem of penalty kick goalkeeping for RoboCup Small Size soccer robots. Two different approaches were presented and compared to each other. The first approach was a simple hard-coded algorithm and the second one was based on reinforcement learning. In reinforcement learning (RL) in addition to the common reward function, a novel rewarding function was applied based on epoch value. The results extracting from both simulation and real experiments showed that the RL approaches were more successful in solving the problem in comparison with the hard-coded algorithm. Moreover, in the RL approach, the epoch based reward function was more suitable compared to the common reward function to solve the problem. In conclusion, RL based approaches with the epoch based reward function can be a proper choice for the problem compare to the hard-coded methods.

The full paper is available Here.

The goals of this project were to design and build the electronic circuit, low-level control, generate an obstacle avoidance path, and motion control of an omnidirectional mobile robot in the presence of moving obstacles with a novel method based on the probability of the obstacles position in the future. This project was implemented using the ROS framework on “Parsian Robotics Center” Small Size Soccer Robots.

Parsian has been using an ERRT algorithm for years that is mostly used in real-time approaches. In order to decrease the number of collisions and also minimize the travel time, a new approach for obstacle avoidance has been developed. This method does not intend to change ERRT implementation or propose a new way to avoid obstacles; its rather about how to define the obstacles space. This method is based on opponent robots capabilities:

1. Maximum Acceleration

2. Maximum Velocity

3. Agility Factor (Agility Factor represents by how many degrees, the movement direction of a robot can change, during a specified time in its maximum velocity.)

4. Current Velocity

A probability area can be chosen for a certain upcoming time interval. If the probability area for opponent robots and future position of our robot overlaps, then the obstacle avoidance try to avoid that common space.

Here is a video of how it works.

All of the models and controllers are simulated in the Matlab.

Here is a short video of this project.

Robot Operating System (ROS) is a collection of software frameworks for robot software development. ROS provides services designed for heterogeneous computer clusters such as hardware abstraction, low-level device control, implementation of commonly used functionality, message passing between processes, and package management. Running sets of ROS-based processes are represented in a graph architecture, where processing takes place in nodes. Despite the importance of reactivity and low latency in robot control, ROS itself, is not a real-time OS (RTOS), though it is possible to integrate ROS with real-time code. There are three types of software In the ROS ecosystem:

1. Language and platform-independent tools
2. ROS client library such as ROSCPP, ROSPY, ROSJAVA, etc.
3. Packages containing application-related code by using ROS client libraries

We used ROS as the main framework of a robotic soccer team “Parsian”. 

In this project the control and AI nodes are written in C++ using ROSCPP. GUI, test nodes and tools like profilers are implemented with python scripts (ROSPY).

  • Architecture


Packages are the first-level directory that separate source codes; so to implement a package for the first time, debug, upgrade or even re-factor it, only that particular package and its dependencies need to be changed.

First-level dependencies of Parsian packages to ROS packages are shown in the figure below.


Each package has a number of nodes inside, which are actually executable files. Graph of nodes that run a game with one agent and AI is illustrated in figure below. Nodes can be implemented with different languages and environments. They are executed separately, so when one node freezes or crashes, other ones still execute without any problem.


The most important part of designing a distributed service, is defining the messages that are going to be passed between nodes. This project tries to use pre-defined ROS messages as much as possible, to make it easier for integration with currently implemented services and nodes. You can find Parsian messages, in its repository: https://github.com/ParsianRoboticLab/parsian_msgs

In the purpose of velocity control, a Fuzzy-PID controller has been implemented. In fact, the proportional, integral and derivate (KP, KI, KD) gains of the PID controller are adjusted according to the FUZZY Logic.
The major problem of applying the common PID to BLDC motors is the non-linear characteristics of the motor which are generally difficult to be modelled precisely. Hence, with tuned static PID gains, the controller is not able to achieve the desired control specifications under different motor velocities and disturbances. On the other hand, by applying a self-tuned Fuzzy-PID, dynamic PID gains are achieved, and the controller can get the desired control specifications in the presence of disturbance, and at different velocities.
The inputs of the Fuzzy-PID controller are the velocity error (the difference between the current speed and the desired speed), the derivative of the velocity error, and the current velocity of the motor. The amount of the error indicates how fast the controller should compensate the error, the derivative of the error is an indication of how the error is going to change, and the current speed is also chosen due to the nonlinear characteristics of the motor.
Each input’s “universe of discourse” is divided into five overlapping fuzzy sets {Negative Large, Negative Small, Zero, Positive Small, Positive Large} with triangular membership functions.
The motor and its driving system were connected to MATLAB software by serial communication. Experiments were conducted on the motors under different condition of errors, derivative of errors and instant motor speeds and at each condition, the parameters of the PID controller were tuned by the MATLAB with respect to the pre-defined rise time, settling time, and overshoot. Then the results were used to make the rule table for fuzzy logic. Due to the importance of computational complexity on the FPGA, the Takagi-Sugeno Deffuzification algorithm was implemented.
The self-tuning Fuzzy-PID controller has a relatively uniform and better performance in transient and steady state response, better dynamic response curve, smaller steady-state error, smaller overshoot, shorter response time, and higher steady precision no matter how large the load disturbance is. The structure of the controller is shown in the figure below.

In order to achieve perfect motion control, a new learning-based method has been implemented which fixes open-loop motion errors. In polar coordinates, the robots’ movement is expressed as direction angle (θ), velocity (V) and angular velocity (ω). In this method, two offsets have been added to θ and ω; linear velocity is accurate enough and remains without offset. At first, a PSO method was implemented with a complicated cost function to optimize multiple variables simultaneously; but after reviewing the results, it was realized that these two parameters (θ and ω) are almost independent, and a simple method can be employed separately, for each parameter.
One efficient method that can be utilized to optimize a parameter, is Error Back Propagation. It’s mainly used in finding weights of neural networks. The result of this method was satisfying; one instant is depicted in the figure below.