JPH0534700B2 - - Google Patents

Description

DETAILED DESCRIPTION OF THE INVENTION The present invention relates to a method for controlling a multiple program that has a plurality of programs that perform different tasks and for selecting and executing one of the programs, and particularly for a small computer such as a microcomputer. The present invention relates to a method for controlling multiple programs in a computer.

Conventionally, for example, in a serial printer with a built-in microcomputer, multiple programs are stored in the microcomputer to perform different tasks such as interfacing with a keyboard and reading data from a host computer. The program is controlled according to the monitor program shown in the block diagram shown in FIG. That is, in the same figure, P ₁ to Pn are multiple programs for performing the above-mentioned different tasks, TCP is a task control program that determines execution, suspension, and priority of P ₁ to Pn, and TKC is P ₁ to Pn.
This is a task instruction processing program that decodes instructions from and notifies TCP of the completion of their processing. HTM is a timer processing program that controls the start and stop of a timer built into a microcomputer, and IP is a timer processing program that determines interrupt priority when an external interrupt occurs, and saves registers in the microcomputer's central processing unit (CPU). This is an interrupt processing program that issues commands such as

Figure 2 shows the operation timing of the monitor program in Figure 1. _T1 to _T5 are time division timings created by a timer, and program Pn is executed until _T1 , and at _T1 , program Pn is executed. Execution is suspended and the CPU begins computing. When ΔT has elapsed from T ₁ , the program P ₁ is executed, and at T ₂ the execution of the program P ₁ is interrupted and the CPU returns to calculation.

The execution and interruption of the programs P1 to Pn as described above are all set in advance in the monitor program shown in FIG. 1, that is, the monitor program manages the programs P1 to Pn at the moment.

The above-mentioned method of managing multiple programs using a monitor program was originally developed using programming techniques suitable for medium-sized and large-sized computers with high-speed CPUs and large-capacity memories. However, microcomputers built into terminal devices such as serial printers are small and have small memory capacity, and
Due to the slow calculation speed of the CPU, (i) the monitor program occupies a large amount of memory, necessitating the addition of more memory and increasing costs;

(ii) Slow calculation speed for complex monitor programs
Since it is executed by the CPU, the processing time becomes long.For example, in a serial printer,
This results in a decrease in printing speed.

The following drawbacks arose.

This invention was made in consideration of the above-mentioned drawbacks, and instead of the complicated monitor program shown in FIG. 1, a simple monitor program having flags corresponding to each of the programs _P1 to Pn is prepared, It is an object of the present invention to provide a method for controlling multiple programs in which each program P ₁ to Pn is executed or interrupted by setting and resetting flags.

Hereinafter, an embodiment in which the present invention is applied to a serial printer having a daisy wheel type typeface will be described based on the drawings from FIG. 3 onwards.

Figure 3 is a block diagram of the control circuit of a serial printer.
It is a master CPU with input/output functions and receives printing commands from an external host computer (not shown).
The PC is input and the entire control circuit is controlled via bus B. TM is a timer for creating clock pulses that set the operating timing of the MCPU, RAM is a readable and writable random access memory for temporarily storing MCPU calculation data, etc., and ROM is a program P ₁ to be described later.
This is a read-on memory in which P ₃ , main monitor program MMP, etc. are stored in advance.

SW is a group of switches including serial printer start/stop switch, paper feed switch, etc., I/O
is an input/output device that interfaces between SW and MCPU. In addition, M ₁ and M ₂ are stepping motors for type selection and carriage movement, respectively.
SCPU ₁ and SCPU ₂ perform calculations based on commands from the MCPU, and control the stepping motors M _{1 and 2} , respectively.
This is a slave CPU that outputs _M2 drive data.

FIG. 4 is a block diagram of the monitor program of this embodiment, where INT is an interrupt request command from SW etc., and TI is an interrupt request command by time division of the timer TM.

ICP is a processing program for processing interrupts based on INT and TI commands.

P ₁ , P ₂ , and P ₃ are programs each responsible for three tasks: alarm operation (by buzzer or light emitting means) when the print position margin is exceeded, detection of SW operation, and reading of commands from the host computer. It is. MMP is a main monitor program that calculates the printing position of the typeface, the amount of carriage movement, etc. In addition to these calculation functions, it also provides monitor flags F that correspond to programs P ₁ , P ₂ , and P ₃ . ₁ , F ₂ , F ₃ and save flags SF ₁ , SF ₂ , SF ₃ (see FIG. 5). Note that TF ₁ , TF ₂ , and TF ₃ are task flags provided in the ICP corresponding to P ₁ , P ₂ , and P ₃ respectively, and these will be explained with reference to FIG.

Figure 5 is a flowchart of the main monitor program MMP.
The TM starts, and the clock pulses generated by the timer TM interrupt the following program at regular intervals. Next, the calculation
Start control processing, then monitor flag F ₁ ,
Set both F ₂ and F ₃ to "1" and continue calculation/control processing. Note that this calculation/control processing also includes the operation of transferring print data to SCPU ₁ and SCPU ₂ . Calculation after a certain period of time
When the control process is completed, the monitor flags F ₁ , F ₂ ,
Reset all _F3 to "0" and save flag
Determine the set status of SF ₁ , SF ₂ , and SF ₃ . If the save flags SF ₁ , SF ₂ , SF ₃ are in the reset state, the calculation/control processing continues, and the save flags SF ₁ , SF ₂ ,
When SF ₃ is in the set state, the save flag SF ₁ ,
In addition to resetting SF ₂ and SF ₃ , the program
Processing of P ₁ , P ₂ , and P ₃ begins. Furthermore, program P ₁ ,
All interrupts are disabled at the start of P ₂ and P ₃ processing. After the processing of programs P ₁ , P ₂ , and P ₃ is completed, interrupts are enabled and the processing returns to the calculation and control processing by the main monitor program. Subsequently, the monitor flags F ₁ , F ₂ , and F ₃ are all set to "1" and the arithmetic/control processing is continued. After this process is completed, monitor flags F ₁ , F ₂ , and F ₃ are all reset to "0", and the set states of save flags SF ₁ , SF ₂ , and SF ₃ are determined. If the save flags SF ₁ , SF ₂ , SF ₃ are in the reset state, the arithmetic/control processing continues, and if they are in the set state, the programs P ₁ , P ₂ , P ₃ are restarted.
Start processing. At this time as well, programs P ₁ , P ₂ ,
Interrupts are disabled while P ₃ is running. After the processing of programs P ₁ , P ₂ , and P ₃ is completed, the process returns to the calculation and control processing by the main monitor program. Subsequently, the monitor flags F ₁ , F ₂ , and F ₃ are all reset to "0", and the set states of the save flags SF ₁ , SF ₂ , and SF ₃ are determined. If the save flags SF ₁ , SF ₂ , and SF ₃ are in the reset state, the calculation/control processing continues,
Also, if it is in the set state, the programs P ₁ , P ₂ ,
Start processing _P3 . As mentioned above, the program
Interrupts are disabled while P ₁ , P ₂ , and P ₃ are being executed. When the execution of programs P ₁ , P ₂ , P ₃ is finished,
Returning to the calculation/control processing by the main monitor program, the main monitor program repeats the above loop.

Next, the TimerTM clock or switch
Main monitor program MMP (5th
The interrupt program for FIG.

In FIG. 6, when an interrupt is started, first, interrupt disabling processing is performed so that the next interrupt will not be involved, and it is determined whether or not the interrupt is an external interrupt. External interrupts, i.e. switches
If it is a SW operation, etc., it performs the corresponding processing, enables interrupts, and returns to the main monitor program MMP. Furthermore, if it is a periodic interrupt other than an external interrupt, that is, a periodic interrupt caused by the clock of the timer TM, the set state of the task flag _TF1 is determined. Note that task flags TF ₁ , TF ₂ , and TF ₃ are 1 and 1 in the initial state of the main monitor program MMP.
0, 0 (hereinafter, set is expressed as ``1'' and reset is expressed as ``0''). Now, when task flag TF ₁ is set, monitor flag F ₁
If the monitor flag _F1 is in the reset state, the program _P1 is processed.
Also, if it is in the set state, the program
Temporarily save the calculation parameters of _P1 to a predetermined register. When the processing of the program _P1 or the above-mentioned save operation is completed, the save flag _SF1 is set, the task flag _TF1 is reset, the task flag _TF2 is set, and after interrupt enable processing, the program returns to the main monitor program MMP. If task flag TF ₂ or TF ₃ is set,
Program the same process as above depending on the status of monitor flag F ₂ or monitor flag F ₃ .
Do this for P ₂ or P ₃ . However, task flags TF ₁ , TF ₂ , and TF ₃ are set and reset cyclically. i.e. task flag
When TF ₂ is in the set state, after the above processing (TF ₁ , TF ₂ , TF ₃ ) is (0, 1, 0) → (0,
0, 1), and when the task flag TF3 is set, after the above processing is completed (TF ₁ , TF ₂ ,
TF ₃ ) is switched from (0, 0, 1) to (1, 0, 0).

Next, according to FIG. 7, the operation time charts of the main monitor program MMC and programs P ₁ to _{P 3} according to the flowcharts of FIGS. 5 and 6 above, and the corresponding flags F ₁ to F ₃ and SF ₁ to SF ₃ ,
The set/reset states of TF ₁ to TF ₃ will be explained.

When power is applied to the control circuit, the main monitor program is started by the clock pulse of TimerTM.
Periodic interrupts are started for MMP, and the main monitor program MMP calculations and
Control is also started. First, when flags F ₁ to _{F 3} are set to "1" in the main monitor program MMP, when the above-mentioned interrupt occurs at _T1 , the program shifts to the interrupt program shown in FIG. Since task flag TF ₁ is set at this time,
The monitor flag _F1 has been determined, and since the monitor flag _F1 is in the set state, the parameters of the program _P1 are temporarily saved in a predetermined register of the MCPU.
After immediately setting the task flag _TF2 and setting the save flag _SF1 , the program returns to the main monitor program MMP. i.e. program P ₁
Since it only saves its parameters and does not execute them, the calculation and control of the main monitor program MMP can be continued with only a short interruption of Δt. After this calculation is completed and the data is transferred to, for example, SCPU ₁ for carriage movement, the monitor flag is set at timing X ₁ .
When F ₁ to _{F 3} are reset to "0", the save flag SF ₁ is determined, and since it is set to "1", the save flag SF ₁ is reset to "0" and then saved from the register. The previous parameters are returned and program _P1 is executed. program
An interrupt from the timer TM is about to occur at timing _T2 of _P1 , but since all interrupts are disabled during this time, program _P1 is executed as is. After the program P ₁ ends, the calculation and control of the main monitor program MMP is started again. Next, monitor flag at timing X2
F ₁ , F ₂ , and F ₃ are all set to "1".

When an interrupt occurs next at timing _T3 , the interrupt program shown in FIG. 6 is entered, but since task flag _TF2 is in the set state, program _P2 is programmed in relation to the set state of monitor flag _F2 . Parameters are saved. Also,
Immediately after this, the save flag _SF2 is set, the task flag TF2 is reset, the task flag _TF2 is set, and the main monitor program is restarted.
Return to MMP.

Subsequently, when an interrupt occurs at timing _T4 , the parameters of _{program P3} are saved, the save flag _SF3 is set, and the task flag _TF3 is set due to the set state of monitor flag _F3 . A reset and setting of the task flag _TF1 is performed. Furthermore, the timing
When an interrupt occurs at _T5 , in relation to the set state of task flag _TF1 , the parameters of program _P1 are saved, the save flag _SF1 is set, the task flag _TF1 is reset, and the task flag _F1 is set. Flag TF ₂ is set. In this way, all save flags SF ₁ to SF3 are set to "1". Next, when the monitor flags F1 to F3 are reset to "0" at timing _X3 , the save flags _SF1 , _SF2 , and _SF3 are determined, and since they are in the set state, the save flags _SF1 ,
SF ₂ and SF ₃ are reset and the program
P ₁ , P ₂ , and P ₃ are executed. Programs P ₁ , P ₂ ,
After completion of _P3 , when an interrupt occurs at timing _T7 , the task flag _TF2 is in the set state, so the monitor flag _F2 is determined and the monitor flag _F2 is reset to "0". Therefore,
Program _P2 is executed, and after its completion task flag _TF2 is reset and task flag _TF3 is set.

As described above, according to the present invention, in a control device having a plurality of programs that should execute tasks sequentially in a time-divided manner, a monitor flag that instructs execution/standby of a main program that performs calculations, and a task A control program is provided that has task flags that issue commands to execute or stop a plurality of programs that are to be executed separately, and a program that corresponds to the task flag that is in the execution command state in relation to the standby state of the monitor flag. Because it is now executed automatically, there is no need for a complicated monitor program that commands the order and time division settings of multiple programs, etc., as in the past.
Since multiple programs can be managed simply by automatically setting and resetting flags, the memory capacity required to store such management programs can be significantly reduced, resulting in cost reduction.

Moreover, since the calculation time of the management program is also reduced, by applying the present invention to a terminal device such as a serial printer, the printing speed can be increased.

In the above embodiment, multiple programs P ₁ to _{P 3}
Although three are executed, it goes without saying that the present invention is not limited to that number.

In addition, the monitor flag F ₁ in the above embodiment
~ _F3 may be limited to one and set/reset that one monitor flag,
Alternatively, the monitor flags _F1 to _F3 may be set asynchronously depending on the time required to execute each program _P1 to _P3 .

[Brief explanation of the drawing]

FIG. 1 is a block diagram of a monitor program of a conventional control device, FIG. 2 is a time chart of the operation of the monitor program of FIG. 1, FIG. 3 is a block diagram of a control circuit according to an embodiment of the present invention, and FIG. 5 is a flowchart of the main monitor program, FIG. 6 is a flowchart of the interrupt program, and FIG. 7 is a time chart of the operation of the monitor program of the present invention. It is. ROM...Storage means, MCPU...Control means,
MMP……Main monitor program, P ₁ to _{P 3} …
...Program, F ₁ to F ₃ ...Monitor flag, TF ₁
~TF ₃ ...Task flag, _SF1 ~ _SF3 ...Evacuation flag.

Claims (1)

[Scope of Claims] 1. Storage means storing a main program for executing operations and a plurality of task programs for executing different tasks. A control device that is equipped with a control means capable of separately controlling the execution or stopping of a main program and a task program, which performs a save process for storing data of the task program in a register, a program process for executing the task program, and a main program. Monitor flags F ₁ to F ₃ for determining whether it is time to execute or stop calculations and tasks for selectively executing one of the task programs in a predetermined order in response to each task program. Flags TF ₁ to TF ₃ and save flags to identify the task program that saved data to the register.
According to SF ₁ to SF ₃ , in connection with reading a task flag, when the monitor flag determines when to execute an operation, it executes the save process for the task program corresponding to the task flag, and then executes the save process for the task program that has been saved. After setting the corresponding save flag and executing the program processing of the task program corresponding to the task flag when the monitor flag determines when to stop calculation, first control for updating the task flag and setting the save flag. a second control that reads data of the task program specified by the save flag in the first control from a register in relation to the first control and executes program processing of the task program. Method.