Software development device, software development program, and software development method

Abstract

To provide a solution which allows a share of software between controllers using semiconductor devices with different specifications.SOLUTION: There is provided a software development device which generates an execution code executed by a controller with at least one pad from a source code. The software development device includes: analysis means for analyzing the source code and extracting a specification for the at least one pad; and generation means for generating an execution code which includes a specification for an extracted pad with reference to hardware information of a target controller.SELECTED DRAWING: Figure 12

Description

[Technical field]

[0001] The present disclosure relates to a software development apparatus and a software development program. [Background technology]

[0002] Recent advances in Information and Communication Technology (ICT) have been remarkable, and devices connected to networks such as the Internet are no longer limited to conventional information processing devices such as personal computers and smartphones, but are now expanding to include a wide variety of things. This technological trend is known as the "Internet of Things (IoT)," and various technologies and services are being proposed and put into practical use. In the future, it is expected that billions of people and tens of billions or even trillions of devices on Earth will be connected simultaneously. To realize such a networked world, it is necessary to provide solutions that allow connections to be made simpler, safer, and more freely.

[0003] In devices used in IoT (also called "edge devices"), various programs are executed using semiconductor devices. Regarding the relationship between such semiconductor devices and software, for example, Japanese Patent Application Laid-Open No. 2006-213145 (Patent Document 1) discloses a mechanism for sharing software among multiple specifications that use different designated terminal pins while using the same ECU in terms of hardware. [Prior art documents] [Patent documents]

[0004] [Patent Document 1] JP 2006-213145 A Summary of the Invention [Problem to be solved by the invention]

[0005] The semiconductor devices that make up edge devices are also making remarkable progress. As these semiconductor devices improve, their specifications may change, which can lead to issues such as how to maintain and manage software.

[0006] The mechanism disclosed in the above-mentioned Patent Document 1 is intended to realize multiple functions with different specifications with a single piece of software using the same hardware, and does not solve the problem of sharing the same software among multiple semiconductor devices with different specifications.

[0007] An object of the present disclosure is to provide a solution that enables software to be shared between controllers that use semiconductor devices with different specifications. [Means for solving the problem]

[0008] According to one aspect of the present disclosure, there is provided a software development device that generates, from source code, execution code to be executed in a controller having one or more pads. The software development device includes an analysis means that analyzes the source code and extracts specifications for one or more pads, and a generation means that references hardware information of a target controller and generates execution code including code corresponding to the specifications for the extracted pads.

[0009] A pad may be a physical interface between the controller 200 and any hardware.

[0010] The hardware information may include information for identifying the connection relationship between the pins and pads of a semiconductor device mounted on the controller.

[0011] The designation for one or more pads may include identification information for identifying a pad to be used from among the one or more pads.

[0012] The generating means may generate the execution code by using code specific to the target controller, instead of a library module commonly used between the controllers.

[0013] According to another aspect of the present disclosure, there is provided a software development program for generating, from source code, execution code to be executed in a controller having one or more pads. The software development program causes a computer to execute the steps of analyzing the source code to extract designations for one or more pads, and generating execution code including code corresponding to the extracted designations for the pads by referencing hardware information of a target controller. Effect of the Invention

[0014] According to the present disclosure, software can be shared between controllers using semiconductor devices with different specifications. [Brief description of the drawings]

[0015] [Figure 1] 1 is a schematic diagram showing an example of an overall configuration of an IoT system according to an embodiment of the present invention. [Diagram 2] FIG. 1 is a schematic diagram showing an example of a hardware configuration of a software development apparatus according to an embodiment of the present invention. [Diagram 3] FIG. 2 is a schematic diagram showing an example of a hardware configuration of a controller according to the present embodiment. [Figure 4] FIG. 2 is a diagram for explaining a microcomputer used in a controller connected to the software development apparatus according to the present embodiment. [Diagram 5] 1 is a diagram for explaining pads provided by a controller connected to the software development apparatus according to the present embodiment. FIG. [Figure 6] 6 is a diagram showing the connection relationship between the microcomputer and pads shown in FIG. 5. [Figure 7] FIG. 7 is a diagram showing an example of source code directed to the controller shown in FIGS. 5 and 6. [Figure 8]3 is a diagram showing an example of source code that can be input to the software development device according to the present embodiment; FIG. [Figure 9] 1 is a block diagram showing an example of a functional configuration of a software development apparatus according to an embodiment of the present invention; [Figure 10] 2 is a diagram for explaining a data structure of an execution code generated by the software development device according to the present embodiment. FIG. [Figure 11] 11A to 11C are diagrams for explaining application examples of pads provided by a controller according to the present embodiment. [Figure 12] 10 is a flowchart showing a processing procedure for generating execution code from source code in the software development device according to the present embodiment. DETAILED DESCRIPTION OF THE PREFERRED EMBODIMENTS

[0016] DETAILED DESCRIPTION OF THE PREFERRED EMBODIMENTS The present disclosure will now be described in detail with reference to the accompanying drawings, in which the same or corresponding parts in the drawings are designated by the same reference numerals and will not be described repeatedly.

[0017] In the following description, as a typical example, the software development device 10 according to the present embodiment will be described. 0 will be described as being applied to an IoT system, but the present disclosure is not limited to IoT systems and can be applied to any system and controller.

[0018] <A.IoTシステム1> First, the overall configuration of an IoT system 1 including a software development apparatus 100 and an edge device 2 according to the present embodiment will be described.

[0019] Fig. 1 is a schematic diagram showing an example of an overall configuration of an IoT system 1 according to the present embodiment. With reference to Fig. 1, in the IoT system 1, typically, a program (execution code) to be executed in an edge device 2 is generated in a software development device 100. The generated program is transferred from the software development device 100 to a controller 200 included in the edge device 2.

[0020] The software development device 100 is provided with an integrated development environment (IDE: Integrated Development Environment), and the user can create any program on the integrated development environment.

[0021] The edge device 2 can be any device, but typically, factory equipment, various devices in the home, social infrastructure equipment, moving objects such as vehicles, and any portable device are assumed. More specifically, the edge device 2 includes a controller 200 including a processor and one or more hardware devices 4. The hardware device 4 includes any sensor, actuator, communication device, etc. that constitutes the edge device 2.

[0022] The controller 200 and the hardware device 4 are electrically connected by wiring (hard-wired).

[0023] As a typical processing procedure in the IoT system 1 shown in FIG. 1, first, the user creates source code using the software development device 100 ((1) Source code creation). Then, the created source code is compiled in the software development device 100 to generate an execution code ((2) Execution code generation). The generated execution code is transferred to the controller 200 of the edge device 2 ((3) Execution code transfer). The transferred execution code is executed by the controller 200 ((4) Execution of the execution code). By executing the execution code in the controller 200, any signal may be exchanged with the hardware device 4.

[0024] In this way, the software development device 100 generates an execution code to be executed by the controller 200 from the source code.

[0025] <B. Hardware configuration example> Next, a hardware configuration example of a device included in the IoT system 1 according to the present embodiment will be described.

[0026] (b1: software development device 100) The software development device 100 is typically realized by a general-purpose computer.

[0027] Fig. 2 is a schematic diagram showing an example of a hardware configuration of software development device 100 according to the present embodiment. With reference to Fig. 2, software development device 100 includes, as main components, a processor 102, a main memory 104, an input unit 106, a display 108, a hard disk 110, and a communication interface 122. These components are connected via an internal bus 120.

[0028] The processor 102 is, for example, a central processing unit (CPU) or a graphics processing unit (GPU). A plurality of processors 102 may be provided. , a processor 102 having multiple cores may be employed.

[0029] The main memory 104 is configured with a volatile storage device such as a dynamic random access memory (DRAM) or a static random access memory (SRAM). The hard disk 110 may be replaced with a non-volatile memory such as a solid state drive (SSD) or a flash memory. A volatile storage device may be used. A designated program from among the programs stored in the hard disk 110 is loaded onto the main memory 104, and the processor 102 sequentially executes computer-readable instructions included in the program loaded onto the main memory 104 to realize various functions as described below.

[0030] Typically, hard disk 110 stores source code 112 created arbitrarily by the user, a software development program 114 for realizing an integrated development environment, and execution code 116 generated from source code 112. Software development program 114 generates execution code 116 from source code 112 created arbitrarily by the user, and includes a module that provides a program development environment.

[0031] The input unit 106 accepts input operations from a user who operates the software development device 100. The input unit 106 may be, for example, a keyboard, a mouse, a touch panel arranged on a display device, or operation buttons arranged on the housing of the software development device 100.

[0032] The display 108 displays the results of processing by the processor 102. The display 108 may be, for example, an LCD (Liquid Crystal Display) or an organic EL (Electro-Luminescence) display.

[0033] The communication interface 122 is responsible for data exchange with the controller 200. The communication interface 122 includes, for example, a wired connection terminal such as a Universal Serial Bus (USB) port, a serial port such as IEEE1394, or a legacy parallel port. Alternatively, the communication interface 122 may include an Ethernet port.

[0034] All or part of the software development device 100 may be implemented using a software program such as an ASIC (Application Specific Integrated Circuit) incorporating a circuit that corresponds to a computer-readable instruction. This may be implemented using hardwired circuitry, or alternatively, using circuitry corresponding to computer-readable instructions on a field-programmable gate array (FPGA). Moreover, it may be realized by appropriately combining the processor 102, a main memory, an ASIC, an FPGA, and the like.

[0035] The software development device 100 may further include a component for reading the stored software development program 114 including computer-readable instructions from a non-transitory medium that stores the program. The medium may be, for example, an optical medium such as a Digital Versatile Disc (DVD), a semiconductor medium such as a USB memory, or the like.

[0036] The software development program 114 may be installed in the software development device 100 via a medium, or may be provided from a distribution server on a network. This may be done.

[0037] (b2: Controller 200) The controller 200 may be implemented using a general purpose computer or may be implemented using a semiconductor substrate that contains the necessary components to implement the processing.

[0038] Fig. 3 is a schematic diagram showing an example of a hardware configuration of a controller 200 according to the present embodiment. Referring to Fig. 3, the controller 200 includes, as main components, an arithmetic processing unit 210, a wireless communication module 212, a USB controller 214, a communication controller 216, and a microcomputer 218 including an IO driver electrically connected to one or more pads 220.

[0039] The arithmetic processing unit 210 is a calculation unit that executes a program, and includes a processor 202, a main memory 204, and a flash memory 206 as main components. The processor 202 is configured with, for example, a CPU or a GPU. A plurality of processors 202 may be arranged, or a processor 202 having a plurality of cores may be adopted. The main memory 204 is configured with a volatile storage device such as a DRAM or an SRAM. The flash memory 206 is a non-volatile storage device that holds programs executed by the processor 202 and necessary data. Of the programs stored in the flash memory 206, a specified program is expanded on the main memory 204 and executed by the processor 202 to realize various functions.

[0040] The wireless communication module 212 is responsible for wireless data exchange with any other device. The wireless communication module 212 may include a processing circuit and an antenna for wireless communication with a device, a router, a mobile base station, etc. The wireless communication module 212 supports wireless communication such as Wi-Fi (registered trademark), Bluetooth (registered trademark), ZigBee (registered trademark), LPWA (Low Power Wide Area), GSM (registered trademark), etc. , W-CDMA, CDMA200, LTE (Long Term Evolution), 5th generation mobile communications It may be either system (5G).

[0041] The USB controller 214 is responsible for data exchange with the software development device 100. The communication controller 216 is responsible for wired data exchange with any other device. The communication controller 216 may be compatible with known data exchange methods such as serial communication, parallel communication, and GPIO (General-purpose input / output).

[0042] The microcontroller 218 is responsible for the exchange of electrical signals with any device electrically connected via the pad 220. The microcontroller 218 outputs electrical signals according to commands from the arithmetic processing unit 210. Also, the microcontroller 218 detects electrical signals applied via the pad 220 and outputs the detection results to the arithmetic processing unit 210. More specifically, the microcontroller 218 is composed of a signal generation circuit, a signal detection circuit, a buffer circuit, and the like.

[0043] The pad 220 has exposed conductors and corresponds to the physical interface between the controller 200 and various hardware.

[0044] The controller 200 may be driven by power from a battery (not shown). <C. Problems and Solutions> Next, the problems to be solved by the software development apparatus 100 according to the present embodiment will be described.

[0045] FIG. 4 is a diagram for explaining the microcontroller 218 used in the controller 200 connected to the software development apparatus 100 according to the present embodiment. FIGS. 4(A) and 4(B) illustrate cases where the microcontrollers 218A and 218B are employed, respectively.

[0046] As shown in FIG. 4, even for microcontrollers 218 that provide substantially the same functions, the specifications of the microcontroller 218 itself (size and number of pins) and the pin positions to which each function is assigned may be different.

[0047] For example, in the microcontroller 218A shown in FIG. 4(A), pins numbered "5", "6", "7", "12", "13", "14" are used as I / O terminals. Also, in the microcontroller 218B shown in FIG. 4(B), pins numbered "17", "18", "19", "20", "21", "22" are used as I / O terminals.

[0048] Fig. 5 is a diagram for explaining pads 220 provided by controller 200 connected to software development device 100 according to the present embodiment. As shown in Fig. 5, terminals of microcomputer 218 and pads 220 are electrically connected. Any combination is possible depending on the positional relationship between the terminals of microcomputer 218 and pads 220.

[0049] Fig. 5(A) shows a configuration example using the microcomputer 218A shown in Fig. 4(A). In this configuration example, the pads 220 numbered "1" to "6" are electrically connected to the pins numbered "5", "6", "7", "14", "13", and "12", respectively. Also, Fig. 5(B) shows a configuration example using the microcomputer 218B shown in Fig. 4(B). In this configuration example, the pads 220 numbered "1" to "6" are electrically connected to the pins numbered "22", "21", "20", "19", "18", and "17", respectively.

[0050] Fig. 6 is a diagram showing the connection relationship between the microcontroller and pads shown in Fig. 5. Fig. 6(A) shows the connection relationship shown in Fig. 5(A), and Fig. 6(B) shows the connection relationship shown in Fig. 5(B).

[0051] As can be seen by comparing Figures 6(A) and 6(B), the pin numbers and logical ports connected to pads 220 numbered "1" to "6" are all different between microcomputer 218A and microcomputer 218B.

[0052] Due to such differences in hardware, it has been difficult in the prior art to standardize the software executed by the controller 200.

[0053] Fig. 7 is a diagram showing an example of source code 112 directed to controller 200 shown in Fig. 5 and Fig. 6. Source code 112A and 112B shown in Fig. 7 prescribe a process for outputting signals indicating a predetermined message through pads 220 numbered "5" and "6".

[0054] 7A includes definitions 1121 of variables indicating messages and definitions 1122 of variables (OutPort1 and OutPort2) indicating output ports. The value of the message is set by the function getText() (instruction 1123).

[0055] Also, the port connected to the pad 220 used to send a signal indicating a message is enabled (command 1124A). The command 1124A sets the logical ports "IO_05" (OutPort1: pin number "13") and "IO_04" (OutPort2: pin number "12") of the microcomputer 218A to "Out" (output) (see FIG. 6(A)).

[0056] Then, command 1125 is executed, and signals indicating messages are sent out from the two logical ports that have been set.

[0057] In contrast, in a configuration using microcontroller 218B, pads 220 numbered "5" and "6" are electrically connected to logical ports "IO_02" (pin number "18") and "IO_01" (pin number "6") of microcontroller 218B, and therefore this difference in configuration must be reflected in source code 112.

[0058] Specifically, the command 1124B shown in Fig. 7(B) enables a different logical port from the command 1124A shown in Fig. 7(A). The command 1124B sets the logical ports "IO_02" (OutPort1: pin number "18") and "IO_01" (OutPort2: pin number "17") of the microcomputer 218B to "Out" (output) (see Fig. 6(B)).

[0059] In this way, it may become necessary to modify the source code 112 every time the specifications of the microcomputer 218 used in the controller 200 are changed.

[0060] To address this issue, software development apparatus 100 according to the present embodiment is designed to enable direct specification of pads 220 that are to be electrically connected to any device.

[0061] Fig. 8 is a diagram showing an example of source code 112 that can be input to software development device 100 according to this embodiment. Like source codes 112A and 112B shown in Fig. 7, source code 112 shown in Fig. 8 specifies a process for outputting signals indicating a predetermined message through pads 220 numbered "5" and "6".

[0062] 8 includes definition 1121 of a variable indicating a message, and definition 1126 of variables indicating pads to be used (ActivePad1 and ActivePad2). Definition 1126 corresponds to a specification of pad 220 of controller 200, and includes identification information (in this example, the pad number) for identifying a pad to be used among one or more pads 220.

[0063] The value of the message is set by the function getText() (instruction 1123).

[0064] Also, information specifying the pad 220 used to send the signal indicating the message is set (instruction 1127). The instruction 1127 sets "5" and "6", which are the identification information of the pad 220 to be used, to variables ActivePad1 and ActivePad2, respectively.

[0065] Then, the command 1128 is executed, and signals indicating a message are sent from the two pads 220 that have been set.

[0066] Thus, in the software development apparatus 100 according to this embodiment, it is possible to create the source code 112 that specifies the pads actually connected to the device. By being able to specify the pads in this way, differences in specifications such as the microcomputer implemented in the controller 200 can be abstracted. That is, even when the specifications of the microcomputer or the like implemented in the controller 200 are changed, the same software can be reused as it is.

[0067] By adopting such a programming configuration, the user of the controller 200 can continuously use the software assets without being aware of the specifications of the hardware or the like, and thus obtains the advantage. Also, even when the specifications of the microcomputer or the like used by the manufacturer or vendor of the controller 200 are changed, as long as the internal wiring is designed to meet the requirements preset for each pad, there is no need to cause changes or modifications to the source code.

[0068] <D. Functional Configuration of Software Development Apparatus 100> Next, the functional configuration of the software according to this embodiment will be described.

[0069] FIG. 9 is a block diagram showing an example of the functional configuration of the software development apparatus 100 according to this embodiment. Each function shown in FIG. 9 is typically realized by the processor 102 of the software development apparatus 100 executing the software development program 114.

[0070] Referring to FIG. 9, the software development program 114 receives the input of the source code 112 and generates the execution code 116 (assembler code). More specifically, the software development program 114 includes a preprocessor 1141, a compiler 1142, an optimizer 1143, and a code generator 1144.

[0071] The preprocessor 1141 performs lexical analysis and syntax analysis on the source code 112, and controls the behavior of the compiler 1142, the optimizer 1143, and the code generator 1144. The preprocessor 1141 corresponds to an analysis means, and analyzes the source code 112 to extract specifications for one or more pads 220.

[0072] The compiler 1142 generates an object code based on the results of lexical analysis and syntax analysis of the source code 112. The optimizer 1143 optimizes the generated object code. The code generator 1144 outputs the final execution code 116 based on the results of optimization by the optimizer 1143.

[0073] The compiler 1142 , optimizer 1143 and code generator 1144 correspond to a generating means, and generate an execution code including a code corresponding to the specification for the extracted pad 220 by referring to the hardware information of the target controller 200 .

[0074] The software development device 100 has a configuration 118 that includes hardware information of the controller 200 on which the execution code 116 is executed. A configuration 118 is prepared for each controller 200, and a configuration 118 is selected according to the target controller 200.

[0075] The configuration 118 typically includes information for identifying the connection relationship between the pins and pads of an implemented semiconductor device (typically a microcomputer) as shown in Fig. 6. The software development device 100 selects a corresponding configuration 118 according to the type of controller 200 on which the execution code 116 is executed, and determines path information and the like required to utilize the pads 220 specified in the source code 112 by referring to the contents of the selected configuration 118. In other words, the configuration 118 includes setting information for absorbing differences in the hardware constituting the controller 200.

[0076] The type of controller 200 may be selected manually by the user, or may be automatically acquired by connecting the software development device 100 and the controller 200. The configuration 118 may be additionally acquired by the software development program 114 from a pre-specified server, or may be stored in advance in the storage of the controller 200 and read out by the software development device 100 as necessary. This is also fine.

[0077] Furthermore, the execution code 116 may be generated to suit the target controller 200 .

[0078] Fig. 10 is a diagram for explaining the data structure of execution code 116 generated by software development device 100 according to the present embodiment. Referring to Fig. 10(A), execution code 116A is made up of one or more object codes (object codes 1161 and 1162 in the example of Fig. 10(A)) and a necessary library module 1163. Library module 1163 becomes a part of the object codes referenced by object codes 1161 and 1162. Typically, necessary data is passed from object code 1161 or 1162 to library module 1163, processing is executed, and the result is returned to object code 1161 or 1162.

[0079] 10(B), the code handled by library module 1163 in execution code 116A shown in Fig. 10(A) is incorporated as unique codes 1165 and 1167 into object codes 1164 and 1166. That is, object codes 1164 and 1166 include unique codes 1165 and 1167 for executing processing unique to the target controller 200.

[0080] Thus, instructions (object code) generated to be compatible with the controller 200 for the object codes 1164 and 1166 may be incorporated. That is, the software development apparatus 100 may generate the execution code 116 with code specific to the target controller 200 instead of the library module 1163 that is commonly used among controllers. By adopting such a configuration, the possibility of execution errors occurring in the controller 200 can be reduced, and faster processing can also be expected.

[0081] <E. Application Examples of Pads> Next, application examples of the pad 220 provided by the controller 200 according to the present embodiment will be described. As described above, in the present embodiment, various processes can be executed by specifying one or more pads 220 included in the controller 200. By using such pads 220, a physical interface with various hardware can be realized.

[0082] FIG. 11 is a diagram for explaining an application example of the pad 220 provided by the controller 200 according to the present embodiment. Referring to FIG. 11, the controller 200 has a plurality of pads 220 arranged in a matrix, and an adapter 300 that can be electrically connected to these pads 220 is prepared. In the mounted state, the adapter 300 is configured such that terminals can be arranged at positions where they can be electrically connected to each pad 220.

[0083] For each of the plurality of pads 220 arranged in a matrix, a function may be defined in advance.

[0084] FIG. 11 shows an example in which only some of the plurality of pads 220 (numbers "6" to "10" and numbers "16" to "20") are used. Any device connected to the adapter 300 will exchange signals with a specific pad 220 of the controller 200.

[0085] As described above, due to the change in the specifications of the microcomputer 218 incorporated in the controller 200, even if a new hardware configuration is adopted to maintain the layout and provided functions of the pad 220, as long as the configuration 118 that defines the hardware configuration is prepared, the source code 112 can be reused as it is. That is, the change in the hardware configuration of the controller 200 can be absorbed by software.

[0086]

[0087] <F. Processing Procedure>

[0088]

[0089]

[0090] Referring to FIG. 12, the software development apparatus 100 executes lexical analysis and syntax analysis on the input source code 112 (step S100). Based on the analysis result, the software development apparatus 100 determines whether any pad 220 is specified (step S102). That is, the software development apparatus 100 analyzes the source code 112 to extract the specification for one or more pads 220.

[0091] If none of the pads 220 are specified (NO in step S102), the processes in steps S104 and S106 are skipped.

[0091] If any of the pads 220 are specified (YES in step S102), the software development apparatus 100 acquires the configuration 118 corresponding to the controller 200 that is the transfer destination of the execution code 116 (step S104), and determines the path information necessary to use the specified pad 220 with reference to the acquired configuration 118 (step S106). This path information includes information for resolving the pin numbers and logical ports of the microcomputer connected to the specified pad 220.

[0092] Then, the software development apparatus 100 generates object code in module units included in the source code 112 (step S108), combines the object code, and outputs it as the execution code 116 (step S110). Then, the process ends.

[0093] In this way, the software development apparatus 100 generates an execution code including code corresponding to the specification for the extracted pad 220 with reference to the hardware information (for example, the configuration 118) of the target controller 200.

[0094] <G. Modification Example> In the above description, for the sake of convenience of explanation, as a typical example of the physical interface, the pad has been described. However, it is not limited to the term "pad", and it is similarly applicable to one or a plurality of arbitrary physical interfaces (a part of a circuit capable of sending and receiving signals).

[0095] <H. Advantages> According to this embodiment, it is possible to provide a mechanism that allows the interface to be used among the physical interfaces provided by the controller 200 to be defined in the source code 112, and that allows differences in the hardware configuration of the controller 200 to be absorbed. As a result, from the viewpoint of a device connected to the controller 200, the same interface can be maintained regardless of the type of controller 200, and the software can be used as is regardless of changes to the controller 200.

[0096] The embodiments disclosed herein should be considered to be illustrative and not restrictive in all respects. The scope of the present invention is defined by the claims, not the above description, and is intended to include all modifications within the meaning and scope of the claims. [Explanation of symbols]

[0097] 1 IoT system, 2 Edge device, 4 Hardware device, 100 Software development equipment, 102, 202 Processor, 104, 204 Main memory, 106 Input unit, 108 Display, 110 Hard disk, 112, 112A, 112B Source code, 114 Software development program, 116, 116A Execution code, 118 Configuration, 120 Internal bus, 122 Communication interface, 200 Controller, 206 Flash memory, 210 Processing unit, 212 Wireless communication module, 214 USB controller, 216 Communication controller, 218, 218A, 218B Microcomputer, 220 Pad, 300 Adapter, 1121, 1122, 1126 Definition, 1123, 1124A, 1124B, 1125, 1127, 1128 Instruction, 1141 Preprocessor, 1142 compiler, 1143 optimizer, 1144 code generator, 1161,1162,1164,1166 object code, 1163 library modules, 1165 native code.

Claims

1. A software development device for generating an execution code for a controller from a source code, extraction means for extracting a description specifying a pad from the source code; generating means for generating the execution code according to the extracted pad; The generating means When generating an execution code for a first controller, generate a first execution code in which pins of the first controller connected to pads indicated by the extracted specification are specified from the source code based on hardware information of the first controller; When generating an execution code for a second controller different from the first controller, generate a second execution code in which a pin of the second controller connected to a pad indicated by the extracted specification is specified from the source code based on hardware information of the second controller; A software development device, wherein the hardware information includes the connection relationship between pins and pads of a target controller.

2. 2. The software development device according to claim 1, wherein the description specifying the pad includes identification information for specifying a pad to be used from among one or more pads.

3. 3. The software development device according to claim 1, wherein the hardware information can be added from an external server.

4. 4. The software development device according to claim 1, wherein the hardware information further includes a correspondence between pins and logical ports of a target controller.

5. The software development device according to any one of claims 1 to 4, wherein the generation means refers to the hardware information and determines path information including pins connected to pads specified by the extracted description and logical ports corresponding to the pins.

6. A software development program for generating an execution code from a source code, the software development program including: extracting a description specifying a pad from the source code; generating the execution code according to the extracted pad; The generating step includes: generating, from the source code based on hardware information of the first controller, a first execution code in which pins of the first controller connected to pads indicated by the extracted designation are specified; and when generating execution code for a second controller different from the first controller, generating second execution code in which pins of the second controller connected to pads indicated by the extracted designation are specified from the source code based on hardware information of the second controller; A software development program in which the hardware information includes the connection relationship between pins and pads of a target controller.

7. 1. A computer-implemented software development method for generating executable code from source code, comprising: extracting a description specifying a pad from the source code; generating the execution code according to the extracted pad; The generating step includes: generating, from the source code based on hardware information of the first controller, a first execution code in which pins of the first controller connected to pads indicated by the extracted designation are specified; and when generating execution code for a second controller different from the first controller, generating second execution code in which pins of the second controller connected to pads indicated by the extracted designation are specified from the source code based on hardware information of the second controller; A software development method, wherein the hardware information includes the connection relationship between pins and pads of a target controller.

Images