For many people, RoboDK’s standard graphical user interface is their primary method for using the software. While this is a very intuitive way to program your robot – especially if you are a beginner – the software has a lot more capabilities than you might first realize.

With the API, you can create some very sophisticated programs in just a few lines of code in your favorite programming language.

Whether you’re looking to automate simple repetitive programming tasks or you want to take on more complex challenges, here’s how to use the API…

Automating Repetitive Tasks with RoboDK’s API

One of the tremendous benefits of using robots is that they can take over the dull and repetitive parts of people’s jobs.

But programming robots can also be dull and repetitive. When you have to perform the same programming and configuration steps over and over, you might wish that you had a robot to program your robot.

This is where the API comes in!

With the API, you can script and automate parts of your programming process in just a few lines of code.

Here are a few examples of programming tasks that you could automate:

• Motion and trajectory generation — Perhaps you repeatedly need to generate new robot trajectories, such as when a new product is added to your production. You could create a program to generate these trajectories programmatically and then call the RoboDK API to generate the robot program.

• Passing parameters from other programming steps — The more you automate your production line, the more you will need to pass information between different automation stages. You can use the API to create middleware programs between to act as a bridge between these steps.

• Monitoring the robot’s performance — You can also create programs to monitor the operation of the robot. This could involve simple error reporting or a more complex setup with vision sensors. You could then use the API to send corrective instructions to the robot.

You could even employ more advanced programming techniques, such as using artificial intelligence and machine learning.

Understanding the 5 Elements of RoboDK’s API

What do you need to know about the RoboDK API? It’s helpful to understand the core components.

Below is an overview of the main 5 elements of the API. You can find out more details in the extensive API documentation (here the Python API).

1. robolink

The robolink module is the main module of the API. It provides the fundamental functionality to interact with the RoboDK software and your code.

Robolink can access any item from within your RoboDK program tree, load models, define tools, set robot movements, and generate programs.

2. robomath

Robotic programming often involves a lot of geometrical mathematics. These are difficult to calculate using the standard mathematics functions in most programming languages.

To make this math easier, we have implemented the robomath module, based on the Robotics Toolbox by Professor Peter Corke.

3. robodialogs

Much of the functionality in the graphical interface of RoboDK involves interacting with message boxes and other types of dialogs.

The robodialogs module contains functionality to handle these dialogs, including opening and saving files.

4. robofileio

RoboDK supports a wide variety of file types, including robot program files (such as ABB’s .mod or KUKA’s .ls), CAD files (such as .step or .stl), and standard data files (such as .txt or .csv).

The robofileio provides functionality to handle and analyze files, such as finding if files exist and generating safe variable names that can be used for robot programming.

5. roboapps

Finally, the roboapps module is the API interface for the RoboDK Apps toolbox.

The RoboDK App interface allows you to extend the functionality of RoboDK even further. It allows you to load scripts and executable files as if they were plug-ins in RoboDK software.

An Example of Automating a Complex Trajectory with the API

What does it look like when you use the RoboDK API for more advanced programming automation?

Let’s look at an example of robot art generation (which is a common usage for RoboDK among artists). In this case, say we are using Python to create a fractal trajectory with the robot.

Programming a fractal with RoboDK’s graphical interface alone could be a very tricky activity. Fractals are, by nature, programmatic – they are defined by mathematical formulas. So it makes sense to use programs to create them instead of a graphical interface.

A basic form of fractal is the Koch curve. It is fairly simple to program a Koch curve in Python. Using the method explained in this example here to create a Koch Snowflake, you could generate a Koch curve in your Python code and send the resulting trajectory points to your robot with the RoboDK API. This would be possible in very few lines of code.

If you wanted even more complex fractal designs, such as the Barnsley Fern or Mandelbrot Set, you could also achieve these in a similar way. Most of your program would stay exactly the same – only the fractal generation function would change.

How to Get Started With the RoboDK API

The RoboDK API is a powerful tool that can help you optimize and streamline your robot programming process.

With programming languages like Python or MATLAB, programming doesn’t even have to be difficult. The languages themselves are intuitive enough that you don’t need to be a highly skilled programmer to create powerful programs.

Get started with the RoboDK API by heading over to the documentation and having a look at what it is capable of!

What programming tasks do you find repetitive? Tell us in the comments below or join the discussion on LinkedIn, Twitter, Facebook, Instagram, or in the RoboDK Forum.. Also, check out our extensive video collection and subscribe to the RoboDK YouTube Channel

The post Introduction to RoboDK’s API: How to Automate Repetitive Tasks appeared first on RoboDK blog.

Robotics and machine learning have gone together since the very beginning of modern robotics.

The promise of machine learning is that robots can learn from data and make their own decisions about which actions to perform. However, the process of applying it to robotics has traditionally been complex and fraught with challenges.

The RoboDK API can help you overcome and avoid many of these challenges. It provides a more user-friendly way to access advanced robot programming functionality.

With the RoboDK API, machine learning is more accessible to anyone interested in exploring its potential, regardless of your programming experience.

Why Robot Machine Learning is Traditionally Hard

The robotics field is constantly evolving. New technologies arrive every so often and old technologies continue to improve.

Machine learning has been around for decades. People have also been applying it algorithms to robots for decades, but the process is traditionally very hard, especially for new robot programmers. This means that only highly experienced robot programmers can do it.

There are many powerful machine learning programming libraries available in the world, often for free. However, these are often marred by difficulties with poor interoperability, a lack of reliability, and a lack of clear documentation.

In the past, if you wanted to apply a machine learning algorithm to your robotic application, you had to jump through a lot of hoops to get it up and running. You would have to implement a lot of the lower-level programming yourself.

What was missing was a reliable “glue” — a way to combine the power of these third-party machine learning libraries with the movements of the physical robot.

What is the RoboDK API?

The RoboDK API is a set of functions that allow you to interact with RoboDK through a programming interface. You can use this API to create robot programs, generate trajectories, and perform high-level industrial robotic tasks like machining or drilling.

The API is available for Matlab, C++, C#, and Python. It streamlines the process to create robot programs with these highly popular and versatile programming languages. At least one of these languages will be supported by almost any machine-learning library you want to use.

Using the RoboDK API is as simple as loading the RoboDK library from your program. This makes it quick and easy for you to control your robot from your code.

How the API Makes Robot Machine Learning Easier

The RoboDK API makes machine learning easier by providing a simple interface to access the physical robot.

With the API, you can use your existing knowledge of your preferred programming language and easily integrate the robot with the machine learning library of your choice.

For example, imagine you want to integrate the popular Python machine learning library Keras into your robot program — to use neural networks to sort items automatically in a pick and place application.

Without the RoboDK API, you would need to do a lot of programming work to incorporate the Keras library with the coding interface provided by your robot manufacturer.

With the RoboDK API, you can just load the Keras library together with the RoboDK library and the functionality of both libraries is immediately available to you.

5 Benefits of Using the RoboDK API

The conventional approach to robotic machine learning is to spend a lot of time up front getting the programming interfaces to “play nicely together.” This can lead to a lot of headaches, takes a very long time, and usually produces unreliable code.

Compared to the conventional approach, there are various benefits to using the RoboDK API.

Here are 5 benefits:

• User Friendly — The API provides a very user-friendly way to access more advanced robot programming functionality. You benefit from the user-friendly nature of RoboDK itself along with the simple-to-use API interface.

• Advanced Functionality — The basic RoboDK interface provides you with access to a lot of functionalities, but the real power of the software comes when you combine the program with your own code. The API is one of the easiest ways to do this.

• Access to Powerful Libraries — At RoboDK, we know quite a lot about machine learning, but we are not machine learning experts. It makes sense to access your machine learning functionality from libraries created by the leading experts in their fields. With the API, you can use any third-party library, meaning you have access to a huge amount of powerful functionality.

• Well Documented — We try to make our software as easy for you to use as possible. We have clear API documentation that you can use to get to grips with the programming interface for each supported programming language.

• Active Community — We also have an active community of users at RoboDK who can help you to overcome any programming problem you may have. Many third-party machine learning libraries also have active communities if you have questions about their functionalities.

Thanks to these benefits, the RoboDK API is a great tool for machine learning. It can help you save time and effort.

Start Using the RoboDK API Today

The first step to using the RoboDK API is to install RoboDK onto your computer if you haven’t already.

Get familiar with the basic interface and functionality, as well as the API interface.

You can learn all about our API on our documentation pages for Python, C++, and Matlab.

What project would you like to test with the RoboDK API? Tell us in the comments below or join the discussion on LinkedIn, Twitter, Facebook, Instagram, or in the RoboDK Forum.. Also, check out our extensive video collection and subscribe to the RoboDK YouTube Channel

The post How the RoboDK API Makes Robot Machine Learning Easier appeared first on RoboDK blog.

Whenever an artist uses a robot in their project, it raises new questions that apply to many conventional robot applications like…

How do you maintain “the human touch” when fabricating with robots?

Can a robot create something that is both consistent and pleasingly random?

What new designs are possible by using a robot instead of manual fabrication?

Artists often like to use RoboDK because its simple interface is ideal for less experienced robot users. In the past, we have reported on projects including portrait painting with a KUKA robot, robot-fabricated art installations, and supersized 3D printing for interior design.

This latest artistic application of RoboDK causes us to question the very nature of robotic art.

The Question of the Human Touch in Art

What’s the difference between robot-created art and art made by human hands?

In recent years, the lines between art and technology have been blurred somewhat with the rise of art created by artificial intelligence systems. This has led many people to question whether AI art is really art at all if it wasn’t created by a human. The jury is still out on this question.

When it comes to painting and drawing, one factor that comes into effect is the inherent inconsistency of humans. Even the most skilled painters in the world would paint the same art piece slightly differently every time.

These random — but not completely random — variations are part of what makes art pleasing to look at.

Robots, however, are completely consistent.

When a painting robot in an automotive factory draws a logo on the side of a car, it will be the same every time.

How can you create art with a robot that is not so consistent that it appears “manufactured”?

Introducing… Artist Nicholas LiCausi and Robotic Drawing

One artist who is addressing these issues is Nicholas LiCausi.

Nicholas is a designer and artist from the Tulane School of Architecture in New Orleans, Louisiana. There, he works as a Director of Fabrication where he oversees the operations of several digital laboratories, including 3D printing and CNC.

His work covers a broad range of mediums and topics. His past projects include a virtual reality art exhibition, a parklet constructed of recycled pallets, and a conceptual design that reimagined the city metro as a rollercoaster.

Nicholas’s work into robotics uses the same technology that is usually used with manufacturing tools to instead manipulate the tools of artists, specifically paintbrushes and pens.

The Robotic Setup

Nicholas’s various robotic projects are based around a Universal Robots UR 5e collaborative robot and a custom-designed drawing tool. The robot programming setup is based around RoboDK.

The Custom Drawing Tool

For the “business end” of the robot, Nicholas needed to connect the robot’s wrist to the brush or pen. He went through various designs until he arrived at a tool that provided the perfect trade-off of flexibility and rigidity required for the artistic tasks.

The tool is 3D printed with clear and elastic resin. It utilizes a linear sleeve bearing to provide slight flexibility to the tool.

How He Used RoboDK

Programming was achieved through a combination of RoboDK, the Rhinoceros 3D CAD package, and the robots teach pendant.

By using RoboDK’s native plugin for Rhino, he was able to easily send trajectories directly to the robot from the CAD file. Rhino is popular among designers, architects, and artists for its flexibility in 2D drafting and modeling complex shapes.

Nicholas explains:

“RoboDK was essential in bridging the gap between Rhinoceros and the Universal Robot. We’re able to directly connect to the robot and precisely align to our various work surfaces. RoboDK allows us to quickly prototype and simulate designs when working remotely. It’s been invaluable during the pandemic to test our ideas before trying them in person.”

3 of Nicholas’s Projects that Explore Robotic Drawing

Here are the 3 projects that Nicholas has used with his robotic setup so far:

1. Robotic Painting

Here, Nicholas sought to explore how the same robot program could produce vastly different artworks simply by changing the variable of the type of paintbrush that was used.

The robot was also instructed to dip the paintbrush into the paint at different points throughout the painting process. This simple change also produced very different paintings despite the robot movements remaining consistent.

2. Generative Drawing

The final application shares some similarities with the robotic portraiture project that we reported on in 2016 as it involves turning people’s faces into robot drawings.

Nicholas used Grasshopper (the visual programming language in Rhino 3D) to convert images of people’s faces into vector drawings. Then, he reimagined these images and used the robot to draw the resulting artwork onto paper.

3. Non-Planar Notation

One benefit of using RoboDK is that it gives you access to advanced programming options without requiring you to calculate your own complex algebra and code your own algorithms.

In this project, Nicholas explored the possibilities of using the robot to create artwork directly on curved surfaces, such as a pipe. He used a 3D scanner to digitize the surface into a CAD model then imported this into RoboDK for programming.

What Could You Learn from Robotic Artwork?

If you are an artist yourself, projects like Nicholas’ show some of the immense possibilities that you can access by using a robot and RoboDK.

But, even if you are using robots for more conventional applications, you can still learn something from projects like these.

Artistic projects challenge us to reconsider what is possible with a robot.

For example, just think about what unique touches you could add to your products simply by questioning what more you could do with the robot’s tool!

What do you think of robot art? Tell us in the comments below or join the discussion on LinkedIn, Twitter, Facebook, Instagram, or in the RoboDK Forum.

The post Bridging the Gap Between Abstract Art and Robotic Drawing appeared first on RoboDK blog.

You might wonder… is it even possible to get your chosen feature within RoboDK?

Here are some powerful features that you might not know about yet.

We are always upgrading RoboDK. We have a very active userbase and many of you have suggested new tweaks, upgrades, and features over the years that we have integrated into RoboDK to make it even better.

But, you might wonder if there are features that you may have missed.

What To Do When Robot Software Doesn’t Have Your Killer Feature

Sometimes, we come to a new piece of software looking for a key set of features and we are disappointed. When we don’t see that one killer feature that we need, we discount the software immediately and move to the next software on our list.

This can happen to people when they are looking for new robot programming software. They end up hopping from one software to another, constantly trying out the free demos but never settling on one software package.

But, these people are missing out.

There is more than one way to get that killer feature in a robot software package. In RoboDK, there is a very powerful way of adding new features that few people realize is even there.

The Lesser-Known Superpower of RoboDK Plugins

Unlike many robot software packages, RoboDK is very extensible. There are many ways that you can add new features and extend the capabilities of the software with just a little bit of programming.

At the most basic level, you can use Python programming within RoboDK. This allows you to program your robot directly using this simple and popular programming language.

You can also extend the software’s capability by using the RoboDK API to connect external code with RoboDK. Plus, you can use our CAD/CAM plugins to link RoboDK with many popular CAD/CAM programs.

But, there is one method of extending RoboDK’s capabilities that allows you to supercharge the native capabilities of RoboDK itself.

RoboDK plugins are a hugely powerful way of adding almost any feature you might think of into the software.

You can use one of our existing plugins to access lesser-known capabilities that we have already developed or you can create your own plugin.

9 RoboDK Plugins You Might Not Know About

There is already a set of existing plugins that can boost RoboDK’s capabilities at the click of a button.

This collection is growing and changing all the time, but here we will show you 9 plugins that are available in your copy of RoboDK right now that you might not know about yet. You can access such plugins by going to “Tools>Plug-Ins.”

1. Collision Free Planner

One hotly-anticipated plugin comes in the form of our collision-free planner. This allows you to automatically create robot motions between two points in the robot’s workspace without colliding with any objects. For more information about this feature check out our blog post about how the planner works.

2. Gravity

Gravity is not usually useful in industrial robotic simulation. However, there are some applications where may be useful that objects behave as they would in the real world. The gravity plugin allows you to activate a simple form of gravity for such applications.

3. Palletizing

Palletizing is one of the most common robot tasks in logistics. It is an extended pick and place task where objects are laid out in a regular pattern onto a pallet. The new palletizing plugin provides you with the capability to automatically create this pattern and create the control motions for the robot.

4. Real-Time

Most people use RoboDK to program their robots offline in a simulation and then download the program to the robot itself. This does not require real-time performance. However, it’s also possible to control a robot in real-time, for which you might need the real-time plugin. Check out this blog post for an example.

5. Robot Pilot

Robot pilot is a simple plugin that allows you to move the robot with the click of a button, in a similar manner to “jogging” with a robot’s teach pendant. You simply choose whether you want to move the robot’s reference, tool, or joints then click the corresponding button to move the robot by a defined amount.

6. OPC-UA

The OPC Unified Architecture is a machine-to-machine communication protocol. It is platform-independent and specifically designed to allow for open, secure communication in an industrial setting. It is widely used in automotive manufacturing, food manufacturing, and packaging. The OPC-UA platform allows RoboDK to integrate with it.

7. Chip8 Emulator

Chip8 is a very simple programming language that was used for game design in the past. This fun plugin was developed by embedded systems expert Phillip May. It shows how a robot can be programmed in RoboDK to emulate a Chip8 processor, which really demonstrates the programming power of plugins! You can even load your own game ROMs into it.

8. Your Plugin

The real power of RoboDK’s plugin interface is that you can create your own plugins. The limits of this are only in your imagination and your coding abilities. Check out the Plugin example in our plugin interface Github page to see how it’s done.

9. App Loader

Finally, you don’t even need to create a plugin to get the same benefit! The AppLoader plugin provides a way for you to easily load scripts and executable files into RoboDK as if they were plugins. Check out the AppLoader Github page for more details.

How to Get the Most from RoboDK Plugins

The above plugins are great, but the real power of RoboDK plugins comes when you start creating them for yourself.

You no longer need to be concerned when you think of a killer feature that the software doesn’t have yet.

You can just create it yourself!

Or, you can submit a request in our popular feature-request forum thread.

What features would you like to see in RoboDK? Tell us in the comments below or join the discussion on LinkedIn, Twitter, Facebook, Instagram, or in the RoboDK Forum.

The post 9 Powerful RoboDK Features You Might Not Know About appeared first on RoboDK blog.

Conceived by digital arts pioneers Rob and Nick Carter, the ingenious ‘Dark Factory Portraits’ exhibition features an industrial robot arm from KUKA –dubbed ‘Heidi,’ by the artists–that produces fine art portraits of famous artists in acrylics.

The ‘Dark Factories’ title is a nod to ‘lights out’ manufacturing processes, where robots work autonomously in unlit factory spaces. Heidi also works ‘blind’ –that is, without any cameras or vision sensors. 

How it works

Heidi receives a photograph in digital form, applies some image processing and Google Face API and courtesy of some coding in Autodesk Maya, generates a final image.

The robot must be able to work out where the brushstrokes should go, how long they should be, the angle of the brush and other details.

At this point in the process, the robot has a clear idea of its objective, but it doesn’t understand the mechanics of painting in a human-like way. 

This is where RoboDK comes in. 

I was able to glue together Autodesk Maya and RoboDK using their SDKs, to form a single elegant tool to design any kind of painting and have it painted by a robot.

Says software engineer, Julian Mann, who brought Heidi’s mechanics to life for ‘Dark Factory Portraits.’ 

Using the RoboDK API, Mann coded Heidi’s every movement; from paint and brush selection through to which brushstroke to use and how to clean a paintbrush. As the project progressed, Mann observed that the robot developed some of the fine motor skills that humans take for granted when painting. 

“As development progressed, the system gathered more and more of the skills we take for granted when painting with our own hands,” says Mann. “For example, the robot gently ramps into each stroke and pushes harder and softer in order to modulate the stroke width. It holds different brushes at different angles, and it takes great care to wipe just the right amount of excess off the brush.”

RoboDK enables users to easily program more than 500 industrial robots, from small collaborative robots to large industrial arms –each of which offers a multitude of different ways to apply paint to canvas and sculpt.

While advanced users can use the RoboDK API, non-coders can easily create complex robot programs in RoboDK by pointing and clicking with their mouse in a simulated computer environment. Users can test out their robot’s movements before applying them in the real world. Meanwhile, RoboDK software takes care of translating those clicks into code that the robot understands.

Robotics opens up fresh possibilities for artists and creatives by providing new tools and processes to work with, says RoboDK marketing manager Lauren Ierullo.

“As the brilliant Dark Factories exhibition shows, it’s not about replacing artists, but empowering artists and enabling them to explore new avenues of creativity through automation,” says Ierullo.   

The Carters share this sentiment, seeing robotics as a tool, an extension of their craft, rather than as a threat to human creativity.

The successful collaboration between the Carters, Mann and Heidi, highlights the benefits and creative potential of human-robot collaboration, says Nubiola.

“There are many areas in which the best results come from humans and robots working together and the visual arts is no exception,” he says. “Our software allows artists to add robotic tools to their repertoire and is creating to new types of artists –creative engineers that build the algorithms that robots use to produce art.”

RoboDK was founded in 2015 as a spin-off company from the CoRo laboratory at ETS University in Montreal, Canada. In that time its robot simulation and programming software has helped bring several high-profile artistic projects to life.

Neoset Designs, a New York-based art and digital fabrication studio, was asked to collaborate with music streaming service Spotify on the ‘RapCaviar Pantheon’ robot sculpting project in 2017. Using RoboDK’s milling features the team completed three large sculptures of outstanding rap artists in just 15 days.

Artist Robot Longo’s stunning ‘Death Star‘ sculpture, now part of the Collection of the Burchfield Penney Art Center in Buffalo, New York, consists of 40,000 brass and copper bullets arranged around a steel sphere. To ensure accuracy, RoboDK software was used to control a custom-built, robotic drilling system that prepared all 40,000 holes into which the bullets were placed. 

Ascan Aldag is an artist that pushes the boundaries of 3D-printing by using an industrial robot arm to produce supersized 3D-printed art works. Aldag built a custom extruder to speed up the printing process and RoboDK allowed him to control the entire system, including the tricky task of synchronizing the extrusion speed with the robot’s movements.

And camera motion control specialists, CMOCOS used RoboDK and a collaborative robot arm from KUKA to create instant portrait sketches based on digital photographs. RoboDK software allowed the creative team to simulate the robot’s path for each sketch and then produced the code that set the robot in motion.

“The bulk of RoboDK’s business is in the industrial manufacturing sector, but as ‘Dark Factories’ and other projects demonstrate, our software is a powerful tool for creatives too,” says Nubiola. “We are looking forward to inspiring and empowering future art projects as more people discover the potential of robots to transform the visual arts.” 

‘Dark Factories’ is scheduled to run until April 17^th, 2020. 

The post Lights Out Robot Painting appeared first on RoboDK blog.

When you’re 3D printing with a robot, your software workflow can have an important impact on your productivity. If you can shave even a few minutes off the workflow, over time this could translate into quite a lot of extra productivity.

The time that it takes you to switch between different software packages is usually short, but it makes your workflow less smooth and, as a result, can make additive manufacturing less efficient.

Researchers from Portugal and Norway recently developed an application to streamline RoboDK’s additive manufacturing workflow even further via the RoboDK API.

Meet the Researchers

This engineering application was developed for a study by researchers Filipe Monteiro Ribeiro and J. Norberto Pires from the University of Coimbra, Portugal, and Amin S. Azar from SINTEF — Norway’s leading center for manufacturing research.

The study, titled “Implementation of a robot control architecture for additive manufacturing applications“ was published earlier this year in the journal Industrial Robot.

What Were the Researchers Trying to Achieve?

RoboDK is a great way to add robotics to additive manufacturing. We’ve already seen people use it for printing a diverse array of objects, including 3D printed concrete structures, 3D printed art, and 3D printed food.

The 3D printing workflow is already quite good in RoboDK — you simply generate the GCODE with a slicer software (commonly the open source Slic3r) and then load the resulting path into RoboDK.

However, the team of researchers identified that RoboDK alone does not provide the most streamlined workflow possible. Their study outlines a program they developed to directly combine the capabilities of RoboDK and Slic3r without having to manually move G-code files between the two programs.

To achieve this, the team developed a graphical program using Python and the RoboDK API.

The goals for this study were:

• To develop an additive manufacturing simulation — This is particularly easy with RoboDK, which provides an intuitive environment for robot simulation. The team also added a simple Python program to simulate the deposition of 3D printed material, as this is not something that RoboDK currently simulates itself.
• To allow for offline simulation of robots — According to the researchers, this was an essential part of their application as using a virtual environment reduced the risk of damage to a real robot. RoboDK makes it very easy to turn the simulated robot program into code for the real robot via its numerous post-processors.
• Asynchronous operation — It was important for the team that the program they created did not interfere with the operation of the simulated robot in RoboDK. For example, the simulation should continue running when the program was loading a new model into Slic3r. This is easy to achieve using our robolink Python module, which provides an asynchronous link between RoboDK and any Python program.

The resulting program sits between Slic3r and RoboDK and coordinates the additive manufacturing process.

What Did the Study Demonstrate?

The team’s application made very good use of RoboDK’s capabilities. In particular they demonstrated how effective it can be to use the API to combine parts of your own workflow.

The RoboDK API is a very powerful part of RoboDK, but it is not used by many of our users. This is unfortunate as it can help to significantly improve the smoothness of your robot programming workflow. It supports several programming languages, but the Python library that the researchers used is particularly easy to use — assuming, of course, that you like the Python programming language (and why wouldn’t you? It’s such an easy language!).

The Advantage of Asynchronous Operation

One of the key aspects in the study was the asynchronous operation. It was important for the team to ensure that no part of the program would stop the operation of another part of the program.

RoboDK already runs in an asynchronous manner — you can run multiple Python scripts at the same time and they won’t interfere with each other — but the team needed their own program to also have this asynchronous capability.

For example, they did not want their program to “hang” when waiting for Slic3r to finish generating GCODE. They needed to be able to control the robot while the program was doing other things. They achieved this with the asyncio library for Python which is a popular option for concurrent programming.

How to Improve Your Own Workflow With the API

Although the study was performed by robotics researchers, don’t think that this means that programming with the RoboDK API is complicated. Even if you’re not a programming wizard, you can easily use the API yourself.

If you want to develop your own program to boost your workflow, you can follow the following steps:

1. Become familiar with the API via the documentation page. Read about its capabilities and think about what you could use it for in your application.
2. Plan what parts of your application you will code in the external program.
3. Create your program using the API to interact with RoboDK.
4. Test your program before integrating it into your process.

Of course, you don’t need to write your own code to improve your workflow. You could also use the RoboDK plugins for programs such as SolidWorks which also streamline the workflow when you are using other programs in conjunction with RoboDK.

But, as the team of researchers showed, the API can be very effective in smoothing out disparate parts of your workflow for software that does not already have a plugin.

Remember, even shaving a few minutes off your programming process could lead to extra productivity in the long term.

What could you achieve by using the API in your process? Tell us in the comments below or join the discussion on LinkedIn, Twitter, Facebook, Instagram or in the RoboDK Forum.

The post Case Study: Improving the Additive Manufacturing Workflow appeared first on RoboDK blog.

Recently, we were involved in applying the same automated drilling technology to create a stunning piece of art.

Automated robot drilling can now be found in artistic and digital art projects. This is the case for the piece of art that Neoset Designs’ fabrication studio made for the artist Robert Longo.

In this post we reveal some of the steps used to achieve a high level of automated robot drilling.

A Unique Piece of Art

A custom automated drilling system was built to create a structure named Death Star 2018, designed by the artist Robert Longo.

The artwork is a suspended globe with 40,000 polished copper bullet casings, representing the increase of deaths in mass shootings in the United States during the last 25 years. To support efforts to reduce gun violence, 20% of the proceeds from the sale of Death Star II will be donated to Everytown for Gun Safety.

Technology Challenge: Accurate Robot Drilling

The artwork was manufactured by Neoset Designs’ fabrication studio. By using the latest robot drilling technology they were able to drill 40,000 holes within 0.150 mm tolerance in less than 2 weeks.

Just drilling a hole is easy. However, drilling a hole quickly and accurately is a challenge. The main challenge is to drill on the right spot, maintaining desired tolerances and making sure that no time is wasted.

A robot can help speed up the process, being a cost-effective solution. However, it is well known that robots are not accurate.

The system involved a KUKA Titan robot, the largest KUKA robot available in the market, a machining spindle and a WEISS Turntable. A Creaform C-Track measurement system was also used to reach desired levels of accuracy. RoboDK software was used for calibration and offline programming. It was possible to calibrate the robot to under 0.150 mm, the tolerance required to place each of the 40,000 holes.

Innovation Behind the Scenes

When it comes to industrial robots, no challenge is too big enough for Neoset Designs. They put together the right team and equipment to build this unique piece of art.

To build this 1 Ton sphere of bullets he had to split the sphere in 2 halves. Each half sphere was made from cast steel. This is important for the robot drilling process as it makes robot machining and drilling more stable. Before drilling, each half sphere was machined to have an accurate and perfectly round spherical surface.

The interior structure and I-Beam armature was engineered by Proptogroup.

A former NASA engineer helped Neoset’s team create a list of points that describe the location of each bullet (hole) in the 3D space. A custom algorithm created in Matlab was used to make sure that the spacing between holes remains uniform for all the bullets.

A specially made drilling tool was also designed for this purpose to minimize vibrations. This tool behaves like a mini 3-axis CNC mounted on the robot flange.

Finally, Neoset also used RoboDK software to calibrate the KUKA Titan robot and implement adaptive robot control to drill the 40,000 points (coordinates of the holes). A Python script and the robot driver made real time robot compensation possible in RoboDK. This means the accuracy is validated with the measurement system before the robot is starts the drilling cycle. If the accuracy is not good enough the robot position is corrected using the C-Track 6D measurement (position and orientation compensation). This compensation was applied before drilling each hole to obtain an accuracy better than 0.100 mm.

It is a privilege for me to have been directly involved with Neoset’s team using RoboDK, Matlab and the Python API to build this unique drilling system.

The post When Aerospace Technology Meets Art appeared first on RoboDK blog.

The construction industry is one of the rising opportunities for robotic automation. There are now robots at many stages throughout the entire construction lifecycle, from robots that can 3D print entire concrete houses to robots which can demolish buildings autonomously.

However, although automation is on the rise, the construction industry is still suffering from a lack of skilled workforce in some key areas. One of these shortages is the manufacturing of steel rebar.

A Norwegian startup named Rebartek is looking to change all that with their RoboDK-powered rebar manufacturing process.

Rebar Manufacturing: A Process Crying Out for Robots

Skills shortages (aka skills gaps) occur when there are not enough trained people in the wider jobs market to fill certain positions in an industry. The construction industry is full of them. For example, according to a 2016 study of one US county 38 out of 41 construction jobs had a skills gap caused by a lack of graduates with the required skills to fill key positions.

“Rebar” is a vital component in many modern buildings. It consists of steel bars or mesh which is added to concrete to improve the structure’s strength. Concrete is very strong under compression forces, but will crack under tensile stress. Rebar adds the necessary tensile strength.

Rebar manufacturing is still mostly a manual process. According to Rebartek, 99% of rebar manufacture is performed by hand. This is especially a problem as there are shortages of rebar workers across the world. In a 2013 study, researchers in Ball State University found that “Reinforcing Iron and Rebar Workers” had received one of the top 5 highest pay rises within the construction sector in just 3 years. Such pay rises are often a sign of a skills shortage, as businesses have to increase the wages for hard-to-fill jobs.

Robots are an increasingly good solution to filling skills gaps. This is exactly what startup Rebartek aims to achieve.

Meet Rebartek

Max Trommer, CEO of Rebartek, has some impressive experience in the construction industry. He told us:

“I have been working on construction sites for the last 15 years. On my last project, a major bridge construction, we were prefabricating rebar cages manually. I asked myself, could we use robots for this?”

Rebartek uses industrial robots to manufacture high-quality rebar cages at short notice. This automated approach provides a great deal of scalability. According to Rebartek, they are the first company in the world to do this.

But, bringing a new technology to a well-established task is not always easy. New robotic-based solutions often require a pioneering mindset. Thankfully, Trommer has plenty of experience.

Before founding Rebartek, Max Trommer was no stranger to introducing new technologies to the construction industry. He had already developed web apps to improve the workflow of road construction projects and rolled out new project management software to established construction businesses.

With his team, Trommer hopes that his robotic solution will make waves in rebar manufacture.

How Rebartek Uses RoboDK

Trommer explained the whole process to us:

“The raw materials are delivered as straight  ~12m long bars or as rebar wound-up on coils. First, each rebar goes into a bending machine that straightens, bends and cuts it into the specified shapes. Robots then preassemble those into “cages”.

The team’s solution is based around two KUKA manipulators. One robot uses a welding tool and the other has a customized gripper.

The two tasks that the robots carry out are:

1. Pick and place — The gripper robot picks up individual lengths of rebar and places them in the support frame. In this video, for example, they are using short lengths of rebar and welding them into a square lattice pattern. When the weld is complete, the robot picks up the cage using a custom attachment at the top of the gripper.
2. Welding — The other robot uses a welding tool to join the pieces of rebar. As we discussed in a previous article, robot welding has some great advantages over traditional welding and is easier to achieve than many people think.

Working in tandem, the two robots are able to achieve a potentially continuous output of prefabricated rebar cages with consistent weld quality. The team can also customize the cage design to meet the needs of their clients and use a workflow tailored to their client’s needs.

The benefits, as Trommer explained to us, are huge:

“Our tests show that cage installation saves 90% labour and time on-site compared to in-situ installation on the critical path.”

With RoboDK, the team found it easy to program their robots to work together seamlessly. Its offline programming means that they can tackle small series projects, which is a typical challenge in the construction industry.

The Top 3 Reasons Rebartek Chose RoboDK

What was it about RoboDK that made it the best choice for Rebartek? One deciding factor was its extensive library of robot models

Trommer told us:

“RoboDK enabled us to first simulate the process without investing in expensive hardware or software. It also has a good User Interface.”

The team’s top reasons for choosing RoboDK were:

1. It’s easy to learn — We think that RoboDK is one of the easiest offline programming solutions to learn, and it seems that Rebartek agrees with us. They thought that our documentation was pretty good; it helped them to get up and running easily (they also gave us some pointers to improve it even further, which we always appreciate. Let us know in the forum if you have suggestions of your own.)
2. It has enormous flexibility through the API — The RoboDK API allows for a huge flexibility in robot projects. Although many of our users stick to its graphical interface, it is only when you start programming with the API that you can appreciate the real power of RoboDK. Rebartek has big plans for their solution so this was vital.
3. It’s manufacturer agnostic — Unlike many offline programming solutions, RoboDK is not tied down to any particular robot manufacturer. This was a big benefit for Rebartek as it allowed them to properly assess their solution with a UR robot before investing in two large KUKA robots. For more information, see our article Will Offline Programming Work With My Robot? 

What’s Next for Rebartek

Max Trommer and his team have a very promising business model already. But, they are not going stop there.

Rebartek has some big plans for their future. He told us:

“Our vision is to fully automate the rebar prefabrication process off-site. We are developing artificial intelligence for that. Now that we have verified the concept, RoboDK’s API now enables us to automate our programming processes.”

Is AI-powered automation the future of rebar manufacturing? Rebartek is trying their best to make that happen. They might even help to solve the skills gap.

The post This Startup is Tackling the Construction Industry Skills Gap appeared first on RoboDK blog.

High-level languages can take a lot of the headache out of programming robots. They allow you to create programs with advanced functionality much quicker and more reliably than you could with specific robot languages.

But, which high-level robot language should you choose?

Examples of specific robot languages are RAPID (ABB), KRL (KUKA), JBI (Motoman) and Karel (Fanuc). Among other things, these programming languages are proprietary and limited to one robot manufacturer.

Four popular programming languages are Python, C#, C++ and MATLAB. In this post, I explain the strengths and weaknesses of each. But first, why should we even use high-level languages?

Why Use a High-Level Programming Language?

In the beginning, robots could only be programmed with low-level languages. Early robot languages like MHI, VAL and SIGLA were introduced around 1973 and were very limited. Most languages could only control one specific robot to make basic movements, which made them very inflexible.

Years passed and programming languages became more advanced. People started to use general-purpose, high-level languages to control their robots. C++ entered the robotics landscape in 1982, Python in 1990 and MATLAB in 2012.

Although many robot languages are still single-purpose today, there are huge benefits to using high-level languages. For example:

• They allow you to add advanced functionality to a robot simply by adding an existing software library.
• You can reuse most of your code with different robots.
• Use advanced debugging tools: vendor-specific programming languages rarely provide tools for debugging.
• Solving problems is quick because many people use the languages and the community is usually helpful.

Which Programming Language is Best for Robotics?

This is one of the most common questions I hear from new roboticists. Two years ago, I wrote an article which addressed the question. It has been one of the most popular articles I’ve ever written.

However, although it’s a popular question, there is no simple answer.

The best answer I can give you is: It depends!

It depends on what task you want the robot to do. It also depends on your programming skills and how much time you have to learn a new language. There is really no “best” programming language for robotics. There is only the best programming language for your project and your programming skills.

That’s why you need a programming environment which supports various languages. That way, you can choose the best one for you.

Python vs C#, C++ vs MATLAB: Which is Best?

With that in mind, the best way to pick a robot language for your project is to understand the strengths and weaknesses of each one.

Probably the four most popular languages for robotics are Python, C#, C++ and MATLAB. They are all great options and I have used them many times. For some larger projects, I have even used all three in the same project because each has its own unique strengths.

Python

Python was developed with the philosophy that code should be easy to read and that simplicity is better than complexity.

I picked up Python relatively late in my programming career. It was so easy to learn that I was able to use it immediately and I now use it for most programming tasks. Python is the language that I recommend most often to new robot programmers because it’s so easy to get started with it.

Python’s strengths for robot programming are:

• Easy to learn and easy to read.
• Gives access to many powerful libraries.
• Quick to write usable (and reusable) code.
• It’s very popular so there’s lots of help available from the Python community.

Python’s weaknesses for robot programming are:

• Code can easily become messy for big projects.
• “Jack of all trades, master of none.” It’s good at doing lots of things but it does not excel at anything in particular.
• Sometimes hard to spot errors due to the fact it is an interpreted language, which can lead to problems.

In my opinion, Python is best for quick, small-to-medium robot programming projects. It’s great if you want to access the powerful features provided by libraries and do not need real-time performance. However, if you want reliable, high-performance code, it might not be the best option.

C#

C# (pronounced C Sharp) was developed by Microsoft and released the early 2000s. Since then, C#  has quickly gained popularity and is now one of the most used programming languages in the manufacturing industry.

Contrary to C++, C# is easy to learn. C# is easy because it automatically handles memory management. This is accomplished through the so-called “garbage collection” scheme.

C#’s strengths for robot programming are:

• It is easy to learn and integrate with large projects.
• There is a wide variety of libraries available.
• It has an excellent and free development environment (Microsoft Visual C# Express).
• Microsoft Visual Studio has good tools for team development.
• C# runs on the .NET Framework and it is highly interoperable.

C#’s weaknesses for robot programming are:

• Software Development is limited to Windows.
• You can’t easily deploy your project to non-Windows computers.

Many HMI (Human Machine Interfaces) projects are developed in C#. An HMI is often a part of a SCADA (Supervisory Control and Data Acquisition) system.

C++

C++ is an object-oriented language which is based on the C language. It is based on the philosophy that performance is key and that code should be easy to organize.

If I was forced to choose only one programming language for robotics, it would have to be C++. This might seem a strange thing to say after having told you that I write most programs with Python. However, there is one big reason for my choice: performance.

If you are serious about robotics, I’d recommend learning C/C++. Robotics programming stretches from the lowest level (embedded motor and sensor control) all the way up to high-level Artificial Intelligence. C++ is one of the few languages which excels at all of these.

C++’s strengths for robot programming are:

• Potential for high performance (if your code is good).
• Access to lots of libraries (many Python libraries are just wrappers around C++ libraries)
• It’s the lowest level programming language you can get above assembler (the level of 1’s and 0’s).
• Libraries for robotic hardware components are often written in C/C++.

C++’s weaknesses for robot programming are:

• Takes time to learn and even longer to learn to code properly.
• Usually requires lots of debugging.
• Writing programs takes a long time.
• Third-party libraries are often difficult to use.

In my opinion, C++ is best when you need high performance or need to interact with low-level robotic hardware. However, if you want to program quickly with the minimum of fuss, C++ is probably not the best option.

MATLAB

MATLAB is not just a programming language, it is an entire programming environment. Its name stands for “matrix laboratory” and it excels at matrix mathematics.

Matrices are a fundamental part of robotics, as we covered in the article Robot Euler Angles: The Essential Primer. MATLAB is widely used by engineers to analyze and simulate their robots. Over time, people have created interfaces to allow the software to control physical robots.

I personally have a love-hate relationship with MATLAB. I hate using it to control physical robots as the whole process often seems very convoluted. However, when it comes to data analysis there really is nothing better. This is just my option as I know roboticists who use it for everything.

MATLAB’s strengths for robot programming are:

• A very powerful system for data and robot kinematic analysis.
• Quick to write usable code.
• Its robotics toolbox is widely used.
• Allows complex simulation.

MATLAB’s weaknesses for robot programming are:

• It’s not really designed to interface with robot hardware.
• As a proprietary language, it’s expensive.
• Not easy to share your code as the other person also needs MATLAB.
• Not as many third-party libraries as other options.

In my opinion, MATLAB is best for data analysis and simulation tasks but not for much else. When it comes to actually programming the robot, I usually recommend another language.

In conclusion…

My top 3 takeaways are:

• Python is best if you want an easy life. It’s good for smallish, quick robot projects.
• C# is better if you want a good balance between performance and quick results.
• C++ is best if you want performance.
• MATLAB is best for data analysis.

Whichever language you choose, make sure it is supported by your robot programming environment.
The RoboDK API brings the benefits of your favorite high-level programming language to industrial robots.

What’s your favorite programming language? Tell us in the comments below or join the discussion on LinkedIn, Twitter, Facebook or Instagram.

The post Python vs C++ vs C# vs MATLAB: Which Robot Language is Best? appeared first on RoboDK blog.

How do you control your robot? How do you tell it to start a program? How do you load a new program?

The answer is always the same: with the robot’s Human Machine Interface (HMI).

There is a huge range of options for robot HMIs. You can spend a lot of money on a fancy custom system or you can spend very next to nothing.

But, do you really need an HMI? How can you make an HMI without breaking your budget? Everything you need to know is explained here.

What is a Robot HMI?

HMI stands for Human Machine Interface. The name explains it all, really. The HMI is whatever method you use to “interface with” (i.e. control) the robot. It’s really as simple as that.

In industrial settings, we usually use the term HMI to refer to a touch-screen with graphical buttons. They are often used to control Programmable Logic Controllers (PLCs). Some companies specialize in creating customizable industrial HMIs, which can be expensive. However, this is only one of the many different types of HMI.

An HMI can be as basic as a single button wired into the robot’s controller to tell it when to start or stop. An HMI can be as complex as a 3D laser camera setup with a microphone which detects your body movements, makes the robot copy your dance movements, and stops when you shout out a command. An HMI can also be anything between these two extremes.

The main property of any HMI is that it allows you to control a machine. In the case of robotics, this machine is a robot. If the interface does not control a machine, it is not an HMI.

What’s the Difference Between a UI, a GUI and an HMI?

Outside the world of industrial manufacturing, it’s quite rare to hear people using the term HMI. You’re much more likely to hear UI or GUI.

What is the difference between these terms? Not very much, actually. Here are the definitions:

User Interface (UI)

A User Interface is any space in which there is an interaction between the user (you) and the software or machine. In the early days of computers, the UI consisted of a paper reader into which programmers fed rolls of computer code. These days, the most common UI is probably a touch-screen tablet interface. The next advancement in UI seems to be the growing popularity of audio-based interfaces (think Amazon’s Alexa or Google Home).

UI is a very broad category.

Graphical User Interface (GUI)

Graphical User Interfaces are a specific subset of UIs which use icons and visual indicators to allow users to interact with a  software or machine. Unless you have printed out this blog post on paper, you are currently looking at a GUI.

GUIs are often associated with software-only products. However, the interface you use to control your robot is almost certainly a GUI if it uses graphical icons, buttons, etc.

Human Machine Interface (HMI)

Human Machine Interfaces are also a subset of UIs. Their defining feature, as I’ve mentioned, is that they are used to control a physical machine.

HI (Human Interface) and UI (User Interface) are just two ways of saying the same thing. It’s safe to say that the machine is probably not going to be controlled by a non-human user — unless it’s Teco the bonobo ape who can use a tablet, although unfortunately, the acronym AI (for Ape Interface) has already been taken by Artificial Intelligence.

Not all HMIs use a GUI. An HMI can also consist of physical buttons, knobs and dials, or some other type of interface like audio recognition. However, we usually use the term HMI to refer to a system with a GUI.

The 4 Common Types of Robot HMI

There is an almost infinite number of HMIs for robots and there are new types appearing all the time. However, unless you’re involved with robotics research it’s unlikely that you will want to control a SCARA robot with an Xbox Kinect sensor. You want something a bit more reliable.

There are four types of robot HMI that are used most often in industrial settings:

1. Basic Hardware Buttons — You don’t get much simpler than a button attached to the digital inputs of the robot controller. This type of HMI is reliable enough to be used for emergency stop buttons, but it is not very flexible.
2. Robot Teach Pendant — Many robots come supplied with a teach pendant. These usually include some sort of GUI which you use to program the robot. The main problem with these — in terms of HMI design — is that they are not very customizable. You might be able to customize a few buttons or create a pop-up but the elements of the GUI are usually fixed.
3. Third-party HMI Panel — One option is to invest in an HMI panel from a third-party company. These are basically hardy touch-screen tablets. You can lay-out the GUI elements yourself using some sort of designer software. The main problem with these is that they are expensive — easily upwards of $3000 for the panel alone.
4. Computer GUI — The most flexible option is to create an HMI through a computer. It’s not quite as handy as either the teach pendant or dedicated HMI panel, but it is flexible and low-cost.

How to Make Your Own Robot HMI

It is quite straightforward to program your own robot HMI, as long as you pick the right tools. The key is to pick a system which allows you to easily program the GUI as well as programming the robot. If you don’t want to spend lots of time and money on a third-party panel, the best option is to make a computer GUI and link it to your robot SDK, like RoboDK.

A lot of the professionals that use RoboDK create their HMIs is Visual Studio with C#. The RoboDK API integrates easily with C#. This means you can quickly create an HMI which directly controls your robot.

What types of HMI have you used in the past? Tell us in the comments below or join the discussion on LinkedIn, Twitter, Facebook or Instagram.

The post Robot HMI for Automation Projects appeared first on RoboDK blog.

The first question you need to answer is: Do I want to program my robot online or offline?

Both options have their benefits. But, as we’ve explained before, offline programming has some huge advantages which blow online programming out of the water. Plus, a good offline programming system will allow you to program both offline and online, so it’s a win-win option.

Let’s say you’ve decided to look into offline programming. Now you run into a tricky question: Should you use an SDK? And, if so, which one?

In this article, we explain what a robot SDK is and we introduce the 8 qualities of an excellent robot SDK.

What is a Robot SDK?

What is an SDK? This is a common question. SDKs are often confused with related concepts, particularly API and IDE. In order to understand what a Robot SDK is, it’s necessary to be clear on the differences between these three concepts.

SDK: Software Development Kit

A Software Development Kit (SDK, also known as a Devkit) is a set of software tools which allows you to develop applications for a particular software environment or hardware device.

For example, the Android SDK allows developers to create apps for android phones. The Coszmo SDK allows developers to program the Cozmo toy robot. The Cognex Mobile Barcode SDK allows developers to create barcode reading applications for Cognex cameras.

As you can see from these examples, most SDKs are specifically targeted at one product or application. This creates a problem when it comes to robotics, which I’ll explain in a moment.

API: Application Programming Interface

An Application Programming Interface (API) is a single software library or set of libraries which contain the functions needed to perform a particular task. We often use them in robotics to interact with a specific hardware component.

For example, the Arduino API interfaces with Arduino microprocessors. The Sphero API interfaces with Sphero toy robots. The GoPro API interfaces with GoPro cameras.

IDE: Integrated Development Environment

An Integrated Development Environment (IDE) is a software application which helps you to write programs effectively. You could think of an IDE as a very helpful text editor. IDEs often include compilers, a text editor, debugging support, and tools to automate common tasks. Some IDEs support multiple programming languages whilst others are restricted to only one programming language.

SDK vs API vs IDE

Often, SDKs come packaged with both APIs and an IDE. This makes it easy to confuse the three concepts.

The basic difference is that SDKs are complete development environments. An API is just a single interface, and an IDE helps to write programs. Just remember this useful advice: “All SDKs contain APIs, but not all APIs are SDKs.”

The Problem With Most Robot SDKs

Robot SDKs are simply SDKs which can be used to program robots.

The problem is that most robot SDKs are only designed to interface with one specific robot or hardware component. Often they are also limited to specific applications. This makes them inflexible.

Here’s a typical (fictional) description of a robot SDK: Imaginary SDK 0.2 enables programmers to use Language 1 or Language 2 in Windows 8/10 to control the Imaginary Robot Controller v1 for X, Y, and Z applications.

That’s quite restrictive, isn’t it!?

What if you want to use a different programming language? What if you want to use your robot for a different type of application? Suddenly, you have to employ some time-consuming and complex programming techniques (e.g. writing extensive wrappers) to just program one robot to perform one task.

8 Qualities of an Excellent Robot SDK

Thankfully, not all robot SDKs suffer from this problem. It is possible to find a robot SDK which is very flexible and makes it easy to program a wide range of applications on any robot.

There are 8 signs that a robot SDK is a good one:

1. Various programming language options — You should be able to choose which programming language you want to use, with inbuilt support for popular languages like Python, C++, Matlab, etc.
2. Offline programming and robot simulation — The SDK should allow you to program the robot offline and test your program on a simulation of the robot, which reduces downtime.
3. Allows you to test the SDK for free — Brand-specific robot SDKs often require you to pay upfront. This is risky because you could end up locked into a bad programming environment.
4. Allows you to verify project feasibility before buying a robot — Most SDKs require the physical hardware to test your program. A good SDK should allow you to test your robot application before purchasing anything.
5. Can be used on many different robot brands — The major problem with most robot SDKs is that they’re locked into one specific robot brand. You should be able to program any robot with the same SDK.
6. Makes it easy to switch between robots — If you decide one robot isn’t suited for your task, you shouldn’t have to throw away all your existing code. The SDK should make it easy to transfer the program to a new robot.
7. Can be used with other software — No software can do everything perfectly. It should be easy to integrate the SDK with your favorite CAM package or application-specific software, like Slicer for 3D printing.
8. Is affordable — Some brand-specific SDKs are surprisingly expensive (I say surprisingly because usually, you’ve also invested a lot to buy the physical robot from the same brand). A robot SDK should be affordable.

Which Robot SDK Has All of These Qualities?

We didn’t like all of the restrictions imposed by most robot SDKs. So, we designed RoboDK to overcome the problem.

RoboDK is a flexible robot SDK which has all of the 8 top qualities and more. It allows you to program a huge range of robots from many different manufacturers. It supports the most popular programming languages and makes it easy to test your application on a simulation before purchasing anything.

You can try it out for free today.

What was your most difficult experience with programming robots? Tell us in the comments below or join the discussion on LinkedIn, Twitter, Facebook or Instagram.

The post Why Should You Program With a Robot SDK? appeared first on RoboDK blog.

Visitors and locals touring around Munich, Germany in June, 2016 may have come across an impressive instant automated drawing stand at Vodafone Flagship Store München prepared by CMOCOS using RoboDK and a KUKA Robotics IIWA robot. The project attracted crowds and allowed visitors to have their portrait drawn by a robot. They looked fantastic! How did it all work behind the scenes?

First, a picture of the customer was taken with a Huawei P9 Leica Dual camera and converted into an svg image. From there, CMOCOS used RoboDK’s simulation software to automate the portrait printing from the svg image. RoboDK was used to create and simulate the robot path using offline programming tools and send it to the robot automatically. With those few simple tools, customer after customer had their portrait magically appear by this artistic robot.

The post Instant Portraits By Your Neighbourhood Robot appeared first on RoboDK blog.