Reviving a 20-Year-Old Robot Using NI LabVIEW

Author(s):
Jonas Neubert - Imperial College London

Industry:
Research

Products:
CompactRIO, FPGA Module, Real-Time Module

The Challenge:
Replacing the missing controller of a 20-year-old industrial robot and enhancing it with functions typical for modern-day robot control software to create a system that is operated through an intuitive graphical user interface (GUI) and suitable for teaching in undergraduate laboratory classes.

The Solution:
Using an NI CompactRIO controller as an interface to the robot’s drives and encoders with LabVIEW 8.5 software and a proportional integral derivative (PID) toolbox, 3D image rendering and VI server functionality to implement the robot kinematics in software and make them accessible through a GUI.

Industrial robots have experienced rapid technological development over the past few decades. Since the 1980s, they have evolved from pick-and-place robots, which were merely able to follow a predefined trajectory with limited accuracy, to systems that feature precisions high enough to find applications in operating theatres and that can flexibly adapt to their environments while often interacting with vision systems and other robots in the same production cell. This is why when a 20-year-old Mitsubishi Movemaster robot was found in the stores of our university department, the first idea was to give it to a museum. One faculty member, however, decided to give me, an undergraduate student at Imperial College at the time, an opportunity to revive the robot.

Project Goals

In its younger days, the Mitsubishi Movemaster was accompanied by a handheld teaching box, a microwave-sized drive unit and an optional computer that could communicate desired angular positions for all robot joints to the drive unit through a serial interface. All of those peripherals have been lost since then, so we wanted to fix the 36 unidentified pins at the robot base to give the robot back its original functionality. We needed to replace the archaic programming language once used to control the robot from a PC with an intuitive user interface. Keeping the potential application as a teaching aid in mind, we wanted to create a system that future students could easily extend, especially through different control algorithms.

Design Options

After we tried to reverse-engineer the robot, we needed to define an overall system layout through two main steps. First, we had to develop an I/O solution to drive the robot’s five DC motors and concurrently read its encoder signals. Secondly, we needed to find a way to transmit information to a standard PC and display it in a GUI.

Both the channel counts (15 pulse-width modulation [PWM] digital output signals and 10 digital inputs) and sampling rates (PWM at 1 kHz period and input sampling at 100 kHz) required by the system were not outside the realm of a custom-made solution based on standard microcontroller boards. However, the multitude of programming environments and challenges we faced in developing such a system exceeded the time frame and scope of an undergraduate project. The choice of National Instruments products, which provided the complete set of required functionality from data acquisition through advanced GUI development, was therefore an obvious one.

We selected the CompactRIO programmable automation controller (PAC) for its ability to sample and process the required number of signals concurrently and in real time. And even though the cost of the product exceeded the budget of a typical undergraduate project, the CompactRIO versatility and ease of use made it feasible. Because we could set up the CompactRIO controller (including wiring and deployment of all software) within less than five minutes, we could share one controller with another.

Signal I/O

The field-programmable gate array (FPGA) backplane of the CompactRIO controller enabled the reading, writing and processing of I/O module channels in a truly parallel fashion. With the ample amount of programmable gates, we could output five independent PWM signals with a 1 kHz period and 10 further digital outputs to external motor driver chips while sampling 10 encoder channels at 100 kHz. Also on the FPGA, we processed the signals from two encoders per robot joint into an integer reading representing the relative joint angle. Using prewritten VIs available on the National Instruments website helped us further shorten the FPGA VI development time. Two fast switching digital input and digital output modules each provided a sufficient channel count for our application.

Graphical User Interface

While the feature set of the hardware interface described above is somewhat limited by the capabilities of FPGA technology, the user interface of our system runs on a Windows PC and can make use of the full range of LabVIEW 8.5 features. With the event-driven interface, the user can set the location and orientation of the robot end effecter in Cartesian coordinates both by entering a position vector and by moving the robot up/down, left/right and forward/back incrementally. A coordinate transformation is then made and the desired joint angles for each robot joint are computed. These are then fed into a controller subVI that computes the motor demand signals from desired and actual joint angles.

To allow future students to experiment with different control algorithms, the controller subVI is loaded at run time and can contain arbitrary logic as long as the front panel elements defined by a template are present. This is especially useful because students might not have access to a full-featured LabVIEW environment but only a student edition that lacks the LabVIEW FPGA and LabVIEW Real-Time modules. Even though the student version is not able to open the complete robot software, students can still use it to develop a robot controller and later test it on the robot.

The reliability of our aging robot was an issue throughout the project, and we decided we needed a simulation of the robot to continue working while the robot was under repair. Using the LabVIEW 3D image control, we created a schematic representation of the robot. With the GUI, the user can assess whether the software has an accurate representation of the current robot position. Whenever the visualization does not match reality, the user can send the robot to a home position and reset the software with the push of one button.

Conclusions

With CompactRIO and LabVIEW, we were able to build a complete robot drive and control system from scratch using a single programming environment. Thanks to the ease of use of the CompactRIO controller, harnessing high-tech FPGA technology to awaken our “antique” robot was child’s play. As an undergraduate, I developed the entire system, including the software and hardware, in less than nine months of part-time project work.

Acknowledgements

I carried out this project in the Mechatronics in Medicine Lab, and Dr. Ferdinando Rodriguez y Baena supervised it. This project is based on previous work by Christopher Burton.

Author Information:
Jonas Neubert
Imperial College London
South Kensington Campus
London SW7 2AZ

Browse All Case Studies »