YRC1000 PROFINET: Converting IG# Byte Input to Integer Variable

Overview

When integrating a Yaskawa Motoman YRC1000 controller with a Siemens (or any PROFINET IO Controller) PLC, the field-engineering bottleneck is almost always the same: the PLC hands the robot a byte, the robot stores it in a General Purpose Input group (IG#(n)), and the INFORM III SWITCH/CASE statement only accepts integer (I) variables. The byte (B) variable is unsigned 0-255, so the raw PLC value cannot be used directly inside CASE. A conversion step is required — DIN pulls the byte into a B register, and SET copies the B register into an I register, which SWITCH/CASE accepts.

This reference documents the full conversion pattern, the PROFINET address-mapping rules that determine which IG#(n) your bytes actually appear in, the pendant screen where you verify reception, and the extension to two-byte signed values that the source community flagged for the same hardware (negative integers via IGU into a D variable). The article is written against the standard YRC1000 controller running INFORM III, the optional PROFINET slave board (typically configured under SETUP > FUNCTION SETUP > FIELDBUS > PROFINET), and the on-board General Purpose I/O groups IG#(1) through IG#(8).

Prerequisites

1. YRC1000 controller with the PROFINET option board installed and licensed. Verify under MAIN MENU > SETUP > FUNCTION SETUP > FIELDBUS > PROFINET that the board is ENABLED and shows a NODE ID.
2. Yaskawa GSDML file for the YRC1000 PROFINET device (filename begins GSDML-Vxxxx-Yaskawa-YRC1000-...). Import this into the Siemens TIA Portal / STEP 7 hardware catalog and configure the slot data length (typically 8 or 16 bytes in / 8 or 16 bytes out, configurable on the robot side).
3. Pendant teach pendant (PHG) with access to IN/OUT > GENERAL PURPOSE INPUT and IN/OUT > GENERAL PURPOSE OUTPUT.
4. INFORM III programming knowledge: variable types B, I, D, R; instructions DIN, DOUT, SIN, SOUT, SET; and the SWITCH/CASE block.
5. PLC project with the slot configured and a known test value (e.g., constant 9) ready to write to the robot's input slot.

YRC1000 I/O and Variable Architecture

The YRC1000 separates I/O addresses from program variables. PROFINET bytes do not land directly into B/I variables — they land at fixed input/output addresses, and you read those addresses with DIN/DOUT into variables your program can use.

General Purpose I/O Groups

By default, the on-board digital I/O groups are reserved as follows (addresses shown are decimal; the 20xxx range is inputs, the 30xxx range is outputs):

Variable Types

PROFINET Address Mapping on the YRC1000

The PROFINET board occupies one or more IG#(n) slots whose start address is configurable in SETUP > FUNCTION SETUP > FIELDBUS > PROFINET > INPUT START ADDR and OUTPUT START ADDR. The slot width is set by INPUT BYTES / OUTPUT BYTES (commonly 8 bytes in / 8 bytes out, but can be 16/16 or 32/32 depending on application). Every byte the PLC sends occupies one IG#(n) byte address starting at the configured input start address.

The fastest way to find your actual mapping without reading manuals is the pendant monitor:

1. From the main menu, go to IN/OUT > GENERAL PURPOSE INPUT.
2. The header bar confirms IG# — toggle IG#(1) through IG#(8) at the top of the page.
3. With the PLC online and writing to the slot, change a value at the PLC and watch the eight bits of the corresponding IG#(n) byte flip on the pendant. The group that flips is your PROFINET input group.
4. For a binary-write test, send 0xFF from the PLC and look for the byte to go to all-ones. For a numeric test, send 9 and watch which group's decimal interpretation equals 9 (i.e., bits 0 and 3 are set: 00001001b).

Write down the IG#(n) index you discover and the offset within the PROFINET slot (byte 0, byte 1, byte 2, ...). You will need both.

The DIN/SET Byte-to-Integer Conversion Pattern

There is no single INFORM III instruction that reads an IG#(n) byte directly into an I variable. The instruction set forces two steps:

Step 1 — DIN pulls one byte into a B variable

DIN syntax:

Examples (where IG#(n) is the group you found in the previous section):

DIN B000 IG#(5)   // PROFINET byte 0 → B000 (0..255)
DIN B001 IG#(5)   // PROFINET byte 1 → B001
DIN B010 IG#(1)   // on-board digital input byte → B010

Step 2 — SET copies the B variable into an I variable

SET syntax:

Examples:

SET I000 B000   // I000 now holds the same 0..255 value
SET I001 B001   // I001 holds byte 1
SET I010 B010   // I010 holds on-board input byte

Combined three-line idiom

// Read PROFINET byte 0 (program number) into I000 for SWITCH/CASE
DIN B000 IG#(5)        // byte → B
SET I000 B000          // B → I (SWITCH/CASE requires I)

After these two lines execute, I000 is the unsigned 0-255 value the PLC wrote, and it is a legal CASE constant.

Step-by-Step: Reading IG# and Using in SWITCH/CASE

The following is a complete, runnable INFORM III job that demonstrates the conversion and dispatches to a different sub-job per program number received from the PLC. Use it as a template and replace the sub-job names with your own.

// JOB: PROFINET_DISPATCH
// Purpose: read PLC-supplied program number, convert to I, dispatch via SWITCH/CASE
// Assumes: PROFINET byte 0 = IG#(5), program numbers 1..4 in use

DIN B000 IG#(5)        // raw PROFINET byte into B000
SET I000 B000          // promote to I000 for SWITCH/CASE

SWITCH I000
  CASE 1
    CALL JOB: PICK_PART_A
    BREAK
  CASE 2
    CALL JOB: PICK_PART_B
    BREAK
  CASE 3
    CALL JOB: PICK_PART_C
    BREAK
  CASE 4
    CALL JOB: PICK_PART_D
    BREAK
  DEFAULT
    // unknown program number — safe state
    DOUT OG#(5) B011      // alarm bit pattern to PLC (B011 preloaded with 0x07)
    PAUSE                  // halt cycle until PLC sends valid number
END SWITCH

END

Verification at the pendant

1. Load and run PROFINET_DISPATCH.
2. On the PLC side, write the value 1 to the PROFINET output slot assigned to the robot.
3. On the pendant, open VARIABLE > B > B000 — confirm B000 = 1.
4. Open VARIABLE > I > I000 — confirm I000 = 1.
5. Confirm the robot called PICK_PART_A (status bar shows the active job).
6. Repeat with values 2, 3, 4 to confirm each branch.

Two-Byte Signed Values into D Variables (Negative Numbers)

A single B variable is unsigned and tops out at 255. To receive the full 16-bit signed range -32,768 to +32,767 you must read two consecutive bytes (low byte, high byte) and combine them. The source thread raised exactly this case for the YRC1000 with the IGU (User Group Input) two-byte input.

Pattern A — assemble two B bytes into an I register with sign correction

// Read 16-bit signed value from PROFINET bytes 0 (LSB) and 1 (MSB)
DIN B000 IG#(5)         // LSB
DIN B001 IG#(5)+1       // MSB (use index offset syntax if supported; else DIN into IG#(6) byte 0)

// Combine into I001 with sign extension
SET I001 B001           // I001 = 0..255 from MSB
MUL I001 256            // I001 = MSB * 256
ADD I001 B000           // I001 = MSB*256 + LSB (raw 0..65535)

// Sign correction: if raw value >= 32768, subtract 65536 to get negative
IF I001 >= 32768 THEN
  SET I002 -65536
  ADD I001 I002         // I001 = signed -32768..+32767
END

Pattern B — load a 16-bit value directly into a D variable and let the controller sign-extend

On YRC1000 firmware that supports the SDIN (Signed DIN) or the IGU (Integer Group Unload) two-byte instruction, the simpler form is:

// IGU reads two consecutive IG# bytes as one signed 16-bit integer into a D variable
IGU D000 IG#(5)         // bytes 0 and 1 of group 5 → D000 as -32768..+32767

// Optional: promote to I for SWITCH/CASE
SET I010 D000           // I010 now holds signed integer, legal CASE operand

SWITCH/CASE with a signed range

SWITCH I010
  CASE -1
    CALL JOB: SOFT_STOP
    BREAK
  CASE 0
    CALL JOB: IDLE
    BREAK
  CASE 10
    CALL JOB: HOME
    BREAK
  CASE 100
    CALL JOB: PROD_RUN
    BREAK
  DEFAULT
    CALL JOB: INVALID_CODE
    BREAK
END SWITCH

Pendant Verification: GENERAL PURPOSE INPUT vs USER GROUP INPUT

A frequent source of confusion — and the root cause of the silent-zero problem in the source thread — is which pendant screen you watch. The YRC1000 exposes two related but distinct pages:

If the PROFINET value is visible in GENERAL PURPOSE INPUT but zero in USER GROUP INPUT, the User Group mapping is not yet wired to the correct IG#(n) byte. Fix that with SETUP > FUNCTION SETUP > GENERAL I/O > USER GROUP INPUT MAP. Conversely, if the value is in USER GROUP INPUT but your DIN B000 IG#(n) reads zero, you are reading the wrong IG#(n) — the underlying byte, not the user-group alias.

Diagnostic loop for IG# discovery

The following short job iteratively steps a known value through every IG#(n) byte so you can watch the pendant page and find the live one:

// JOB: SCAN_IG
// Writes a moving test value into each IG# group to find which one the PLC is updating
SET B099 1
*LOOP
  DIN B000 IG#(1)        // try group 1
  DIN B001 IG#(2)        // try group 2
  DIN B002 IG#(3)        // try group 3
  DIN B003 IG#(4)        // try group 4
  DIN B004 IG#(5)        // try group 5
  DIN B005 IG#(6)        // try group 6
  DIN B006 IG#(7)        // try group 7
  DIN B007 IG#(8)        // try group 8
  ADD B099 1             // advance test counter
  PAUSE 100              // 100 ms sample window
  JUMP *LOOP
END

Watch GENERAL PURPOSE INPUT while this job runs and change the PLC value. The group whose decimal value tracks your PLC write is your target.

Common Pitfalls and Field-Confirmed Corrections

Troubleshooting Matrix

Notes on Output Direction (PLC Reads from Robot)

For the reverse direction — robot sending status to the PLC — the symmetric pattern applies:

SET B020 I020          // promote current status from I020 to B020
DOUT OG#(5) B020        // write B020 to PROFINET output byte 0

Watch the value on the PLC side via TIA watch table; the bits should match the byte shown on IN/OUT > GENERAL PURPOSE OUTPUT on the pendant. The 30xxx address range is used for output groups; ensure your PLC is reading from the correct output slot.

Performance and Timing Considerations

The YRC1000 PROFINET cycle is typically 1–4 ms, configurable via the PROFINET "Update Time" parameter (1 ms, 2 ms, 4 ms). A robot job executes the DIN/SET/SWITCH idiom in microseconds; the limiting factor is the PLC's PROFINET send rate, not the robot's scan time. For applications where every millisecond matters (high-speed pick-and-place, press-to-press handoff), set the PROFINET update time to 1 ms and the PLC's PROFINET send clock to match.

Related Controller Notes

The same DIN/SET idiom works on the DX200, FS100, and YRC1000 controllers because they share the INFORM III language base. On the newer Yaskawa Motoman YRC1000micro and iCube controllers, the byte-to-integer conversion is handled implicitly when assigning into an I variable in newer firmware, but the explicit DIN B / SET I pattern remains the most portable and is the one supported across all fieldbus firmware revisions.

FAQ