JP2002229781A - Program, electronic control device, and manufacturing method for program - Google Patents

Abstract

PROBLEM TO BE SOLVED: To provide a program easy to reutilize and its manufacturing method. SOLUTION: A plurality of software components of a program for realizing functions according to a requirement specification and a component platform of a program for realizing the calling functions of processes by the software components are provided. Each software component includes a program for realizing a function to read a constant value from a prescribed memory region and deliver the constant value to the process by the component platform. The component platform includes a program for realizing a function based on the constant value received from the process by each software component. A portion functioning as the prescribed memory region when each software component is executed is provided at a specific portion of the intermediate program of each software component, a value different for each software component is written at this portion as the constant value, then the intermediate program is linked to generate an execution program. The intermediate program can be reutilized without re-compiling a source program.

Description

DETAILED DESCRIPTION OF THE INVENTION

[0001]

The present invention relates to a program, an electronic control unit, and the like.

[0002]

2. Description of the Related Art Conventionally, a program for causing an electronic control unit to function has, for example, been designed to determine a specification for each function unit and to design a plurality of functions in order to realize a plurality of functions. Is common. Then, a source program for realizing each function is created according to the design, a plurality of intermediate programs are obtained by compiling and assembling the plurality of source programs, and these intermediate programs are linked to obtain an execution program. And
The execution program is written in the memory of the electronic control unit, and the electronic control unit reads and executes the execution program written in the memory, so that, finally,
Implement multiple functions as designed.

A program in such an electronic control device is, for example, a software component that realizes a function according to a required specification, and a component platform that is a program for managing the software component and the entire system of the electronic control device. And can be composed of
Then, for example, by configuring a plurality of software components to be called from a component platform and executed, a plurality of functions can be realized by one electronic control device.

Now, in such a software component,
In some cases, a constant is defined as a predetermined constant name in a source program, and processing contents are described in the source program of the software component using the defined constant name. When compiling such a source program, for example, the constant name is replaced with a defined constant by processing by a program such as a preprocessor and then compiled. Therefore, in the intermediate program and the execution program, the constant is embedded in the part of the program corresponding to the part described using the constant name.

For this reason, it is difficult to directly change the values of constants included in these intermediate programs and the like. When changing the values, the values of the constants of the source program are changed, and all the source programs of the changed software components are changed. You need to recompile. For example, if the priority of each software component is defined as a constant, the priority of the software component may change depending on the combination of the software components. When the value of the constant corresponding to the constant name in each software component changes, the source program of each software component must be corrected and recompiled.

Therefore, there is a problem that it is difficult to reuse software components. Further, since it is necessary to recompile each time, there is a problem that development efficiency is deteriorated. Accordingly, the present invention provides a program, an electronic control device, and a program manufacturing method capable of solving the above-mentioned problems, facilitating reuse of software components, and improving development efficiency.

[0007]

According to the program according to the first aspect of the present invention, which has been made to solve the above-mentioned problems, when a computer executes a software component, a predetermined program included in the computer is provided. The constant value stored in the storage area is read and the constant value is passed to the processing by the component platform. In the processing by the component platform of the computer, a predetermined function is realized based on the received constant value. Therefore, by writing a constant value required for the software component to a predetermined storage area before executing the software component, a process using the constant value can be performed by the component platform.

That is, conventionally, at the stage of compiling and assembling a source program, the constant value is developed in a program for realizing a function using a constant in a software component. It was difficult. In particular, when constants are used in a plurality of locations, the constant values are included in the processing, for example, as immediate values, and it is difficult to specify and rewrite the positions of these constants. However, according to the program of the first aspect, since the constant value is obtained by referring to the predetermined storage area, rewriting of the constant value can be realized only by rewriting the value of the predetermined storage area. Therefore, the reuse of the software component is facilitated, and the development efficiency can be improved.

According to a second aspect of the present invention, in a process using a software component, a computer reads component identification information stored in a predetermined storage area and passes the component identification information to a component platform. In the processing by the component platform, a predetermined function is realized based on the received component identification information. Therefore,
In the processing by the component platform, it is possible to identify which software component is called from. Since the component identification information passed by the processing by the software component is read from a predetermined storage area by the processing by the software component, a different ID or the like for each software component should be written in the predetermined storage area. Can be used to identify software components. For example, if the predetermined storage area is fixed to the first byte of each software component, a different value may be written to the first byte of each component.

In the operation of writing a constant value in this way, a human can give the instruction to write the value in the first byte, for example, to the computer, and write the value. It can also be performed by processing. In this way, a constant value can be easily written into each software component. Therefore, the development efficiency can be further improved. Further, for example, when the component identification information is written as a constant value, the program according to claim 12 may further include a program for realizing a function of writing a different value for each software component. By doing so, it is not necessary to check whether the constant value is different for each software component, so that it is possible to prevent mistakes such as writing the same value by mistake and not functioning as component identification information.

A plurality of storage areas for such constant values as the component identification information can be provided. For example, FIG.
As shown in the above, for the constant a, the constant value (A1, B1, C1) stored in the first one byte storage area is used,
The constant value (A2, B2, C2) stored in the next one-byte storage area is used for the constant b, and the constant value stored in the next one-byte storage area for the constant c. Numerical values (A3, B3, C3) may be used.

However, in this case, a large area is used for each software component (three bytes are used for each software component in the above example), and the size of the software component becomes large. is there. Also, it is necessary to write a plurality of constant values for each software component. For example, when a program for automatically writing a constant value to this storage area is created, the program for writing a constant value to this storage area is changed according to the configuration of the storage area. There must be. Therefore, as described in claim 3, it is preferable that the component platform executes the process based on a constant value associated with the component identification information. That is, for example, as shown in FIG. 6, the component identification information (A,
B, C) (A1 to A3, B1 to B)
3, processing is performed using C1 to C3). By doing so, it is not necessary to rewrite a plurality of constant values of each software component as shown in FIG. 5B, and the correspondence between the component identification information of each software component and the component identification information and the constant value on the component platform. All you have to do is rewrite the relationship. Further, it is not necessary to change a program for writing a constant value to the storage area according to the configuration of the storage area.

The predetermined storage area is, for example, "1000".
The address may be an arbitrary address in the memory space such as "address", or a part in the software component may function as a predetermined storage area at the time of execution, and an address assigned to this part at the time of execution may be stored in a predetermined storage area. It may be referred to as an area. For example, assuming that the first byte of the software component A is secured as this part, and this software component A is allocated from address 1200 at the time of execution,
Address 00 is a predetermined storage area. As described above, the predetermined storage area can be an address in a memory space corresponding to a specific part of the software component. In this case, for example, by writing a constant value to this specific portion at the stage of the intermediate object, the constant value can be used at the time of execution.

[0014] Such a software component can be configured as described in claim 4. In this way, it is possible to prevent, for example, erroneous use or unauthorized use of the software components of the intermediate program. Incidentally, the program described in claim 1 can be generated, for example, as described in claim 5. The program described in claim 2 can be generated, for example, as described in claim 6. The program according to claim 6, wherein the component platform includes a program for realizing a function based on a constant value associated with the component identification information, thereby generating the program according to claim 3. can do. The program described in claim 4 can be generated, for example, as described in claim 7.

The program according to any one of claims 1 to 7 can be used to realize an electronic control device as described in claim 8. The program described in claim 1 can be manufactured by, for example, a manufacturing method as described in claim 9. The program described in claim 2 can be manufactured by, for example, a manufacturing method as described in claim 10. Similarly, in the method of manufacturing a program according to claim 10, the component platform includes a program for realizing a function based on a constant value associated with the component identification information. The described program can be manufactured. The program described in claim 4 can be manufactured by, for example, a manufacturing method as described in claim 11.

[0016]

Embodiments of the present invention will be described below with reference to the drawings. It is needless to say that the embodiments of the present invention are not limited to the following examples, and can take various forms as long as they belong to the technical scope of the present invention.

FIG. 1 is a diagram showing a personal computer 10 which is a program development system, and an embedded system 20 which incorporates and executes a program generated by the personal computer 10. The personal computer 10 is a general personal computer and includes a CPU, a ROM, a RAM, an I / O, and the like. A hard disk, a display, a keyboard, a mouse, various input / output devices, and the like are connected to the I / O. An input / output device for transferring a program executed by the embedded system 20 to the embedded system 20 is connected to the I / O. The OS and various application software are installed in the personal computer 10 in the same manner as a general personal computer.
C compiler, assembler, linker, embedded system 20
A development program such as software for transferring a program to a storage device is stored in an executable state.

The embedded system 20 includes a CPU, ROM, R
This is a computer system including a microcomputer having an AM, an I / O, and the like. The CPU reads and executes a program written in a ROM or a RAM to execute the I / O.
To control devices connected to The CPU has a function to enter a sleep state in which the operation clock is changed by executing a sleep instruction to reduce power consumption, and a function to return from the sleep state to a normal state when a wake-up interrupt signal is input. It has a sleep function. The embedded system 20 includes an apparatus for receiving a program from the personal computer 10 and writing the program in the ROM or the RAM in the embedded system 20, and a program for controlling the apparatus.

After the program is written, the embedded system 20 disconnects the connection to the personal computer 10 and, for example, as shown in FIG. ).

Each of the body systems 100 has an I / O
An embedded system 20a connected to the in-vehicle LAN 50 via O and functioning as a body ECU, an embedded system 20b functioning as a D-seat door ECU, an embedded system 20c functioning as a P-seat door ECU, and functioning as an instrument panel ECU And a built-in system 20d. An input device 30 and an output device 40 are connected to the I / O of these embedded systems 20, respectively.

The embedded systems 20b and 20c read the state of the input device 30 to generate a packet and generate a packet.
0 to the embedded system 20a as the body ECU. Also, the embedded systems 20b, 20c, 20d
Is the embedded system 2 input via the in-vehicle LAN 50
0a based on the control information of the packet from the output device 40a.
Control.

Embedded system 20 as D seat door ECU
b denotes an ECU installed on the driver's door, to which a D-seat control switch 30a or the like is connected as the input device 30, and a D-seat door lock motor 40a or a D-seat power window motor is connected as the output device 40. ing. Embedded system 20c as P seat door ECU
Is an ECU installed on the door on the side of the auxiliary seat, which is connected to the P-seat control switch 30b and the like as the input device 30, and connected to the P-seat door lock motor 40b and the P-seat power window motor as the output device 40. . The built-in system 20d as the instrument panel ECU is an ECU installed on the instrument panel.
As 0, a buzzer 40c, a lamp 40d, and the like are connected. The D-seat control switch 30a and the P-seat control switch 30b include a door lock switch for inputting an instruction for locking or unlocking a door, a power window switch for inputting an instruction for opening and closing a power window, and the like. Is included.

Embedded system 20a as body ECU
From the embedded systems 20b, 20c, 20d
Receiving the packet transmitted to N50 every predetermined time,
When it is necessary to control the output device 40 by executing an application program corresponding to the content of the captured packet via the I / O, the embedded system 2 to be controlled is controlled.
Control processing for generating and transmitting packets including control information to 0b, 20c, 20d, and the like is performed.

A program (execution program) executed in such an embedded system 20 is configured as shown in FIG. That is, the execution program includes a component platform and a software component, and the component platform is a program for executing a process of calling the software component and a process of managing the entire system such as the sleep function described above. On the other hand, the software component is a program for realizing a function based on a predetermined required specification. For example, a function based on a required specification such as an output or an input to a device connected to the I / O is a CP.
This is a program to be realized by U. When the processing by the software component is completed, the process returns to the processing by the component platform, and the above-described process of managing the entire system, the process of calling another or the same software component, and the like are performed.

Here, it is assumed that the following required specifications are defined, for example. That is, as a required specification of the software component A, a process of passing a sleep prohibition instruction to the component platform when a packet is input from the in-vehicle LAN 50 is defined. As a required specification of the software component B, a process of passing a sleep prohibition instruction to the component platform when the depression of the power window switch is detected is defined. The software component A and the software component B are called as required specifications of the component platform, and as a result, the CPU is set only when the sleep prohibition instruction is not passed from any of the software components.
Is set to a sleep state, and when a sleep prohibition instruction is passed by processing of any one of the software components, the CPU is released from the sleep state.

The personal computer 1 based on such required specifications
The program according to the present embodiment created in step S.0 is configured as shown in FIGS. That is, as shown in FIG. 4A, in the software component A, a constant value (component ID) is read from the rewriting area, and if there is a packet from the in-vehicle LAN 50 and sleep is not possible, the slpng function of the component platform is used with the constant value as an argument. Call, LAN5 in the car
If there is no packet from 0 and the sleep enabled state, a program for causing the CPU to execute a process for calling the slpok function of the component platform is included. The rewriting area uses, for example, the first byte of the software component A.

Similarly, as shown in FIG. 4B, in the software component B, a constant value (component ID) is read from the rewriting area, and if the depression of the power window switch is detected and the sleep state is disabled, the constant value is set. Call the slpng function of the component platform with the argument as an argument, and if the switch of the power window is not detected and the sleep state is enabled, include a program for causing the CPU to execute the process of calling the slpok function of the component platform I do. The rewriting area uses, for example, the first byte of the software component B.

Then, as shown in FIG. 4C, the component platform calls a software component A and a software component B in the main process, and includes a program for causing the CPU to execute a process for calling the slp function. The calling process of the software component is performed using a function pointer associated with the component ID. The parts platform is slpng
Function, slpok function, and slp function. The slpng function is a function for executing a process of setting (setting the value to 1) a sleep NG flag corresponding to the received constant value (part ID). The slpok function resets the sleep NG flag corresponding to the received constant value (sets the value to 0)
This is a function for executing processing. In the processing by such a component platform, a constant value (component ID) and a 1-bit sleep NG flag for the constant value are stored in association with each other as shown in FIG. And
The slp function includes a program for integrating all sleep NG flags and executing a slpflag generation process for generating a flag slpflag. slpflag indicates whether or not the sleep state is disabled by a flag slpflag having a predetermined bit width (for example, 8 bit width).
, And is a flag used in the conventional sleep processing. For example,
A constant value (part ID) is treated as the predetermined bit. When all the bits of slpflag are 0 (reset state), the CPU is put into a sleep state, and slpflag is set.
If any bit of g is 1 (set state), the program includes a program for executing the processing for bringing the CPU into the normal state.

Before executing this program, for example, 1 is written in the rewrite area of the software component A, and 2 is written in the rewrite area of the software component B. As described above, the constant value (component ID) is used for the software component A and the software component B.
Is different, it is possible to identify which software component called the function in the processing by the component platform. Bit 1 of slpflag corresponds to the sleep NG flag of software component A, and bit 2 of slpflag corresponds to the sleep NG flag of software component B.

As described above, since it is sufficient to write the constant value in the rewriting area before execution, it is not necessary to compile from the source program each time as in the related art. In addition,
The rewriting area in the above-described example corresponds to a predetermined storage area in the claims.

Here, for comparison, an example in which the above-mentioned required specifications are realized by a conventional method will be described. As described above, in the conventional component platform, the flag sl having a predetermined bit width (for example, 8 bit width) is used to determine whether or not the sleep is prohibited.
This is indicated by pflag, and one predetermined bit is assigned to each software component.

For example, as shown in FIG. 8A, in the source program of the conventional software component A, the definition “SLP_NG
A constant SLP_NG is defined as in (1), and as a process, if there is a packet from the in-vehicle LAN 50 and sleep is not possible, the SLP_NG bit of slpflag is set (set to 1).
If there is no packet from the in-vehicle LAN 50 and sleep is possible, the SLP_NG bit of slpflag is reset (set to 0) and the slp function of the component platform is called. "
Describe to execute the process.

Similarly, as shown in FIG. 8B, in the source program of the conventional software component B, the "definition SLP_NG
The constant SLP_NG is defined as shown in (2), and as a process, if the depression of the power window switch is detected and sleep is not possible, the SLP_NG bit of slpflag is set (set to 1), and the power window is set. If the switch press is detected and sleep is possible, the slplag SLP
The _NG bit is reset (set to 0) and the slp function of the component platform is called. "

Then, as shown in FIG. 8C, in the source program of the conventional component platform, a process for calling the software component A and the software component B in the main process and calling the slp function is described. When all bits of slpflag are 0 (reset state) as the slp function, the CPU is put into the sleep state, and any bit of slpflag is set to 1
If the state is (set state), the processing for bringing the CPU into the normal state is described.

Then, the software component A, the software component B, and the component platform are compiled. The compiler uses
The constant SLP_NG of the software component A by the preprocessor
The program is compiled by replacing (1) with the constant SLP_NG of the software component B by (2) and compiling an intermediate program for each component. These intermediate programs are linked by a linker to generate an execution program, which is transferred to the embedded system 20.

Therefore, the soft parts A and B
In the intermediate program, the value of the constant SLP_NG is embedded in the position using the constant name. Therefore, to change the value of this constant, it is necessary to change the definition of SLP_NG in the source program and recompile. Therefore, there is a problem that it is difficult to reuse the software component.

That is, in such a conventional program, the bit indicated by the constant SLP_NG is the bit position of the slpflag to be written by the software component. Therefore, for example, when the software component C (not shown) is a program defined as “definition SLP_NG (1)”, this bit position matches the program of the software component A in FIG. 8A. In such a case, slpfla
Even if the sleep is prohibited by setting the first bit of g, the processing by the software component C may reset the first bit of slpflag to enable sleep. Therefore, it is necessary to change the constant definition of the source program of the software component according to the combination of components and recompile.

On the other hand, according to the software component of the present embodiment described with reference to FIG. 4, the software component does not define a constant but performs processing of reading and passing a constant value from the rewrite area. Therefore, at the stage of the intermediate program, for example, the rewriting area of the software component A (for example, the first
1 is written in the byte, and 2 is written in the rewrite area (for example, the first byte described above) of the software component B, and the respective intermediate programs are linked to obtain an execution program. These rewrite areas correspond to "a specific part of the intermediate program" in the claims.

Therefore, even if the value of the constant SLP_NG needs to be changed, it can be changed in the state of the intermediate program. Therefore, it is possible to reuse the software components in the state of the intermediate program. Further, there is no need to change the source program of the software component, and it is easy to reuse the software component in the state of the source program. Then, since the value of the constant SLP_NG can be changed in the state of the intermediate program, there is no need to recompile the source program. It is sufficient to simply write the constant value in the rewrite area and then link. Therefore, the development efficiency is also increased. Also,
There is no need to pass slpflag between software components and component platforms or to make them global variables.
The dependency between software components and component platforms can be reduced.

As shown in FIG. 5A, a different value may be automatically written in a rewritable area such as the rewritable area by using a tool. This tool is configured as a program for causing the personal computer 10 to execute a constant value writing process. This constant value writing process includes a process of inputting the specifications of slpflag and a process of writing a constant value from the specifications into the rewriting area of the intermediate program of each software component.

The process for inputting the specifications of slpflag is as follows.
Is a process for inputting which intermediate program corresponds to each bit. For example, the first bit corresponds to the file name “partsA.o” of the intermediate program of software component A, and
In this process, the bit corresponds to the file name “partsB.o” of the intermediate program of the software component B. This input may be input from, for example, a GUI or the like, or may be input from a file describing the correspondence between them.

In the process of writing a constant value, a constant value corresponding to the input bit number is written in a rewritable area (rewrite area) of each intermediate program file based on the input correspondence. If the component platform only needs to be able to identify the software component, this tool simply inputs the file name of the intermediate program of the software component to be linked and assigns a different constant value to each software component. Good.

By doing so, it is possible to easily write a constant value to each software component, and it is possible to further increase the development efficiency. And these SLP_
When a plurality of constants such as NG are used, a plurality of rewrite areas are prepared for each constant as shown in FIG.
The program of each software component and the component platform may be configured in the same manner as the configuration shown and described above. Further, in this case, a configuration may be employed in which writing is performed by a tool in the rewriting area for each constant as shown in FIG.

If it is necessary to pass a plurality of constants from the software component to the component platform, the following may be performed. That is, as shown in FIG. 6, only the component ID is stored in the rewrite area as a constant value on the software component side, and the correspondence between the component ID and a plurality of constants is stored on the component platform side, for example, as a map. Then, in the processing on the component platform side, a constant required for the processing is extracted using this correspondence relationship. By doing so, each software component is
It is only necessary to provide an area for storing only the part ID.
Therefore, it is not necessary to change the tool according to the configuration of the writing area. In other words, in the configuration shown in FIG. 5B, each time the specification of the constant (such as the bit width to be used) changes, the tool also needs to be changed in accordance with the specification of the constant. Since it is only necessary to write the ID, there is no need to change the tool.

Further, such a rewrite area can be used as follows. That is, as shown in FIG. 7, such a component ID area is set to be larger than the width required for component identification, and an encryption code is generated and embedded in the area (encrypted area) by a tool. Then, the process of passing this encryption code to the process by the component platform is included in the initialization function of the software component. On the other hand, on the component platform side, a program for determining whether or not the encryption code passed when calling the initialization function of the software component is correct, and executing the process of calling (using) the software component only when it is correct To be included. In this way, unauthorized use of the software component can be prevented.

In this embodiment, an example in which the sleep function is realized has been described. For example, the processing is temporarily suspended for a predetermined time by using a counter corresponding to the passed component ID to the component platform. Provide a wait function,
When each software component calls this wait function, the above-described program can be applied to realize any other functions, such as reading the component ID from the rewrite area and calling it.

Although the present system has been described as a program in an embedded system, the present invention can be applied to a program for causing various computer systems to perform desired operations.

[Brief description of the drawings]

FIG. 1 is an explanatory diagram of a program development system executed by an embedded system.

FIG. 2 is an explanatory diagram of a body system including an example of an embedded system.

FIG. 3 is an explanatory diagram of a configuration of a program according to an embodiment.

FIG. 4 is a diagram illustrating a configuration of a program according to an embodiment for realizing a sleep function as a predetermined function.

FIG. 5 is an explanatory diagram showing an example of rewriting by a tool to a rewriting area and an example of passing a plurality of constant values.

FIG. 6 is an explanatory diagram showing another example of a program for passing a plurality of constant values.

FIG. 7 is a diagram illustrating a configuration of a program for preventing unauthorized use of software components.

FIG. 8 is a diagram illustrating the configuration of a conventional program for implementing a sleep function.

[Explanation of symbols]

 DESCRIPTION OF SYMBOLS 10 ... Personal computer, 20, 20a, 20b, 20c, 20d ... Embedded system 30 ... Input device 30a ... D seat control switch 30b ... P seat control switch 40 ... Output device 40a ... D seat door lock motor 40b ... P seat door lock Motor 40c Buzzer 40d Lamp 50 Car LAN 100 Body system

Claims (12)

[Claims] 1. A program for realizing a predetermined function on a computer, wherein the program is a software component for realizing a function according to a required specification, and a function for calling processing by the software component. And a component platform that is a program for realizing the program. The software component reads a constant value from a predetermined storage area, and causes the computer to realize a process of passing the constant value to a process by the component platform. Wherein the component platform includes a program for realizing a function based on the constant value received from processing by the software component. 2. The program according to claim 1, wherein the constant value is component identification information for specifying the software component. 3. The program according to claim 2, wherein the component platform includes a program for realizing a function based on a constant value associated with the component identification information. 4. The program according to claim 1, wherein the software component has a portion functioning as the predetermined storage area when the software component is executed by a computer, and the software component has the portion as the constant value. Using a cryptographic code, the component platform determines whether or not the cryptographic code received as the constant value is valid, and when invalid, realizes a function of not calling a process by the software component thereafter. A program characterized by including a program for: 5. A source program comprising: a software component which is a program for causing a computer to implement a function corresponding to a required specification; and a component platform which is a program for causing a computer to implement a function for invoking processing by the software component. A program generated as an execution program by generating an intermediate program, processing the generated intermediate program of the software component, and linking the intermediate program, wherein the software component has a constant value from a predetermined storage area. And a program for realizing a function of passing the constant value to a process by the component platform, wherein the component platform realizes a function based on the constant value received from the process by the software component. Including the generated program The specific part of the intermediate program of the software component has a part that functions as the predetermined storage area when the execution program is executed, and the processing includes the specific part of the generated intermediate program of the software component. Writing the constant value into the program. 6. A plurality of software components, which are programs for causing a computer to implement functions according to required specifications,
An intermediate program is generated from a source program with a component platform, which is a program for causing a computer to implement a function of invoking processing by each software component, and after processing the generated intermediate program of each software component, the intermediate program is executed. The software component is a program generated as an execution program, wherein each of the software components reads a constant value from a predetermined storage area and implements a function of passing the constant value to processing by the component platform. The program includes a program for realizing a function based on the constant value received from the processing by each of the software components, and a specific part of the generated intermediate program of each of the software components. When executing the execution program, the predetermined A part that functions as an area, wherein the processing is to write a different value for each of the software components as the constant value to the specific portion of the generated intermediate program of each software component. Features program. 7. The program according to claim 5, wherein, during the processing, an encryption code is used as the constant value, and the component platform determines whether or not the encryption code is valid. In such a case, the program includes a program for realizing a function of preventing a process by the software component from being called thereafter. 8. An electronic control device comprising a computer for realizing the functions according to claim 1 based on the program according to claim 1. 9. A source program consisting of a software component which is a program for causing a computer to implement a function corresponding to a required specification and a component platform which is a program for causing a computer to implement a function for calling processing by the software component. A method of manufacturing a program for generating an intermediate program, processing the generated intermediate program of the software component, and then linking the intermediate program to generate an execution program, wherein the software component is stored in a predetermined storage area. A program for reading a constant value and realizing a function of passing the constant value to the processing by the component platform is included. The component platform has a function based on the constant value received from the processing by the software component. Includes programs to realize In a specific part of the generated intermediate program of the software component, there is a portion that functions as the predetermined storage area when the execution program is executed, and the processing is performed on the generated intermediate program of the software component. A method of manufacturing a program, wherein the constant value is written in the specific portion. 10. A plurality of software components, which are programs for causing a computer to implement a function corresponding to a required specification, and a component platform, which is a program for causing a computer to implement a function for calling processing by each of the software components. A method for producing an intermediate program from a source program, processing the generated intermediate program of each software component, and then linking the intermediate program to generate an execution program. A constant value is read from a predetermined storage area, and a program for realizing a function of passing the constant value to the processing by the component platform is included, and the component platform receives the constant value received from the processing by each of the software components. A program to realize functions based on numerical values A specific part of the generated intermediate program of each software component has a part that functions as the predetermined storage area when the execution program is executed. A method of manufacturing a program, wherein a different value for each software component is written as the constant value in the specific part of the intermediate program of the software component. 11. The program according to claim 9, wherein said processing uses an encryption code as said constant value, said component platform determines whether said encryption code is valid, and In this case, a method for manufacturing a program includes a program for realizing a function of preventing a process by the software component from being called thereafter. 12. A function for writing a constant value to a predetermined storage area in the program according to any one of claims 1 to 4, or writing a constant value to a specific portion in the program according to any one of claims 5 to 7. A program that causes a computer to implement at least one of the functions.