Troubleshooting
Fixing IRMQMessage FlexPendant Interface load error
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
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
IRMQMessageforRMQFindSlot. 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
IpcQueueandIpcMessageconstruction. 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 #
- Capture the complete load message. The instruction name and the option name together are your requirement.
- Read the virtual system's option list in its system configuration.
FlexPendant Interfacewill be absent, and that absence is the entire fault. - 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 Interfaceselected. 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. - Load the module again on its own, with no PC application connected. A clean load closes the option fault.
- 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:
IRMQMessagefirst, thenRMQFindSlot. - 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
IpcQueuecode 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.