
# Industrial Robotics: From Programming to Configuring Robot Applications

In the world of industrial robotics, traditional programming methods have long been the norm. However, recent advancements in robot motion planning technology have transformed the way we interact with robot applications. Leveraging the power of motion planning, engineers can now shift from complex programming tasks to a more intuitive and efficient process of configuring robot applications. Let's explore how this transformation is revolutionizing the industrial robotics landscape.

*Streamlining Configuration*. Traditionally, programming industrial robots involved writing code specific to each robot and task. This process required expertise in a variety of robot programming languages, such as RAPID, Karel, UR Script, INFORM or KRL, and extensive testing to ensure precise movements. However, with the advencements in robot motion planning, engineers can now configure robot applications using intuitive interfaces in no time. These methods leverage 3D models of the robot environment for collisions avoidance, allowing the user to merely configure the start and end robot poses, and add limits on the gripper orientation or speed if the robot is carrying a heavy payload.

<FigureRight width={256} height={128} src="/images/blog/robot_computer.png" alt="Industrial Robot Arm Programming"></FigureRight>

*Fast and Efficient Planning*. With robot motion planning, engineers can define the desired motion of the robot and automatically generate optimized trajectories. Instead of spending days manually iterating over different velocity and acceleration profiles to reduce cycle times, this technology takes into account factors such as reachability, joint limits, and obstacles in the robot's environment to ensure safe and efficient motions, reducing the time and effort required for programming from days to hours.

*Flexibility and Adaptability*. With the traditional programming approach, making changes to robot tasks or adapting to new requirements often involved rewriting code and extensive reprogramming. Robotics programmers can spend days to repurpose a robot from one product line to another for machine tending or configuring additional pallet patterns in robot palletizing. However, by configuring robot applications through motion planning, engineers can easily modify robot applications and adapt to changing production needs. This flexibility enables quicker response times and seamless integration into dynamic manufacturing environments.

*Improved Productivity and Cost Savings*. By leveraging robot motion planning, industrial automation providers can significantly enhance productivity and reduce costs. The streamlined configuration process reduces development time, allowing for faster implementation of robotic solutions. Additionally, the intuitive programming interfaces and automation capabilities minimize the need for specialized programming expertise, reducing training requirements and associated costs.

The paradigm shift from programming industrial robots to configuring robot applications through motion planning marks a significant milestone in the evolution of industrial robotics. This transformation empowers engineers to streamline configuration processes, improve flexibility and adaptability, and ultimately drive productivity and cost savings. As the industrial robotics industry continues to advance, embracing motion planning technology will play a pivotal role in unlocking the full potential of automation.

Are you ready to give robot motion planning a shot? Try the Jacobi motion library [Here](https://account.jacobirobotics.com).


How robot motion planning is transforming industrial robot programming.

Industrial Robotics: From Programming to Configuring Robot Applications


# Fast, Smooth, and Reliable: How Robots are Becoming More Efficient with Motion Planning

Imagine you have a robot that bags your groceries at the supermarket. Let’s say it wants to load your favorite box of peanut butter cups from the grocery belt into your shopping bag. It needs to decide how to grasp the box and quickly put it into the bag while making sure to avoid hitting the cash register or anyone else nearby! This is exactly what motion planning is -  the process of finding an optimal path from an initial robot configuration (e.g., the current pose or state of the robot) to a goal robot configuration while avoiding obstacles.

<FigureRight width={256} height={128} src="/images/blog/robot_groceries.png" alt="Industrial Robot Arm Packing Groceries"></FigureRight>

In robotics today, two common approaches to motion planning are: sampling-based and optimization-based.

Sampling-based approaches generate random samples of robot configurations and only retain the ones that are not in collision with obstacles. This includes methods such as Probabilistic Roadmap ([PRM](https://ieeexplore.ieee.org/stamp/stamp.jsp?tp=&arnumber=508439)), Rapidly-exploring Random Graph ([RRG](https://arxiv.org/pdf/1105.1186.pdf)) and Rapidly-exploring Random Tree ([RRT](https://www.cs.csustan.edu/~xliang/Courses/CS4710-21S/Papers/06%20RRT.pdf)). In the supermarket robot example, we would remove any configurations colliding with a person or item from the set of valid configurations. Then, the motion planner connects neighboring configurations with collision-free segments and searches for a path from the initial configuration to the goal. The robot would then typically select the path with the shortest length and compute the motion time along the path (i.e., time parameterization), determined by the robot’s capabilities. Sampling-based methods can find a solution quickly and are often probabilistically complete (given enough time, they are guaranteed to find a solution if it exists), which are the main reasons they are used by many of the existing motion planning frameworks. However, the shortest length path doesn’t always correspond to the fastest path.

In contrast, optimization-based methods, such as [TrajOpt](https://journals.sagepub.com/doi/full/10.1177/0278364914528132), [STOMP](https://ieeexplore.ieee.org/stamp/stamp.jsp?tp=&arnumber=5980280) and [CHOMP](https://ieeexplore.ieee.org/stamp/stamp.jsp?tp=&arnumber=5152817), leverage prior information about the environment and the robot as constraints to compute a fast and collision-free path. This approach has been proven very effective for solving complex problems such as finding a fast, collision-free path while limiting the jerk in the motions. Jerk is the time derivative of acceleration and a lower jerk means the robot moves more smoothly, reliably, and efficiently. High jerk, on the other hand, can cause wear and tear on the robot, and reduce its overall working life. The downside of these fast, low-jerk optimization-based approaches though, is that they can take much longer to find trajectories, and may get stuck in a local optimum.

<FigureCenter width={512} height={256} src="/images/blog/robot_opt_motion.gif" alt="Optimized Motion Plan for Robotic Arm"></FigureCenter>

To summarize, sampling-based methods require less compute time but can output more time-consuming paths, while optimization-based methods find faster trajectories but can require longer compute times.

That leads us to the question - can we develop algorithms that minimize both execution and compute time?

It turns out it is possible! This [paper](https://www.science.org/doi/10.1126/scirobotics.abd7710) for example, published in Science Robotics, presents a method to compute a time-optimized trajectory within just ~80 milliseconds. It uses a Sequential Quadratic Program (SQP) to compute a time-optimized, jerk-limited, and collision-free trajectory. To address the high compute times, a neural network computes an approximated solution to warmstart the SQP optimizer. The warmstart allows the SQP to start from a solution much closer to the final solution, reducing the number of optimization iterations. Since the final solution is outputted from the SQP, this guarantees that the trajectory meets the jerk and robot constraints, which the neural network on its own cannot guarantee. 

This rapid computation of smooth, fast robot trajectories is particularly important for applications such as robot picking in e-commerce warehouses. 

The Jacobi platform took this approach a step further. With a combination of optimization, deep learning, and motion-planning tools, it computes faster motions within less than 1 millisecond on average. You just choose your robot from the robot library, load your collision environment, train the motion planner, and you’re ready to use time-optimized, jerk-limited, and collision-free trajectories.

[Mallika Parulekar](https://mallikaparulekar.github.io/) is an undergraduate student at the [AUTOLab](https://autolab.berkeley.edu/), in the University of California, Berkeley, and is interested in robotics, algorithms, machine learning and game theory.

From Sampling to Optimization: A Look at Two Approaches to Motion Planning.

Fast, Smooth, and Reliable: How Robots are Becoming More Efficient with Motion Planning


# Combining Navigation and Manipulation with Reinforcement Learning and the Jacobi Library

Mobile robotic manipulation has opened up new possibilities for automation in various industries. With the ability to move and manipulate objects simultaneously, mobile robots can perform tasks that were previously only possible with human intervention. The applications of mobile robotic manipulation are vast, ranging from manufacturing and logistics to service industries, and more.

While existing research on mobile robotic manipulation has focused on improving the final grasping motion, the pre-grasp manipulator configuration is equally important in achieving significant time gains. Our research aimed to address this by exploring the pre-grasp planning problem using Reinforcement Learning (RL). Our RL-based solution for pre-grasp planning significantly reduced the grasp execution time while navigating toward the target object.

<FigureRight width={256} height={128} src="/images/blog/robot_arm_supermarket.png" alt="Robot Arm in Supermarket"></FigureRight>

To evaluate our work, we integrated several open-source grasp planning solutions with our RL environment, such as MoveIt and OMPL. However, we faced challenges due to incompatible software dependencies and the need for middleware, such as ROS. That's when we discovered the Jacobi Library and decided to try it out. Integrating Jacobi with our RL environment was effortless, thanks to its cloud-based platform, which leverages the AWS infrastructure.

Jacobi's easy-to-use API and graphical interface for setting up the scene, coupled with its inbuilt support for most of the commonly used manipulators like UR5e, made it possible to complete the entire integration in just a few hours. We were impressed with Jacobi's scalability, which allowed us to test our mobile robot in different scenarios easily. This helped us gather more data and improve the accuracy of our Reinforcement Learning-based pre-grasp planning solution.

In conclusion, the use of mobile robotic manipulation is a game-changer in various industries, and our research has demonstrated the importance of pre-grasp planning in achieving significant time gains. The Jacobi Library proved to be a reliable and easy-to-use tool for integrating our RL environment and testing our mobile robot in various scenarios. We believe that our work can contribute to the development of more efficient and effective mobile robotic manipulation systems in the future.

[Lakshadeep Naik](https://lakshadeep.github.io/) is a PhD candidate at [SDU Robotics](https://www.sdu.dk/en/forskning/sdurobotics), the University of Southern Denmark, and works at the intersection of vision, motion, and interaction for mobile robots.

How I used the Jacobi Platform for mobile robotic manipulation.

Combining Navigation and Manipulation with Reinforcement Learning and the Jacobi Library


# Why I don't use ROS to program robot arms

Robotics is a rapidly growing field that has the potential to revolutionize our daily lives. As the demand for advanced robotics increases, so does the need for efficient and effective software tools. Robot Operating System (ROS) is a powerful and widely used open-source framework for programming robots. It offers a range of libraries and tools that help with communication between different components and sensors, as well as visualization and simulation. However, despite its popularity, ROS is not without its shortcomings.

One of the biggest challenges with ROS is its steep learning curve. If you're new to ROS, be prepared to invest a significant amount of time into learning the ropes. The platform can be overwhelming, with a range of libraries, tools, and communication protocols that can take some time to master.

<FigureLeft width={256} height={128} src="/images/blog/robot_weld.png" alt="Robot Arm Welding"></FigureLeft>

Another major challenge with ROS is managing software packages and dependencies. ROS requires specific packages to be installed to function properly, and managing these packages can be a headache. This makes it hard to share usage between users, jump between projects, and ensure that everyone is using the same versions of packages. This can lead to compatibility issues and hinder productivity, particularly when working on multiple projects simultaneously.

Lastly, one of the biggest drawbacks of ROS is that it can be time-consuming to set up and try out new ideas. Setting up a new experiment or designing a POC for an application can take days or even weeks, which can be frustrating for developers who want to move quickly and iterate rapidly.

In contrast, the Jacobi platform was created with the goal of simplifying the development of complex robot arm applications. It’s easy to install, offers user friendly APIs, and leverages state-of-the-art algorithms for optimal performance.

Want to see how easy it is to program with Jacobi? Try it out [Here](https://account.jacobirobotics.com).

Robot Operating System (ROS) is a widely used open-source framework for programming robots, but it has its challenges.

Why I don't use ROS to program robot arms


# Programming Robot Arms: Why it's Tricky Even for Experienced Roboticists

If you've ever tried programming a robot arm, you'll know it's no easy feat. Even for experienced roboticists, working with robot arms presents a number of challenges. Let's take the seemingly simple task of moving the arm from point *A* to point *B*, for example:

Firstly, each robot arm has its own programming language, which can be quite different from more modern programming languages like Python or C++. For example, ABB robots use RAPID while Universal Robots use URScript. These programming languages are similar to low-level languages and are not as expressive as the modern languages developers are used to.

<FigureRight width={256} height={128} src="/images/blog/robot_explosion.png" alt="Industrial Robot Arm Explosion"></FigureRight>

Another challenge with programming robot arms is something called robot singularities. This is when the robot arm is unable to move in certain directions, which can occur when planning robot trajectories by specifying the end-effector desired pose. Robot singularities can cause the robot arm to become blocked and unable to perform its intended function. Together, programming robots manually in the robot programming language combined with debugging and fixing robot singularities leads to long programming and deployment times. A robotics engineer may spend around 20 minutes programming a single robot motion, and several weeks programming the entire application.

Finally, there's a trade-off between compute and execution time in open-source motion planning methods. Optimization can find fast motions at the expense of long computation time, while probabilistic methods find a solution quickly, but the solution is usually sub-optimal

But, there is an alternative to traditional robot programming. The Jacobi platform allows you to program any robot application using Python or C++, with the Jacobi Studio providing a user-friendly interface for visualizing and debugging your code. The resulting motions are fast to compute and execute, and don't suffer from singularities. Check it out [Here](https://account.jacobirobotics.com).


If you've ever tried programming a robot arm, you'll know it's no easy feat. Even for experienced roboticists, working with robot arms presents a number of challenges.