JPH01258968A - Printer control device - Google Patents

Abstract

PURPOSE:To allow protocol on a printing side to be changed over using a signal from a data processor side and thereby improve operative efficiency by providing a starting means for starting any program stored in memory in response to a specified signal connected by a data processor. CONSTITUTION:Memories (ROM 305, RAM 307) which store a plurality of programs for controlling the operation of a printing section are provided. In addition, a timer 302 which is a program starting means is provided and in response to a specified signal connected by a data processor, it starts any program stored in the memories (ROM 305, RAM 307) and activates the printing section according to the program.

Description

[Detailed description of the invention] [Industrial application field] The present invention relates to a control device for a general-purpose printer.

[Prior Art] The above data and control data are exchanged between a printer, which is an output device in a computer system, and a data processing device, which sends data to be printed. Device protocols must be the same. For a printer designed to correspond to a specific data processing device, it is sufficient to define the same protocol specifications as the protocol of the data processing device.

On the other hand, for general-purpose printers that are to be used by being connected to multiple types of data processing devices with different protocols, a printer-specific protocol specification is required. Equipped with a conversion device.

The protocol conversion device uses a protocol conversion program (
Emulation software) was generally run on the printer's control processor to convert control information output from the data processing device into control information possessed by the printer.

In this case, the printer side performs a process of decoding and converting the converted control information into internal parameters that further control the operation of the printer.

However, in devices equipped with multiple types of emulation software, once one of the emulation software is started, it is possible to switch to another emulation software only by resetting it in hardware. Ta.

[Problem that the invention seeks to solve]

Therefore, there is no problem when using the printer continuously while connected to a specific data processing device, but if the printer is connected to multiple data processing devices with different protocol specifications and the data processing devices are switched at any time, etc. This method has the disadvantage that it cannot be applied to the following applications.

The present invention has been made in order to solve such problems, and provides a printer that can be used for the above-mentioned purpose by having a configuration that allows switching of emulation software to be executed using a control signal from a data processing device. The purpose is to provide a control device.

[Means for solving problems]

A printer control device according to the present invention is interposed between a printing section and a data processing device that provides data to be printed by the printing section, and controls the operation of the printing section. In the printer control device that controls the operation of the printer, there is provided a memory that stores a plurality of programs for controlling the operation of the printing section, and a memory that stores a plurality of programs for controlling the operation of the printing section, and an arbitrary program that is stored in the memory in response to a predetermined signal given from the data processing device. The present invention is characterized by comprising a program starting means for starting a program.

Another feature is that a program for controlling the operation of the printing section, that is, emulation software, can be written into the memory from a data processing device or other external device.

Another feature is that a program unique to the printing section and other programs can be executed in a time-sharing manner.

Note that this printer control device may be assembled integrally with the printing section, that is, built into the printer, or may be separate from the printer.

[Effect]

When the data processing device issues a predetermined signal, an arbitrary program in the memory is activated. Also, the emulation software can be given from the outside and written into the memory.

Furthermore, the emulation software and the program specific to the printing section can be switched and executed at any time based on a signal from the data processing device.

〔Example〕

The present invention will be described below based on drawings showing embodiments thereof.

[Outline structure]

First, a schematic configuration of a printer according to the present invention will be explained. FIG. 1 is a block diagram showing the configuration of a printer 10 of the present invention. The data from the general-purpose data processing device 1 is
In order to improve the throughput of the data processing device 1, the data is stored in the file buffer 2 and then output to the printer 10. The printer 10 includes a bitmap type data processing device BMU 3, that is, a printer control device of the present invention;
Print engine 4 equipped with an electrophotographic process laser, etc.
and accessory devices such as an external paper feed unit 5 and a sorter 6.

FIG. 2 shows the appearance of the printer system.

An electrophotographic process and a BMU 3 are built into the housing of the print engine 4, and an external paper feed unit 5 and a sorter 6 can be connected as accessories. Further, the print engine 4 is equipped with a display panel 44 on which a display section showing the status of the system and keys for performing simple operations are arranged.

FIG. 3 shows details of the display panel 44. 9
01 to 903 are input keys, and 910 to 918 are display elements. A key 901 is a Bose key for temporarily suspending the print operation, a test key 902 is a test key for starting a test print;
When pressed at the same time as the shift key 03, it becomes a cancel key that interrupts printing.

FIG. 4 is a schematic block diagram of the control system of the printer 10. The bitmap type data processing device 3 includes a bitmap memory BM-RAM 32, and a bitmap memory BM-RAM 32.
32, a bitmap writing section 31 (see FIG. 9), a font section 33, and a bitmap control section 30 controlling these sections. Connection with the print engine 4 is made through a bus B3 for control data (number of sheets, accessories, etc.) and a bus B4 for image data.

The print engine 4 corresponds to the above-mentioned printing section and is mainly composed of three controllers. First, the interface control section (IFC) 40 processes control data from the bitmap control section 30 and controls the display panel, and also controls the overall timing of the print engine 4 via the internal bus B5.

The electrophotographic control section 41 controls the electrophotographic processing section 45 in accordance with data sent from the interface control section 40 via the internal bus B5.

The print head control unit 42 follows the information sent from the bitmap writing unit 31 via the internal bus B4.
It controls the light emission of the semiconductor laser of the print head section 43 and the rotation of the polygon motor. Further, the external paper feed unit 5 and the sorter 6 are also controlled by the interface control section 40 through the internal bus B5.

[Configuration of control unit]

FIG. 5 shows the configuration of the bitmap control section 30 according to the present invention. The overall configuration consists of data input/output interfaces (301, 309, 310° 311
), the central CPU 303 of the control unit, its system ROM, RAM (305, 307), CPU 3
A timer 302 that periodically interrupts 03, and a buffer memory for data storage (304, 306, 3
08).

Next, the operation of each part will be explained. First, data fetched from the data processing device interface 301 through the bus B2 is stored in the R-buffer 304.

As shown in FIG. 6, the system ROM 305 includes a host process 65 that temporarily edits data sent from the host, that is, a data processing device, and writes the data as a packet to the bucket buffer 1308; Analyze and bitmap writing interface 310
A packet process 64 sends data to the bitmap writing unit 31, or to the font unit through the font interface 309, and further to the interface control unit 40 through the print engine interface 311.
It contains an independent program. and,
The scheduler 62 written in the system ROM 305 switches each process according to the state using a timer interrupt 61 from the timer 302.

In the system RAM 307, there is an area called a current process status (CPS) block as shown in FIG. 7(a).
Since the register contents of 03 are stored in the CPS, each process can operate independently. .

The CPS block is a packet process 64. Host process 65. There is a save area for each user process 66 (described later) and a save area shared by these processes.

Further, the system ROM 305 stores an initialization start process 63 for when the printer is started, and is started directly from the host process 65.

The memory configuration of the system RAM 307 is shown in FIG. 7(b). The download segment of system RAM 307 is provided with an area 66' for user process 66. Data processing device interface 301
from the data processing device 1 through the font interface 309 or read from the font cartridge through the font interface 309
6) into this area 66' of system RAM 307. Then, the scheduler 62 can perform time-sharing processing like other processes. This user process 66 is a program that converts data sent in a protocol different from the protocol unique to this printer (host protocol) into the host protocol.

In this case, the data flow is as shown in FIG. 8, for example, from the data processing device 1 through the interface 301 to the system RA? The user process 66 extracts the received data (data of a protocol other than the host protocol) stored in the R-buffer 304 and converts it into data of the host protocol. System RA? OR- in 1307
Accumulate in buffer 306. The host process 65 that temporarily edits data can take out the OR-buffer 306 and treat it as host protocol data when the user process 66 is started (and when the user process is not started, that is, as host protocol data). In some cases, it is sufficient to simply retrieve the data in the R-buffer 304 (no other changes are necessary).

As shown in FIG. 7(C), the user processes 66 are stored in the system ROM 305 in a plurality of protocols for each protocol that can be supported by the printer control device, that is, the data processing device 3. A specified user process may be loaded into the download area (user process area) 66' in the system RAM 307 using a process specification code.

To summarize above, the host protocol is the host process 65
The data sent using this protocol is stored in the R-buffer 304 of the system RAM 307.
, and temporarily edit this to create a system. It writes to the bucket buffer 308 of the AM 307.

On the other hand, a program for converting data sent using a protocol other than the host protocol into data using the host protocol, that is, a user process 66 (one or more types may be used) is stored in the download area 6 of the system RAM 307.
6', but this can be given from the data processing device 1, or external devices such as font cartridges can be given from memory, and furthermore, it can be given from the system RAM.
A plurality of them may be prepared in advance at 305, and these may be given selectively. In this case, the data once written to the R-buffer 304 is transferred to the user process 66.
The data is converted into host protocol data and stored in the UR-buffer 306, and then written to the packet buffer 308. FIG. 28 shows an example of data sent from the data processing device 1 side to the printer control device of the present invention.

In this example, a code that specifies user process "1" (for example, ESCESC[1]) and target data in a format compatible with user process "1" are sent, and then user process "2", which is different from the user process "1", is sent. ” (for example, ESCESCU2) and target data in a format that matches this user process “2”, and then sends a code that specifies the host process (for example, ESCESC00) and data (native data) that matches this. Send.

The printer that receives this automatically prints each data continuously.

Furthermore, since there is no need to change other processes that control printer operations, the user process 66 is simple and only performs data conversion, making development easy.

FIG. 9 shows a detailed block diagram of the bitmap writing section 31. The functions of the bitmap writing section can be roughly divided into BM-R.
Drawing function to AM 32 and BM-RA when printing
It is divided into a function of outputting the data of M32 to the print engine 4.

The drawing function to the 8M-RAM 32 is further divided into two parts: drawing of a line of one circle performed by the graphic image writing section 316 and font drawing performed by the font image writing section 311. Both writing sections 316,3
11 Tomo bitmap control unit interface 317
This is a logic section that operates on the intermediate code sent from the bitmap control section 30 through the graphics image writing section 316, but most of the processing in the graphic image writing section 316 involves analyzing the parameters in the intermediate code and drawing it in the RAM 32. On the other hand, most of the processing of the font image writing section 311 is to draw a font image read from the font section 33 through the font section interface 314 into the BM-RAM 32 according to data in the intermediate code.

On the other hand, the function of outputting data during printing is performed by the print head control unit interface 315. That is, from the bitmap control section to the interface 31
Upon receiving the print start code sent via the bus B4, the print start code is sent via the bus B4 in accordance with the synchronization signal sent from the print head control unit 42 of the print engine 4 via the bus B4.
Data in M-RAM 32 is output to the print head controller.

Next, we will explain the concept of image area.

An example is shown in FIG. In Figure 10, the entire area (A
The portion indicated by 1) corresponds to the size of the paper.

The margin area (A2) on the periphery is the blank space when actually printing on the paper, and the image area (A3) inside is where the print data is drawn.
This is the part. Printing starts from the upper left of the image area, and characters are printed sequentially according to the printing direction AIO. If a line feed code is entered on the way, line feed direction A
ll, the next printing position moves by the line feed width A12. Furthermore, when the return code is input, the next printing position moves to the return position A13 at the left end of the image area. Note that the margin area A2 can be changed on a page-by-page basis according to a designation from the data processing device 1.

Next, the operation of this system will be explained with reference to a flowchart. The program of this system is divided into the following three parts.

Host process parses the data in the receive buffer and
Generates packet data for controlling the drawing section and print engine section.

Packet process Actual drawing of BM-RAM and engine control are performed using packet data generated by the host process.

User Process The host process converts protocol inputs of different formats into parsable protocols and passes them to the host process, provided by downloading from a font cartridge, system ROM 305, or data processing device fl. Do not perform protocol conversion if it is not necessary.

These processes are independent programs that run in parallel using time-sharing processing with priorities. The priority is packet process, host process,
This is the ranking of user processes.

In addition, there is a scheduler that manages these processes using timer interrupts, and a start process that is activated at startup.

Next, each process will be explained.

[Start process]

FIG. 11 is a flowchart showing the start process. This process is launched only once at startup.

First, when the power is turned on (step #1), internal initialization is performed (step #2), and the R-buffer, OR-buffer, and bucket buffer (FIFO) are cleared (steps #3 and #4). #5) 0 Next, as a preparation for starting the host process after this, set the bit indicating the host process in the request vector (Step #6), and set the bit indicating the output process in the current vector (Step #7). , a number indicating the user process is entered in CRTPRS (step #8).

A request vector is used by a process whose execution has been interrupted to convey to the scheduler a request to abandon execution and start another process when the scheduler is started by a timer interrupt, and contains bits corresponding to each process. to set or reset. The current vector is configured to set a bit corresponding to the process being executed, and when the scheduler is started, the bit of the process whose execution has been interrupted is set. Furthermore, CRTPRS contains the number of the process indicated by the current vector, and the process number increases as the priority level increases. Using this request vector, current vector, and CRTPRS, the scheduler determines the execution destination of the next process (details will be described in the next "Scheduler" section).

After this, the CPS block is initialized (step #9). Specifically, in each CPS, a start address value of each process program is placed in an area for storing CPU execution address pointer data, and a predetermined address value is placed in an area for storing a stack pointer. Initial values of other pointers are also entered as necessary.

After completing these initial settings, you can enable interrupts (step #10) and wait for timer interrupts (step #11).
) enters the loop.

[Scheduler]

FIG. 12 is a flowchart showing a scheduler activated by a timer interrupt. First, when an interrupt is generated by a timer (step #30), the values of each register of the CPU are saved to a save area in the CPS block (step #31). Next, REQ the highest priority process number among the bits set in the request vector.
into PR5 (step #32). Here CRTPR
S contains the process number immediately before interrupt handling, so by comparing this with REQPR5, it is determined whether there is a startup request for a process with a higher priority (step #33). There is no activation request (No in step #33)
Step #
42) If not abandoned (YES in step #42), set the data in each register in the save area of the CPS block to the CPU (step #39) and return. In this case, the process that was interrupted by the timer interrupt continues to run. If abandoned (step #42
If the process is lower than the process indicated by CRTPRS and the highest process number is entered in REQPR5 (step #41), it is the same as when there is a request to start a higher-level process (YES in step #33). Process. Here, step # transfers the value of the save area to the CPS of the process whose execution is interrupted as indicated by CRTPRS.
35) , RI! The cps0 value of the process indicated by QPRS is transferred to the save area (step #36).

Furthermore, R1 to CRTPRS! Input the value of QPRS (step #37), set only the bit of the current vector of the process indicated by REQPRS, and reset the others (step #38). As a result of these processes, the register value of the process indicated by REQPRS is stored in the save area, so that the process indicated by REQPRS becomes the return destination.

[Host process]

FIG. 13 is a flowchart showing the operation of the host process. The initial activation of the host process is performed by the start process using a request vector to request the scheduler to start the host process, and the scheduler activated by a timer interrupt switching to the host process. At this time, the start address of the host process is set in the program counter of the CPU (303) of the control unit.

To explain the flow of processing, first, flags used in the host process are initialized (step #51). Specifically, tlsE indicates whether or not a user process is being executed.
Set the RF flag to 0 and set LPWRITE to 0, which indicates that the temporary image is being edited in the received data processing routine.
Set to .

Furthermore, set the HOSTEND flag to O, which indicates that the host process is in a state where execution processing is not possible, and set the USERWAIT flag, which is a common flag with the user process and indicates that the user process is being switched, to O. . Then, in preparation for intermediate code creation, font attributes are read from the font section 33 (step #5
2). At this time, check whether there is a user process specified in advance by the dip switch (DIPSW) in the font cartridge.Step #5
3. #54), if available, system RAM 30
Load the user process specified in the predetermined area of 7 (Step #55), wait for the end of loading (Step #56), and set the USERF flag indicating execution of the user process to 1 (Step #57), and load the request vector. Set user process bits (step #5
8).

This is so that the lowest process always sets the request vector bit and does not abandon its own execution. Thereafter, the designated user process is set in the emulation vector (step #59). After performing these initialization operations (step #51 to step #59), the main loop (step #60
~ Step #66) is entered. Also, dip switch DI
If there is no user process specified by PSW (No in step #53), there is no user process specified by deep switch DIPS- in the ROM (N in step #54).
o) If so, go to step #60.

In the main loop, if there is no FIFO empty area or USE
RF = 1 (Step #61 YES) (7) When UR-Buffer, USERF = 0 (Step #6
1 (No), the received data processing (step #64) is performed except when the R-buffer becomes empty (step #63: NO).

Also, if data processing is not performed (NO in step #60, step #62, step #63), JOBOUT
Process 1 is executed (step #69). Here [IR-
If the buffer is empty (NO in step #62) and user process switching is in progress (YES in step #67)
) HO3T indicating that the process switching process has finished
Set the END flag Step #68) Then JO
Execute BOUT processing 1. The contents of the JOBOUT process 1 are shown in FIG. 14, and this is a process in which the host process updates a request vector in order to request the scheduler to switch to a higher-level process (packet process in this embodiment). Specifically, set the packet process bit of the request vector in step #72.
), the user process is started (step #7)
3 YES) HO3TfEND, USBRWAIT
The flag is not set (NO in step #77).

If YES in step #80), the host process bit of the request vector is reset and its own execution is abandoned. Also, there is no user process (N in step #73)
In case o), the host process becomes the lowest process, so the host process bit in the request vector is left set.

The host process can continue processing when the user process is switched, that is, the OR-buffer 306
If data remains (YES in step #73), the received data processing continues. At this time, if there is no space in the FIFO (NO in #60), "JOBOUT processing 1" is executed, but if the user process is being switched (No in #80), the host process bit of the request vector Since the set processing is not executed, "JOBOLIT processing 2" is then executed in the packet process and the bit of the packet process is reset (step #2
31° FIG. 21), the request vector is still set by the host process, so it returns to the host process.

If the data in the OR-buffer 306 is empty, the HO5TEND flag is set in step #68, so the answer is YES in step #77, and the USERWAIT flag and HOSTEND flag are set to 0 (steps #78 and #79). With this process, step #8
If it is 0, it becomes YES, and the host process bit of the request vector is reset (step #74).

In this way, the user process switching process is completed, and it is possible to move on to the next user process. Note that timer interrupts are disabled during these processes (step #71).
．． #75) Try to prevent malfunctions.

As is clear from these flows, when not switching user processes (USERWAIT=0), certain conditions (no empty area of F4FO, R-buffer or U
R-Condition such as buffer being empty. Until JOBOUT processing 1 is executed by the receive data processing subroutine (step #64) and the request flag is updated, even if the scheduler is started by a timer interrupt, it will return to the host process again. Therefore, the received data processing will be repeated.

Also, when switching user processes, the OR-buffer 30
Since the host process bit of the request vector is not reset until the host process 65 becomes empty and the HOSTEND flag is set, only the host process 65 and the packet process 64 are activated and wait until the remaining data is processed. Thereafter, when the switching process is completed, the host process bit of the request vector is reset, so that the user process 66 that was switched without doing anything after moving to the packet process 64 is activated.

When these processes are completed, a check is made to see if the test key 902 on the display panel 44 is pressed (step #65), and if it is, a test print process (step #66) is performed. If it has not been pressed, the process returns to the start of the main loop (step #60).

[Test print]

Test printing is a function used to check the font in use and the image status of the print engine 4, and is activated by the test key 902 on the display panel 44. The display panel 44 is controlled by the interface control section 40, which issues a test print request to the bitmap control section 30. Actual activation is performed by detecting this request in step #65.

FIG. 27 is a flowchart showing the details of the test print process (Step #66 in FIG. 13). As shown in this flowchart, the test print is executed in the BM-RAM 32 and the packet buffer 308. Drawing and temporary editing have not been performed (steps #81 and #
82). If such conditions are satisfied and test printing is possible, first the mode being executed is saved (step #83).

Next, set the test print mode (step #8
4). The setting items include the number of copies, the bin used by the sorter 6, etc.

Next, the test pattern (including available font patterns and current setting mode) is transferred to the packet buffer 30.
8 (step #85). The test pattern has a message printing area for the user process, and when the user process is activated (step #
(USIERF=1) in step #86) writes the data and print pattern specified in advance by the protocol from the data processing device 1 from the test pattern user process work area of the user process that is being activated (step #87).

Next, eject the page (PAGEEJE) in normal mode.
CT) Output the function to the bucket buffer 308. Step #88) Return to the original mode (Step #89).

[Received data processing]

The processing flow of received data is shown in Fig. 15(a) and Fig. 15(
Shown in b).

First, in order to process the received data, it is necessary to extract the data from the receive buffer. As shown in FIG. 18, the received data is fetched from the data processing interface 301 by a data reception interrupt and stored in the R-buffer 304.

Here, if there is a user process 66, R-buffer 3
After performing protocol conversion on the data of 04, it is stored in the UR-buffer 306, so when USHRF is 1 (YES in step #101), it is stored in the UR-buffer 306, and when it is 0 (No in step #101), it is stored in the UR-buffer 306. Load data from the R-buffer 304 (step #102,
Step #107).

Here, the received data is classified into the following five types.

・IFC related codes (print engine related codes:
) “(Step #103 to Step #105)・JOB
Control code (JOBSTART, PAGEEJECT
) (Step #108 to Step #112) - Format control code (Step #113 to Step #11
4) ・Print data (character code, graphic code) (
Step #130. Step #140) - In the case of user process control code print data (YES in step #130), L
The PWRITE flag is set to 1 (step #131), and the intermediate code is converted into a corresponding format and output to the FIFO. In the case of a character code, the format is the same as the format to the font/image writing section 311, and the address of the font pattern (step #135) and the write address to the BM-RAM corresponding to the print position on the image area (step #135) are written. 136) and write mode (step #137). In the case of a graphic code, it is output in the same format as the command to the graphic image writing unit 316 (step #141);
At this time, in the case of a character code, the next character printing position is updated ((Step #128).

The IFC-related code (step #103) is output to the interface control unit 40, but in order to synchronize with the print data, it is output to the FIFO as an intermediate code of a function type different from the print data. (Step #104). And “JOBOU
T process 1 is executed (step #105).

The JOB control code includes the PAG used to separate pages.
E EJECT code (step #110) and JOBSTART (step #1) used to separate page groups.
There are two options: 08 (YES). Both are output to FIFO in the same way as the IFC related code (step #109.
step; #152).

For PAGE EJECT code PAGE EJEC
After the T process (step #111), "JOBOUT process 1" is executed (step #112), and the process returns. The format control code (step #113, step #114) controls the printing format. If the code specifies the number of copies of the same image (YES in step #115)
, outputs a function corresponding to the FIFO in order to synchronize with the print data (step #116).

[Format Control and PAGE EJECT Processing] FIG. 17 shows the processing sequence of format control codes. If it is a return code (YES in step #161), the next print position is moved to the left end (step #162), and if it is a line feed code, the next print position is moved down one line (step #165). Also, when specifying random (step #
If YES at 166), the next printing position is updated after adding the offset value (step #167).

Figure 16 is PAGE! It shows the flow of EJECT processing. This PAGE EJECT process is
This is a virtual process when temporary editing is performed as an intermediate code on the FO, and it is different from the process in which paper is actually ejected in intermediate data processing (FIG. 22(b)). PAGEEJE
CT processing first goes to the bucket buffer 308.
Output an intermediate code indicating JECT (Step #1
52). Here, the actual paper ejection operation is performed when the packet process receives this intermediate code. Thereafter, the next printing position is returned to the beginning in preparation for editing the next page (step #153). These series of operations are determined by the LPWRITE flag indicating temporary image editing (step #151, step #154), and the output of empty pages is prevented.

Switching of user processes is performed using a user process specification code. This code is a transparent code,
In other words, codes that can be distinguished from codes of any protocol system (for example, ESCAPE C0DE = 2
(something like 7 twice in a row). Also, the parameter of this code switches between the host process and multiple user processes, and its value is EM[lN0
It is set to W (step #1I8). Furthermore, the user process being activated at that time is set as a value assigned to the emulation vector.

In the case of user process specification code (step #117
After setting the parameter specified user process number to EMUNO- on the system RAM 307 (step #118), check whether the user process is activated or not (step #119), USERF
When the flag is O (YES at step #119) or when USERF is 1 and EMUNO- and the emulation vector are different (YES at step #120), load the user process indicated by EMtlNOW. 121), after waiting for the loading to finish (
Step #122), set USERF to 1 (
Step #123).

After these processes are completed or step #119゜#
If No in step 120, the user process is initialized, specifically, the user process save area of the current process status block shown in FIG. 7(a) is initialized (step #124), and finally the request is Set the user process bit in the vector (step #1
26). USER for user process release code
The F flag is set to 0 (step #12B), and then the user process bit of the request vector is reset (step #129).

Information to be written in the user process print area of the test print is specified using a user process test print data specification command. This command allows you to set the information to be printed based on parameter values. When this command is accepted (Y in step #139)
ES) to analyze its parameters in step #14
0), after inputting the engine status data specified by the parameters (step #141), the temporarily edited data to be written in the user process print area of the test print is stored in the EMUNO on the system RAM 307.
Write the test pattern of the user process indicated by W in the user process area (see Figure 29) (Step #14
2).

[Packet process]

FIG. 19 is a flowchart showing the processing of the packet process.

First, when the power is turned on (step #200), the BM-
Clear the RAM image area Step #202
), the control flag is initialized (step #203).

Specifically, clear JOBACT, which indicates the print status, and BMWRITE, which indicates the drawing status to BM-RAM.
Clear and set C0PY, which indicates the number of copies of the same number, to 1.
CC0U to calculate the number of copies of the same number of sheets.
Set NT to 1.

After this, the main loop enters, and the processes performed by the main loop are: - Intermediate code analysis and drawing to BM-RAM (step #212 to step #215), - Print sequence control (step #205 to step #211). The data flow is as follows. First, when the paper discharge condition flag JOBACT is 1, the print
Sequence (step #208, step #211)
to go into.

Also, if JOBACT is not 1, check whether there is an intermediate code from prpo (step #213).
Intermediate code processing is performed.

When entering the print sequence here (step #
205) and when there is no more packet data in the FIFO (step #215), JOBOUT processing 2 in FIG. 21 is executed to transfer execution to a lower process (step #230). The processing content is to reset the packet process bit (step #231). At this time, since the request flag is set in the lowest-level process, the packet process, which is the highest-level, drops the request flag, and the scheduler shifts execution to the lowest-level process. In this way, the packet process has the highest priority, so the program is in a waiting state (
In the case of step #205), the process is transferred to the lower process only when it becomes unexecutable (in the case of step #215).

[Intermediate code processing and print sequence control tertiary,
The processing flow of the intermediate code stored in the FIFO is
Shown in Figure 2 (a) and (b).

Here, sequence control is mainly performed such as drawing to the BM-RAM according to the intermediate code and outputting commands to the print engine section.

First, in the case of print data (YES in step #303:
In the case of graphics, the intermediate code is sent to the font/image writing unit (step #304), and in the case of graphics (step #310)
(N) is output to the graphic image writing section (step #311).

If writing data for the first time (BM-WRITE flag = 0) (YES in step #305), BM-Round I
The TE flag is set to 1 (step #306), and a paper advance command PFCMD is output to the interface control unit 40 to cause the print engine 4 to prepare for paper feeding in advance (step 4308). As a result, once the bitmap data processing device 3 completes the print preparation, the photoreceptor can be exposed to laser light immediately.
Throughput is improved corresponding to paper feeding time.

IFC related codes and JOBSTART codes are
Output to FC (step #312 to step #31
3).

If the number of copies is set (step #319), the number of copies is updated (step #320). FIF
The output from O305 to the bitmap writing unit 31 is performed sequentially as long as there is intermediate code data, but PAGE E
When the JECT code is detected (YE in step #315)
S) Since signal conversion for one page has been completed, printing operation begins. First, the number of copies set in the CC0UNT flag for counting the number of copies copy is set, and the print startup process begins (step #317
) (Figure 23). In the print startup process, the JOBACT flag indicating that print processing has started is set.Step #401) The print head control unit interface is set to a printable state.Step #402) The print command PRNC is sent to the interface control unit 40.
Output the MD (step #403).

As a result, the print head control unit interface 3
At step 15, data in the BM-RAM is outputted via the bus B4 in synchronization with pulses sent from the control circuit of the print head control section 42.

When printing is completed, since the JOBACT flag is still set, the process proceeds from step #204 to step #205 in FIG. 19, and in step #206, an interruption of the exposure end command EXPEND from the interface control unit 40 is awaited. As shown in FIG. 24, the EXPEND reception interrupt processing sets the EPEND flag and resets the packet process bit of the request vector. When EXPEND is detected, the EPEND flag becomes 1, the loop is exited, and copy control of the same image is performed (steps #208 to #211).

First, the copy number counter CC0UNT is decremented (step 620B), and a check is made to see if a predetermined number of copies have been completed (step #209). If the process is finished, the print start process begins (Fig. 20). Here, BM-RAM is cleared for drawing the next image, and step #
241, reset the JOBACT flag to cancel the printing state (step #242), and clear BMWRITt' indicating the drawing state to BM-RAM.
(Step #243). If copying is not completed, try again.
Start printing with the same image (Step #21
1).

[User process]

FIG. 25 shows a processing example of a user process.

The user process itself has several programs depending on the corresponding protocols, but the basic form is as follows. In particular, (steps #501 to #503
．． #507. Unless step #510) is shared by each user process, it will not be possible to correspond with other processes.

First, it is checked whether there is data in the R-buffer (step #501), and then whether there is free space in the OR-buffer is checked (step #502). If there is no space in the OR-buffer (NO in step #502), a host process startup request is made using the request vector (step #510) to create space in the UR-buffer.

口R-When there is free space in the buffer (step #502
YES), import data from the R-buffer (step #503), and perform protocol conversion processing (step #50).
4~#506. #508. #509).

If it is a user process specification code (YES in step #511), send a page eject code to eject the paper if there is data being drawn (step #512).
), the user process designation code is sent as is to the UR-buffer 306 (step #513). After this, the request vector bit of the upper process is set (step #513), the emulation vector is set to the value of the process specified by the parameter of the user process specification code (step #515), and the remaining bits of the previous user process are set. USERWAIT to process data
is set (step #516). Then, it waits for an interrupt from the scheduler (step #517).

USERWA IT is a common flag with the host process 61, and when this flag is set, the designated user process will not be executed until the host process 65 processes the data in the OR-buffer 306 to prevent malfunction.

FIG. 26 shows an example of switching timing of these processes. In this way, the scheduler is activated by periodic timer interrupts, but the process is switched when the execution abandonment condition for each process is satisfied.

〔effect〕

In the case of the device of the present invention as described above, data can be sent and received not only with a data processing device that sends and receives data using a protocol that matches the protocol unique to the printing unit, but also with a data processing device that uses a different protocol. Of course, there are
The protocol on the printer side can be switched using signals from the data processing device side without any hardware operations, which not only improves operability but also allows multiple data processing devices with different protocols to share one printer. It becomes possible to do so.

[Brief explanation of the drawing]

Fig. 1 is a configuration diagram of the printer of the present invention, Fig. 2 is a perspective view showing the external appearance of the printer, Fig. 3 is a front view showing details of the display panel, and Fig. 4 is a block diagram of the main parts of the control circuit of the printer. , FIG. 5 is a block diagram showing the configuration of the bitmap control section of the present invention, FIG. 6 is a conceptual diagram showing the software configuration of the device of the present invention, FIG. 7 is a conceptual diagram showing the configuration of the system RAM, and FIG. 8 is a conceptual diagram showing the configuration of the system RAM. is a block diagram showing the flow of received data, No. 9
10 is a detailed block diagram of the bitmap writing unit, FIG. 10 is an explanatory diagram of the image area, FIG. 11 is a flowchart showing the start process, and FIG. 12 is a flowchart showing a scheduler activated by a timer interrupt.
FIG. 13 is a flowchart showing the operation of the host process, FIG. 14 is a flowchart showing the contents of JOBOUT processing l, FIG. 15 is a flowchart showing the processing procedure of received data, and FIG. 16 is a flowchart showing the procedure of the PAGEEJECT device. FIG. 17 is a flowchart showing the format control code processing procedure, FIG. 18 is a flowchart showing received data interrupt processing, FIG. 19 is a flowchart showing packet process processing, and FIG. 20 is a flowchart showing print startup processing. Figure 21 shows JOB
Flowchart showing OUT processing 2, FIG. 22 is a flowchart showing intermediate code processing, FIG. 23 is a flowchart showing print startup processing, and FIG. 24 is EXPEND
25 is a flowchart showing the user process, FIG. 26 is a time chart showing an example of process switching timing, FIG. 27 is a flowchart showing the test print processing procedure, and FIG. 28 is a flowchart showing the reception interrupt reception ring. 2 is a format diagram showing an example of transmission data from a data processing device. FIG. 61... Timer interrupt 62... Scheduler 63... Start process 64... Packet process 65... Host process 66... User process patent Applicant Agent for Minolta Camera Co., Ltd.
Patent Attorney Noboru Kono No. 1 Figure 2 Figure 3 Figure 4 Figure 6 (a) (b) Figure 7 Figure 10 Wataru 11 Figure 14 Figure 16 #160 Figure 17 Figure 20 Figure 21 Figure 22 (b) #400 #42
0Figure 23Figure 27Figure 28 ESCESCUI ESCESCUOFigure

Claims (1)

[Scope of Claims] 1. A printer control device that is interposed between a printing section and a data processing device that provides data to be printed by the printing section and controls the operation of the printing section, comprising: a memory storing a plurality of programs for controlling operations of the unit; and a program starting means for starting any program stored in the memory in response to a predetermined signal given from the data processing device. A printer control device characterized by: 2. The printer control device according to claim 1, wherein the memory has an area in which a program unique to the printing section is stored in advance. 3. In a printer control device that is interposed between a printing section and a data processing device that provides data to be printed by the printing section and controls the operation of the printing section, the printer control device controls the operation of the printing section. a memory for storing a plurality of programs for the program; a means for storing an externally applied program in the memory; and a means for storing an arbitrary program stored in the memory in response to a predetermined signal applied from the data processing device. 1. A printer control device comprising: program starting means for starting a program. 4. The printer control device according to claim 3, wherein the memory has an area in which a program unique to the printing section is stored in advance. 5. In a printer control device that is interposed between a printing section and a data processing device that provides data to be printed by the printing section and controls the operation of the printing section, a program specific to the printing section is executed. a memory for storing a plurality of printing operation control programs including a plurality of printing operation control programs; means for storing a program given from the outside in the memory; and means for storing a program given from the outside in the memory; What is claimed is: 1. A printer control device comprising: program starting means for starting an arbitrary program; and means for time-sharingly executing the unique program and other printing operation control programs.