Siemens LOGO! 8 M-Flag Reference: 6ED1052-1MD08-0BA1 Memory Map

The Siemens LOGO! 8 logic module with order code 6ED1052-1MD08-0BA1 is frequently misidentified as a 0BA1 device because of the trailing "0BA1" in the part number. The 0BA1 generation, launched in the mid-1990s, exposed only four digital marker flags to user code. The current 0BA8 / 0BA8.FS4 platform (commonly called LOGO! 8.3) provides a much larger marker memory: 64 digital M-flags, of which 8 are reserved for system functions. This technical reference decodes the order number, maps the actual flag memory available to user programs, lists the reserved M-flag range, documents the analog flag and network flag sets, explains remanence and power-fail behavior, and provides a field verification procedure that runs from the on-device keypad when the PC tool is unavailable.

Decoding the Order Number 6ED1052-1MD08-0BA1

Siemens LOGO! order numbers follow a fixed structure. Decoding the part number eliminates the confusion between the legacy 0BA1 platform and the modern 0BA8.FS4 platform that has led field users to underestimate available flag memory. The part number decomposes as follows.

The 0BAx generation code is encoded in the sub-family (052 = 0BA8 / 0BA8.FS4) and the FS suffix (08 = FS04). The trailing "0BA1" in the part number is decoded by Siemens sales tooling as region code, not generation.

LOGO! Generation Timeline and M-Flag Counts

The digital M-flag count has increased with each generation. The source article confirms the 0BA1 (4 flags) and the current platform (64 flags, 8 reserved). The intermediate generations and the full timeline are summarised below. The 0BA1 and 0BA8 counts are confirmed by the source; intermediate-generation counts are the published values from the system manuals for those generations and should be re-verified against the current LOGO! System Manual if a program is being migrated.

The jump from 32 to 64 between 0BA7 and 0BA8 reflects the migration to a byte-structured marker memory and the introduction of the 8 reserved system markers needed to drive the cursor keys, the backlight event signal, and the system clock pulses. The "only 4 flags" statement that propagated through some user knowledge bases is accurate only for 0BA0/0BA1 and should not be used as a reference when sizing a LOGO! 8 program.

LOGO! 8 Hardware Variants in the 6ED1052 Family

The 6ED1052 sub-family of LOGO! 8 basic modules includes several supply / I/O combinations. The variant code (third segment, two characters) determines I/O count, supply voltage, and output type. The 6ED1052-1MD08-0BA1 falls in the "MD" row of the table below.

All variants of the 0BA8 basic module expose the same 64 M-flag, 16 AM-flag, 250-byte remanent memory, 400 function-block, and 8,500 program-line resource set. The variant code affects I/O count and supply class only; flag memory is identical across the family.

LOGO! 8 (0BA8 / 0BA8.FS4) Flag Memory Map

The 0BA8 generation introduced a structured marker memory. Digital M-flags are byte-wide internally, but each bit is independently addressable as M1, M2, ... Mn in the program. The full map is:

Of the 64 markers, 56 are user-writable (M1-M24 and M33-M64). The remaining 8 (M25-M32) are reserved for system functions. The LOGO! 8 System Manual for the installed functional state is the authoritative source. For the 6ED1052-1MD08-0BA1 (FS04 / V8.3.x), the M25-M32 reservation is in effect.

Reserved M-Flags and System Functions

The eight reserved M-flags (M25-M32) are not arbitrary. They map to system-level functions that the LOGO! runtime updates every scan, and user code cannot override them. Writing to them in user logic (M25-M32 from a function block coil) is masked off by the firmware; the runtime continues to drive the system value. The table below reflects the typical mapping shown in the current LOGO! 8 System Manual. The exact function of each reserved marker is implementation-detail; treat the table as a starting point and re-verify against the manual for the installed FS code.

Field practice uses M31 and M32 as free-running clock sources. M25-M29 mirror the four arrow keys plus the OK key of the LOGO! display - they are the internal "soft input" flags that the cursor-key inputs (CURSOR_UP, CURSOR_DOWN, CURSOR_LEFT, CURSOR_RIGHT, CURSOR_OK) write to. Reading these markers from a function block is permitted and is the standard way to debounce cursor keys without a separate input block. Writing to them is rejected at runtime.

Analog Flags (AM) and Network Flags (N / NA)

Beyond digital M-flags, the LOGO! 8 also exposes:

• Analog markers (AM): 16 (AM1-AM16) in 0BA8 - these are word-wide (16-bit) integer values, range 0..32767 (some FBs accept -32768..+32767 in 2's complement). Use AM-flags for any value that needs to cross between an analog input and an analog output; do not pack bits into M-flags to mimic integers.
• Network digital markers (N): 64 (N1-N64) in 0BA8 when the LOGO! is a master or peer on an Ethernet S7 connection. These are the input/output buffers of the network function blocks (NI, NQ). Writing to N-flags from user logic is ignored outside the network FB context.
• Network analog markers (NA): 32 (NA1-NA32) in 0BA8. Word-wide network buffers, range 0..32767 / -32768..+32767.

Remanence and Power-Fail Behavior

Retentive behavior is configured per-flag in LOGO!Soft Comfort V8.3 under the marker coil's Properties dialog. There is no global "all retentive" switch. The default is non-retentive for all digital M-flags and AM-flags; the reserved M25-M32 range is always non-retentive and cannot be forced retentive by user code.

Behavior on power loss:

1. Non-retentive M-flag -> reset to 0 on power-up.
2. Retentive M-flag -> holds last state across power cycle; LOGO! 8 backs these up to internal EEPROM and restores on the first scan after power-up.
3. Retentive AM-flag -> holds last 16-bit integer value across power cycle.
4. Retentive counter / timer values -> hold last value across power cycle (counters and timers have their own retention attribute in their block Properties).

The 0BA8 hardware stores up to 250 bytes of remanent data. Worst-case retention footprint: 64 single-bit M-flags (8 bytes) + 16 word AM-flags (32 bytes) + counter / timer / shift-register backup = 40 bytes minimum, up to the 250-byte ceiling. The 0BA1 generation supported 32 bytes of remanent data, which is why early migration projects sometimes hit a "too many retentive flags" error after porting from 0BA1 to 0BA8 - the projects were sized against the smaller budget.

Programming M-Flags in LOGO!Soft Comfort V8.3

In the FBD editor, drag a Marker Output (M) coil from the toolbar. The Properties dialog lets you assign the output number and (separately) the retention attribute. Place a Marker Contact (M) input where you need to read the flag. The same block (M coil) is used to set and reset; the coil symbol and the network context determine direction.

Minimum working example: 1 Hz clock output to physical output Q1, with a user M-flag as the toggle memory.

Network 1: free-running 1 Hz pulse
  [M31] (NO) ----[M coil M1, retentive=NO]

Network 2: divide-by-two (toggle)
  [M31] (NC) ----[M coil M1, retentive=NO]
  [M1]  (NC) ----+
                    |
                    +----[Q1]

This toggles Q1 every second using the system pulse M31 and the toggle memory M1. The first network sets M1 high whenever M31 is high. The second network resets M1 whenever M31 is low and M1 is high, producing a 1 Hz square wave on Q1. Replace M1 with any unused user M-flag in the M1-M24 or M33-M64 range.

Worked example: 2-stage process with manual start, 30 s run timer, and cycle counter using M-flags and AM-flags.

Network 1: cycle start latch
  [I1]    (NO) ----[M coil M1, retentive=YES]  // cycle-in-progress
  [M1]    (NC) ----+
  [M2]    (NO) ----+                            // M2 = run complete

Network 2: 30 s timer
  [M1]    (NO) ----[On-delay T1, 30s]
                    +----[M coil M2, retentive=YES]

Network 3: cycle counter
  [M2]    (NO) ----[Up/Down counter C1, threshold=AM1]
  [AM1]            (NC) ----[Reset]
                    +----[Q1, run indicator]

Network 4: shift register for fault history
  [I2]    (NO) ----[Shift register SR1, depth=8]
                    +----[AM2, last fault code]

This example uses M1 and M2 in the user-accessible M1-M24 range, plus retentive state on the counter and shift register. For deeper fault history, raise the shift register depth up to the LOGO!Soft Comfort V8.3 maximum of 32 bits per shift register.

Best-practice constraints:

• Never write to M25-M32 from user code - the write is masked off; the flag holds its system value.
• Avoid M8, M16, M24, M32, M40, M48, M56, M64 as cross-block handoffs: they sit at byte boundaries and a partial-word optimization in LSC can mask read/write hazards. Any M-flag is valid, but byte-aligned ones are the conventional "anchors" for interlock conventions.
• Use AM1-AM16 for any value that needs to cross between an analog input and an analog output - do not pack bits into M-flags to mimic integers.
• Reserve a contiguous M-flag block per process subsystem (e.g. M1-M8 for the heating loop, M9-M16 for the lighting loop) to ease cross-subsystem review and to make remanence accounting auditable.

Program Resources, Expansion, and Performance

The 0BA8.FS4 module supports up to 400 function blocks and 8,500 program lines (whichever limit is hit first). M-flag usage does not count against either limit; only the count of FB instances does. Scan time on 0BA8 is approximately 0.1 ms per FB average; a project at the 400 FB limit runs at a 40 ms cycle, which is acceptable for HVAC, lighting, and small machine control but tight for high-speed counting (use the high-speed counter FB at I3/I4 only, max 5 kHz).

Expansion: the 6ED1052-1MD08-0BA1 is a basic module. It can be expanded with up to 24 digital / analog expansion modules on its right-hand bus. The expansion bus does not consume M-flags; it allocates I-flags (input flags) and Q-flags (output flags) in the LOGO!Soft Comfort V8.3 I/O list. Net digital I/O for a fully-expanded system is 24 DI + 20 DO (basic + DM16 + DM8 in mixed configuration); net analog I/O is 8 AI + 8 AO (basic + AM2 / RTD / AI modules).

Networked configurations: the LOGO! 8 supports up to 16 LOGO! peers on an Ethernet S7 subnet. Each peer consumes its own local M-flags; cross-peer communication uses N / NA flags routed through NI / NQ / NA network FBs. The 64 N-flags and 32 NA-flags are sufficient for most multi-peer HVAC and lighting applications.

Field Verification Procedure

When the device is on the bench and the PC tool is not available, enumerate the available M-flag range from the LOGO! display:

1. Apply supply power. Wait for the LOGO! to enter RUN (display shows the configured start screen).
2. Press ESC to enter parameter-assignment mode, then navigate using the arrow keys to "Program" -> "M-Flag" (the menu path varies slightly by FS code; on 0BA8.FS4 it is reached via the menu arrow keys, then the OK key, then the gear icon for settings).
3. Pick a candidate marker (e.g. M64) and attempt to set it to 1. If the LOGO! accepts the write and the value persists in RUN, the marker is user-accessible.
4. Repeat with M32, then M25. If the LOGO! rejects the write or the value reverts on the next scan, the marker is in the reserved range.
5. Power-cycle and verify that user-set, non-retentive flags (M1, M2, M3) return to 0 while a retentive M-flag holds its state.

Programmatic verification in LOGO!Soft Comfort V8.3:

// LSC V8.3 Info menu: Tools > System Information > Memory
// Reports: Digital Flags Total / Used / Reserved / Free
// Reports: Analog Flags Total / Used / Free
// Reports: Function Blocks Total / Used / Free
// Reports: Remanent Memory Used / Free

If "Total: 64, Reserved: 8" is reported, the device is a 0BA8 (or newer). If the report shows "Total: 4", the device is 0BA0/0BA1 and the legacy 4-flag restriction is in effect.

Migration from Older LOGO! Generations

Programs written for 0BA5 / 0BA6 / 0BA7 can be opened in LOGO!Soft Comfort V8.3 and re-compiled for 0BA8. The compiler emits warnings when the source program references M-flags in a range that exists in the target but in different size (e.g. an 0BA6 program that used M24 - 0BA6 had 24 flags, 0BA8 has 64; the reference still compiles but the M24 flag is now in the user-writable range, not reserved). The migration checklist:

1. Open the source LSC project (.lsc / .lld) in LOGO!Soft Comfort V8.3.
2. Save under a new filename to preserve the original.
3. Change the target device in Project -> Properties -> Hardware to the 6ED1052-1MD08-0BA1 (or your specific 0BA8 module).
4. Recompile. Review any warnings about flag ranges or unsupported FBs.
5. Verify the M-flag usage against the new memory map: any flag in M25-M32 must be remapped to M33-M64.
6. Verify the AM-flag usage: 0BA6 had 8 AM-flags, 0BA7 had 8 AM-flags, 0BA8 has 16 AM-flags. New AM9-AM16 are now available.
7. Verify the remanent memory: if the source program used more than 32 bytes of remanent memory (e.g. 0BA1 with 32-byte budget), the migration to 0BA8 lifts the limit to 250 bytes - no action required, but verify in Tools -> System Information.
8. Test on the bench before deploying to the live system.

Troubleshooting Matrix

For the definitive reserved-range list, refer to the LOGO! 8 System Manual. For the current catalog and firmware releases, refer to the Siemens LOGO! product page. For block-level remanence behavior and the marker coil properties, refer to the LOGO!Soft Comfort V8.3 Help file.

FAQ