Sign in to watch this lesson

This video will show you how to connect your robot to NCHyper, starting from scratch, even if you don't have NCHyper installed yet. The first task is installing NCHyper. It's straightforward. Run the installer.

I also recommend checking the option to install MachineMaker because that's the tool we'll use to build the robot cell. Launch MachineMaker. On first run, it offers a quick tutorial, highly recommended. You can open it anytime by clicking the question mark on the right.

Make sure you're in the robotic cell mode, since we'll be controlling robots, not machine tools. MachineMaker includes a large library of ready-to-use mechanisms, literally thousands. Our robot is already there, so we just add it from the library. The end effector isn't in the library, but that's fine.

We have a 3D model, so we can add it ourselves. Choose the 3D model. If you see an unclear prompt, click No. In general, when unsure, click No to avoid issues.

Select the 3D model parts you need for the end effector, in our case, the whole model. Position the end effector in the same orientation as on the real robot, tool facing down for me, and define the tool types that can be mounted in this end effector. This is a test project, so I'll allow a wide range of tools. Milling, part handling, pretty much anything.

Next, we can mount a tool on the end effector. Ideally, you should do this with calibration. We have a dedicated app for that. For a test project, relying on the 3D model's accuracy is acceptable.

Now let's add a table, because our robot obviously isn't standing on the floor. It's on a table. Import the table's 3D model and give it a clear, readable name. Let's call it Table.

Define the robot's mounting point. Snapping is available and you can switch views as needed. Remove any X-Y offsets, and name this new coordinate system to keep things organized. Mark it as a mounting point for another mechanism, not a workpiece location.

Optionally, add another coordinate system. Useful, for example, for placing workpieces. This task is optional. You can add coordinate systems in MachineMaker or later in NCHyper.

Whatever is convenient. We have a table, a robot, and an end effector. In our setup, the robot isn't mounted directly to the table, but via a spacer plate. Adding the plate is the same as adding the table.

Import the model, and give it a clear, readable name. Lower it slightly so it doesn't float. Looks good. Go to Kinematics and set the robot's mounting point on the plate.

Place the coordinate system exactly where the robot will be installed. Again, this is a mounting point for another mechanism, not a workpiece. That's it. It's time to assemble the cell.

Check the coordinate systems. Here's the robot. Here's the workpiece location. Now place the plate on the table and the robot on the plate.

Our cell is assembled. This is the digital twin of the real robot. Reset the pose. Oops, the cell dropped below floor level.

Don't do that. Always keep the cell aligned with the floor. Now it's correct. Robot on the table, table on the floor.

Just like real life. Save the cell. Export the cell to . mma format.

The . mma format is convenient because it's a single portable file. Not an XML plus images plus 3D models, but one file that contains the entire cell. NCHyper and MachineMaker both work with .

mma files. Open NCHyper and load the . mma file. Inside this one file you have the 3D geometry and the cell definition, so you can share it via email or cloud services.

NCHyper has loaded the cell so we can already start programming. Let's make a simple motion. The robot moves to a point and returns. That's the first and most important task.

We now have a digital twin of our real cell. Our next step is connecting NCHyper to ENCY and preparing an ENCY project so it can be opened in NCHyper. This step is optional. If you don't need ENCY, for example, you don't have complex toolpaths, you can skip ahead.

In this example we'll look at a milling toolpath. Export the operation parameters. The parameter file will be saved next to the project file. Here it is.

This file contains the operation parameters. The NCHyper operator will adjust these parameters, but they don't need all of them. We provide a special utility that lets you curate which parameters will be editable in NCHyper. Drag and drop the parameter file into the utility, review all parameters, and select the ones to expose in NCHyper, for example, milling type and strategy.

Save the result. Here they are. You can access virtually any parameter available in ENCY and make it editable in NCHyper. Now we have the project file and the curated parameter file.

Open the project in NCHyper. In settings, make sure the robot type is set correctly, KUKA in our case. That's important. Also confirm that NCHyper knows where ENCY is installed, because NCHyper will ask ENCY, running in the background, to recalculate toolpaths, update the project, and load it back.

NCHyper does this automatically. We can create a stock model if we like, but it's not required. Go to the programming section and add the ENCY project block. Select the actual ENCY project file.

At this point, NCHyper launches ENCY in the background, recalculates the toolpath, and imports it. Here it is, the toolpath computed by ENCY. NCHyper can simulate it and also run it on the real robot. The key advantage is that the NCHyper operator can change parameters right here.

For example, switch the strategy from spiral to zigzag, then have ENCY recalculate the toolpath in the background, and immediately see the new result. You can also change the milling type. The toolpath updates quickly, no manual round trips and no exporting or importing between NCHyper and ENCY. It's automatic and seamless for the user.

In short, NCHyper leverages the full power of the ENCY-CAM system. Recalculate toolpaths, tweak project parameters, do whatever you need, and then run it on the robot right away. If you remember, our original project used a spiral strategy. Now it's a single pass path.

We can add extra blocks, modify the process, anything we like. Time to move on to setting up the KUKA robot so we can connect to it. First, install the C3 bridge utility on the robot. Go to Settings -> Arrow Administration -> Arrow Windows.

KUKA runs on Windows, so you can launch standard executables. Copy C3 bridge onto the desktop and run it. That's enough. The utility is available online, free, and open source.

Next, define user global variables. This task is required. You're not editing system variables, only user variables needed for runtime. You'll find the required list in your installed NCHyper.

There's a text file with the variables. Copy them from that file into config. dat under user globals. It's perfectly safe.

You can remove them anytime, and they cannot harm your system. That completes the KUKA setup. Now configure networking. You need the robot's IP address so we can connect via Ethernet or Wi-Fi.

Open the network settings on the robot and note the IP address in subnet mask. Back in NCHyper, open your project and go to Project Settings via the Home menu. Scroll down to Robot Driver Settings. Ensure the robot type is KUKA and enter the correct IP address.

You can use tools like Ping to verify reachability. For safety, I recommend limiting the robot's maximum speed, say to 10%. Also make sure NCHyper and the KUKA controller are on the same subnet. You can set a fixed IP on the NCHyper PC and verify the subnet mask.

One last task, put the robot into auto mode and enable the drives. That's it. Your KUKA robot can now be controlled with NCHyper. Open your project in NCHyper and connect to the robot.

If the robot requests confirmation, approve it. This is normal KUKA safety protocol confirming you intend to run programs. Click Next and the robot will start moving. NCHyper streams commands in real time and tracks motion in real time.

You can change operation parameters and immediately run the updated program. The robot follows the path smoothly. You maintain full control, speed up, slow down, stop immediately, adjust parameters, and relaunch the updated program on the real robot seamlessly. You can pause and resume to debug ENCY projects while standing right next to the robot, without recalculating operations manually or changing parameters back in ENCY.

You do it directly in NCHyper. Let's let it run a bit more. It's mesmerizing to watch. We can switch strategy, say, to zigzag and recalculate.

NCHyper calls ENCY to generate a new toolpath. You can see it updated, and we launch it on the robot right away. So, we've gone end-to-end. Installing ENCY on a clean machine, configuring a KUKA robot, and running a program.

Executing an ENCY toolpath on a real robot through NCHyper. The whole process took less than 15 minutes. Please try it out! Use NCHyper, use ENCY, and share your feedback!