lejos.sourceforge.io No paid content found

Epson industrial robots are best understood as a family of high-speed, compact SCARA and 6-axis machines built for repetitive, precision tasks in tight spaces. They are not the right answer for every factory job. The practical way to choose is to start from the task, not the brand: define the motion, payload, reach, cycle time, and environment, then compare Epson against cobots, other industrial robot brands, and fixed automation on those specific numbers. This guide walks through that decision process step by step.

Step 1: Define the task before comparing any robot

Write down the answers to these questions. Vague answers are the main reason automation projects stall.

• What is the motion? Pick-and-place, assembly, dispensing, inspection, machine tending, and packaging each stress different specs.
• What is the part? Weight, dimensions, material, and whether it is fragile or hot.
• What is the required cycle time? Parts per minute or seconds per cycle, measured at the actual station.
• What is the working envelope? Distance from the robot base to the farthest pick and place point, including any obstacle the arm must reach around.
• What is the environment? Cleanroom, dust, washdown, vibration, or a shared space with people.
• What is the volume and changeover pattern? One product for years, or frequent line changes.

Only after this list is concrete does a robot comparison become meaningful.

Step 2: Map common factory tasks to robot types

Epson's lineup centers on SCARA and 6-axis industrial robots, with compact models for space-constrained cells. That makes Epson a strong candidate for the first four rows above, and a weaker fit for collaborative tasks where a cobot's safety-rated design is the deciding factor.

Step 3: Compare Epson against the main alternatives

Epson industrial robots vs. cobots

Cobots trade speed and rigidity for the ability to work near people with less fencing. If your task is high-speed and you can fence the cell, a traditional industrial robot like Epson's is usually the more productive choice. If the cell must be open, or the task is low-volume and frequently re-taught by hand, a cobot often wins on safety and setup effort.

Epson vs. other industrial robot brands

Most major brands offer comparable SCARA and 6-axis categories. The real differentiators are:

• Footprint and mounting options — ceiling, wall, or table mount can decide whether a cell fits at all.
• Controller and software ecosystem — how the robot is programmed and how it talks to your PLC, vision system, and conveyor.
• Local support and spare parts — downtime cost usually exceeds the price difference between brands.
• Integration effort — available vision, force sensing, and conveyor tracking options.

Epson vs. fixed automation

Fixed automation (cam-driven indexers, dedicated pick heads, hard-tooled stations) is faster and cheaper per unit at very high volumes with a single unchanging product. Robots win when the product changes, when volumes are moderate, or when you need flexibility to redeploy the same machine later. A useful rule: if the product will not change for several years and volume is very high, evaluate fixed automation seriously; otherwise a robot is usually the more durable investment.

Step 4: Check the specifications that actually decide the outcome

• Payload — Use the rated payload, then subtract the weight of the gripper, camera, and cabling. A robot rated for a given payload at the flange carries much less once tooling is attached.
• Reach — Measure to the farthest point of the actual motion path, not the center of the work area. Add margin for approach and retreat.
• Repeatability — This is not the same as accuracy. For assembly and inspection, repeatability is usually the number that matters.
• Cycle time — Ask for cycle time at your payload and path shape, not the catalog's best-case figure.
• Controller compatibility — Confirm the robot's controller can exchange signals with your existing PLC, vision, and safety system without a costly gateway.
• Mounting and cable routing — Verify the arm can be mounted the way your cell requires and that cable management does not collide with the motion path.

Step 5: Run a structured evaluation

1. Build a one-page task spec using the Step 1 list.
2. Shortlist two or three robot types, including at least one non-Epson option for comparison.
3. Request a cycle-time estimate at your real payload and path from each vendor.
4. Model the cell layout to confirm footprint, reach, and safety fencing fit the floor space.
5. Estimate total cost of ownership: robot, controller, gripper, vision, safety hardware, integration labor, programming, training, spare parts, and expected downtime.
6. Pilot the task on the leading candidate before committing to a full line.
7. Confirm support terms — response time, local service, and spare-part availability.

Common trade-offs to expect

• Floor space vs. reach — Longer reach usually means a larger footprint or a different mounting position.
• Speed vs. safety — Faster motion typically requires more fencing and stricter safety assessment.
• Flexibility vs. cost — Robots cost more upfront than fixed automation but can be reprogrammed for new products.
• Programming effort — Some controllers and software environments shorten setup; others require more specialized integrator time.
• Total cost of ownership — The robot is often a minority of the project cost. Grippers, vision, safety, and integration usually dominate.

A practical rule of thumb

Choose Epson-class SCARA and 6-axis robots when the task is high-speed, repetitive, precision-oriented, and can be fenced. Choose a cobot when the cell must share space with people or changeover is frequent. Choose fixed automation when the product is stable and volume is very high. In every case, let the measured payload, reach, cycle time, and integration requirements make the decision — not the brand name on the arm.

ICommand is the leJOS NXJ PC-side interface for sending direct commands to an NXT brick from a host computer over Bluetooth or USB. Use it when you want the PC to control the brick in real time — start a motor, read a sensor, play a tone — without uploading and running a Java program on the NXT itself. If your goal is to run autonomous Java code on the brick, you want the NXJ firmware and the on-brick API instead; ICommand is for the PC-driven case.

Direct commands vs. the NXJ protocol

These are two different control paths, and mixing them up is the most common source of confusion:

Direct commands are the same low-level command set the standard LEGO firmware understands. That means ICommand can talk to a brick that is still running the stock firmware, which is useful for quick experiments before you commit to flashing NXJ.

Opening a connection and creating a command object

The general shape of a PC-side session is: open a transport, wrap it in a command object, issue commands, then close.

1. Pick a transport. Bluetooth for a paired brick, USB for a cabled connection. Both implement the same NXT connection interface, so the rest of your code is identical.
2. Open the connection to the brick. For Bluetooth this means the brick must be paired with the PC first; for USB the brick must be connected and the leJOS USB driver available.
3. Instantiate the command object from the open connection. This is the object that exposes the direct-command methods.
4. Issue commands — motor, sensor, sound, and so on.
5. Close the connection when done, so the port is released for the next session.

The exact class and constructor names live in the leJOS NXJ PC API documentation on the site; check the API section there for the current signatures rather than relying on remembered names, since the API has changed across releases.

Common direct commands

Through ICommand you can reach the standard NXT command groups:

• Motor control — set forward/reverse, set speed, brake, reset the rotation counter, and read the tachometer.
• Sensor reads — poll a sensor's current value or switch it into a different sensor mode.
• Sound — play a tone with a chosen frequency and duration.
• System and status — query battery level, firmware version, and brick status; some builds also expose reset and sleep.

Because these map onto the standard firmware command set, the values you read back (tachometer counts, raw sensor values) are the same ones the stock firmware reports.

Troubleshooting

• Connection fails immediately. For Bluetooth, confirm the brick is paired and powered on; for USB, confirm the cable and driver. A brick that is already in an NXJ program may not accept direct commands until it returns to the firmware's command loop.
• Commands appear to do nothing. Check that you are addressing the right motor port or sensor port, and that the sensor is in the mode your read expects.
• Works once, then fails. You probably did not close the previous connection; the port stays busy.
• API mismatch. If a method you expect is missing, you are likely on a different leJOS NXJ release than the documentation you are reading — the PC API has been revised over time.

For the current class list and method signatures, use the leJOS NXJ API pages linked from the site's NXJ section.

The LEGO Mindstorms NXT is a programmable robotics brick, and leJOS NXJ is a Java-based replacement firmware that lets you run Java programs on it instead of the stock firmware. You would choose NXJ when you want to write NXT robot logic in Java, using the leJOS NXJ API and PC API rather than the graphical or vendor-supplied programming tools. This article explains what NXT is, what NXJ is, how Java actually executes on the brick, and the basic workflow to get running.

What the NXT Is, and How It Differs from RCX and EV3

The NXT is one generation in LEGO's Mindstorms line of programmable robotics bricks. leJOS supports multiple generations, which is why the site lists separate firmware and API sets:

The key distinction for a beginner: NXT is the hardware brick, while NXJ is the software layer that replaces its firmware so it can execute Java. RCX and EV3 are different bricks with their own leJOS variants, so NXJ instructions and APIs apply to the NXT, not to the others.

What leJOS NXJ Is

leJOS is described on the site as "a Java based replacement firmware for the Lego Mindstorms RCX microcontroller," and NXJ is "a Java based replacement firmware for the Lego Mindstorms NXT microcontroller." In other words, NXJ is the NXT-specific member of the leJOS family.

Practically, that means:

• You replace the NXT's normal firmware with the NXJ firmware.
• You program the brick in Java.
• You use the leJOS NXJ API for on-brick robot behavior and the PC API for communication between a host computer and the NXT.

How Java Runs on the NXT: TinyVM and the Java VM

The NXT does not run a full desktop Java environment. leJOS NXJ relies on a small Java virtual machine — the site's keyword list includes TinyVM — so that Java bytecode can execute within the brick's limited resources.

The mechanism, in plain terms:

1. You write Java source code on your PC.
2. It is compiled to Java bytecode.
3. The bytecode is uploaded to the NXT, where the leJOS NXJ firmware and its small VM execute it.

This is why NXJ is described as replacement firmware rather than just a library: the Java execution capability lives on the brick itself, not on the PC.

Basic Workflow: From Java Code to a Running NXT

The site points to NXJ tutorials and downloads as the starting resources. The general sequence is:

1. Install the NXJ firmware on the NXT, following the leJOS NXJ tutorial and download instructions.
2. Write Java code using the leJOS NXJ API for robot behavior.
3. Compile the code on your PC.
4. Upload the compiled program to the NXT.
5. Run it on the brick.

If your program needs to talk to a PC — for example, sending commands or receiving sensor data — you use the PC API alongside the on-brick NXJ API.

A concrete task example

Suppose you want the NXT to drive forward until a sensor triggers, then report back to your PC. You would write the motor and sensor logic with the NXJ API, compile it, upload it to the NXT, and use the PC API on the host side to receive the report. The exact classes and methods are documented in the NXJ API and PC API references linked from the leJOS site.

Where to Go Next

The leJOS site organizes NXT material into these entry points:

• leJOS NXJ API — classes for programming the brick.
• PC API — classes for host-to-NXT communication.
• Tutorial — guided setup and first programs.
• Downloads — the NXJ firmware and related files.
• FAQ and Forum — troubleshooting and community help.

For related questions, the site's own structure separates NXJ (the firmware and how it runs Java) from ICommand (how direct commands are sent to an NXT), so treat those as distinct topics when you search the documentation.

The LEGO Mindstorms RCX is the first-generation programmable brick in the Mindstorms line, and leJOS is a Java-based replacement firmware that lets you run Java programs on it instead of the stock firmware. You'd choose this route if you already own an RCX and want to program it in Java rather than the original RCX code or third-party alternatives. The leJOS project site (lejos.sourceforge.io) documents a dedicated RCX API, tutorial, and downloads section alongside its later NXJ and EV3 work.

What the RCX is

The RCX is the programmable controller at the center of the original Mindstorms Robotics Invention System. It runs a small on-board runtime, accepts programs downloaded from a PC, and drives motors and reads sensors through its input and output ports. It predates the NXT and EV3 bricks, so it has less memory, a slower processor, and simpler sensor support than later hardware.

How leJOS replaces the RCX firmware

The site describes leJOS as "a Java based replacement firmware for the Lego Mindstorms RCX microcontroller," with NXJ as the equivalent for the NXT. In practice this means:

• You replace the firmware LEGO shipped on the brick with the leJOS firmware.
• That firmware hosts a small Java runtime (the project's TinyVM lineage) on the brick.
• You write Java on a PC, compile it, and upload the resulting program to the RCX, where the runtime executes it.

So the RCX stops running its original firmware and starts running Java bytecode under leJOS. The brick's own hardware limits — memory and CPU — still apply, which is why leJOS programs for the RCX are small and avoid heavy libraries.

Writing Java for the RCX

leJOS provides an RCX-specific API rather than the NXT or EV3 APIs. The site's navigation lists separate leJOS RCX API, Tutorial, and Downloads pages, which is where you find the classes for motors, sensors, and brick control, plus worked examples. The NXJ and EV3 sections are separate products with their own APIs, so code written for one brick does not carry over unchanged.

Getting started: install firmware, then upload a program

The exact menu names and tool versions live on the leJOS RCX tutorial and download pages; the general sequence is:

1. Check prerequisites — an RCX brick, the means to connect it to your PC (the RCX's IR link), and a Java development setup on the PC.
2. Download the leJOS RCX package from the Downloads section of the site.
3. Install the leJOS firmware onto the RCX, replacing the stock firmware, following the tutorial's steps.
4. Write and compile a small Java program against the RCX API.
5. Upload the program to the brick over the same connection and run it.
6. Verify by watching the brick's motors or sensors respond as your program directs; if nothing happens, re-check the firmware install and the upload step first.

Limitations to expect

Because the RCX is the oldest Mindstorms brick, leJOS on it is constrained compared with NXJ on the NXT or leJOS EV3 on the EV3. Expect tighter memory, a slower processor, and a smaller API surface. The site's own release notes show the project's active development moved on to EV3 (0.9.1-beta in 2015) and NXT, so RCX material is best treated as legacy support. If you are choosing hardware now rather than working with an existing RCX, the NXT and EV3 paths have more current documentation and tooling.

NXJ is the leJOS replacement firmware that lets a LEGO Mindstorms NXT brick run Java programs. You use it when your target hardware is the NXT (not the older RCX or the newer EV3), and you want to write robot code in Java instead of the stock NXT-G visual language. The leJOS project describes itself as "a Java based replacement firmware for the Lego Mindstorms RCX microcontroller," with NXJ being "a Java based replacement firmware for the Lego Mindstorms NXT microcontroller" — so NXJ is the NXT-specific branch of the same project.

Where NXJ fits in the leJOS family

The leJOS site splits its work by brick generation. Picking the wrong branch is the most common early mistake, because the firmware, API, and PC-side tooling differ per brick.

If you own an NXT, NXJ is the branch you want. If you own an EV3, the site's news entries point you to the EV3 releases and their Wiki instructions instead.

How Java actually runs on the NXT

The NXT brick does not run a desktop Java Virtual Machine. NXJ relies on a small Java runtime — the project's keyword list names TinyVM, the compact VM lineage behind leJOS — that fits the brick's limited memory and processor. Your Java source is compiled on the PC, then the resulting class files are linked and uploaded to the brick, where the on-brick runtime executes them.

Two practical consequences follow from that design:

• You develop on a PC, run on the brick. Compilation and linking happen on the host; only the finished program goes to the NXT.
• The PC side needs its own API. leJOS provides a PC API and an ICommand layer so host software can talk to the brick — for uploading programs and for communicating with a running robot.

The basic workflow

The exact menu names and commands live in the leJOS NXJ tutorials and Wiki, which the site links from its NXJ section. At the level the project documents, the sequence is:

1. Install the NXJ firmware on the NXT brick, replacing the stock firmware.
2. Set up the PC toolchain — the leJOS NXJ downloads include the API and the host-side tools you compile and upload with.
3. Connect the brick to the PC using the PC API / ICommand communication path.
4. Write and compile your Java program against the leJOS NXJ API.
5. Link and upload the program to the brick, then run it there.

Verify each stage before moving on: after step 1 the brick should boot into leJOS rather than the stock firmware; after step 5 the program should start on the brick without the PC attached.

Common sticking points

• Wrong branch. Installing EV3 or RCX tooling against an NXT will not work; confirm you are in the NXJ downloads and tutorials.
• Version drift on the host side. The EV3 release notes show the project's habit of requiring you to update the Eclipse plugin alongside the firmware. Expect the same discipline on the NXT side: keep the PC API and the brick firmware from the same release.
• Assuming a full JVM. Because the on-brick runtime is a compact VM, not every desktop Java library is available. Check the NXJ API for what the brick actually supports.

Where to start

The leJOS site organizes NXJ as three entry points: API, PC API, and Tutorial, plus a Downloads page. Begin with the tutorial and downloads for your release, keep the API reference open while coding, and use the PC API when you need host-to-brick communication. The FAQ and forum are linked from the same navigation if you hit a problem the tutorial does not cover.