Software development apparatus and processing method

Abstract

We provide a solution that allows software to be shared between controllers that use semiconductor devices with different specifications. [Solution] A software development device is provided that generates, from source code, execution code to be executed by 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 the target controller and generates execution code including code corresponding to the extracted specifications for the pads.

Description

[Technical Field]

[0001] The present disclosure relates to a software development device 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 traditional 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 a variety of 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 enable simpler, safer, and more free connections.

[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 Laid-Open Publication No. 2006-213145 (Patent Document 1) discloses a mechanism for sharing software among multiple specifications that use different designated terminal pins using the same ECU in terms of hardware. [Prior art documents] [Patent documents]

[0004] [Patent Document 1] Japanese Patent Application Laid-Open No. 2006-213145 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 create issues such as how to maintain and manage software.

[0006] The mechanism disclosed in the above-mentioned Patent Document 1 aims to realize multiple functions with different specifications using the same hardware with a single piece of software, 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 allows 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, executable code to be executed by a controller having one or more pads. The software development device includes: analysis means that analyzes the source code and extracts specifications for one or more pads; and generation means that references hardware information of a target controller and generates executable code including code corresponding to the extracted specifications for the 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 of one or more pads may include identification information for specifying the pad to be used from among the one or more pads.

[0012] The generating means may generate the execution code using code specific to the target controller, instead of a library module that is 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, executable 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 specifications for one or more pads, and referencing hardware information of the target controller to generate executable code including code corresponding to the extracted specifications for the pads. [Effects of the Invention]

[0014] According to the present disclosure, software can be shared between controllers that use semiconductor devices with different specifications. [Brief explanation 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. [Figure 2] FIG. 1 is a schematic diagram illustrating an example of a hardware configuration of a software development apparatus according to an embodiment of the present invention. [Figure 3] FIG. 2 is a schematic diagram illustrating 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. [Figure 5] FIG. 10 is a diagram for explaining pads provided by a controller connected to the software development apparatus according to the present embodiment. [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]FIG. 2 is a diagram showing an example of source code that can be input to the software development device according to the present embodiment. [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] 3 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] 10A to 10C are diagrams for explaining application examples of pads provided by the 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 INVENTION

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

[0017] In the following description, as a typical example, software development device 10 according to this embodiment 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] 1 is a schematic diagram showing an example of the overall configuration of an IoT system 1 according to the present embodiment. Referring 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 apparatus 100. The generated program is transferred from the software development apparatus 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 bodies 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). When the execution code is executed by 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, an example of a hardware configuration of a device included in 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] 2 is a schematic diagram showing an example of a hardware configuration of software development device 100 according to this embodiment. Referring to Fig. 2, software development device 100 includes, as main components, processor 102, main memory 104, input unit 106, display 108, hard disk 110, and communication interface 122. These components are connected via internal bus 120.

[0028] The processor 102 is configured by, for example, a CPU (Central Processing Unit) or a GPU (Graphics Processing Unit). 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 DRAM (Dynamic Random Access Memory) or an SRAM (Static Random Access Memory). 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 also be used. A designated program from among the programs stored on the hard disk 110 is loaded onto the main memory 104, and the processor 102 sequentially executes computer-readable instructions contained in the program loaded onto the main memory 104, thereby realizing various functions as will be described later.

[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 processing results of 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 exchanging data 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 IEEE 1394, or a legacy parallel port. Alternatively, the communication interface 122 may include an Ethernet (registered trademark) port.

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

[0035] Software development device 100 may further include a component for reading a software development program 114 containing computer-readable instructions from non-transitory media that stores the program. The media may be, for example, optical media such as a DVD (Digital Versatile Disc), semiconductor media 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 containing the necessary components to perform the processing.

[0038] 3 is a schematic diagram showing an example of a hardware configuration of controller 200 according to the present embodiment. Referring to Fig. 3, 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 programs, and includes, as its main components, a processor 202, a main memory 204, and a flash memory 206. The processor 202 is configured, for example, by a CPU or a GPU. Multiple processors 202 may be provided, or a processor 202 having multiple cores may be employed. The main memory 204 is configured by 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, thereby realizing 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 devices, routers, mobile base stations, etc. Wireless communication supported by the wireless communication module 212 includes, for example, 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 can be either a 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 an electrical signal according to a command from the arithmetic processing unit 210. Also, the microcontroller 218 detects an electrical signal given via the pad 220 and outputs the detection result 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 an exposed conductor and corresponds to a 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 that the software development apparatus 100 according to the present embodiment tries to solve 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 adopted, respectively.

[0046] As shown in FIG. 4, even if the microcontrollers 218 provide substantially the same functions, the specifications of the microcontrollers 218 themselves (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] 5 is a diagram illustrating 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 an example of a configuration using the microcomputer 218A shown in FIG. 4(A). In this example of a configuration, the pads 220 numbered "1" to "6" are electrically connected to the pins numbered "5," "6," "7," "14," "13," and "12," respectively. FIG. 5(B) shows an example of a configuration using the microcomputer 218B shown in FIG. 4(B). In this example of a configuration, 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 microcomputer 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 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 define processing when signals indicating a predetermined message are output through pads 220 numbered "5" and "6".

[0054] 7A includes a definition 1121 of a variable indicating a message and a definition 1122 of variables indicating output ports (OutPort1 and OutPort2). 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 (instruction 1124A). The instruction 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, when command 1125 is executed, signals indicating messages are sent 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 this embodiment is designed to allow direct specification of pads 220 that are 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 the present embodiment. Similar to source codes 112A and 112B shown in Fig. 7, source code 112 shown in Fig. 8 specifies processing for outputting signals indicating a predetermined message through pads 220 numbered "5" and "6."

[0062] 8 includes definitions 1121 of variables indicating messages and definitions 1126 of variables indicating pads to be used (ActivePad1 and ActivePad2). Definition 1126 corresponds to a specification for pad 220 of controller 200, and includes identification information (in this example, the pad number) for specifying the pad to be used from 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 to be used to send the signal indicating the message is set (instruction 1127). 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 instruction 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 identifies the pads actually connected to the device. By being able to identify 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 an advantage is obtained. 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, no changes or modifications to the source code will occur.

[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 a software development program 114.

[0070] Referring to FIG. 9, the software development program 114 receives an input of the source code 112 and generates an 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 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 executable code 116 based on the results of optimization by the optimizer 1143.

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

[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 specifying 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 depending on the type of controller 200 on which the execution code 116 is executed, and determines, by referencing the contents of the selected configuration 118, routing information and the like required to use the pads 220 specified in the source code 112. In other words, the configuration 118 includes setting information for accommodating differences in the hardware that constitutes the controller 200.

[0076] The type of controller 200 may be selected manually by the user, or may be acquired automatically 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 needed. That's fine.

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

[0078] 10A and 10B are diagrams illustrating the data structure of execution code 116 generated by software development device 100 according to this embodiment. Referring to FIG. 10A, execution code 116A is made up of one or more object codes (object codes 1161 and 1162 in the example of FIG. 10A) and a necessary library module 1163. Library module 1163 is a part of the object code referenced by object codes 1161 and 1162. Typically, library module 1163 receives necessary data from object code 1161 or 1162, executes processing, and returns the results 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. In other words, object codes 1164 and 1166 include unique codes 1165 and 1167 for executing processing unique to the target controller 200.

[0080] Thus, the generated instructions (object code) adapted to 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 the code specific to the target controller 200 instead of the library module 1163 commonly used among the 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] <Application Example of E-Pad> Next, an application example 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 of the pads 220 and the functions provided, 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 performs lexical analysis and syntax analysis on the input source code 112 (step S100). The software development apparatus 100 determines whether any of the pads 220 are specified based on the analysis result (step S102). That is, the software development apparatus 100 analyzes the source code 112 to extract the specifications 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 for using the specified pad 220 by referring 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 by referring to the hardware information (as an example, the configuration 118) of the target controller 200.

[0094] <G. Modified 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 more 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 define in the source code 112 the interface to be used among the physical interfaces provided by the controller 200, and to provide a mechanism that can absorb differences in the hardware configuration of the controller 200. As a result, from the perspective 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 in all respects and not restrictive. The scope of the present invention is defined by the claims, not by 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 specific code.

Claims

1. A software development device for generating controller executable code from source code, Extraction means for extracting identification information from the source code to specify a particular pad among a plurality of pads electrically connected to the controller, The system comprises a generation means for generating the executable code according to the extracted pads, The generating means is A means for identifying the controller pin corresponding to the pad indicated by the extracted identification information, based on hardware information corresponding to the type of controller, A software development apparatus comprising means for including code in the executable code for performing specific processing according to the type of controller.

2. The software development apparatus according to claim 1, wherein the code for performing the aforementioned specific processing includes object code generated to be adapted to the controller.

3. The software development apparatus according to claim 1, wherein the identification information includes the pad number for specifying the particular pad, as described in the source code.

4. The software development apparatus according to any one of claims 1 to 3, further comprising an acquisition means for automatically acquiring the type of the controller by connecting to the controller.

5. The software development apparatus according to any one of claims 1 to 3, wherein the hardware information includes information for identifying the connection relationship between the pins and pads of the semiconductor device of the controller.

6. The software development apparatus according to claim 5, wherein the generation means associates a designated pad with a pin corresponding to a logic port based on the connection relationship between the pins and pads of the semiconductor device.

7. A method for generating controller executable code from source code, which is executed by a computer. The steps include: extracting identification information from the source code to specify a particular pad among a plurality of pads electrically connected to the controller; The step of generating the executable code according to the extracted pads, The above generation step is, A step of identifying the controller pin corresponding to the pad indicated by the extracted identification information based on hardware information corresponding to the type of controller, A processing method comprising the step of including in the executable code code for performing processing specific to the type of controller.

Images