Explainer
How Q series PLC addressing works for I/O and analog modules
Short answer
A Q series point's address comes from the I/O assignment: 16-point hex blocks numbered in mounting order through one sequence shared by X and Y, so two 32-point input cards then two output cards land at X0000, X0020, Y0040 and Y0060. Analog values never appear in X/Y space; they sit in the module's buffer memory, read with FROM or TO through a head number equal to the Start XY with its last hex digit dropped.
On this page
- The address carries the slot; no instruction asks for it
- One shared 16-point hex sequence serves X and Y
- Move whole cards as words with digit designation
- Worked example: four 32-point cards and one analog module on a Q00CPU
- Analog values live in buffer memory, not in X/Y
- A QD62E counter runs on the same pattern
- Questions asked
Two rules decide every address on a Q series rack, and neither is a slot operand, because the instruction set has none. First, a point's address comes entirely from the I/O assignment: 16-point blocks numbered in hexadecimal, running in mounting order from slot 0 through one sequence shared by inputs and outputs, so four 32-point cards mounted as two in and two out land at X0000, X0020, Y0040 and Y0060. Second, analog and every other intelligent module never put their data in X/Y space: the X and Y points they occupy are status and command bits, and the converted values sit in the module's buffer memory, reached with FROM and TO through a head number equal to the Start XY with its last hex digit dropped.
The address carries the slot; no instruction asks for it #
Coming from a controller where you write slot and channel into the instruction, the first instinct is to hunt for a slot argument. There is none. Position is encoded twice: in the four-hex-digit X or Y device number for digital points, and in the head number handed to FROM and TO for buffer memory. Two things follow. You cannot write "read slot 3"; you must know what Start XY that slot holds, and the rung address follows from it. And the map is fixed in the PLC Parameter I/O assignment before any rung is written, so the first step on any Q rack is to read that screen, not the program.
One shared 16-point hex sequence serves X and Y #
Numbering starts at X0000 in slot 0 of the main base and advances 16 points per block in hex: X0000 through X000F is the first block, X0010 through X001F the next. From there, four rules hold:
- A 32-point card consumes two blocks, a span of 0020.
- Inputs and outputs draw from one shared count. An output card does not restart at Y0000; it continues the running number with Y devices. A 32-point input card in slot 2 would occupy X0040 through X005F; the same card as an output occupies Y0040 through Y005F.
- Empty slots consume points too, at the allocation set in the PLC system parameter, which is why a spare gap silently moves every card to its right.
- With Start XY left blank, the automatic I/O assignment renumbers the downstream slots whenever the rack changes. Fill Start XY in explicitly for every slot, write the parameters, and power cycle with the machine in a safe state, because outputs can change at restart. The map then survives adding, removing and swapping cards.
One limit to respect before the layout grows: the Q00CPU accepts fewer I/O points than the larger Q CPUs, and the figure is a specification-table entry in the CPU user's manual, so compare it against your point total early.
Move whole cards as words with digit designation #
Bit rungs are not the only option. A digit designation packs a run of bit devices into a word operand: K1 through K8 precede the head device and set how many 4-bit groups transfer, K4 being 16 bits and K8 being 32. It is legal only in instructions that accept a 16- or 32-bit word operand, and K8 is a 32-bit operand, so it takes the D-prefixed 32-bit form, DMOV rather than MOV.
MOV K4X0 D0 // X0000..X000F -> D0, low 16 points of the slot 0 card
MOV K2X0 D4 // X0000..X0007 -> D4, upper 8 bits read as zero
DMOV K8X20 D2 // X0020..X003F -> D2 and D3, the whole second card
MOV D10 K4Y40 // D10 -> Y0040..Y004F
X and Y are bit devices and D is a 16-bit data register, taken in pairs for 32-bit transfers. Start the run on a 16-point boundary such as X0000, X0010 or X0020; an unaligned head works but costs scan time. The lowest-numbered point lands in the lowest bit, which makes the transfer self-testing: jumper only the terminal at X0008 and D0 reads 2 to the power 8, or 256 (hex 0100); clear the jumper and D0 falls back to 0. One DMOV per 32-point card, run once at the top of the scan, gives a shift register, a change-of-state compare and a diagnostic word in a single instruction, so write logic against that copy rather than against the card.
Worked example: four 32-point cards and one analog module on a Q00CPU #
The inputs:
- CPU: Q00CPU, with four 32-point digital modules mounted consecutively from slot 0, two input then two output, and one analog input module beside them (the reader's rack).
- Block size: 16 points, hexadecimal numbering, one shared X and Y sequence, from the Q series I/O assignment rule.
- Card size: 32 points, which is two blocks, a span of 0020 hex.
Rule in words: numbering starts at 0000 in slot 0, each 32-point card advances it by 0020, the letter X or Y follows the card's direction, and an intelligent module's head number is its Start XY divided by 16.
The arithmetic:
- Slot 0, input: Start XY 0000, so X0000 through X001F. Check: 0x1F + 1 = 32 points.
- Slot 1, input: 0000 + 0020 = 0020, so X0020 through X003F.
- Slot 2, output: 0020 + 0020 = 0040, so Y0040 through Y005F.
- Slot 3, output: 0040 + 0020 = 0060, so Y0060 through Y007F.
- Slot 4, analog input: 0060 + 0020 = 0080, and head number 0x0080 divided by 16 = 8, written H8.
| Slot | Module | Start XY | Devices |
|---|---|---|---|
| 0 | 32-point input | 0000 | X0000–X001F |
| 1 | 32-point input | 0020 | X0020–X003F |
| 2 | 32-point output | 0040 | Y0040–Y005F |
| 3 | 32-point output | 0060 | Y0060–Y007F |
| 4 | analog input | 0080 | buffer memory, head H8 |
Decision: the inputs are X0000 through X003F and the outputs Y0040 through Y007F, so a rung addressing X0040 for the third card is wrong with this layout, because that card's points are Y0040 through Y005F. Read the analog module only through head H8. And since every number above came from position, a card inserted later with Start XY blank renumbers the whole right-hand side: set Start XY explicitly for all five slots now.
Analog values live in buffer memory, not in X/Y #
No instruction "reads analog," and a MOV from an X address never returns a channel value. Analog input, analog output, counter and network modules are intelligent function modules: each carries its own buffer memory holding everything worth reading, including converted counts, range settings, averaging and error codes, while the module's X and Y points carry the ready, conversion-complete and error flags plus a few command bits.
LD X80 // module ready: first X point of the module's range
FROMP H8 H10 D100 K8 // 8 words from buffer address hex 10 -> D100..D107
Which buffer address holds which channel is the analog module manual's buffer memory map. Mind the radix: those lists are decimal, while FROM and TO accept both K and H designators, and the most common bad transfer is a decimal manual address typed as hex. Carry the manual's decimal number in with K and the trap is gone. Gate every transfer on the module's ready bit, the first X point of its own range, because reads issued during startup return zeros.
The module utility can also refresh chosen buffer words into D devices automatically, which is the gentler path when a few channels matter. Never run your own FROM or TO against the same words at the same time: two access paths to one location is exactly why values "update sometimes." Direct operands in the U4\G11 style work as well; keep them out of loops and high-frequency subroutines, and prefer the pulsed FROMP and TOP forms when every-scan updates are not needed. Whatever the access path, the module returns raw counts for the configured range, so scale to engineering units in ladder, because nothing does it for you. The principle is family-wide, too: on the compact MELSEC-FX CPUs, FX5U thermocouple readings need a dedicated TC input.
A QD62E counter runs on the same pattern #
The counter module is an intelligent function module, so no new rules apply, only different addresses. Take its Start XY from the I/O assignment and derive the head number the same way. In the module manual's I/O signal list, count-enable and preset commands are Y bits at fixed offsets from Start XY, and coincidence, overflow and error flags are X bits at fixed offsets. The buffer memory list offers far more registers than any job uses; pick the few that matter, typically present value, preset value, coincidence setpoint and error code. Write the configuration once with TOP on a first-scan bit rather than every scan, and read the 32-bit present value in a single transfer, either two words with a K2 count or the 32-bit DFRO form, because two separate 16-bit reads tear the count when it rolls over between them. The pulse inputs land on the module's own terminals, never on a digital input card, so nothing the counter does shows up in a K4X0 word read.
Questions asked
How do I confirm which card owns a number without trusting my arithmetic?
Jumper one field input at a time and watch the device monitor: the bit that follows the jumper is that terminal's address, and the card label gives the rest of the range. Cross-check against the I/O assignment screen in GX Works, which shows Start XY for every slot once the parameters are written. If the two views disagree, the parameters were never written to the CPU.
Can the software move analog values into D registers so I can skip FROM?
Yes. The module's automatic refresh setting copies the buffer words you choose into D devices, and the ladder then reads only those D registers, with no FROM instruction at all. It suits jobs where a handful of channels matter. The one rule is exclusivity: never let automatic refresh and your own FROM or TO touch the same buffer words, because two access paths to one location is what makes values update intermittently.
What head number does a module at Start XY 0100 use?
Drop the last hex digit of the whole Start XY: 0100 becomes H10, which is 16 decimal, not H1. The head number is the Start XY divided by 16, so each 16-point block steps it by one. A module that moves from 0080 to 0100 goes from head 8 to head H10, and every FROM and TO written against it has to move with it.
Why did every address after a new card shift by 0020?
That signature, everything downstream moving by exactly 0020 per 32-point card, is the automatic I/O assignment renumbering slots after a rack change, which happens when Start XY is blank. Fill Start XY in for every occupied and empty slot, write the parameters, and power cycle; after that, adding or swapping a card leaves the rest of the map alone.
Do CC-Link remote I/O points use these same X and Y numbers?
They use X and Y devices, but in ranges the network parameter assigns, not the base I/O assignment that numbers the local rack. Treat the two as separate maps: the rules here fix the local base and its extension bases, and each remote station's points land where the network configuration puts them. Number the local rack first, then read the remote ranges off the network configuration.