JPH0376498B2 - - Google Patents

Description

DETAILED DESCRIPTION OF THE INVENTION <Technical Field> The present invention relates to a computer peripheral device having a built-in multi-task control function effective for a system management program of a microcomputer.

<Prior art> In a multi-task control system, there are times when it is necessary to exchange data (communication) between tasks during the execution of a task, or when it is necessary to control the execution order of two tasks for processing reasons. There are cases where it is necessary to wait until the processing of one task is completed without processing the other task.
Furthermore, when using common resources between tasks, such as I/O, memory, files, etc., it may be necessary to prohibit simultaneous use of multiple tasks.

In order to carry out the above-mentioned control, conventional computer system software OS (operating systems) use control flags called mail boxes and semaphore to control data transfer, synchronization of tasks, and mutual exclusion. I was doing it.
In such a software method, registration areas for mail boxes, semaphore files, and tasks to be controlled must be prepared in the user's data memory. Therefore, the load on the user program is heavy, and the OS program occupies part of the program memory space, so there are restrictions on the size of the user program and the address at which the user program is located.

<Object of the invention> The present invention provides two methods for devices to perform data exchange, synchronization, and mutual exclusion between tasks.
This can be done with just one command. This device has built-in mailboxes, control flags, task registration areas, etc., and if this device is incorporated into a multi-task control system, the OS
The above-mentioned control by software is no longer necessary,
The burden is reduced. It also does not require user data memory space.

<Example> An example of the present invention will be described below with reference to the drawings.

FIG. 1 is a diagram showing an example of the configuration of a microcomputer system. Element (or device) 1
is configured as an independent multi-task support processor for realizing multi-task control according to the present invention, and is supplied in the form of input/output elements like other peripheral devices.
Hereinafter, this device will be referred to as a multi-task control element. A master CPU 2, a program memory (ROM) 3, a data memory (RAM) 4, and other peripheral input/output elements 5 such as I/O are provided as a well-known microcomputer system, and are capable of multi-tasking. The control element 1 and the control element 1 are connected to each other via a bus 6 . The program memory 3 independently programs an initialization program for the multi-task control element 1 and a plurality of tasks.

Multi-task control element 1 is the master CPU
It is an independent functional element that manages these multiple tasks executed by the master CPU 2 other than the master CPU 2,
Task scheduling function (switching execution tasks in priority order or time-sharing), inter-task synchronization and communication function (sending and receiving data between each task, deciding whether to suspend or resume task execution), memory It has a management function (prohibition of overlapping use of the memory area used by each task), a clock function (setting the time using a built-in timer), etc. In other words, this multi-task control element 1 is characterized in that the multi-task control function is not a function of the OS itself of the computer system, but a peripheral device that has this function.

FIG. 2 is a block diagram showing an example of the internal configuration of the multi-task control element 1.

Multi-task control element 1 is master CPU 2
It has a group of registers that can be accessed from.

The command parameter register CPIO holds parameters input from the master CPU 2 when executing a command and parameters output after execution. The command/status register CNST functions as a register for writing commands during writing, and as a register for storing execution information of executed commands during reading. The new stack pointer register SPN is a register for outputting the value of the stack pointer of a task that will be newly executed from now on as task switching information. Also, the old stack pointer register
SPB is a register for inputting the value of the stack pointer of the task that has been in the execution state as task switching information.

The master interrupt control register MIC is a register for controlling the generation of interrupts to the master CPU 2 in the device 1, and the interrupt vector register MIV writes an interrupt vector value. Data registers P1D, P2D, and P3D are registers for data input/output of port 1, port 2, and port 3. Ports 1 and 2 are 8-bit input/output ports whose data input/output direction can be set bit by bit by a program, and port 3 is a 1-bit input port. Port 3 can be set to an event input (transition of a task in a stopped state to a ready state by transition of an input signal to port 3) by a program.

The above register group is accessed by the master CPU 2 and used for mutually exchanging information between the device 1 and the master CPU 2. data·
Bus interface DBI, bus timing generation/control circuit BTGC, interrupt control circuit INTC
is provided as an interface circuit with the master CPU 2.

Task control blocks TCB1-TCB8 are memory areas for saving the states of tasks. It is possible to handle up to eight tasks here. As shown in Figure 3, each block has the task status, task priority, the number of the task connected to Lady Q first, and the number of the task connected to Lady Q afterward.
It has an area to store the number of the task connected to the task, the start address of the work memory occupied by the task, its size, the mail box number used, and the stack pointer value when task execution is interrupted. are doing.

The mail box MBX is a buffer memory area provided so that data can be exchanged between tasks.

The memory map MEMMAP is a memory area for managing work memory.
It consists of 32 bytes as shown in the figure. Memory map MEMMAP allows work in units of 256 bytes.
It is possible to manage memory. When the work memory is not in use, the bit corresponding to that area is "0", and when it is occupied, the bit is set to "1".

The timer TM generates an interrupt signal in element 1 for time-sharing processing (processing to execute tasks with the same priority at fixed intervals), and the system clock area SCA simultaneously uses the output of the timer TM. This is a memory area that stores time data such as hours, minutes, and seconds to be counted.

The internal arithmetic control circuit CONT stores the logic arithmetic unit (ALU) and the program for this element 1.
It has ROM, RAM for temporary storage, flag registers for various controls, etc.

Access from the master CPU 2 to the multi-task control element 1 is performed by a command issued from the task being executed, and access from the multi-task control element 1 to the master CPU 2 is as follows:
This is performed based on the generation of an interrupt signal by the multi-task control element 1. FIG. 5 is a diagram showing command types, input parameters, and output parameters.

The basic operation is as follows. In addition,
It is assumed that the state of each task is already stored in the task control block TCB.

The multi-task control element 1 selects the task with the highest priority from the tasks in the executable state, and prepares the registered stack pointer value of that task in the new stack pointer register SPN. After preparing the stack pointer value, multi-task control element 1 returns to the master CPU.
Generates an interrupt for 2. The master CPU 2 executes the interrupt processing routine, loads the value of the stack pointer set in the multi-task control element 1 into its own stack pointer, and loads the initial value of the register written in advance. Pop it from the stack and rewrite the register. Then, the designated task is executed under the control of the master CPU 2.

Multi-task control element 1 remains active until there is a command input from the task being executed or an interrupt due to input to timer TM or port 3.
is in a waiting state. For example, if a command is input here, the multi-task control element 1 analyzes the command and processes the command. If this command includes a task switching function, the value of the stack pointer of the next task to be switched is stored in the new stack pointer register SPN.
, and generates an interrupt to master CPU2. This interrupt causes the master CPU 2 to stop executing the task currently being executed, and reads from the multi-task control element 1 the value of the stack pointer of the task to be executed next.

A more detailed explanation will be given below with reference to a flowchart.

FIG. 6 is a flowchart explaining the operation of the main routine of the multi-task control element 1.
Figures 21 to 21 are flowcharts explaining the operation of the processing routine for each command 0 to 14, Figure 22 is a flowchart explaining the operation of the task switching routine, and Figure 23 is interrupt processing due to event input to port 3. Flowchart for explaining the operation of the routine. FIG. 24 is a flowchart for explaining the operation of the interrupt handling routine by the timer TM.

In FIG. 6, when the system is powered on, the multi-task control element 1 performs a reset operation to initialize each internal functional element (step). Then, it waits for a command to be written from the master CPU 2 to the command/status register CNST (step). When a command is written, command processing corresponding to each command code is performed (step).

Command 0 (command name: INIT, flowchart in Figure 7) is a command to initialize multi-task control element 1, and multi-task control element 1 generates an interrupt to master CPU 2. This command is used to register for each task the vector value to be output to the master CPU 2 when executing the command, the start address and size of the work memory area managed by the multi-task control element 1, and the priority of the task. be.

When this command is executed, the input data is checked for errors (step), and if there is an error in the input data, an error code is set in the command/status register CNST (step).

If there is no error in the input data, from the data sent to the command parameter register CPIO,
The interrupt vector value is written to the interrupt vector register MIV (step), and the memory map MEMMAP is initialized based on the start address of the work memory area and its size data (step). Then, each task control block TCB is created based on the written priority of the task (step). Then, they are arranged in descending order of priority to form a ready Q (step). At this time, the ordering is performed by the in the task control block TCB. After generation, the normal completion code is set in the command/status register CNST (step), and the internal arithmetic control circuit CONT
The TSKCHG flag is reset (step) and the process returns to the main routine shown in FIG.

If an error code is set in the command/status register CNST, the TSKCHG flag is similarly reset and the process returns to the main routine.

Command 1 (command name: TSTR, flowchart in FIG. 8) is a command for moving the initialized multi-task control element 1 to an execution state.

This command 1 checks whether the process of command 0 has been executed (step).
Only when the task has been executed, the TSKCHG flag (control flag of the internal arithmetic control circuit CONT) is set to move the task connected to the head of Ready Q (the task with the highest priority) to the execution state (step). , returns to the main routine of FIG. If it has not been executed, an error code is set in the command/status register CNST (step) and the process returns to the main routine.

The above commands 0 and 1 and the information written to the multi-task control element 1 are stored in advance in the initialization program of the program memory 3 shown in FIG. 1, for example, and the program can be changed according to the task content. Thereby, the multi-task control element 1 can be initialized in various ways.

Command 2 (command name: TCRT, Figure 9 Time Chart) is a command to arbitrarily generate a task after initial settings, and the number of the task to be generated and its priority as input data is the command of this element 1. -Written to parameter register CPIO.

When this command 2 is executed, the input data is checked for errors (step),
Command/Status register if there is an error
Write error code to CNST (step).
If there is no error, a task control block TCB for the task specified by the input data is generated (step).

The task/status (see FIG. 3) in the task control block TCB includes the following four flags.

The RUN flag indicates that the task is in a running state.

The READY flag indicates that the task is in a ready state and is connected to ready Q.

The PENDW flag indicates that the device is waiting to receive a message.

The SUSPEND flag indicates that the task is in a suspended state.

When the task control block TCB is generated (step), the READY flag in it is set at the same time.

Then, in order of task priority, Ready Q
(step). Next, a normal completion code is set in the command/status register CNST (step), and the TSKCHG flag is set to compare the priorities of the running task and the task connected to the beginning of ready Q (step). ), the process returns to the main routine of FIG.

Command 3 (command name: TDEL, time chart in Figure 10) is a command for erasing unnecessary tasks, and is executed using the number of the task to be erased as input data.

In checking whether there are any errors in the input data (step 〓〓), if there is an error, an error code is set in the command/status register CNST (step 〓〓), and the process returns to the main routine of FIG.

If there is no error, to release the work memory occupied by the task to be erased, read the occupied memory start address and occupied memory size in the task control block TCB of this task, and map the memory map based on this data.
Clear the corresponding area on MEMMAP to “0” (step 〓〓). Next, if this task is in the ready state, the task control block TCB of the task to be erased is separated from the ready Q (step 〓〓), and all of this task control block TCB is cleared (step 〓〓). When finished, command /
Set the normal completion code in the status register CNST (step 〓〓) and return to the main routine.

Command 4 (command name: TRSM, flowchart in FIG. 11) is a command for making a waiting or stopped task with a task number specified by input data into a ready state (restartable state). Execute the task number as input data.

When command 4 is executed, the input data is first checked for errors (step 〓〓),
Command/Status register if there is an error
Set the error code in CNST (Step 〓〓),
Return to main routine.

If there are no errors, the specified task
The PENDW flag or SUSPEND flag is reset, the READY flag is set, and the task control block TCB is connected to the ready Q in order of priority of the tasks (step 〓〓). Then, the normal completion code is set in the command/status register CNST (step 〓〓), and the priority of the task in the running state and the task connected to the beginning of Lady Q are compared.
Set the TSKCHG flag (step 〓〓) and return to the main routine.

Command 5 (command name: TSPD, flowchart in FIG. 12) is a command for bringing a task in a running or ready state with a task number specified by input data into a stopped state.

When this command 5 is executed, the input data is checked for errors, and if there is an error, an error code is set in the command/status register CNST and the process returns to the main routine (steps 〓〓〓〓〓〓).

If there is no error, first check whether the input data specifies that the task that is in the stopped state is to be made ready (restarted) by the input signal (external event) from port 3 ( Step〓〓). If no external event is specified, the process skips to step 〓〓. If specified, it is checked whether another task is already using the external event (Step 〓〓), and if it is, an error code is set in the command/status register CNST (Step 〓〓). 〓〓) Return to the main routine. If not used, enable internal interrupts due to the transition of the input signal of port 3 (step 〓〓). That is, by setting the input data of this command 5, it is possible to specify the activation of an external event.

Then, including the case of skipping, the RUN flag in the task control block TCB (if the specified task is in the running state) or
Reset the READY flag (if it is in the ready state) and set the SUSPEND flag (step 〓〓). When finished, command/status/
Set the normal completion code in register CNST (step 〓〓). Then, considering the case where the specified task is in the ready state, this task is separated from the ready Q, the task control block TCBs connected to the ready Q are rearranged in priority order (step 〓〓), and the task is returned to the execution state. The TCKCHG flag is set to compare the priority of the task connected to the beginning of Lady Q with the priority of the task connected to the beginning of Lady Q (Step 〓〓), and the process returns to the main routine.

Command 6 (command name: TPRI, flowchart in FIG. 13) is a command for changing the priority of the task with the number specified by the input data.

In checking whether there is an error in the input data (Step 〓〓), if there is an error, an error code is set in the command/status register CNST (Step 〓〓) and the process returns to the main routine.

If there is no error, the priority of the specified task in the task management block TCB (see Figure 3)
is rewritten to the change priority value of the input data (step 〓〓). Next, the task management block TCBs connected to Lady Q are rearranged in priority order (step 〓〓), and the command/status registers are
Set the normal completion code to CNST (Step 〓〓). Then, the TSKCHG flag is set to compare the priorities of the running task and the task connected to the head of the ready Q (step 〓〓), and the process returns to the main routine.

Command 7 (command name: TSLI, flowchart in FIG. 14) is a command for limiting the master CPU occupation time of a task group having a priority specified by input data. That is, this command specifies time-sharing processing of tasks with the same priority. Time-sharing processing is effective only when there is no ready task with a higher priority than the specified priority. If there is a ready task with a higher priority, that task will be executed and time-sharing processing will be disabled, but if there are no tasks with a higher priority, it will become effective.

When this command 7 is executed, first, the input data is checked for errors (step 〓〓). If an error is detected, the command/status
An error code is set in register CNST (step 〓〓), and the process returns to the main routine.

If no error is detected, it is determined whether the input data is a designation for canceling time-sharing processing (step 〓〓). In case of cancellation,
Clear the time division control registers SLICNT and SLIPRI in the internal arithmetic control circuit CONT to "0" (steps 〓〓〓〓〓〓). If the input data specifies new time-sharing processing settings, use the input data to specify the CPU occupation time control register for the task.
SLICNT is set (Step 〓〓), and the priority of the task that performs time-sharing processing is set in another control register SLIPRI (Step 〓〓). Finally, a normal completion code is set in the command/status register CNST (step 〓〓) and the process returns to the main routine.

Command 8 (command name: CSET, flowchart in Figure 15) is the multi-task control element 1.
This command is used to set the time on the internal clock. The master CPU 2 writes hour, minute, and second data as input data to the command parameter register CPIO in the device 1 and executes the command.

The input data is checked for errors (Step 〓〓), and if an error is detected, an error code is set in the command/status register CNST (Step 〓〓), and the process returns to the main routine.

If there are no errors, the system clock area
Hour, minute, and second data is transferred to SCA (step 〓〓). and command/status registers
Set the normal completion code in CNST (step 〓〓) and return to the main routine. This clock is kept ticking by a timer interrupt routine to be described later.

Command 9 (command name: CGET, flowchart in FIG. 16) is a command for reading the current time from the above clock.

When this command 9 is executed, the hour, minute, and second data from the system clock area SCA are transferred to the command parameter register CPIO accessible from the master CPU 2. After the transfer, a normal completion code is set in the command/status register CNST (step 〓〓) and the process returns to the main routine.

Command 10 (command name: MALC, flowchart in Figure 17) is the multi-task control element 1.
This command allows the task that executed the command to use the requested size of work memory from the work memory area managed by . Write the requested work memory number (in units of 100H) to the command parameter register CPIO and execute the command.

When command 10 is executed, error detection of input data is performed (step 〓〓). If an error is detected, the command/status register
Set the error code in CNST (step 〓〓) and return to the main routine.

If no errors are detected, the memory map
Examine MEMMAP and check whether the requested work memory is free (step 〓〓). If there is no free space, a memory occupancy disable code is set in the command/status register CNST (step 〓〓) and the process returns to the main routine. If free space is found, the memory map is expanded to the size requested by the task that executed the command.
Set the corresponding bit on MEMMAP to "1" (Step 〓〓). Then, set the respective values in the occupied memory start address and occupied memory size area (see Figure 3) in the task control block TCB of the task that executed the command (Step 〓〓), and then set the command parameters. Write the occupied memory/start address to register CPIO.
If written, command/status register
Set a normal completion code in CNST (step 〓〓) and return to the main routine.

Command 11 (command name: MREL, flowchart in FIG. 18) is a command for freeing the occupied work memory area.

If the task that executed command 11 does not occupy the work memory (step <<>), an error code is set in the command/status register CNST (step <<>) and the process returns to the main routine.

If work memory is already occupied, the task control block of the task that executed the command
Refers to the values of the occupied memory start address and occupied memory size area registered in the TCB, and resets the corresponding bit on the memory map MEMMAP to "0" (step 〓〓).
Then, the area of the occupied memory start address and occupied memory size in the task control block TCB is cleared (step 〓〓). Finally, a normal completion code is set in the command/status register CNST (step 〓〓), and the process returns to the main routine.

When a task requests memory as described above, command 10 (memory occupancy command, MALC) is executed to the multi-task control element 1. Also, if the memory used by a task is no longer needed and you want to release it, execute command 11 (memory release command, MREL).

In this way, the multi-task control element 1 is registered in advance by these commands 10 and 11.
It has a function that determines whether a work memory area of up to 64K bytes is in use in units of 100H bytes, searches for free space of the size requested by a task, and allocates it to the task.

This function is effective in effectively utilizing limited memory space among multiple tasks, and is also useful in preventing multiple tasks from using the same memory area overlappingly. Note that the setting of the work memory area in the multi-task control element 1 is performed at the time of initial setting of the multi-task control element 1 (at the time of execution of command 0).

Command 12 (command name: POST, flowchart in FIG. 19) is a command for sending data to a memory area called mailbox MBX provided in the multi-task control element 1. Mail Box MBX uses this command 12
It serves as a message relay point between the task that executed the task and another task (command 13 execution, which will be explained next). One of the five mailboxes MBX1 to MBX5 can be specified. Command parameter register
Mail box MBX number used for CPIO,
and writes the data to be sent to the specified mail box MBX and executes the command.

When command 12 is executed, the input data is checked for errors (step 〓〓), and if an error is detected, an error code is set in the command/status register CNST (step 〓〓) and the process returns to the main routine.

If no error is detected, the transmitted data is written to the mail box MBX of the designated number (step 〓〓). Next, it is checked whether there is a task that has already executed command 13 and is waiting for data to be sent to the specified mail box MBX by executing command 12 (step 〓〓). This is in the task status in the task control block TCB of all tasks.
This is done with reference to the PENDW flag and mail box number. If there is no task waiting to be sent, skip to step 〓〓. If there is a task waiting for transmission (only one is allowed in this embodiment), the PENDW flag in the task control block TCB of the task waiting for transmission is reset, the READY flag is set, and Ready Q is given priority. Reconnect in order (step 〓〓).

Then, whether there is a task waiting for transmission or not, a normal completion code is set in the command/status register CNST (step 〓〓), and
Set the TSKCHG flag (step 〓〓) and return to the main routine.

Command 13 (command name: PEND, flowchart in Figure 20) is a command to receive data from another task via the specified mail box MBX. Command parameter register
Mailbox receiving data to CPIO
Write the MBX number and execute the command. When command 13 is executed, the input data is first checked for errors (Step 〓〓), and if there is an error, an error code is set in the command/status register CNST (Step 〓〓), and the process returns to the main routine. .

If no errors are detected, the specified mail
Check whether data has already been written to the box MBX (step 〓〓). If not written, reset the RUN flag,
Set the PENDW flag (step 〓〓) and
Set the TSKCHG flag (step 〓〓).
And then the command/status register
Set the data unarrival code in CNST (step 〓〓) and return to the main routine. If data has already been written, the command parameter register
Transfers the data written to the mail box MBX specified by CPIO (Step 〓〓), sets a normal completion code in the command/status register CNST (Step 〓〓), and returns to the main routine.

Command 14 (command name: PMOD, flowchart in FIG. 21) is a command for setting the data input/output direction of port 1 and port 2. Set the code for specifying the input/output direction of port 1 and port 2 in the command parameter register CPIO and execute the command.

Specify the input/output direction of ports 1 and 2 based on the code set in the command parameter register CPIO (Step 〓〓), and set the normal completion code in the command/status register CNST (Step 〓〓). , return to the main routine.

Any command 0~ issued by the task above
After executing the processing routine No. 14 and returning to the main routine shown in FIG. 6, it is first determined whether an error code is set in the command/status register CNST (step 〓〓). If the error code is set, the program skips to step 〓〓, and if the error code is not set, then it is determined whether the TSKCHG flag is set (step 〓〓). If the TSKCHG flag is “0”, skip to step 〓〓,
If it is "1", a task switching routine is executed (step 1, the task switching routine is described in detail in the flowchart of FIG. 22). When the program returns to the main routine by skipping from Step〓〓 or Step〓〓 or after executing the task switching routine (Step〓〓), it prepares to accept the next command (Step〓〓) and resets the TSKCHG flag ( Step〓〓). Then, the process returns to the step and waits for the next command to be accepted.

As mentioned above, in the command processing routine,
When the TSKCHG flag is set (to "1"), a task switching routine is executed. In the flowchart of FIG. 22, when the task switching routine is entered, it is first checked whether command 1 (end of initial setting and start of execution) is to be executed (step 〓〓).

If command 1 is being executed, skip to step 100, and in the subsequent processing, command 0 will be executed first.
An interrupt signal is generated to the master CPU 2 to cause the task that is in the ready state and has the highest priority to be executed from among the tasks registered in (initial setting). First, the task control block TCB of the task connected to the beginning of Lady Q is disconnected from Lady Q (step 100), and the value of the task stack pointer (see Figure 3) in this task control block TCB is set to the new stack. - Write to pointer register SPN (step 101). and,
Set the RUN flag in the task status in the task control block TCB (step 102).
), generates an interrupt signal to the master CPU 2 (step 103).

The master CPU 2 reads the value of the stack pointer of the new task by the task switching interrupt routine on the master CPU 2 side based on this interrupt signal, and executes the task under the control of the master CPU 2 at the same time as the interrupt routine returns.

At times other than when command 1 is executed, it is checked whether the task is in the execution state (step 〓〓). If it is not in the execution state, it skips to step
Write and save in the task stack pointer area in the TCB. After this, step 100~
103 to perform another task through processing.
From multi-task control element 1 to master CPU 2
generates an interrupt signal.

If the task is in the RUN state, it is checked whether it is the time-up time for time-sharing processing (step 〓〓). When a task specified for time-sharing processing times up, it skips to step 〓〓. This skip routine is the 24th skip routine that will be explained later.
It only passes during timer interrupt processing in the flowchart.

If it is not time up, a check is made to see if there is a task connected to Lady Q (step 〓〓). If not, that is, if there is no task in the ready state other than the task currently in the execution state, the process returns to the main routine of FIG. If there is a task connected to Lady Q, then the priority of the task in the running state is compared with the priority of the task connected to the head of Lady Q (step 〓〓). If the priority of the task in the execution state is higher, the process returns to the main routine shown in FIG. 6 as well. If the main routine is returned by steps 〓〓〓〓〓〓, no interrupt signal will be generated and the task currently being executed will continue its execution.

If the priority of the task connected to the head of Lady Q is higher, the task control block TCB of the task being executed is connected to Lady Q, and the RUN flag is reset (step 〓〓).
and the old stack pointer register SPB
data in the task control block TCB.
It is saved in the stack pointer area (step 〓〓), and an interrupt is generated through the subsequent processing of steps 100 to 103. In addition, from step 100
At step 103, the other task that newly enters the execution state is the task connected to the head of Lady Q, as described above, and is the task that has become the highest priority due to command execution or the like. After generating the interrupt signal, return to the main routine shown in Figure 6.
Prepare to accept the next command (step in Figure 6).

23 and 24 are flowcharts of the interrupt handling routine for the main routine of FIG. 6.

FIG. 23 shows interrupt processing by input to port 3, in which a task in a stopped state is activated by an external event by command 5 (stop task, flowchart in FIG. 12).

This routine is activated by the transition of the signal input to port 3. In this routine,
Connect the task control block TCB of the task for which external event activation is set with command 5 to the ready Q in priority order (step 104), reset the SUSPEND flag in the task control block TCB, and set the READY flag ( step
105). That is, this enables the stopped task to be restarted, and once this is completed, the interrupt processing routine returns.

FIG. 24 shows interrupt processing by a timer. The signal from the timer TM in FIG. 2 is used as an internal interrupt signal, and when this occurs in fixed time units, the timer interrupt processing routine is entered.

When an internal interrupt signal is generated from timer TM,
First, the clock values (hour, minute, and second data) registered in the system clock area SCA are advanced (step 106). Next, the priority registered in the register SLIPRI set by command 7 (setting of task time-sharing processing, flowchart in Figure 7),
The priority of the task currently being executed is compared (step 107). Time-sharing processing is effective only when there is no task in a ready state with a higher priority than the specified priority. If there is a ready task with a higher priority, that task will be executed and time-sharing processing will be disabled, but if there are no tasks with a higher priority, it will become effective. The comparison in step 107 above is equivalent to checking whether the task with the priority registered in the register SLIPLI is being executed, and if the task specified for time-sharing processing is not in the execution state, it is immediately executed from the interrupt processing routine. Return.

If the priority registered in the register SLIPRI matches the priority of the currently running task, that is, if the currently running task is a task with time-sharing processing specified, then the time registered in the register SLICNT has elapsed. (step)
108). If the elapsed time has not elapsed, return from this interrupt processing routine. That is, multi-
Task control element 1 returns to the main routine and waits for the next command, and the master CPU
2, the task currently in the execution state specified by time-sharing processing is executed continuously.

When the registered time has elapsed, the task control block TCB of the task in execution state is readied.
At the same time, reset the RUN flag and set the READY flag (step 109).
), calls the task switching routine shown in FIG. 22 (step 110).

In the flowchart of FIG. 22, if the time has expired for a task designated for time-sharing processing, the process skips from step 〓〓 to step 〓〓. Then, the processing from steps 〓〓〓 to 103 is performed. By doing this, the data of the old stack pointer register SPB is saved in the task stack pointer area of the task that was previously in the execution state (step 〓〓), and the same priority specified for time-sharing processing is saved. The task control block TCB of the task with the
Write the data in the pointer area to the new stack pointer register SPN (step 101).
Finally, the RUN flag is set in the task status (step 102). After performing such a task switching routine, the program returns from the interrupt. The master CPU 2 executes another task designated for time-sharing processing by the operation of the multi-task control element 1 described above.

As described above, the multi-task control element 1 of this embodiment can support up to eight tasks at the same time. In order to support more than eight tasks, tasks can be created and deleted using command 2 (task creation) and command 3 (task deletion), and tasks can be replaced as necessary. Then, the multi-task control element 1 allocates exclusive rights to the master CPU 2 to each task in order of priority. Further, by using command 7 (setting of time-sharing processing for tasks), it is also possible to schedule multiple tasks with the same priority in a time-sharing manner. Although the priority of each task is set when the task is generated, it can also be changed during program execution by the master CPU 2 using command 6 (change task priority).

At the start of time-sharing processing, the execution order of tasks follows the order of tasks generated by command 0 (initial setting) or command 2 (task generation). Command 7 (setting time-sharing processing for tasks) while a task is running
If the priority of the executed task is equal to the time-sharing specified priority, time-sharing processing becomes effective from the time of execution.

Command 12 (sending message), Command 13
(Message reception) allows data (messages) to be exchanged between tasks using the mail box MBX of the multi-task control element 1.

When command 12 is executed, if a task with a higher priority than the executed task has already executed command 13 and is in a standby state, the task that was waiting starts execution due to task switching. If a task with a low priority is on standby due to command 13, that task simply becomes ready, and the task that executed command 12 continues execution. When command 12 is executed, if command 13 has not been executed, the data (message) will be saved in the mail box MBX and the task execution will continue in the same way.

When executing command 13, if data (message) has already arrived at the specified mail box MBX, the task must immediately read the received data (message) from command parameter register CPIO. I can do it.

Furthermore, by using the standby function of command 13, it is possible to perform not only data communication between tasks, but also synchronization and mutual exclusion between tasks. Note that during synchronization and mutual exclusion between tasks, the data written to the mail box MBX is dummy data and does not need to be used for actual task processing.

There are cases where it is necessary to control the execution order of two tasks for processing reasons. For example, if you want to wait until one task finishes processing the other task, use command 12, command
13 can be used as follows to synchronize each other.

Task 2, execute command 13. Task 2 enters a standby state because no message has arrived.

Execute task 1 processing before task 2 processing.

Execute task 1, command 12. Allow execution of task 2 processing.

Execute task 2 processing.

Next, regarding mutual exclusion, when multiple tasks use one common resource, such as I/O, memory, etc., there are cases where it is necessary to prohibit simultaneous use. For example, if simultaneous use of printers is prohibited, they can be excluded from each other as follows.

Execute task 1, command 12.

Execute task 1, command 13. Already command
12 is running, so it does not enter a waiting state,
Lock the exclusive part.

Task 2, execute command 13. This command
13 puts the task in a waiting state.

Task 1: Use a printer.

Execute task 1, command 12. Unlock the exclusive part and lock the exclusive part of task 2 at the same time.

Task 2: Use a printer.

Task 2, execute command 12, unlock the exclusive part.

Synchronization and mutual exclusion between tasks can also be achieved as described above.

Although the multi-task control element 1 in this embodiment has hardware integrated on one LSI, there is no problem in creating a device by combining circuit elements as appropriate.

<Effects of the Invention> As described above, according to the device of the present invention, in a multi-task control system, the device performs data exchange, synchronization, and mutual exclusion between tasks. There is no need to prepare a program, and the user program only needs to write two commands, reducing the burden on the software. In particular, the synchronization and mutual exclusion described above utilizes a reception command standby function, and can be realized with simple control.
Furthermore, since the master CPU itself does not have to perform data exchange, synchronization, and mutual exclusion processing, the processing speed of user programs can be improved.

[Brief explanation of drawings]

FIG. 1 is a diagram showing an example of a system configuration using the device of the present invention, FIG. 2 is a block diagram showing an example of the internal configuration of the device in an embodiment of the present invention, and FIG. 3 is a diagram showing the task control block of FIG. 2. A diagram explaining the TCB area, Figure 4 is a memory map of Figure 2.
Figure 5 is a diagram explaining the MEMMAP area, Figure 5 is a diagram explaining commands used in this device, input parameters, and output parameters, Figure 6 is a flowchart explaining the operation of the main routine of this device, Figures 7- FIG. 21 is a flowchart explaining the operation of the processing routine by each command, FIG. 22 is a flowchart explaining the operation of the task switching routine, and FIG. 23 is a flowchart explaining the operation of the interrupt processing routine by event input. FIG. 24 is a flowchart illustrating the operation of the timer interrupt processing routine. 1... Multi-task control element, 2... Master CPU, 3... Program memory, 6... Data memory, INTC... Interrupt control circuit,
...Interrupt signal, TCB...Task control block,
CONT...Internal arithmetic control circuit, MBX...Mail box, MIV...Master interrupt control register, CPIO...Command parameter register, CNST...Command/status register, SPN...New stack pointer register ,
SPB...Old stack pointer register.

Claims (1)

[Claims] 1 A device that manages multiple tasks executed by a single master CPU in a time-sharing manner using a device other than the master CPU, and has a mail box area used for exchanging data between tasks. A means for controlling data exchange between tasks that issues commands via the mail box area according to send and receive commands issued by the task being executed by the CPU, and a means for controlling data exchange between tasks when the above-mentioned receive command is issued. If there is no command, the master CPU
A multi-task control device that is characterized by executing processing independently of.