IMD SolutionComputing LibraryShop main store

Troubleshooting

Fixing IRMQMessage FlexPendant Interface load error

Operating systems on the plant floor Published 5 min read

Short answer

The error names a missing controller system option, not a code fault: the virtual controller's system was built without FlexPendant Interface, so the RAPID module is rejected at load and the PC SDK receive path is never tested. Build the virtual system with the option (a backup of the real controller is the reliable source), then debug the IpcQueue exchange only after the module loads.

On this page
  1. What the error actually gates
  2. Fixes that cannot change the result
  3. Giving the virtual controller the option
  4. Sending a controller event to a PC SDK application
  5. Worked example: one test module against zero matching options
  6. Load failures and exchange failures are different faults
  7. Questions asked

The message The instruction IRMQMessage requires the option FlexPendant Interface is a controller system gate, not a fault in your RAPID logic or your C#. The virtual controller's system was built without FlexPendant Interface, so the module is rejected at load and the messaging exchange is never tested. Fix the system, not the code: create the virtual controller from a backup of the real controller, which carries that machine's option list, or build the system with FlexPendant Interface selected. The identical error from RMQFindSlot confirms the diagnosis — in your test, both message-queue instructions sat behind the same missing option.

What the error actually gates #

A RAPID module is checked against the option set of the system it loads into. Every instruction must be covered by an installed option, and the loader names the one it cannot satisfy: FlexPendant Interface for IRMQMessage, on your virtual system. When that check fails, nothing from the module runs. No queue is created, no message is sent, and your PC application has nothing to receive. A load-time gate is the earliest and cheapest failure in the chain, and it answers deterministically — the same rejection, every attempt, until the system changes.

Fixes that cannot change the result #

You have probably tried some of these already; none of them touches the gate:

  • Editing the C# receive code. The module is rejected on the controller before your application is part of the picture.
  • Swapping IRMQMessage for RMQFindSlot. Your test produced the same error for both, which is the signature of a shared option dependency, not a poor instruction choice.
  • Reloading the module, restarting the virtual controller, reopening the solution. A configuration check returns the same answer every time.
  • Debugging IpcQueue and IpcMessage construction. That is real work, but only after a module loads; right now there is no message for those classes to carry.

Giving the virtual controller the option #

  1. Capture the complete load message. The instruction name and the option name together are your requirement.
  2. Read the virtual system's option list in its system configuration. FlexPendant Interface will be absent, and that absence is the entire fault.
  3. Rebuild the system with the option present. The reliable route is to lay the virtual controller out from a backup of the real controller, because the backup carries the installed option list; otherwise create a new system with FlexPendant Interface selected. Options are licensed system content, so this stays a system-configuration step under the licensing you hold — never an edit to program or system files to skip the check.
  4. Load the module again on its own, with no PC application connected. A clean load closes the option fault.
  5. Only then connect the PC SDK application and test the exchange.

Sending a controller event to a PC SDK application #

Keep the two directions apart once loading is solved. A PC-to-controller command and a controller-to-PC event use the same machinery from opposite ends, and your case is the second: a RAPID procedure raises an event that a PC application consumes.

The controller side sends with the RAPID message-queue instructions. The PC side receives through the messaging domain of the PC SDK: IpcQueue and IpcMessage under ABB.Robotics.Controllers.Messaging, with the RAB DLL referenced from your installed SDK so the classes resolve. The PC SDK application manual works with existing queues in the controller, so the queue name the RAPID task writes and the queue name your code opens must be the same — check that correspondence first once the module loads. The sample that demonstrates the pattern is a C# solution built on VS2008 and described as working against real and virtual controllers alike; treat the toolchain as sample context, not a requirement. Start the receiver before you trigger the procedure.

One limit to respect: this channel is coordination and diagnostics, not safety. Messages can be delayed or dropped, so no personnel-protection function may depend on the PC side receiving one.

Worked example: one test module against zero matching options #

Inputs:

  • 1 RAPID test module written to raise a controller event, from the failed load attempt.
  • 2 messaging instructions tried: IRMQMessage first, then RMQFindSlot.
  • 1 option named by the load error both times: FlexPendant Interface.
  • 0 matching entries in the virtual system's option list.

Rule in words: a module loads only when every instruction in it is covered by an installed option. Count the distinct options the module's instructions require, subtract the ones installed, and the remainder is the number of blockers.

The arithmetic:

  • Distinct options required: 1, FlexPendant Interface, named by both errors.
  • Matching options installed: 0.
  • Blockers: 1 − 0 = 1.
  • Messages the module has sent: 0. Messages the IpcQueue code has handled: 0.

One blocker is enough. The loader rejects the module at the first instruction, in both variants, on every attempt, and the PC SDK receive path has executed zero times — which is why no amount of C# debugging has moved this error.

The decision, with its threshold: at 1 or more blockers, the only fix is the system configuration, rebuilt as above. At 0 blockers the module loads and you move to the exchange checks — receiver started first, queue names matched, messages received equal to messages sent.

Load failures and exchange failures are different faults #

Observation What it tells you Next move
Module will not load; the error names an option A gate on the system configuration Rebuild the system with the option
Module loads; the procedure never reaches its send instruction A RAPID execution path problem Trace the procedure logic before touching C#
Procedure sends; the PC receives nothing Queue-name mismatch or a late receiver Match the queue names and start the receiver first
Unread messages accumulate until the controller reports a full queue Nothing is draining the queue Fix the receive loop before more messages pile up

If messages flow and then stop, that is a live exchange stalling — a different fault from a module that never loaded — and fixing RAPID IPC messaging when queues go silent is where that diagnosis starts. Queue-full behavior has its own anatomy: on an IRC5, trap interrupts are a known source, covered in fixing IRC5 IPC queue full errors from trap interrupts, and resolving S4C+ IPC queue full system failures covers the equivalent failure on the older controller generation. When suspicion shifts to the PC host itself, proving an IPC slowdown is hardware, not software keeps that call honest.

Questions asked

How do I add FlexPendant Interface to a virtual controller?

The option belongs to the controller system, not to the RAPID program or the PC SDK project. Lay the virtual controller out from a backup of the real controller, which carries that machine's option list, or create a new system with FlexPendant Interface selected. One option clears both instructions: your test showed IRMQMessage and RMQFindSlot behind the same requirement, so a single system rebuild fixes the module either way.

Will the real controller reject the module too?

Only its own option list decides that. Virtual systems are often built with a minimal option set, which is why the error surfaces there first. Read the real controller's installed options before assuming the two systems match; if the option is present, the same module should load unchanged.

What is the best way to send an event from a RAPID procedure to a PC SDK application?

Use the RAPID message-queue instructions on the controller side and the IpcQueue and IpcMessage classes under ABB.Robotics.Controllers.Messaging on the PC side, opening the same queue the task writes, with the RAB DLL referenced from your installed SDK. If you also need the PC-to-controller direction, test it separately; one direction working says nothing about the other.

The module loads now but nothing arrives at the PC. What next?

Check three things in order: the procedure actually reached its send instruction, both endpoints use the same queue name, and the receiver was running before the procedure fired. The controller discards a message it cannot handle and reports it against the task's queue, RMQ_T_ROB1 for T_ROB1, so messages sent before your receiver started are lost, not queued.

Keep reading

  • Troubleshooting

    Fix CoDeSys communication error 0 when ping succeeds

    When ping, FTP and Telnet succeed but CoDeSys login returns Communication error (#0), the network is proven and the station is not: the documented minimum is the CPU, at least one I/O or communication module, and a K-bus termination module. Install the missing terminator, then verify the controller's Ethernet settings and that CoDeSys targets 192.168.1.20 on port 1200.

    Operating systems on the plant floor

  • Troubleshooting

    Fix TwinCAT IPC staying in Config mode after power cycle

    Set Auto Boot to Run mode under Boot Settings (Target) in SYSTEM > SETTINGS and activate the configuration. If the IPC still boots to Config mode, read the TwinCAT runtime build on the target itself: one reported 4024-to-4026 migration behaved this way until the runtime was returned to 4024.67.

    Operating systems on the plant floor

  • Comparison

    C# or Python for industrial PC software beside the PLC

    Write the Windows-side application in C#. The camera SDK ships only C# bindings and the vendor's own ADS implementation for Windows is the .NET library, so Python adds two maintained translation layers for no capability gain; keep deterministic sequencing in Structured Text on the PLC and keep Python for standalone utilities.

    Operating systems on the plant floor