How to Achieve Effortless Programming With Skills
Posted on Oct 19, 2017 7:00 AM
Can robot programming really be this easy? Well yes! We compare the traditional vs the new way of programming.
Robot programming is tricky. Even apparently straightforward actions can end up taking hours of complex programming. This pushes back your deployment schedule and stresses out the whole team.
Consider actions like torque turning, linear search, part detection and pick up. With the right hardware, these should be simple for the robot to perform… or so you would think. However, if you have ever programmed a robot to do these actions, you will know that they are often hair-pullingly difficult. Some of them are so complex that they have been the subject of years of research.
During our recent Robotiq User Conference 24 Hour Challenge, the participants were able to effortlessly bypass these issues and program their robots quickly and easily.
By using the new Robotiq Skills! These freely available add-ons help to boost your programming to the next level by performing pre-programmed actions at the click of a button.
What's the advantage of using Skills? As Paul Keeling from Raruk Automation LTD told us about the 24 Hour Challenge:
"It's a steep learning curve, but with the use of Skills it's made it smoother than it would have been."
Skills can make your life a whole lot easier.
The Problem of Robot Programming Without Skills
Usually, programming with sensors and peripherals is a pain in the neck. When I worked as a robotics researcher, I would spend weeks trying to get a piece of hardware to play nicely with the robot.
For example, if I wanted the robot to insert a pin into a hole using force feedback, it would have taken me months! I'd spend days integrating the force sensor into the robot software, a week or three to write code that reliably converted the force signals into data that I could actually use, and several more weeks to develop a reliable strategy to insert the pin using this data.
Ain't nobody got time for that!
This is a common problem in robotics, which I explained back in 2016 in the post Do Roboticists Have to Reprogram the Wheel? For too long, we have had to program most functionality from scratch.
Example: Programming Peg-in-Hole With vs Without Skills
Let's look at an example of programming a task "the difficult way" then then see how it could be made easier using Skills.
Consider the action of screwing a bolt into a hole. It seems like an easy task, right? You simply program the robot to grasp the bolt, insert it into the hole and then turn it around. However, things are not so simple.
This task involves at least five major steps:
- Detecting the bolt.
- Grasping the bolt.
- Moving it to the hole.
- Detecting the exact location of the hole.
- Screwing the bolt to a specific torque.
This is similar to part of the 24 Hour Challenge which we set RUC participants.
Programming "The Difficult Way"
Traditionally, this bolt screwing task would include several challenging programming steps:
- Integrate the force sensor with the robot code using its libraries.
- Integrate the gripper with the robot code using its libraries.
- Integrate the camera with the robot code using its libraries.
- Implement a bolt-detect sequence using the camera, using library functionality and custom algorithms.
- Program functionality to convert the bolt location detected by the camera into its location relative to the robot.
- Program the robot to move to the detected location and grasp the bolt.
- Move the robot to the rough hole location.
- Implement functionality which uses the force sensor to detect the exact location of the hole.
- Implement functionality which uses the force sensor to screw the bolt to a specified torque.
That's a lot of steps and a lot of time!
Programming all of this functionality from scratch (as we used to) would take a huge amount of effort. Each of these steps could take hours, days or weeks to program. Sure, some existing functionality might have made the task a little easier — in the camera library, for example — but even with predefined functions this is a lot of work.
"Programming" With Skills
With Skills, this task becomes a whole lot easier.
During the 24 Hour Challenge, Paul Keeling told us:
Everything was pre-loaded. All I had to do was pull up the functions task, then fiddle around with the parameters to make sure that it was working as quickly and smoothly as I wanted it to be. From there it was all pretty straightforward. It wasn't a long setup time at all.
Here's what programming this task might look like with Skills:
- Load the Sensor Add-On Skill to immediately integrate the force sensor.
- Load the Gripper Add-On Skill to immediately integrate the gripper.
- Load the Camera Add-On Skill to immediately integrate the camera.
- Use the Camera Auto-Pick Skill to automatically detect the bolt and grasp it.
- Move the robot to the rough hole location.
- Use the Spiral Search Skill to automatically align the bolt using force feedback.
- Use the Torque Turning Skill to screw the bolt to the specified torque.
With Skills, you hardly have to write any code at all!
The participant teams of the 24 Hour Challenge were able to integrate six robots over the course of only a few hours. These predefined functions were a major factor in their achievement.
Instead of wasting all of their time on low-level programming, Skills allowed participants like Paul to focus on the more important aspects of the application, like synchronizing the different robots and optimizing the operation.
Right now, we've got a handful of Skills available. Check them out at skills.robotiq.com (you'll need to register, which is free). They provide loads of great functionality that I wish I had when I was researching robots. As time goes on, our engineering team will continue to develop Skills to make robot programming easier.