To short single command description
Overview to ELP_Commands usage and ELP Command generator

This document describes

The ELP_Command line generator is a great tool to configure the most needed command sets, but does only support via his user interface the most important ELP functions. Beside that you have access to over 50 command sets, which we are pretty sure, that minimum one of the sets comes pretty close to your requirements.

An ELP_Command is valid for the whole data stream, even if it contains several print jobs. However ELP provides an additional PCL command which turns the ELP functionality through the processing of the data stream temporary off <Esc>)s-996Z and back to on again<esc>s996Z. There is also an ini file key calls ELP_Command_Active, which deactivates the provided ELP_Command from the beginning of the job. In this case a <esc>s996Z is needed for activation.

These commands can be used any time, but they make only sense between two jobs. If used within a job, most likely the begin page commands from the ELP_Command may already been performed before the off command <esc>s-996Z is found. Or the other way around, the top of page commands are not performed, when the command is turned somewhere on the page on.

 

There are three major methods to use the ELP_Command

1. Uncommon but possible: The ELP_Command is directly inserted in In the data stream

In that case the command needs to start with two trigger characters, default <<, and end with a also 2 trigger characters, default >>. These trigger characters can be changed to any other character, using the keys ELP_CMD_Start_Char and ELP_CMD_Stopp_Char.

The ELP Server will erase the command[s] out of the data stream.

The key ELP_SearchCommandInDataStream string defines if and how the command is searched in the data stream;
ON: In the last instance ELP searches the data stream for an ELP_Command of this form: <<command;command;>> (This is the default mode)
OFF: The data stream is not searched (Speeds up the process for larger streams)
ALL: The whole data stream is searched and the last found command is used.

ELP is designed to detect the command trigger even within print data, generated by windows drivers. If possible please follow these rules:
A) Use only proportional printer internal fonts, best choice is ARIAL.
B) Do not expand the command over one line, if required: reduce the font size to fit the whole command in one line.

As described above the command looks like this:

<START_SIGN><START_SIGN><Command[CommandOption][;...];><STOP_SIGN><STOP_SIGN>

Example using the default trigger signs: <<X;K2;D2;C1F1000;C2F2000;>>

 

2. In any configuration file (ini file), triggered by an [automatic] rule using the key ELP_Command

Command[CommandOption][;....];

ELP example for the usage in a command (ini) file:
ELP_COMMAND=X;K2;D2;C1F1000;

Note: For more details regarding rules please study Rules Theory

 

3. Put the command into the first line of a file called default.elp

This command is executed as if it was in the rule GLOBAL.

The maximum length of an ELP_Command can be 2048 bytes. As the the ini file entry length is maximum 512 Bytes, a second key: ELP_Command_Add can be used to extend the existing ELP_Command.

 

The ELP_Command syntax:

Looking at the ELP_Command table here you may have noticed, that there are primary and secondary so-called C#-commands available.

Every primary command starts with one or two command character[s] and MUST be ended with a semicolon. There is no required order for the specification of a single command in the full command line.

Secondary C#-commands can only be used within the primary commands: C#, and also in EI, EJ or EX.

There can be ELP variables used within the ELP_Command_Add and ELP_Command keys, but:

  • those variables must be available latest at the end of all trigger analyses.
  • The variables can only be edited manually in the ELP_Command Generator, where the variable is behind the command character

    The key ELP_Replace_Variables=ON advises ELP to replace the variables already when the ELP command is found in a rule. If at that time the variable does not exist, it is not replaced. This key can be used with ELP_Command_ADD and the Search_xxx keys to build a page dynamic ELP_Command. But remember maximum up to 2K Bytes.

Most of the primary ELP_Command keys are used to the complete data stream, like stapling T#; or printing copies with K#; or R#; commands.


The C# command and how is a page processed

C#[:# | :L | :R | :X | :#-#]C-commandSet; - What to do per page

| | | | | #-# the following C-commandSet is used on a range of pages, e.g. 10 to 20

| | | | X the following C-commandSet is used on L or R sided page

| | | R the following C-commandSet is for right handed pages

| | L the following C-commandSet is for left handed pages

| the following C-commandSet is just used on page #

Defines for which copy the following C-commandSet is valid

So first number # after the C defines, for which printed copy of the incoming data stream this command is valid. Like C1 for the first copy, the original, C2 for the second and so on.

To understand the syntax you must look at the command line from the printing process. ELP is just in a copy 1, 2 or 3 etc and on a specific page. The following table explains how ELP finds a valid C-command. Whenever the printed page number falls in the range or page described by the C-command, the valid command is found and the execution of the command starts.

1. C#:# Command definition for copy C#: and the exact page number
2. C#:#-# Command definition for copy C#: and the actual printed page must be located between the pages #-# (from-to)
If the Command C#:# is not provided, then this is the second searched choice.
3. C# Command definition for copy C#
4. D#; Just in case the copy number C# is not defined at all, ELP Looks for the primary D#; default copy command. The number # after the D defines the number of the default copy description. So ELP will run the page number again against the copy # .
5. C#:# Command definition for copy C#: and the exact page number
6. C#.#-# Command definition for copy C#: and the actual printed page must be located between the pages #-# (from-to)
7. C# Command definition for copy C#

Whether a C# command from above is found or not, this C-commands will be evaluated. Examples:

ELP_Command=C1F1000;C1:1F1100;
On every page the Form 1000.mac is printed, but on C1:1 (page 1) there the form 110 is uses and as the ranking is higer then C1, the C1F1000 is NOT used for page 1

ELP_Command=K2;C1F1000;
K2; means generate 2 copies. on all pages of copy 1 is Form 1000 printer, and as C2 is not used at all, total copy 2 is not touched at all

ELP_Command=K2;C1F1000;C2F1000;
Same as last one, got on all pages of both copies is form 1000 printed

ELP_Command=K2;D2;C2F1000;
Same as last on, C1 copy is not defined, but D2; tells ELP to use for copy 1 the same set as for copy 2: C2

ELP_Command=C1F1000;C1:1F1100;C1#PREPARSEPAGECOUNT#I9;
Here the first page get form 1100, The last page is drawn form a different paper tray (i9) and all pages in between gets form 1000.
But what happens if the job has only one page: C1:1 has a higher hierarchy as the same command behind: C1:1I9

K3;C1:1F1000;C1F2000;C2F2000F3000;D1;
The first copy page one is different to all other pages of copy one. The second copy again, But as no C3 is defined, the ELP system detects the D1; command the third copy is treated the same as copy 1

C1:10S1;C1S0;C1:11-29F8888;
All pages of the first copy from page number 10 up to 29 will be printed in duplex mode. All the other ones in simplex. However to print duplex there are 2 commands needed: page 10 to turn duplexing on and a dummy command 11-29 which puts a non existing form on. This is needed as the command C1:10-29S1 would still print all in simplex (Why does my duplex ELP command fail?)

A lot more can be found here: A lot of ELP_Commands

On top of the page a number of those options are also selectable:

C#:L Additional command which will be executed only for left pages right after the standard C#Command, if available This command will help to use forms specific on left and right handed pages.
C#:R Additional command definition for right hand pages
C#:X This is a very special command. It is only executed, if an EX; (C-Command at the end of the job) or EA; (C-Command at the beginning of the job) is defined. In this case the given commands are executed directly before the EA command, so at the beginning or at the end of the print data stream.
This command is used to give the EA; and EX; command some copy specific settings.

Tip: If you only want to attach to the first copy a special form, then use an dummy EX; command like EXF54711; where the form 4711 is not defined at all, and use C1:XF1234; for example to print the Form 1234. For the second copy the dummy form 4711 is still called, but as the C2:X..; command is missing, there will be no additional page/form inserted.

ELP_Command=C1:1S1F1100;C1:RF1000;C1:LF1010;
On page one there is a duplex command, Forma 1100 and Form 1000. On pages 2,4,6,... is form 1010 and on pages 1,3,5,... is form 1000

A lot more can be found here: A lot of ELP_Commands

Important:

  • Additional pages which are inserted using the C-command FF are counted.
    Example: If on the first page the T&Cs are inserted on the back, the second printed page is for ELP the third processed page.
  • C#:L and/or C#:R definitions are always executed after the C#:#/C#:#-#/C# C-command.
  • The Default Copy Command D#; has got the lowest priority. It will be performed on every page on a particular copy, which is not addressed with a C# and/or C#:# <and/or C#:# C-command;.

It is also possible to use variables within ELP_Commands. One major usage of this functionality is to generate dynamic ELP_Commands. The following advanced example demonstrates how some pages within a larger job can be drawn out of different paper tray, when a special word is found on that particular page:

[GLOBAL]
; Generate an own page counter using the Variable
; #myPageCounter# and initialize it to 1 (first page)
Variable=#myPageCounter#:1
; Normally all pages are drawn out of tray NORMAL
ELP_Command=C1I1;

[search for next page and increase page counter]
; search for form feed and next sequence(s) to find form feeds
Search_Binary=\x0C\x1B&l1X
; As now the next page is read, increase the counter
Counter=#myPageCounter#
; Speed up, do not read all keys
ReadOnlySearchKeys=ON


[Rule for pages drawn from other tray]
; There must be a special trigger text on that page
Search_Windows=Payment form page
; in this example the trigger needs to be erased
Erase_Binary=1
; Any Variables in ELP_COMMANDS[_ADD] are immediately replaced
; when the command is read form the ini file
ELP_Replace_Variables=ON
; Add to the current ELP_Command the exception command for that
; particular page. The variable #myPageCounter# is directly
; replaced by reading the section.
ELP_Command_Add=c1:#myPageCounter#I9;

Result: If the trigger word "Payment form page" was found on page 2, 8 and 12 then the final ELP_Command is: C1I1; C2:2I9; C2:8I9; C2:12I9;
The limitation is the maximum length of the ELP_Command with 2048 Bytes. Or with the above routine a document with about 220 payment forms.

 

The hierarchy of selecting ELP_Commands:

ELP_Commands can be selected in different rules or methods. Here is the list of possible activation. As ELP_Commands are replaced, there is always only one valid, which is the last one found. The hierarchy table is listed in the same order as ELP processes the job:

  • Printer name
  • User name
  • Driver name
  • Port name
  • Searched rules in the way the search argument is found the the data stream
  • Triggered rules in the way they are listed in the ini file
  • The highest priority is the ELP_Command found in the data stream.

Beside the highest option, an ELP:Command can also be located in a record in the ELP data base. So if any of the rules searches a data base file, the stored ELP_Command has a higher priority as the probably found ELP_Command of the rule itself.

 

Description of all ELP C#_commands:

Those keys after call C#-commands as it always need a copy # definition after the C.

 

C#-Command A[-]#; Page size selection*

This command is uses for the paper size selection the PCL commands \x1B&l##A. Any entered value larger zero is valid. Here is a list of some paper sizes:

26 A4 27 A3 25 A5 24 A6
28 A2 29 A1 30 A0 90 DL envelope
91 C5 envelope 100 B5 envelope 1 Executive 3 Legal
2 Letter '101 custom    

The optional - in the command advices ELP not(!) to erase the existing page size commands in the data stream. This can be used for example to insert a separation page at the end of splitting a data stream. Note:
- If there is another A# command in the ELP_Command without minus, then the existing page size commands will be erased!
- The page size selection command itself is invisible to the ELP process. So you may need to set on the next page / paper sheet the data stream back to the default page size.

If pages are not printed in duplex: Why does my duplex ELP command fail?

 

C#-Command B#; Back page selection

This command is used in conjunction with the duplex command. The following values are supported:
B0; Continue on next printing side
B1; Continue on next front side
B2; Continue on next back side

Important notes:

  • This command may perform a form feed, but in case it does, the page will not be counted, as ELP only count Form Feeds! In this case no next page definitions are performed.
  • This command should be used always in conjunction with the duplex command, which needs to be defined first in the ELP command.

C#-Command C#; Color management

The following variables are possible:
C0; No changes are made to the data stream
C1; Color is printed as Color
C2; Color is converted by the printer to gray

Note: This command is set for the full page. It is not possible to set the printed data to monochrome/gray printing, and turn back later for the form to color. If this is your intention, then use a black and white driver. Usually those drivers do NOT use the responsible PCL command, and you can switch to color in the form itself.

 

C#-Command D[-]#; Printing Direction*

The following variables are possible:
D0; Portrait
D1; Landscape
D2; Reverse Portrait
D3; Reverse Landscape

The optional - in the command advices ELP not(!) to erase the existing print direction commands in the data stream. This can be used for example to insert a separation page at the end of splitting a data stream. Note:
- If there is another A# command in the ELP_Command without minus, then the existing print direction commands will be erased!
- The print direction selection command itself is invisible to the ELP process. So you may need to set on the next page / paper sheet the data stream back to the default print direction .

 

C#-Command E; Erase OutSearch_....

Once this command is found, ELP will erase all outsearch _binary, outsearch_windows and outsearch_text searches. See also Search_Only_Once key

This can be used for e.g. to stop inserting some additional commands on the last copy:

[Global]

Search_Windows_New=confidential

; This example sets for the first copy behind the text Blank,- the Euro sign (You may need to change the uses symbol set to 13U)

ELP_COMMAND=K2;C2:1E;

[OutSearch]

OutSearch_Binary=" ,-"

Add_Binary=" \x128"

 

C#-Command F[RL|RP|L|P][-] # [,x[,y[,d]]]; Call macro

F#; The minimum definition F# calls the macro/form with the ID number (#) on the actual with the C command defined page. Any number between 1 and 32000 is valid. But especially for SAP users, it is strongly recommended not to use any macro number below 1000.
Forms with IDs between 25000 and 32767 are on their appearance every time loaded to the printer. The barrier of 25000 can be move using the key: ReloadMacrosAbove=30000. This enables ELP to generate for example page counters on every printed page
Examples:
C1:1F500F100;C1F502; ELP inserts on page 1 of copy 1 the forms 500 and 100, on all other pages of copy 1 the macro 501. Demo-macro 500 is a letter head, macro 100 the watermark "Original", macro 502 just the company logo, which needs to be printed on all pages. the forms are loaded only once.
C1F25000; generates a page counter on every page
F#[,x[,y[,d]]]; Sometimes the macro/s is/are needed to be positioned on the page, like a signature for example. Therefore the new position coordinates can follow the macro number separated with commas. The first number is the x position and the optional second the y position.
In any case, those commands are send right before the macro call and remain active until they are changed. Either using other offsets in the next F# command, or the general PL and PS or PX commands. If those P commands need to be positioned behind the F C-Command, in order to change back the offset settings.
Finally you may add a print direction to that macro, it can be 0 (default), 90, 180 or 270 degrees. This value is temporarily and if provided, it is set to 0 (normal print direction) immediate after the macro is loaded
Note: PX can't be used at the beginning of the page, so if you want to reset positioning done in the C#_Commands F and G use PL0PS0 on the next page.
Examples:
C1F1000,0,0,90 Rotate the form by 90 degrees
C1F1000,100,200F1010,0,0; Print form 1000 and 1010 on every page, but the form 1000 is moved 100 units to the right and 2000 units down the print orientation. Form 1010 is printed on it natural position, and all pages after it as well.
C1PXF1000,100,200; The form is always printed with an offset, and PX resets the next page to the default coordinating system.

A second alternative is to set during the generation of the form a default offset just for that form.
F-#; If the form number is provided as a negative value, ELP searches for the positive form file, but at the end of the job, the mac/form file will be deleted from the storage media! Use this method to delete temporary form files, which may have been previously generated by another print job using the F# command.
FL#; FP#; The form is only loaded if the page is printed in portrait (P) or landscape (L).
Note:The data stream must have from the first page on the PCL statements for the page orientation (Esc&l#O). if not, then you need to declare with the key Variable=#VAR_ORIENTATION#:Number the default orientation. The values for the numbers are: 0 Portrait, 1 Landscape, 2 reverse Portrait and 3 reverse Landscape.
FRL#; FRP#; The form is only loaded if the page is printed in reverse portrait (RP) or reverse landscape (RL).

The macros/forms should be preferred generated with PPAdmin Macros Register Tab, Generate an ELP usable form or using in the data stream the ELP_Command <<F#;>>. See below and above

ELP inserts in the first step the PCL5 command for macro select and call. If the download switch is active (Macro_Download=ON), and the macro file (*.mac) is located in the actual ini-File path (default ...\forms), ELP will automatically download the macro to the printer. If the macro cannot be found in the Ini-File path and the macro is not stored in the printer, the command has no effect.

Notes:

  • In order to work correctly, this command needs Form Feed as the page separator in the data stream. If you use for example on the last page \x1BE instead of Form Feed, there will be no forms added on that last page!
  • You can add in one C command as many F statements as you like. Again note, the maximum length of the total ELP command is limited to 1023 bytes.
  • All command options can be combined FRL-5555,300,40,-90; Print on reverse landscape printed pages [RL] the form 5555.mac shifted 300 units to left, 90 units up and even rotated by 90 degrees. Also delete the physical form file after the job.

Variables in ELP can be used for example to define a set of forms dedicated to a queue, and then they can be used in common ELP_Commands. C1:1F#myForm#;

 

C#-Command F[[R[L|P]|[L|P]]]"FileName" [,x[,y[,d]]]; Call macro

Forms can be loaded by its file name. If the file name comes with only one backslash, ELP assumes, that the full path is provided. If there is none, the Working Directory path is added. This path can be changed with the WKDIR key.

Moving the forms or rotation follows the same syntax as described above at the F command.

 

C#-Command FF; Form Feed

This command inserts a Form Feed into the data stream. This function can be used to print for example a terms and condition form on the backside of the actual side. This is possible, because all F commands are performed on the end of the page. See below C-Command S for an example.

Important: Be careful using this parameter, because a recursive situation happens very easily. So C1F2000FFF3000; is absolutely such an invalid command. Form 2000 is printed on the first page, then Form Feed, and a second page is inserted. But during the phase of the process the second page is again a first page. So you will get a lot of empty pages with Form 2000 and 3000 on.

There are 3 ways to get around this:

  1. If the page should only be inserted once for example on the back of the first page; then use this command: C1:1F2000FF;C1:2F3000;C1F3000;
  2. If the page should be inserted any time: C1:RF2000FF;C1:LF3000;So on every right sited page a Form Feed is inserted, which results in a left hand page, where form 3000 is inserted
  3. See next command

C#-Command FN; Form Feed using next page command

This command is pretty the same as the form feed, (FF command). The printer will move the cursor to the next page. The difference is, that ELP will not recognize, that the page change happened.

Coming back to the FF command example the third solution here is: C1F2000FN3000;

 

C#-Command FS; Suppress the next Form Feed

This command is mainly used to arrange 2 printed pages on one page. So e.g. N A4 pages can be printed on A3, but using only 5% of the paper, e.g. first page left, second to the right, third back page left, fourth back page right etc. See F1 online help for an detailed Example.

 

C#-Command G[-]#[,x[,y[,d]]]; Call macro

Same like C#F, but called at the beginning of the page. This function is pretty similar to the F-Command, but has the benefit, that colored forms are printed underneath the printing data.

The disadvantage is, that an additional page may be printed at the data stream end, because the command is inserted right at the beginning of the page, where it is still unknown if there is one additional data to be printed. So it is wise to add a page number to the C# command like: C1:1G8000;

For further information Printing colored forms and watermarks underneath black text .

If using the G#,x,y form move command, and you want to reset the offsets for data stream, use the PL and PS commands which need to be set after the G command.

If the form number is provided as a negative value, ELP searches for the positive form, but at the end of the job, the mac/form file will be deleted! Use this method to delete temporary form files, which may have been previously generated by another print job using the F# command.

Sometimes the form is printed on the first page and the data on a second and beginning with the third page all fits. You can usually avoid that, if the ELP command is extended with the page size, orientation, simplex/duplex and the input tray ELP_Commands, which have to be located before the G command. So for A4, Portrait and Plain paper the complete command would be:

ELP_COMMAND=C1:1A26I1D0S0G8000;

In any case, all page commands must be set in front of the G command. If set behind the form, it will be separate printed from the data, one page in front.

If you want to underlay with a colored form all pages, then use this ini file setting:

[Global]

PreParsing=ON

; Print form from first to last page underneath the black text,

; no additional page is printed!

ELP_COMMAND=C1:1-#PREPARSEPAGECOUNT#G500;

Just in case the second page should be printed from another paper tray and using another form

[Global]

PreParsing=ON

ELP_Command=C1:1H7G500;C1:2-#PREPARSEPAGECOUNT#H4G502;

Finally as indicated above, if the form and the data stream are printed on seperate pages, move all page commands into the ELP_Command for the first page

[Global]

PreParsing=ON

; Set all page commands on first page, A4 (A26), Simplex (S0), Paper tray (H7),

ELP_Command=C1:1A26S0H7G500;C1:2-#PREPARSEPAGECOUNT#H4G502;

 

C#-Command G"FileName"[,x[,y[,d]]]; Call macro

Same as above C#Ffile, but the forms are loaded by their file name. If the name does come with only one back slash, ELP assumes, that the full path is provided. If there is none, the Working Directory path is added. This path can be changed with the WKDIR key.

Moving the forms or rotation is now possible, PL0PS0 behind the G command will set the print origin back to 0.

 

C#-Command H[-]#; Input paper tray selection*

This command should only be used, if the designated printer is not able to handle the next described I#; command.

This command uses for the paper source selection the old PCL commands \x1B&l##H.

The disadvantage is, that there is no clear numbering of the tray. In most cases it is different between each printer model. Usually follow this numbering:

1 Main paper source
2 Manual tray
3 Envelope feeder manual
5 Tray 3
6 Tray 4

The optional - in the command advices ELP not(!) to erase the existing paper tray selection commands in the data stream. This can be used for example to insert a separation page at the end of splitting a data stream. Note:
- If there is another A# command in the ELP_Command without minus, then the existing paper tray selection commands will be erased!
- The paper tray selection command itself is invisible to the ELP process. So you may need to set on the next page / paper sheet the data stream back to the default print direction

If there are no printer manual available, then use MS Word and a PCL5 printer driver and follow those steps:

  1. Open a new blank document
  2. File -> Document settings -> Select the proper paper input tray
  3. print the empty document to a file: File -> Print -> Mark Print to File -> Ok
  4. Load the print file into MS Word
  5. Search for &l (lower case L) and look if there is an h or H in the Escape Sequence. The number before this character is the searched H-value for this command.

If pages are not printed in duplex: Why does my duplex ELP command fail?

 

C#-Command I[-]#; Input paper tray selection*

This command defines the input paper tray. Instead of using the PCL sequences for paper tray, which are unfortunately different form printer to printer, the digit behind the I command defines the requested paper type.
This Command is only supported by HP LaserJet Series 4000, 2100 and newer.

I#

1 Plain 7 Cardstock 13 Thick2 19 Green 25 Glossy 31 Special2
2 Bond 8 Prepunched 14 Thick3 20 Orange 26 Envelope 32 Special3
3 Color 9 Preprinted 15 Thin 21 Red 27 Translucent
4 Labels 10 Transparency 16 Heavy 22 Pink 28 Ivory
5 Recycled 11 Rough 17 Blue 23 Gray 29 Postcard
6 Letterhead 12 Thick 18 Yellow 24 Purple 30 Special

The optional - in the command advices ELP not(!) to erase the existing paper tray selection commands in the data stream. This can be used for example to insert a separation page at the end of splitting a data stream. Note:
- If there is another A# command in the ELP_Command without minus, then the existing paper tray selection commands will be erased!
- The paper tray selection command itself is invisible to the ELP process. So you may need to set on the next page / paper sheet the data stream back to the default print direction

The benefits of specifying paper types instead of tray numbers are:

  • You may use any tray for a special type of paper. This gives the user the benefit, that he can load the printer with paper according to his needs. Those needs are certainly in a production environment different than for example in the bookkeeping area.
  • If the application wants to draw a special type of paper, you have either different kinds of papers loaded in the printer trays, or the user is notified through the front panel of the printer, to load a special paper.
    In both cases, the printer needs to stop if the tray is empty. In order to achieve this, each tray needs to be assigned to one of the above listed paper types. In this case the programmer doesn't need to know, how the printer is loaded.
  • The name of the paper does not need to match the real type of paper, which you want to print on. It is just a name, nothing else.
  • If the command is not given, the data stream will not be changed. But if the command is once given, the converter will erase all tray selection commands, \x1B&l_H, \x1B&n_Wxxxxxx and \x1B&l_M.
  • The \x1B&l0H remains unchanged in the data stream (eject page).

Example: C1:1I2;C1I3;C2I3F1000; Page 1 of copy 1 is drawn put of tray bond. The rest pages of copy 1 and all pages from copy 2 are drawn out of tray Color. In addition C2 prints watermark macro 1000 on every page.

If pages are not printed in duplex: Why does my duplex ELP command fail?

 

C#-Command J; Job Offset

A J in any C-command enables the Job Offset mode. There are no arguments needed.

If the command is not given, the data stream will not be changed. If the command is once given, the converter will erase all PCL5 job offset commands, \x1B&l_T and turn the Job Offset on!

It is enough to send this command only once on any page. Note: not all manufacturers support that command.

 

C#-Command L; Report Lines Generator

Inserts the usually gray report line using the build in generator. See Report Line Generator for further information

 

C#-Command M[-]#; Paper out tray selection* (stacker)

M# Output (Media) Bin Selection
0 : Automatic selection
1 : Upper bin
2 : Left or Rear bin
3 to 15 selects the destination bin of the mailbox or stapler bin.

If the C-command is not given, the data stream will not be changed. If the command is once given, the ELP print processor will erase all paper out tray selection commands, \x1B&l_G

The optional - in the command advices ELP not(!) to erase the existing paper out tray (stacker) selection commands in the data stream. This can be used for example to insert a separation page at the end of splitting a data stream. Note:
- If there is another A# command in the ELP_Command without minus, then the existing paper out tray selection commands will be erased!
- The paper out tray selection command itself is invisible to the ELP process. So you may need to set on the next page / paper sheet the data stream back to the default print direction

Example: Send job to different mailbox out-trays, depending upon the amount of printed pages

 

C#:#-Command N; No Page print

The N command will advise ELP to not print the page. The following notes are important for this command:

  • Use the command only on a special page of a copy. If it is the first page of the first copy, then use C1:1N;
  • This command does not work for the last page of a job. However, in this case, instead of the data, a blank page will be printed.
    In that case please use PJL commands, for example do only print the first 2 pages:

    [out search for the first JOB NAME]

    OutSearch_Binary=@PJL JOB NAME

    Add_Binary="="WELP-JOB modified by Ricoh" START=1 END=2\x0A@PJL COMMENT

    Search_only_Once=ON

  • Always use the N command on a specific page. The command C1N; does not make sense, because there will be only a blank page printed for the first copy.
  • This function is not supported in conjunction with the R command.
  • See here for more samples of not printing pages.

 

C#:#-Command N1; Ignore Form Feed

The N1 command can be used to combine 2 pages to one page. There is an example in the F1 Online help how to handle an DIN A5 data stream that always 2 pages are printed together on an A4 sheet.

Example: Printing two A5/A4 on one A4/A3 page

 

C#-Command O[-]#; Overlay*

In principle the overlay function has the same functionality as the C#-command F# , but:

  • the form will be automatically called on every page, the printer feeds.
  • The value of 0 disables the actual enabled overlay macro.
  • Per C-command is only one Overlay command possible. If you want to call more than one as an overlay, generate by hand a new macro, which calls the other ones.

If the form number is provided as a negative value, ELP searches for the positive form, but at the end of the job, the mac/form file will be deleted! Use this method to delete temporary form files, which may have been previously generated by another print job using the <<F#>> command.

 

C#-Command PL#; Long edge positioning*

Any positive or negative digit will move the long-edge origin of the page coordinating system to the new value. A value of 0 is setting the default value.

Negative values move the origin out of the page. But note that printing information can be lost, when they are positioned outside the unprintable area.

Positive values move the origin to the right. Printing information can be lost on the other side of the page, when printed outside the unprintable area.

If the command is not given, the data stream will not be changed. If the command is once given, the converter will erase all related sequences in the data stream.

In order to reset any movement in front of the form call F#,x,y use the PX command.
If using the G#,x,y form move command, and you want to reset the offsets for the data stream, set the PL command after the G command.

Example: C1PL300; Printing for example a left bounded ASCII data stream, this command will move the whole text on an A4 portrait page 300 units to the right. Printing two A5/A4 on one A4/A3 page

 

C#-Command PS#; Short edge positioning*

Same functionality as PL#, but on the short edge of the paper.

 

C#-Command PM; Move existing commands instead of erasing them

Using PL and/or PS will result in setting a new 0x0 coordinate point and ELP deletes all related PCL sequences in the data stream and forms.

However, very uncommon, the data stream or the forms use those commands to set their cursor (not very smart). In that case the result might look totally rubbish.

Using the PM parameter will set the provide new 0x0 point onto of the requested pages, but when an offset command is found in the data stream or form, ELP adds the new positive or negative offset value. So the print out is only moved.

As those commands in loaded Forms are also modified, you might not use the offset definition in the form, but instead move it in the ELP F or G with the add-on ,x,y option.

 

C#-Command PX; sets PL#; and PS#; to 0,0

If this command is given, the previous defined PL# and PS# moves will be set to 0,0 right before the form feed and before any macro using C-command F# is called.

If only this command is used, any \x1B&lU or \x1B&lZ in the data stream will not be erased!

 

C#-Command Q#; Single page reprint factor

The reprint factor must be a positive digit larger than 0.

This command reprints a single page # times, as it is defined 1:1, no additional forms or other ELP_Commands are issued.

 

Please note: Any Esc&l#X commands, which are already defined in the incoming data stream may overwrite the Q# command. So maybe add this rule to ensure the command set is working:
[Erase provided page copy command]
Search_Binary=\x1B&l1X
Erase_Binary=ON
ReadOnlySearchkeys=ON

 

The command is normally not used in duplex mode, as the pages are simply copied by the printer. For the page counter, those additional pages are currently NOT counted!

The commands should be very carefully used in conjunction the page copy commands K#; Q#; and R#;

Example: K1;C1:1Q2;C1:2Q3; The complete document is printed once K1; but the first page 2 times and the second (and all following pages) 3 times.

 

C#-Command R#; Reset Page Count

This command resets the page counter. It can be used to create page number based recursive ELP_Commands actions. But note: If accounting is enabled, this command will lead into wrong accounting results.
If no page number is set, then next page will be treated as page 1. Otherwise set the number to one less then the next page should be looked at.

Example: A data stream is endless. It contains n times 3 pages, and the pages have to be drawn out of different paper trays.

[Global]

; The 3rd page will reset the page counter to 1

ELP_COMMAND=C1:1H4;C1:2H1;C1:3H6R;

The result of the R command in the definition of the 3rd page is, that the 4th page is performed as it is would be the first page, the 6th also again as the first etc.

This method only works for jobs which have constantly the same amount of pages. If this is not the case, then the new ELP Escape Sequence \x1B)s-995Z can also be uses on the last page of a section. Whenever this sequence is found , ELP will then reset the page counter on the next page to 1.

Example:
Invoice printing by a huge data stream with a lot of invoices: On the first page form 2000 is requested on all the other pages form 3000. If the text "Payment period 30 days" is found on the page, the next page will be again a page 1:

[Global]

ELP_COMMAND=C1:1F2000;C1F3000;

[Search for last page of invoice]

Search_Binary=Payment period 30 days
Add_Binary=\x1B)s-995Z
ReadOnlySearchKeys=ON

Doing it this way, ELP will lose the total page counter. But there are other ways, you may have a look at the key OutPort.

You can also define any other recursive page number. So sometimes the first pages unique and the following pages are for example printed duplex and special forms have to be printed on front and back pages:

 

C#-Command S#; Simplex / Duplex*

This C-command sets the printer in the simplex or duplex mode. Those parameters are possible:

0 : Simplex
1 : Duplex long side
2 : Duplex short side

Notes:

  • Any other # number then 0,1,2 are ignored.
  • Once this command is used, all PCL commands for simplex/duplex in the data stream are erased. This means, if you want to set the complete job in duplex, then simply turn it on the first page C1:1S2 on.
  • A duplex command needs to be always sent on the front page.
  • Turn off duplex printing also on the front page!
  • You may C-Command B to select the next printing page

Example: C1:1F1100S1FFF1000;C1:3S0; This example demonstrates how to print terms and conditions on the first page only. Copy 1 page 1 starts printing in duplex S1 before the page form feed, the macro 1100 is inserted, then the Form Feed FF and on the new page 2 the macro 1000. After that point the original Form Feed from page 1 is performed. So next page is number 3 and the duplex mode is turned off.

If pages are not printed in duplex: Why does my duplex ELP command fail?

 

C#-Command T#; Top Margin*

Any values form 0 to 70 lines. The line spacing is either 6 lines per inch or a before set lpi setting.
Note: The A (paper size) command does reset the command to 1 line.

 

C#-Command X#; Don`t use this C Command on print page #

This C-command is used to suppress the command on a specific page. It is important to use the command right after the C-definition.

Example: C1:1S1F5000;C1:RX1S1F50001;

The purpose of this example is to print a duplex job. On the first page the letterhead form 5000 needs to be printed. No forms are printed on the back pages. Finally a different logo than on page 1 needs to be printed on each following front pages.

C1:1S1F5000; Page 1 is duplex and Form 5000 used
C1:RX1S1F50001; All right pages, except page 1, are duplex and use form 50001

 

C#-Command Y#; Turn Perforation Skip ON

Once this command is used, text can be positioned on the page from the very top to the very button. However, this does not mean that the printer is able to print the text at that location. So it is strongly recommended to use Form Feed to go to the next page.

The practice the printer does by default perform a form feed if the text cursor is set in the approximately range of the last centimeter of the page. Once turned on, you still can print there text.

Example: C1Y;

* Once one of those page related commands is/are defined in an ELP_Command:
1. the corresponding PCL Command will be removed all over the document
2. the selected command is inserted on the requested pages.
3. Once set, all following pages will be handled like that, the command does not need to be reset
4. Therefore it is recommended to use those page commands always on a page number, e.g the first one of a copy: C#:1
5. See here why: Why does my duplex ELP command fail?

For example: Once set the paper size to A4 for example. It remains A4 until the end of job, or it is changed. For pure ASCII data stream this page size can survive even all copies. This may become critical, when you print has an odd amount of pages and needs to be printed in duplex. So the first page of the second copy will be on a back page. In this case enter the command ET; which will add a separator between the copies.

 

Description of all primary ELP_Commands:

D[+]#; - Default Copy Command

The command value # defines, which C# command definition will be selected by default, when there is no C-command defined for the actual copy number.

Example (without the C-command descriptions): <<K4;C1...;C2...;D2;>>
This command will print the data stream 3 times. For the first copy the definition of C1 is used, for the second C2. The D2; command now defines, that if there is no page copy description, the description of the number of the D command is used. In our example, the copies 3 and 4 are treated the same way, as copy 2.

Using the optional + sign after D, you can define two D definitions in the ELP_Command. The plus indicates the definition for odd copy numbers. The second D in the command line without plus the definition for even copy numbers.
Important Note: The D+#; description must be always defined in the ELP_Command in front of the D#;

Examples:

ELP_Command=K5;C1:1I1;C2:1I9;D+1;D2;
The data stream is copied 5 times. K5;
The complete Copy 1 is drawn out the Paper Tray assigned with Media Type Plain C1:1I1;
The complete Copy 2 is drawn out the Paper Tray assigned with Media Type Preprinted C2:1I9; (It is enough to set the Media Type on the first page.)
For Copy 3 and 5 The D+1; does apply, so definition for C1.. is used
For Copy 4 The D2; command does apply, so definition for C2.. is used

ELP_COMMAND=C1:1F4444;C1F4445;C2:1F5444;C2F5445;D+1;D2;K6;
K6; generate 6 copies
Copy 1, 3 and 5 print on first page form 4444 and on all following forms 44445
Copy 2,4 and 6 print on first page form 5444 and on all following forms 54445

 

EA$$$$; - Send a C-Command right before the first print data

This command is used also for initializing the printer. The $$$$ can be any combinations of C# commands, like macros, simplex/duplex commands etc.

Example 1: EAS2B2F4711; This command will set the data stream to duplex printing, and selects the backside as the first printing page. Also on this back page the form 4711 is printed. If there is after this command in the data stream no PCL command which will make perform a Form Feed, the following data starts printing on that back side page.

Example 2: EAS2B2F4711FF;C1:2S0; Pretty much the same command, but the first page will have only the form, maybe the forms is using same variables for printing the user name and print time, but then the form feed tells the printer to feed the page. As the B2 command is not performing a form feed, the page counter is set to 2 after the FF command. The C1:2 command will set the rest of the data stream to simplex printing.
The following command does the same, but as 2 Form Feeds are sent, the empty first page is counted: EAS2FFF4711FF;C1:3S0;

Notes:

  • The major difference compared to the EB command is, the EB loads a form in front of the data stream; The EA command can then set the printer within the data stream to any initialization; The K-copy command does even reprint this initialization, which is not the case for the EB command.
  • Any page initialization of C1 or C1:1 command will be sent out before the EA commands.
  • In order to enable copy specific tray selections, the Command C#:X is searched and if defined executed right before the EX commands.
  • You may use several EA statements in a command line.,

ET3; - Select 300 dpi resolution
ET6; - Select 600 dpi resolution

Those commands can only be used in conjunction with an EB#; If you do not want to call a macro right at the beginning of the data stream, please enter a unused macro number, like for example 9999.

Those commands set the printer to a specific resolution, 300 or 600 dpi.

 

EB#; Send a form/job at the beginning of complete job

EE#; Send a form/job after the end of the complete job

The # in the command is the macro/form ID number, which is called right before = EB and right after = EE the provided data stream (See F command).

In most cases, the EB command is used to initialize the real data stream, like the job_ini.mac, or downloading forms or setting the printer into a specific state. But it can also be used as a cover sheet, in this case do not convert a print file into a macro, as the job itself is the macro including all initializations, so print your form to file and store it with the name ###.mac (### is the macro number) direct in the folder c:\ProgramData\WELP.

Example for a cover sheet: EB22000; Inserts the ELP provided demo form 22000 at the beginning of the print job.

Notes for PCL data streams:

  • The EB and EE command can be used several times in the ELP_Command. The intention is to have for example loaded several items at the beginning of the data stream specific fonts, like normal or bold, depending on the real addressed fonts.
  • The macro ID number must be larger than 0 and less than 32000.
  • There is no other ELP Command performed on those 2 inserted jobs. This means, the first ELP page is the first page of the provided data stream. The EE pages do not count.
  • The Search Binary and Windows definitions in the ini file are performed on these macros, as well as the variable replacements.
  • There will be an UEL inserted right at beginning of the data stream (EB only).
  • If the data stream itself contains an UEL (\x1B%-12345X) or a PCL Reset (\x1BE) statement, this method can't be used to set the printer, ELP does NOT add any MacroCalls, nor page ejections..
  • An easy way to generate such is valid file could also be to print the form direct into a ####.MAC file, without converting it using the macro Tab. The benefit is, that all printer statements are still in the file, like choosing
  • EE#; and EB#; commands ale also performed on every splitted data stream using OutPort or OutArchiveDir command keys.
  • If the footer pages (EE#; ) should be stapled to the remaining document, then you need to remove the PJL headers and take care about your own header, see next link for further details.

EI#$$$; - Performs an ELP_Command at the beginning of the # copy

Right before the # reprint copy of the job, the provided ELP command is performed. This command is only performed if the K#; command is provided.

Example: K300;EI51I9FF;EI101I9FF; There are 300 copies in order 123... 123... 123... printed. After every 50th and 100th copy and before the 51th copy an empty sheet is drawn from paper try with media type preprinted.

Notes:

  • If the default ELP_Command D#; is used, and the EI# for the actual copy is not defined, ELP will then search for EI command for the named copy number of the D#; command
    Examples:
    K2;EI1F501FF; will print in front of copy 1 the terms and conditions document.
    K2;EI1F501FF;D1; will print in front of all two copies the terms and conditions document.
  • This command can`t be used while splitting a data stream to an archive or another queue.. If needed try to use search and add commands to add your needed functionality at the end of a job in the PCL section.
    If the command is for all copies the same, try to use the PCL_EXIT_PCL ini-file command key.
  • You can use different EI# commands for each copy.

 

EJ#$$$; - Performs an ELP_Command at the end of the # copy

Mostly same as above described EI command but at the end of the copy. Note: EI2F501; and EJ1F501; lead to the same result. There is one exception compared to the EI command:!

Example: ELP_Command=EJ1I9F8000FFF8001; Prints after the first copy form 8000 - form feed - 8001 on next page and both are drawn out of the preprinted assigned paper tray.

Important limitation note: Any macro used the first time in the job and AFTER(!) the last copy will NOT be loaded! Also any macros after the previous copy which had been used before, and they should be reloaded, as they are above macro number 25000, are NOT reloaded, so in this case after the previous copy the same addon is printed as the copy before!

Example: ELP_Command=K3;EJ1F28000;D1;

Print 3 copes (K3) and after each copy print form 28000 (because of D1 always EJ1 is used). Macro 28000 which is a sort of cover page with variables on.
As a result the page after the last copy will have the same content as the second last page. (Not the form is not reloaded)

Correct example: ELP_Command=K3;EJ1F28000;D1;EJ3X1;EE28000;

Here the EJ3 will hit after the last copy and the C# command will do nothing. Finally the Form 28000 is again loaded, the variables replaced and added.

 

ET[J]; - Wrap in PJL JOB statements

This command should be used, if the data stream provides only ASCII characters, and doesn't initialize the job correctly: No BEGIN and no END-OF-JOB Sequences.

ET; wraps the data stream into well defined PCL5 PJL commands. As the result the printer treats the output stream as one job.

ETJ;K#; The parameter J is only usable in conjunction with the K#; parameter. If both are used ELP wraps each copy job independently. Maybe used to staple each job together, if the job itself is not well bounded.

 

EX$$$$; - Send a C-Commands right at the end of print data

This command is used to add forms at the end of the data stream. The syntax of the command is similar to the EA command. $$$$ can be any combinations of C# commands, like macros, simplex/duplex commands etc.

However you may always use C-Command FF for ending the last page.

Notes:

  • This command is only activated the before the reset sequence \x1BE or before the UEL commands \x1B%-12345X, whatever comes first. So minimum one of those 2 commands need to be used at the end of the data stream!
  • In order to enable copy specific tray selections, the Command C#:X is searched and if defined executed right before the EX commands.
  • You may use several EX statements in a command line, if they are combined while processing with ELP_COMMAND_ADD.
  • You may also combine several pages even from different trays using duplex.
    Example: EXS2I9F1000FFF1001FFF1002FFF1003FF;
    The macros 1000 to 1003 are added at the end of the job, separated by FF, so each macro is printing on one page, using long edge duplex printing and finally the paper is drawn from paper tray with media type preprinted.

F#; - Generate a new mac file on the fly

This command will store the actual data stream up to the first form feed into a macro file named #.mac. You may use this command to generate new forms on the fly, without using PPAdmin. A second need for this command is to select printing pages and combine them to one print job.

So for example F4711; will generate the file 4711.mac in the working directory

Notes:

  • The print file is only stored up to the first form feed in the printing file
  • Like the macro conversion by PPAdmin, all escape sequences, which may cause form feeds are erased, even when they are defined in the ELP_Command! Example 1: F4711;C1S2I5; file 4711.mac is created, but all C1 commands are ignored.
    Example 2: F4712;C1:F1999; file 4711.mac is created, and at the end of the new form, the form 1999 is called. Note: PCL allows only 2 levels of nesting.
  • Previous stored files are overwritten, without any warning!
  • If this printing file needs to be called by another print file, then use simply the newly predefined number.

K#; - Document reprint factor

The positive number # tells the system how often the complete data stream has to be printed, original + reprints. The minimum value is 1 for the original. If there is no K,Q or R factor in the ELP command defined, K1 is assumed.

The K-factor can be overwritten by a copy factor defined in the print file. ELP Key: ELP_Use_Qty_Factor or you may use any own defined variables .

Example: The page printing order of a document with 3 pages using the K4; command is like this: 123 123 123 123

Notes:

  • If the copy number is more than 1, the total size of the data stream is limited to the heap memory available in the system. The limitation is different for each supported platforms. For a printer internal version about 2 to 3 Megabyte, otherwise mostly 10 Gigabytes.
  • If the 1 MB is not enough, then use ELP_MAX_HEAP key in the ELP ini File to redefine the maximum available heap to any size.
  • The K#; should only be used once in the ELP command line.
  • If any valid number is given, the PCL copy command \x1B&l_X is ignored
  • As each page is stored as a macro, do not define any additional macro within the data stream.
    For Unix: if bar codes are used on the page, therefore in definit.h remark out the definition: TEXT_WITH_MACRO. It is not enough to set the definition value to 0.
    For MS Windows: If bar codes are needed, do not print the bar code with readable text, or ask your local distributor to send you a system with the TEXT_WITHMACRO turned off.
  • The value can be overwritten using those keys: ELP_SET_COPYFACTOR and ELP_USE_QUANTITY_FACTOR.
  • Print jobs can be splitted for each copy using the OutArchiveDir or OutPort commands, in conjunction with the SplitAfterEachCopy key.

 

N1; - Pass-through

This command will switch the ELP functionality to pass-through. There will be no changes made on the data stream beside to present the content of the file job_init.mac, if the file exists.

 

N2; - NoPrinting

ELP will not print any data. This ELP command can be used to avoid the print out, but in conjunction with archiving the data it still can be sent to another directory or port, like fax.

 

Q#; - Pages reprint factor

The positive number # tells the system how often the complete data stream has to be printed. The minimum and default value is 1. This command should not be used in conjunction with the R#; or K#; command.

The Q-factor can be overwritten by a copy factor defined in the print file. ELP Key: ELP_Use_Qty_Factor or you may use any own defined variables

Compared to K#; parameter, this Q#; parameter works totally different. The document will be copied using the printers copy function. This means, that the data stream goes only once to the printer.

Example: The page printing order of a document with 3 pages using the K4; command is like this: 1111 2222 3333

Note: Only the C1[:#]commands can be used, all other C commands for copies higher then 1 are ignored!

 

R#; - Pages reprint factor, with changeable ELP content

The R#; command produces the same page print order like the Q#; command. But on each printed page/copy you may select any C#[:#] command.

The R factor can be overwritten by a copy factor defined in the print file .

The R-factor can be overwritten by a copy factor defined in the print file. ELP Key: ELP_Use_Qty_Factor or you may use any own defined variables.

In rare cases, printer will print one empty page at the end of the job, you have two possibilities to avoid that:

  • Set the printer in its menu to suppress blank pages, and if that still does not work:
  • Make sure that the key PreParsing=ON is set in the rule Global and
    That the job contains a t the beginning an PJL command: @PJL JOB NAME, (if not, please contact the ELP support) and
    Finally add this rule:

    [Set document to print X pages]

    Search_Binary=@PJl JOB NAME

    ; Calculate how many pages are really printed (Times the reprint factor, here 3)

    Counter=#PREPARSEPAGECOUNT#;*3

    ; Add at the command line end the start and end page count

    ReplaceNextTerm=\x0D\x0A: START=1 END=#PREPARSEPAGECOUNT#\x0D\x0A

 

S; - Flip front and back side in a duplex job.

This command exchanges the even and odd pages. It is mostly used for duplex jobs to get the document correct out for several envelope inserters. In order that this function works correctly there are several items to be considered:

  1. There are no macros definitions allowed in the printing data stream. If this is the case, please get in contact with your distributor for a quotation to overcome this requirement.
  2. As some PCL sequences perform page breaks when used, it must be ensured with the ELP_Command, that they are set on the first page ONLY. Those commands are especially: Paper size (A) and orientation (D), input (I or H) and output trays (M) as well as the duplex command itself (S).

So it is a must to name them on the first side only. This can be done by using a little more specific ELP_COMMAND:

ELP_COMMAND=S;C1:1S1A26O0H4;
S; turns the exchange on.
C1:1 defines the first page setup, as a side effect if one of those commands come in the data stream thereafter, they will be erased, and the second problem is not applicable anymore.
This first and therefore all following pages are printed in Duplex (S1), A4 (A26) and from HP Paper tray 2 (H4);

Notes:

  • This command also ensures that the PCL sequences for front / next and back page selections are recognized and converted to form feeds if needed.
  • Currently no forms are allowed to be called in the ELP_Command key, beside the C1:LF####; command. A form can be only be inserted on the incoming left hand pages, which then, after the S; Command, will be the front page.
    If also a form is needed on the back page then ELP offers 2 options:
    1. Run the job again through ELP, and the second time add on every (!) page the form. Every page means C1F####; Every because only after the switched pages comes the form feed, so on the reversed back page.
    2. Insert at the beginning of the job the form needed on the new back page, for example with a searched rule. Here in this sample the forms 1000.mac is inserted just even before the first PCL page command.

    [Insert form, no call]

    Search_Binary=\x1B&l
    Insert_Binary=\x1B&f1000Y
    ReadOnlySearchKeys=ON
    Search_only_once=ON


    Then add on each new back page the form.

    [Insert form while writing out on back page]

    Search_Binary=\x1B&a2G
    Add_Binary=\x1B&f1000y3X

  • Tray / simplex / duplex settings can be called anytime, but only on front pages! Same technical reason as above.
  • If the document it not duplexed anymore, or the form and data on the back page printed on two separate pages, then you need to move the tray commands to the first page. See here for more details.

     

T#[:#]; - Staple print job with stapler/stacker

The T#; command is used to staple, punch or add any other PJL Command to a print job, or add any ot. Once used, the existing PJL commands for stapling and punching are deleted.

To add more commands is pretty easy, Open the file c:\ProgramData\WELP\stapling.ini and add new functionality if needed.

Be sure, that the out bin escape sequence in the data stream is set to the correct out bin! If there is an ELP command, which changes the out bin to a non stapling bin, the T command will have no effect.

See example: Stapling/punching and splitting mail merge documents

For mail merge support, the option :# can be added. This static option defines how many pages should be stapled. Usually it is the amount of pages per single mail document. If you intend to print mail merge stapled document with Microsoft word, then please have a look at the Microsoft Word chapter of the installation manual . There is an easier way described.

Some printer manufacturer are not able to staple several copies of a job together with one staple. Then you can use the key EraseAllPJL in order to erase and the following PJL commands. Then embed the copies with the ELP_Command ET; and staple them together,

Example for generating 2 copies of a stream, but stapled together:

[Transportation papers for truck]

; if found in the data stream:

Search_Windows_new=DeliveryNote

; then make 2 copies, erase the PJL part but make a new one (ET) around the complete job

ELP_Command=K2;ET;T200;
EraseAllPJL=ON

Notes:

  1. In order to work correctly, a print job needs to begin with an UEL command (\x1B%-12345X). If you are not sure, then load the print file into any editor. If this command is missing, use the ET; ELP_Command.
  2. Keep in mind that a defined ELP command in the data stream is sent with every printed record, but ELP looks only for the first true command. In order to not print the commands on the second and following records, either prints them in white color, put the print command into a contraction: "If first record then print command, else do nothing", or use the IniFilemethod.
  3. Mail merge with variable page numbers is NOT supported! Each record needs to print Tx:# pages.
  4. There should be no additional UEL statements in the middle of the data stream.
  5. SPEED: In order to enhance speed:
    A) Use macros for standard parts of mail merge form
    B) from the programmer standpoint, there some speed tuning could be made, but this needs to be weighed up against cost.
  6. Example: Your MS Word mail merge document contains 3 pages, and you want to staple all 3 pages together, then your ELP_Command may look like this: T1:3; For huge jobs, printing may getting slower and slower. In that case use the OutPort method for splitting files.

X; - test command syntax

Through the development phase of your project, you may have the wish to test if your syntax of the ELP command is correct. As by default, the Server is not generating any output, the X; command was inserted for testing purposes.

Any Warning or wrong syntax in your ELP command will be dumped to the standard output, while the command is interpreted. Of course if the Log_Mode is set minimum to the Error-Level, the entry is also printed into the log-file.

As the Windows based server runs in the background, there is usually no visible output. For ELP development, you may want to start the active part of the server manually. Open a DOS window, change to the ELP Workpath and start for test purposes the converter manually from the command line like:

convert infile outfile -dWorkpath -cIni-File ....

Notes:

  • You can capture any incoming data in the IN_data.prn file, using the -o command call, or using the archive or debug ini-file keys.
  • The HP LaserJet hardware version does ignore this function.