Problem Details
A Deckel Dialog 11 control aborts an incoming NC program transfer and posts Datei zu klein ("file too small"). The message appears on the control side during or immediately after a serial upload from a PC, typically using an LSV2-capable transfer package. The transfer terminates, and either no program is stored or a truncated program block remains in control memory.
The message is a control-side rejection, not a PC-side error. That distinction matters: the PC transfer tool usually reports a completed or timed-out send while the Dialog 11 reports the file condition. Treat the PC log and the control message as two independent pieces of evidence.
Root Cause Candidates
Work these in order of likelihood. Each one produces the same control message, so isolate by test rather than by guesswork.
| # | Candidate cause | Evidence to look for |
|---|---|---|
| 1 | Transfer aborted early — handshake or line-break mid-stream | Program appears in memory but ends mid-block; PC tool reports fewer bytes sent than file size |
| 2 | Serial parameter mismatch (baud, data bits, parity, stop bits, handshake mode) | Garbled characters in received text, or no data accepted at all |
| 3 | Missing or wrong file terminator / block structure the control expects | File transfers fully but the control never sees a valid end-of-program condition |
| 4 | Wrong receive mode selected on the control (program load vs. block-by-block reload) | Control expects a continuous feed but receives a finite file, or vice versa |
| 5 | Insufficient free program memory or fragmented memory on the control | Transfer of a small test program succeeds, large program fails |
| 6 | PC-side hardware layer: USB-to-RS-232 adapter dropping bytes or mishandling flow control | Failure is intermittent and size-dependent; a native COM port or a different adapter behaves differently |
| 7 | Cable wiring — handshake lines not carried through | Short files succeed, longer files stall once the receive buffer fills |
Decision Path: Pick the Right Transfer Strategy First
Before troubleshooting the wire, decide what the machine actually has to do. Three operating models are commonly used with Deckel Dialog controls, and they have different failure modes:
- One-off file transfer. A single program is pushed into control memory, then run from memory. Simplest to commission; only needs a working serial link and enough free memory. Choose this if the current job is a single program and external programming is not a standing requirement.
- General external programming with upload to the machine. Programs are authored/post-processed on a PC and transferred to control memory as a routine workflow. Requires a repeatable, documented serial configuration and a naming/archiving convention. Choose this when the machine holds programs long enough to run them but the shop wants the PC as the master source.
- Reload / drip-feed mode (Nachlademodus). The control executes blocks as they arrive over the serial link instead of storing the whole program. Choose this when the program exceeds available control memory — for example long 3D contour or surfacing programs. This mode is far more sensitive to handshake correctness, because the link stays active for the entire cut.
If the program in question is large, option 3 removes the memory constraint entirely and may be the fastest route past a "Datei zu klein" condition that is really a memory/allocation issue. If the program is small, option 3 adds risk without benefit — fix the link and use option 1 or 2.
Solution Procedure
Step 1 — Establish a known-good baseline
- Create a minimal test program on the PC: a few valid blocks with the correct program start and end structure for the Dialog 11 dialect.
- Transfer it into control memory. If this succeeds, the physical link and basic serial parameters are functional and the fault is size-, structure-, or memory-related. If it fails identically, the fault is in the link or in the serial parameters.
Step 2 — Verify serial parameters on both ends
- Read the interface settings out of the control's machine/interface parameters and write them down exactly: baud rate, data bits, parity, stop bits, and handshake method (hardware RTS/CTS vs. software XON/XOFF).
- Configure the PC transfer software to the identical values. A single mismatched stop bit or parity setting will pass short bursts and corrupt longer ones.
- Confirm which handshake the control is configured for. Hardware handshake with a 3-wire cable is a classic cause of transfers that die once the control's receive buffer fills — which reads on the control as an incomplete, therefore "too small", file.
Step 3 — Validate the cable
- Confirm TxD/RxD are crossed correctly for the control's DTE/DCE role.
- If hardware handshake is configured, confirm RTS/CTS (and any DTR/DSR lines the control requires) are actually wired end-to-end — not looped back at one connector.
- Keep the run short and away from drives, servo cables and contactor wiring. Use shielded cable with the shield grounded at one end only.
Step 4 — Address the PC layer
- Prefer a native RS-232 port. Where only USB is available, use an industrial USB-to-serial adapter with a well-supported chipset and current drivers.
- Use transfer software that is maintained for Windows 10/11 and explicitly supports the Deckel LSV2 protocol. Legacy DOS-era transfer utilities frequently fail on modern Windows because direct UART timing access is no longer available.
- Disable PC power-management sleep on the USB/serial device for the duration of a drip-feed session.
Step 5 — Check control memory
- Delete or archive unused programs from control memory and retry.
- If the file only transfers after clearing memory, the original message was an allocation failure. Either keep memory clear as policy, split the program, or move to reload/drip-feed mode.
Step 6 — Check file structure
- Confirm the file uses the line-ending convention the control's receiver expects. Mixed or missing terminators can leave the control waiting for a block that never completes.
- Confirm the program header/number and end-of-program block match Dialog 11 syntax exactly. A post-processor emitting a foreign dialect can be accepted byte-wise but rejected structurally.
- Strip stray control characters, BOM markers, or trailing binary garbage introduced by an editor.
Verification
| Check | Pass criterion |
|---|---|
| Byte count | Bytes sent by the PC tool equals the file size on disk |
| Program integrity on control | Last block displayed on the control matches the last block in the source file |
| Block count | Control-side block count matches the PC-side block count |
| Repeatability | Three consecutive transfers of the full-size program complete without error |
| Dry run | Program runs to end-of-program in single block / dry run with feed and spindle inhibited |
| Drip-feed stability | If using reload mode, the link sustains an entire program without buffer underrun at production feed rates |
Commissioning Notes for Long-Term Use
- Document the working serial parameter set and cable pinout, and attach a copy to the machine. This is the single highest-value artifact once the link works.
- Standardize on one PC and one adapter for machine transfers. Mixed adapters reintroduce timing variability.
- Keep an archive of every program as sent, byte-identical, so a suspect transfer can be compared against a known-good file rather than re-post-processed.
- Decide early between store-and-run and reload mode; the two impose different requirements on link reliability, and mixing them ad hoc makes intermittent faults hard to attribute.
- If an external specialist is engaged, insist on a documented test transfer of both a minimal program and a full-size production program before sign-off.
FAQ
What does "Datei zu klein" mean on a Deckel Dialog 11?
It means the control received less data than it expected or could not resolve a complete program from the incoming stream. In practice it usually indicates a truncated or mis-framed serial transfer, or a memory allocation problem — not a genuinely undersized part program.
Can I transfer programs to a Deckel Dialog 11 from Windows 10 or 11?
Yes, provided you use transfer software that is maintained for Windows 10/11 and supports the Deckel LSV2 protocol. Legacy DOS-era utilities typically fail because they rely on direct UART access that modern Windows does not allow.
Should I load the program into memory or use drip-feed (Nachlademodus)?
Load into memory when the program fits in available control memory — it is simpler and tolerates brief link interruptions. Use drip-feed when the program exceeds control memory, but only after you have proven the serial link and handshake are stable for an entire run.
Why do short programs transfer but long ones fail?
That pattern points to handshake or buffer overflow: the first blocks fit in the control's receive buffer, then flow control fails. Check that hardware handshake lines are physically wired through the cable and that the PC software uses the same handshake method configured in the control's interface parameters.
Could a USB-to-serial adapter be causing the error?
Yes. Adapters with poor drivers or aggressive buffering can drop bytes on long transfers, producing an incomplete file at the control. Test with a native RS-232 port or a different industrial-grade adapter before chasing control-side parameters.