Program： Map creation and automatic navigation with myAGV
Equipment：
1 myAGV：
myAGV is an autonomous navigation smart vehicle from Elephant Robotics. It uses the competition-level Mecanum wheels and a full wrap design with a metal frame. There are two built-in slam algorithms to meet the learning of mapping and navigation directions.

2 PC：
A normal computer.

The autonomous robot positioning and navigation technology include two parts: position&map creation (SLAM), and path planning&motion control. SLAM only completes the robot's positioning and map creation.

The main solution for implementing localization and navigation technology is SLAM, path planning, and motion control.

The process that a robot describes the environment and recognizes the environment mainly depends on the map. It uses environmental maps to describe its current environmental information and adopts different forms of map descriptions with the algorithm and sensor differences used.
We use the gmapping algorithm in the SLAM algorithm. The gmapping algorithm builds the map based on the raster map.
Gmapping：
Gmapping is a SLAM algorithm based on 2D LiDAR using RBPF (Rao-Blackwellized Particle Filters) algorithm to complete 2D raster map construction. 
 Advantages:
gmapping can build indoor environment maps in real-time, with less computation in small scenes and higher map accuracy, and requires less LIDAR scanning frequency. 
 Disadvantages:
As the environment grows larger, the memory and computation required to build the map become huge, so gmapping is unsuitable for large scene composition. An intuitive feeling is that for a range of 200x200 meters, if the raster resolution is 5cm and each raster occupies one byte of memory, then each particle carries 16M of RAM for the map, and if it is 100 particles, it is 1.6G of RAM.
Raster Map：
The most common way for robots to describe the environment is Grid Map or Occupancy Map, which divides the environment into a series of grids, where each grid is given a possible value indicating the probability that the grid will be occupied.

Start the project:
Because myAGV has a built-in Raspberry Pi computer, controlling myAGV requires leaving the keyboard and mouse, and monitor, so a computer is needed to control myAGV's computer. We use the VNC remote control.
VNC:
VNC (Virtual Network Console) stands for Virtual Network Console. It is an excellent remote control tool software developed by the famous AT&T's European research labs.VNC is a free open source software based on UNIX and Linux operating systems with powerful remote control capabilities, efficient and practical, and its performance is comparable to any remote control software in Windows and MAC. 

Place the myAGV on a horizontal surface.

The launch file will start the odometer and IMU sensor of myAGV.
Enter the command in the terminal

roslaunch myagv_odometry myagv_active.launch

After turning on the odometer and IMU sensors, we then turn on the radar and gmapping algorithms to start the map creation.
Enter the command in the terminal:

roslaunch myagv_navigation myagv_slam_laser.launch

This is the page we just started, then we move myAGV and we can draw the map out. To control myAGV movement, Elephant Robotics gives us keyboard control.

Saved the map.
Enter the command in the terminal

rosrun map_server map_saver

The next step is to make myAGV able to navigate automatically on the map, where myAGV can avoid obstacles to its destination (navigation) automatically by clicking on it.
First, we load the map and modify the path into our startup file.
Path planning + motion control:
Movement planning is a big concept. For example, the movement of robotic arms, the flight of vehicles, and the path planning of myAGVs we are talking about here, all are in motion planning.
Let's talk about motion planning for these types of wheeled robots. The basic capability required here is path planning, that is, the ability to perform what is generally called target point navigation after completing SLAM. In short, it means planning a path from point A to point B, and then make the robot move over it.

1. Global Planning.
To achieve this process, motion planning has to implement at least two levels of modules, and one is called global planning, which is a bit like our car navigator. It needs to pre-plan a route on the map and also the current robot's position. This is provided by our SLAM system. The industry typically uses an algorithm called A* to implement this process, which is a heuristic search algorithm that is excellent. It is mostly used in games, such as real-time strategy games like Starcraft and Warcraft, which use this algorithm to calculate the movement trajectory of units.

2. Partial Planning
Of course, just planning the path is not enough. There are many unexpected situations in reality. For example, a small child is in the way, so the original path needs to be adjusted. Of course, sometimes, this adjustment does not require a recalculation of the global path, and the robot may be able to make a slight detour. In this case, we need another level of planning called local planning. It may not know where the robot will end up, but it is particularly good at getting around the obstacles in front of it.
Next, we start the program and open the saved maps and the autopilot function.
Enter the command in the terminal

roslaunch myagv_navigation navigation_active.launch

Use keyboard control to make myAGV rotate in place for positioning. After the positioning is completed and the point cloud converges, proceed to the next navigation step.

Click "2D Nav Goal" on the top, click the point on the map you want to reach, and myAGV will set off towards the target point. You can also see a planned path of myAGV between the starting point and the target point in RVIZ, and myAGV will move along the route to the target point.

This is the end of the project
Summary:
The navigation demonstrated at present is only a relatively basic situation. There are many mobile robots on the market, such as sweeping robots. It needs to plan paths according to different environments, which is more complicated. For the problem of path planning in different environments, there is a unique called space coverage, which also proposes a lot of algorithms and theories.
There is still a lot of work to be done to navigate the SLAM algorithm in the future.
If you have good ideas to express welcome to discuss with us in the comments below ~
About Elephantrobotics:
Home
GitHub
Gitbook for myAGV

Introduction

Our theme is to break the distance limit of the collaborative robotic arm and connect it with the mobile robot (myAGV) to realize a case.
The two devices we are going to use today are:
1 mechArm 270-M5Stack:
mechArm 270-M5Stack is the most compact six-axis robotic arm with an industrial-like configuration launched by Elephant Robotics. It's tough but reliable for its centrosymmetric structure, and its effectiveness enables users to increase programming efficiency with reliability.

2 myAGV:
myAGV is the first mobile robot of Elephant Robotics. It adopts competition-grade Mecanum wheels and fully wraps the metal frame. The ROS development platform has two built-in slam algorithms ta o meet the learning of mapping and navigation directions. It provides rich expansion interfaces and can be equipped with robotic arms(myCobot280,mechArm270,myPalletizer260).

Case

What we want to achieve today is the case of the combination of mechArm270-M5Stack and myAGV as a compound robot by controlling the myAGV to move to the designated position and then controlling the mechArm270 M5Stack to grab the wooden block myAGV and move it to the designated position.

Demo

Connection

To bring two robots together, they must first be connected. There are two ways to establish the connection:
● Wireless connection (TCP/IP)
Let myAGV establish contact through the IP address of the mechArm 270-M5Stack. First, set them in the same WiFi network environment, and obtain the IP address of the mechArm 270 M5Stack. When the team designed the M5Stack Basic, Elephant Robot designed the function of displaying the IP address, which can quickly obtain the IP address. (Port defaults to 9000)

Briefly introduce the socket method: a function used to establish communication in python, which can send information to each other.
The elephant robot has an open source library, pymycobot, which encapsulates a MyCobotSocket() method, similar to the socket method, to send instructions to the robotic arm.
Code:

from pymycobot import MyCobotSocket
# MyCobotSocket(ip,port) port defaults to 9000
mc = MyCobotSocket("192.168.10.22","9000")

#After the normal connection, you can send commands to the robot arm, such as returning the robot arm to the origin.
mc.send_angles([0,0,0,0,0,0],20)
#Get the angle information of the current robotic arm.
res = mc.get_angles()
print(res)

● Wired connection
The wired connection is relatively easy. Plug in a type-C data cable to connect to myAGV, then we can control the robotic arm.
Note: After connecting, because of the rules of Ubuntu system, we need to grant permissions to the robotic arm's serial port to operate normally. Type in the terminal

sudo chmod 777 /dev/tty***(***refers to the serial port number of the robotic arm)

Control

Let myAGV move
Once connected, we can start controlling this compound robot.
In the movement of myAGV, the elephant robotics provides two control methods: keyboard control and PS2 handler control.
The ros language controls it. (below is how to do it)
Keyboard control:
Start Node：
Enter the command in the terminal.

roslaunch myagv_odometry myagv_active.launch

Open the keyboard control interface
Enter the command in the terminal.

roslaunch myagv_teleop myagv_teleop.launch

Press the corresponding button on the keyboard to make myAGV move.
myAGV uses a Mecanum wheel that can move in all directions and an IMU for positioning compensation. It can be turned around on the spot, and the control is very easy.
PS2 handler control:
The first step is to start the node, and the second control program is to open the PS2 handler.
Enter the command in the terminal.

roslaunch myagv_ps2 myagv_ps2.launch

After running, can freely control myAGV through the PS2 handler.
Implementation of the case
Grab the block with the robotic arm and put it into the corresponding bucket.
Combining the control of the mobile robot and the control of the robotic arm, this project can be realized.
First, start the mobile control of myAGV with either keyboard control or PS2 handler control. I choose PS2 handler control here. Move the robotic arm in front of the small piece of wood, send code to mechArm to control its movement, and control the gripper to grab the piece of wood. It is placed in the corresponding location.
Code for mechArm:

from pymycobot import MyCobotSocket

mc = MyCobotSocket("192.168.10.22","9000")

mc.send_angles([0,0,0,0,0,0],50)
time.sleep(2)
mc.send_angles([1.75,58.53,29.44,4.92,(-77.69),5.09],50)
time.sleep(2)
mc.send_angles([1.75,76.02,(-25.31),12.3,(-61.61),(-2.81)],50)
time.sleep(2)
mc.set_gripper_state(0, 80)
time.sleep(1)
mc.set_gripper_value(50,80)
time.sleep(1)
mc.send_angles([2.37,(-2.1),(-9.66),9.66,68.64,(-33.13)],50)
time.sleep(2)
mc.send_angles([2.81,48.77,(-10.1),2.63,(-55.72),(-30.32)],50)
time.sleep(1)
mc.set_gripper_state(0, 80)

Summary

I don't know what you think about this case, if you have any ideas or opinions, please leave a message below! I'll take interesting suggestions to try!
More information:
Home | Elephantrobotics
Gitbook | Elephantrobotics
GitHub| Open-Source

Thank you for your support, what problems occur during the use, or if you want to ask for opinions, please let us trust us. We are happy to receive such feedback.

We offer a wide range of adapters, grippers, and suction pumps.
Different scenarios use corresponding adapters.

if you want to learn more about the adapters, click here.

myCobot 320 M5Stack is an upgraded product of the myCobot series, a preferred choice for individual makers and researchers.
It supports secondary development according to users' needs and achieves personalized customization. myCobot 320 is very cost-effective with safety, practicability, and efficiency.

Here we are going to review the myCobot320 and see what is different after upgrading.

Appearance

The material is made of photosensitive resin in 3D, and the equipment details are more precise. The exterior is treated with a special process, giving myCobot 320 a new look. And the unique black color design makes myCobot 320 look very powerful.

Hardware

The configuration and performance have also been greatly improved as shown in the table below.

Software

It still supports the development of major mainstream programming languages and platforms, such as Python, ROS, ROS2, C++, and Arduino. The most crucial thing in this upgrade is the vast improvement in the internal algorithm of the robotic arm and the communication speed.
● The original robotic arm would shake during operation, but this problem has been solved through the optimization of the algorithm, and now the operation is smoother.
● Serial communication efficiency has been dramatically improved from 100ms per transmission to 20ms per transmission, which helps the user save a lot of time when developing.

Summary

This upgrade meets more users' needs and optimizes the user's experience when operating the myCobot 320. The multi-interface design is convenient for users to carry out secondary development. The joint motor speed and current reading interface help users develop more possibilities in robotic projects. myCobot 320 is an excellent choice for individual developers who are new to robotics and want to create prototypes for personal or industrial use.

Video demo

https://www.youtube.com/watch?v=5hFusQbYgkY

If you have a myCobot 320, what project will you achieve? Welcome to leave a message below, we will adopt some interesting and novel ideas to try to develop!
Details for myCobot320
Elephant robotics

At present, myAGV only supports the development of ROS for the time being. In the future, our team will migrate myAGV to ROS2 and look forward to it!

@jacobhub said in The highest cost-performance mobile robotic platform for individual developers.:

Can it support ROS2？

Thank you for your approval！
1 The maximum weight of a robotic arm is 1kg. The trolley can actually bear more weight, but it is not recommended to use it with more weight, as the motor cannot bear it.
2 Yes, the myAGV has an IMU to compensate for that for localization.

@kehu said in The highest cost-performance mobile robotic platform for individual developers.:

Looks very nice. A couple of questions:

• Your website says that the payload is 2000g – is that a typo? 2kg payload is not a lot and the arm that you show mounted on it looks like it might weigh a lot more than that.

• Omni-directional wheels have notoriously poor odometry. Does the robot have an IMU that is used to compensate for that for localization?

1. Introduction
myAGV is the first mobile robot of Elephant Robotics. It uses the competition-level Mecanum wheels and a full wrap design with a metal frame. There are two built-in slam algorithms to meet the learning of mapping and navigation directions. It provides multiple interfaces and can be equipped with different robotic arms to become a compound robot to achieve more applications.

1.1 Mecanum Wheel:
The installation of the Mecanum wheel enables myAGV to perform the all-direction moving, which can save a lot of unnecessary paths when moving towards the destination and move more flexibly for a massive range of motion.
1.2 Detachable
The fully wrapped design with a metal frame makes the myAGV more compact and tough. The built-in Raspberry Pi 4B and split structure make the robot can be disassembled independently, and users can design and create a DIY robot.

2. Functions
2.1 Mapping
SLAM mapping is required in the use of myAGV because the core of the mobile robot to achieve autonomous walking is to achieve autonomous positioning and navigation. In independent positioning and navigation technology, problems such as positioning, mapping, and path planning will be involved. The quality of the map construction will directly affect the walking path of myAGV. If myAGV wants to reach a specific destination, it must draw a map like humans. The process of describing the environment and understanding the environment relies on the map. The two mapping algorithms used by the myAGV are introduced below.
2.1.1 Gmapping algorithm
Gmapping is an efficient particle filter. It is a SLAM algorithm based on 2D lidar using the RBPF (Rao-Blackwellized Particle Filters) algorithm to complete the construction of a two-dimensional grid map. Gmapping can build indoor maps in real-time, requiring less computation and higher accuracy in making small scene maps.
RUN：
First, place the mobile robot at an appropriate starting point in the environment where the map needs to be built because opening the launch file will open the IMU sensor and Odom odometer, and artificially moving it will cause the mobile robot to be distorted. First open the SLAM Scan file,
Run the command:

cd myagv_ros
source ./devel/setup.bash
roslaunch myagv_odometry myagv_active.launch

Then open the gmapping mapping file, and control the myAGV to move in the required space.
Run the command:

roslaunch myagv_navigation myagv_slam_laser.launch

Save the map when you see that the required space is created in the image
Run the command to save the created map:

rosrun map_server map_saver

2.1.2 Cartographer algorithm
Cartographer is a set of SLAM algorithms based on graph optimization.
The cartographer algorithm mainly uses the concept of Submap. Whenever the data of a laser Scan is obtained, it is matched with the currently recently established Submap so that the laser Scan data of this frame is inserted into the optimal position on it. The Submap is also updated while inserting new data frames. A certain amount of data is combined into a Submap, if there is no new Scans are inserted into the Submap, it is considered that the Submap has been created, and then the next Submap will be created. The specific process is as follows.

All created Submaps and the current laser Scan will be used for Scan matching for loopback detection. Loopback detection is performed if the recent Scan and all created Submaps are close enough in the distance. After the loopback detection is completed, the map construction is completed, too.
The process of building a map with the cartographer algorithm is the same as the process of building a map with the Gmapping algorithm. First, open the ridar and the cartographer algorithm file to control the myAGV to walk in the area built to complete the map.

Some people may doubt why introducing two algorithms for building a map.
Let's compare the two algorithms to solve this doubt.
Gmapping can build indoor maps in real-time, requiring less computation and higher accuracy in building small scene maps. Compared with Cartographer when building a small scene map, Gmapping does not require too many particles and has no loopback detection, so the amount of calculation is less than that of Cartographer, and the accuracy is not much worse. When building a small scene map, compared with Cartographer, Gmapping is not only fast but also can build high-precision maps, and the number of particles required for Gmapping to expand the map can easily burst the memory. The latter can solve the problem of map expansion, and the effect of mapping can be excellent (the above picture is in the same terrain).

2.2 Map Navigation
In the map we built in the previous step, the robot can automatically navigate to a certain destination on the map. This all stems from the navigation function package of ROS.

move_base in navigation:
global planner：
The overall path planning is carried out according to the given target position.
In the navigation of ROS, the global route of the robot to the target position is calculated first through international path planning. The Navfn package implements this function. Through Dijkstra's optimal path algorithm, Navfn calculates the minimum cost path on the cost map as the robot's global route.
local planner：
Plan the avoidance route based on nearby obstacles.
Local real-time planning is implemented using the base_local_planner package. This package uses the Trajectory Rollout and Dynamic-Window approaches algorithms to calculate the speed and angle (dx, dy, dtheta velocities) the robot should travel during each cycle.
The base_local_planner package uses map data to search for multiple paths to the target through algorithms, uses some evaluation criteria (whether it will hit an obstacle, the time required, etc.) to select the optimal path, and calculate the required real-time speed and angle.
Next, we will introduce the process of our reproduction:
In the beginning, we had to determine the location of myAGV and used ACML in ROSto locate it. (Find the location of myAGV on the map)

After a few laps in place to complete the positioning, we can start automatic navigation.

When we click "2D Nav Goal" and then click the point we want to reach on the map, myAGV will start towards the target point, and we can also see in RVIZ that there is a planned path for myAGV between the starting point and the target point, it will move along the route to the target point.
2.3 PS2 handler control
As a mobile robot, wireless control is essential.
We developed the ps2 handler to control myAGV so that myAGV can move freely and realize more possibilities.
The following is the sequence diagram of our handle control. Maybe it can provide some ideas for you to do more development on the handle.

3 Summary
What would you do if you had a mobile robot like this? What kind of myAGV can you refit it into in its split-structure detachable mobile robot? Is it to add some weapons to the mobile robot as a combat vehicle or to refit it to carry a variety of machines full of the future sense?
Thank you for watching. Please comment if you have any good ideas!
The above is our initial introduction to myAGV, and the follow-up will introduce myAGV equipped with different robotic arms, including the myCobot, myPalletizer, and mechArm.
If you own an M5Stack, how would you combine it with myAGV?

This looks like a good suggestion.

Question:
The main content of this post is that the robotic arm starts RVIZ in the ROS environment, which will cause the system to freeze, affecting the program's crash. Is there any way to improve the stability of RVIZ and enable it to operate normally?
Operation:
I run the program with two versions of myCobot280 series robotic arm. One is the robotic arm with M5Stack master control, and another is the robotic arm with Raspberry Pi 4B master control.
The M5Stack's robotic arm runs in a laptop configuration, and the Raspberry Pi's robotic arm runs in its own Raspberry Pi 4B (64-bit 1.5GHz quad-core).

Figure is myCobot280-M5Stack

Figure is myCobot280-Pi
Here are a few ways to use myCobot280 with RVIZ.
Slider Control：
Move the slider to control the movement of myCobot280, and the movement of myCobot280 will be fed into the RVIZ interface in real time.

Movement Planning：
Given two positions, one is position A, and the other is position B, send commands to the myCobot280 to move from A to B.

Artificial Intelligence Kit：
Guide the robot through robot vision and realize intelligent grabbing simultaneously. The intellectual grabbing of wood blocks and the intelligent grabbing of image objects have been developed.


Problems
1: After the myCobot280 generally runs for a while, the machine heats up, and the RVIZ cannot run normally.
2: On the Raspberry Pi version, after opening the RVIZ, I found that the computer's CPU was instantly occupied and could not run stably.
Try to solve

1. At first, I thought that the file (URDF) of the built model was too large, which made RVIZ freeze. We optimized the model file (URDF) and found little improvement.
   Reflections：
   1: It is relatively stable to run programs with a small amount of code, so is it possible to optimize the code to improve the stability of RVIZ? We are currently trying to migrate its adaptation environment from ROS1 to ROS2 to see if the whole will be more stable.
   2: When the RVIZ is turned on, the CPU is full. We try to start with the CPU to see if we can improve the performance of the CPU processing to be more stable.
2. After I modified the CPU processing capability of the virtual machine, it was much more stable when I used it again. You may think that Raspberry Pi is a computer. How to upgrade the CPU? Is it going to have to change the motherboard? We use a socket method to connect to the Raspberry Pi (like a TCP/IP connection) to solve this problem.
   Socket function:
   The principle of the socket method is to use its virtual machine to establish a connection with myCobot280-Pi (remote control), and the virtual machine sends instructions to myCobot280-Pi instead of sending instructions to the robotic arm in its Pi motherboard. This solves the problem of low CPU performance.
   code:

def get_logger(name):
    logger = logging.getLogger(name)
    logger.setLevel(logging.DEBUG)

    LOG_FORMAT = "%(asctime)s - %(levelname)s - %(message)s"
    #DATE_FORMAT = "%m/%d/%Y %H:%M:%S %p"

    formatter = logging.Formatter(LOG_FORMAT)
    # console = logging.StreamHandler()
    # console.setFormatter(formatter)

    save = logging.handlers.RotatingFileHandler(
        "/home/ubuntu/mycobot_server.log", maxBytes=10485760, backupCount=1)
    save.setFormatter(formatter)

    logger.addHandler(save)
    # logger.addHandler(console)
    return logger


class MycobotServer(object):

    def __init__(self, host, port):
        try:
            GPIO.setwarnings(False)
        except:
            pass
        self.logger = get_logger("AS")
        self.mc = None
        self.s = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
        self.s.bind((host, port))
        print "Binding succeeded!"
        self.s.listen(1)
        self.connect()

    def connect(self):
        while True:
            try:
                print "waiting connect!------------------"
                conn, addr = self.s.accept()
                port_baud = []
                while True:
                    try:
                        print "waiting data--------"
                        data = conn.recv(1024)
                        command = data.decode('utf-8')
                        if data.decode('utf-8') == "":
                            print("close disconnect!")
                            break
                        res = b'1'
                        command = command.replace(" ", "")
                        if len(port_baud) < 3:

                            port_baud.append(command)
                            if len(port_baud) == 3:
                                self.mc = serial.Serial(
                                    port_baud[0], port_baud[1], timeout=float(port_baud[1]))
                                port_baud.append(1)
                        else:
                            self.logger.info(command)
                            command = self.re_data_2(command)
                            if command[3] == 170:
                                if command[4] == 0:
                                    GPIO.setmode(GPIO.BCM)
                                else:
                                    GPIO.setmode(GPIO.BOARD)
                            elif command[3] == 171:
                                if command[5]:
                                    GPIO.setup(command[4], GPIO.OUT)
                                else:
                                    GPIO.setup(command[4], GPIO.IN)

                            elif command[3] == 172:
                                GPIO.output(command[4], command[5])

                            elif command[3] == 173:
                                res = bytes(GPIO.input(command[4]))

                            self.write(command)
                            res = self.read()
                            if res == None:
                                res = b'1'
                        conn.sendall(res)
                    except Exception as e:
                        self.logger.error(str(e))
                        conn.sendall(str.encode("ERROR:"+str(e)))
                        break
            except Exception as e:
                self.logger.error(str(e))
                conn.close()

    def write(self, command):
        self.mc.write(command)
        self.mc.flush()
        time.sleep(0.05)

    def read(self):
        data = None
        if self.mc.inWaiting() > 0:
            data = self.mc.read(self.mc.inWaiting())
        return data

    def re_data_2(self, command):
        r2 = re.compile(r'[[](.*?)[]]')
        data_str = re.findall(r2, command)[0]
        data_list = data_str.split(",")
        data_list = [int(i) for i in data_list]
        return data_list

（The essence of the socket approach is to use a virtual machine to connect to the Raspberry Pi, and we then boost the CPU processing power of the virtual machine.）
Discuss:
For now, our solution for RVIZ is just this. I am wondering whether there is a better way to handle your RVIZ related issues. Everyone is welcome to discuss, and I will learn from your opinions and put them into practice.