JP2019114223A - Method and computing system for automatically generating built-in software on virtualized system - Google Patents

Abstract

To shorten build time of built-in software by reducing a degree of dependence on a size and performance of a resource.SOLUTION: The method includes: providing a tool for a user interface for enabling a user to edit a source code on a cloud development environment connectable via the Web; executing simulation to a source code edited by using the tool for the user interface on a first virtual system; feeding back a simulation result for the source code to the user by using the tool for the user interface; providing prebuild software generated in advance on the basis of an operating system for operating built-in software on a target board on a second virtual system; and connecting the source code with the prebuild software generated in advance for the target board to generate a binary output executable on the target board on the second virtual system.SELECTED DRAWING: Figure 5

Description

  The present invention relates to embedded software and embedded systems, and more particularly, a workflow capable of automatically generating embedded software (software executed on the embedded system) on a virtualized system and the workflow executed and embedded It relates to a computing system that automatically generates software.

  An embedded system means a device that incorporates a microprocessor or microcontroller to perform only the functions specified by the original producer, and generally with hardware to perform special tasks as part of a larger system. A particular application system that includes software.

  Such embedded systems are used in various application fields such as factory automation, home automation, robot control, control field including process control, mobile phone, PDA, smart phone, terminal field including LBS etc, printer, Internet refrigerator, game machine It is applied to various fields such as home information appliances field including HDTV, etc., network field including exchanges, routers, home servers, home gateways etc., automotive ECUs, car navigation, control of operations such as vehicle parts etc. It is done.

  As described above, embedded systems are becoming more sophisticated in hardware specifications as advanced technology develops.

  Meanwhile, to ensure market competitiveness, embedded system products must be manufactured to reflect the user's requirements, and must be released within a short period of time, so for rapid development of products. , Embedded system developers use design and test tools.

  However, such tools could not keep up with the development speed of hardware parts. In order to compensate for such speed differences, simulation tools of the target system are used. Target platform simulation, a virtual platform, will allow embedded software developers to analyze and try out their software on the virtual platform without having to wait for development of real hardware to complete. Such conventional simulation systems include SimOS, SkyEye, QEMU, and SID.

  On the other hand, the process of developing such conventional embedded systems and embedded software executed by the embedded systems can be performed on a computing system in which a virtual development environment is established as shown in FIG. Another prior art embedded software development process simulates Tool-chain, which is a collection of tools for software development, on a target board (S230), as shown in FIG. S210) A process (S220) of building with source code executable on the target board is included. However, the process of building such source code (S220) has to be executed anew every time the Tool-chain is changed (S210) or every target board, and the output of the build generated in this process Since the size of the data is enormous and the process of building source code takes a long time, there is a problem that it is difficult to take quick measures at the time of debugging or correction.

Republic of Korea Patent No. 10-2011-0037140 "System for Providing Embedded Software Virtual Development Environment" (Apr. 13, 2011)

  In order to build a development environment tool chain (Tool-chain) in the conventional development environment, there is a problem that the developer must secure the know-how for construction by himself, and embedded software (binary image) for each target board It took an average of several hours to build to generate.

  Also, in the conventional development environment, hard disk capacity of several tens of gigabytes or more was required to generate embedded software for each target board.

  In the conventional development environment, when developing embedded software by team work, time and physical resources are required for build file sharing among team members. It was necessary to build a development environment for each team member's computing system, and it was necessary to share a build file for each target board. The process of sharing the build file, i.e., copying only required a lot of time and space. Even if you share the build file, there is a possibility that it does not work properly depending on the environment of each computing system. That is, time was spent debugging due to an unintended error.

  The present invention has been made to solve the above-mentioned problems of the prior art, and in the development process, reduces the dependence on the size and performance of the developer's computing system resources (hard disk and memory), and targets The goal is to significantly reduce the build time of embedded software, which is the final output per board.

  Another object of the present invention is to provide a cloud-based integrated development environment, and to provide a development system implemented so as to be able to develop with a user interface through the web such as a browser.

  Also, the present invention provides a cloud system that can generate binary images that are outputs per target board, store them in a cloud-based integrated development environment, and allow developers to download binary images as needed. For further purposes.

  The present invention has been made to achieve the above object, and a computing system for automatically generating embedded software on a virtualized system according to an embodiment of the present invention includes at least one or more processors. The at least one processor provides a tool for user interface that allows a user to edit source code individually or collectively, and uses the tool for user interface on a first virtual system. Based on an operating system for executing a simulation on the edited source code, feeding back the simulation result for the source code to the user using the user interface tool, and operating the embedded software on the target board Providing pre-generated pre-built software on a second virtual system, combining the source code with the pre-generated software previously generated for the target board, and executing on the target board DOO produces a binary result was possible.

  Here, the first virtual system may mean a virtual machine, a virtualized system, a virtual system, or virtualization software that is implemented to allow a user to simulate source code. For example, it can take the form of a QEMU IDE container.

  The second virtual system may mean a virtual machine, a virtualized system, a virtual system or virtualization software implemented to generate pre-built software for each target board.

  The embedded software means the output of the final binary file to be executed on the target board, and the embedded system can be implemented by executing the embedded software on the target board.

  The processor of the computing system of the present invention can execute the first virtual system and the second virtual system on the same host operating system hierarchy.

  The processor of the computing system according to the present invention shares the development environment information used (utilized) in the process of generating the pre-built software on the second virtual system in the simulation process executed on the first virtual system. be able to.

  The processor of the computing system according to the present invention generates, on the second virtual system, the pre-built software on usage information (usage information) for the source code obtained in the simulation process for the source code on the first virtual system. Can be shared in the process of

  The processor of the computing system of the present invention can provide the user interface tool so that the user can edit the source code on a cloud development environment connectable via the web.

  The processor of the computing system of the present invention may generate a file system for the source code and store the file system for the source code on the cloud development environment.

  The processor of the computing system of the present invention may create a file system for the binary result and store the file system for the binary output on the cloud development environment.

  A method of automatically generating embedded software on a virtualized system according to an embodiment of the present invention is a user interface that allows a user to edit source code on a cloud development environment connectable via the web. Providing a tool for performing simulation on the source code edited using the tool for user interface on a first virtual system, and using the tool for user interface for simulation result of the source code Providing feedback to the user; providing pre-built software generated on the basis of an operating system for operating embedded software on a target board on a second virtual system; and The binary outputs that can be executed in advance the target board combine with the pre-built software generated for Tobodo comprising generating on the second virtual system. The method for automatically generating embedded software on a virtualized system according to the present invention is cloud computing, which is a collection of the at least one processor of the computing system alone or a collection of the at least one processor. It can be implemented by techniques.

  According to the present invention, the development process reduces the dependency on the developer's computing system resources (hard disk and memory) and performance, and the build time of embedded software is the final output per target board It can be greatly reduced.

  According to the present invention, a cloud-based integrated development environment can be provided, and a development system implemented so as to be able to be developed with a web-based user interface such as a browser can be provided.

According to the present invention, there is provided a cloud system capable of generating a binary image which is output per target board, storing it in a cloud-based integrated development environment, and allowing a developer to download the binary image when necessary. be able to.

It is a figure which shows the outline | summary of the embedded software development system of a prior art. It is a figure which shows the outline | summary of the embedded software development system of a prior art. FIG. 2 illustrates a cloud service system or cloud computing system that automatically generates embedded software on a virtualized system according to an embodiment of the present invention. FIG. 8 is a diagram showing the overall software development process using a cloud service system or cloud computing system that automatically generates embedded software on a virtualized system according to an embodiment of the present invention. FIG. 6 is an operational flowchart illustrating a method of automatically generating embedded software on a virtualized system according to an embodiment of the present invention. FIG. 6 is an operational flowchart illustrating a method of automatically generating embedded software on a virtualized system according to an embodiment of the present invention.

  The above object, and other objects and features of the present invention will be apparent from the description of the embodiments based on the attached drawings.

  Preferred embodiments of the present invention will be described in detail with reference to the attached drawings. In the description of the present invention, when it is determined that the detailed description of the related known configurations or functions may obscure the gist of the present invention, the detailed description will be omitted.

  The commonly used "source code" refers to the code set prior to the compilation process to generate the final output binary output, from pseudo-code to program code immediately before compilation. It means a very wide range. The "source code" referred to herein is not restricted to any particular meaning, and goes beyond just meaning pre-compilation program code, in particular if it contains only checkpoints for target functions and specifications, ie developers It will be used as a concept that includes the case of code close to the "source" to generate the final output in the context of

  The cloud service systems of FIG. 3 and FIG. 4 described below may include at least one or more server computing systems. At least one or more server computing systems may each include at least one or more processors, and the at least one or more processors alone or collectively may be features of the first virtual system and the second virtual system. A system can be created, and user interface tools, pre-built software, and embedded software can be created and provided.

  Here, the first virtual system can mean a virtual machine, a virtualized system, a virtual system, or virtualization software that is implemented so that the user can simulate source code, for example, QEMU IDE It can take the form of a container. The first virtual system may be a cloud service system or a simulator executed in a cloud computing system, and the simulator means software for virtualizing a target board capable of simulating operation on the target board in advance. .

  The second virtual system may mean a virtual machine, a virtualized system, a virtual system or virtualization software implemented to generate pre-built software for each target board.

  The embedded software means the output of the final binary file to be executed on the target board, and the embedded system can be implemented by executing the embedded software on the target board.

  FIG. 3 is a diagram illustrating a cloud service system or cloud computing system for automatically generating embedded software on a virtualized system according to an embodiment of the present invention.

  The system 300 of FIG. 3 can be understood as a cloud service system or cloud computing system. System 300 includes at least one processor (not shown). At least one or more processors may be responsible for performing the following operations within the system 300 alone or collectively.

  The system 300 provides a user interface tool 340 so that the user can edit source code, and for the source code edited using the user interface tool 340 on the first virtual system 331 A simulation can be performed and the simulation results for the source code can be fed back to the user using the user interface tool.

  The system 300 provides on the second virtual system 332 the first pre-built software generated in advance based on the operating system for operating the embedded software on the first target board, and operates the embedded software on the second target board The second pre-built software generated in advance based on the operating system of the third virtual system 333 may be provided on the third virtual system 333.

  The system 300 may combine the source code with the first pre-built software generated in advance for the first target board to generate a first binary output for the second virtual system, which may be executed on the first target board. A second binary output that can be generated on 332 and can be executed on the second target board by combining the source code with the second pre-built software generated beforehand for the second target board Can be generated on the third virtual system 333.

  The user can develop source code and develop an application using the user interface tool 340 (S311). To this end, the system 300 can implement the user interface tool 340 as another virtual system and provide it to the user. The user interface tool 340 is displayed on the user's computing system and provided to the user, and the operation and information processing performed by the user interface tool 340 are executed by the system 300. Of course, depending on the embodiment, the user can use the system 300 directly to develop an application (S311). In this case, the user's computing system immediately matches system 300.

  According to the user's transmission command input through the user interface tool 340, the system 300 is pre-built for the target board with the application (source code) developed by the user using the user interface tool 340. It can be transmitted and shared to virtual systems 332, 333 that can provide pre-built software (S313).

  The second virtual system 332 generates a final output of the first embedded software for the first target board (S 314), and generates a first binary output (first binary image) which is a final output of the first embedded software. It can be transmitted to the second file system 342 in 300 (S315). Similarly, the third virtual system 333 generates the final output of the second embedded software for the second target board (S 314), and the second binary output (second binary image) which is the final output of the second embedded software. Can be transmitted to the second file system 342 in the system 300 (S315). The second file system 342 may store the first binary output and / or the second binary output, which is the final output of embedded software corresponding to a plurality of target boards.

  Meanwhile, the first file system 341 on the system 300 may store source code applications (App1, App2,..., ApppN) for application development built in the user interface tool 340. Here, although not shown in FIG. 3, before the source code developed by the user interface tool 340 is transmitted to the second virtual system 332 and the third virtual system 333, the second virtual system 332 and the third virtual system 333 may be The first and second pre-build softwares may be pre-built in each of the three virtual systems 333. Here, the pre-built software may mean information in the form of pseudo binary image generated in advance including information such as an operating system associated with the target board, except for an application operating on the target board.

  Here, since it is sufficient for the first pre-built software to be pre-built before combining with the source code on the second virtual system 332, the pre-building process of the first pre-built software is a tool 340 for the user interface of the user. While developing an application using (S311), it may be executed in parallel in the background, or may be executed before a user develops an application.

  According to the present invention, for example, since the first pre-build software for the first target board and the second pre-build software for the second target board have already been generated, the user can select the first target board and the second target board. Assuming that it takes several seconds to several minutes to develop an application commonly applied to the target board (S311), the application source code is firstly generated in each of the second virtual system 332 and the third virtual system 333. The time taken to finally obtain the first binary output and the second binary output by compiling in combination with each of the pre-build software and the second pre-build software is a few seconds to several minutes for compilation. Is sufficient. After that, even when modifying the application by modifying the target function to be executed on each target board, the time taken for development of the application and the compilation time of the final result are satisfied only to meet the modified target function. Final output can be obtained.

  In the past, it took an average of several hours to build the final output for each of the target boards after modifying the target function every time the target function was modified. According to the invention, even when an application is developed and applied simultaneously to a large number of target boards, the development time of embedded software can be dramatically reduced. Also, according to the present invention, since each generation process of embedded software for each of a large number of target boards can be performed in parallel, a developer can make a target board the final output derived in his application development process. It is possible to check quickly and have the effect of enabling significant reduction in debugging time and overall development process.

  The system 300 may provide the user interface tool 340 so that the user can edit the source code on a cloud development environment connectable via a web.

  The system 300 may generate a first file system 341 for source code and store the first file system 341 for source code on the cloud development environment.

  The system 300 may generate a second file system 342 for binary output, and store the second file system 342 for binary output on the cloud development environment.

  Although two virtual systems 332, 333 for generating pre-built software are shown in FIG. 3, the virtual systems for generating pre-built software can be provided for each target board, so the number of virtual systems is the target It can vary depending on the number of boards. The concept of the present invention should not be interpreted in a limited manner by the embodiment of FIG.

  The first file system 341 and the second file system 342 in the system 300 may mean the file system of the host. All containers (virtual systems) can share the same file system space, or can be separated into other spaces to transmit source code and output. In FIG. 3, a first file system 341 for storing source code for application development and a second file system 342 for storing final binary output (binary image) are shown to be separated and generated on a virtual system. The binary output is shown as being transmitted to the second file system 342. Such a transmission is not only a transmission on a logically set virtual system but also on a similar logically set file system, which necessarily involves transmitting and receiving information physically. It will be clearly understood by those skilled in the art that there is not.

  The first virtual system 331 in the system 300 works in conjunction with the user interface tool 340 to perform simulation of source code required in the development process of the user. The first virtual system 331 may be a user application container or a container in which a user interface tool 340 is executed. Here, the first virtual system 331 and the second virtual system 332 are executed on the same host operating system 360 hierarchy. Similarly, the first virtual system 331 and the third virtual system 333 are also executed on the same host operating system 360 hierarchy. Host operating system 360 may create container engine 350 to create and manage multiple virtual systems, and create and manage multiple virtual systems on container engine 350.

  Because the development environment provided by the first virtual system 331 and the second virtual system 332 (a container where pre-built software is provided and pre-build and source code are combined) are executed on the same host operating system 360, the first virtual system 331 Since the development environment provided by the system 331 and the second virtual system 332 is shared in a substantial part, even if the user modifies the source code, the second virtual system 332 compiles immediately without the prebuilt software and code set modification be able to.

  The system 300 may share the development environment information utilized in the process of generating the first pre-built software on the second virtual system 332 in the simulation process executed on the first virtual system 331.

  Since information used (utilized) in the process of generating the first pre-built software on the second virtual system 332 is used and / or shared as it is in the simulation process on the first virtual system 331, the source that has undergone the simulation process The process of combining the code and the first pre-built software is easy, and the final first binary output (the first embedded software) is generated only by a simple compilation process when combining the source code and the first pre-built software be able to.

  Thus, the present invention can reduce the time required to develop and generate embedded software as compared to the prior art. The reason why it took a long time to build the source code into the final binary file for execution on the target board in the prior art is the tool chain (the description that describes the customized function and target specification etc.) and the target board each time The source code itself had to be newly built by combining environment information, operating system information, and so on. On the other hand, toolchain may mean a collection of development tools and software for building an image for a target board. The present invention is provided as a form named pre-built software by pre-building a development environment applied to a target board and a code set including main information on an operating system, and is used when generating pre-built software. Use information about the development environment and operating system on source code simulation. The source code simulation can be performed and verified quickly because it is a logic-based simulation with no dependency on the target board in the process of checking whether the function of the source code meets the target specification of the user. That is, since information used in the process of pre-building / generating pre-built software can be checked and viewed in advance when simulating with the first virtual system 331 (user application container) on the same operating system, the source code Easy to combine with pre-built software. In addition, since the burden factor during source code simulation is selectively eliminated, it is possible to prevent the source code simulation time / cost from being increased by the verification of the compatibility with the target board.

  Thus, if the source code that has undergone simulation and feedback verification is combined with the pre-build software, binary output (embedded software) can be obtained through a simple compilation process.

  The system 300 may share utilization information about the source code obtained in the simulation process for the source code on the first virtual system 331 in the process of generating the first pre-built software on the second virtual system 332. .

  When providing a development environment linked to a cloud service system, if the file system of pre-built software in the cloud system (which can be implemented, for example, in the form of a binary image) and the file system of binary output are changed It can be updated so it can be shared across. At this time, inconsistencies between file systems distributed and stored in the cloud system are checked, and all file systems for the same software content can be synchronized.

  The content of the pre-built software can be updated separately from the synchronization of all file systems to the same software content. In general, even if upper layer application software and source code change, pre-built software having a similar role to the appliance does not necessarily have to be re-built. The pre-built software of the present invention requires that the source code be easily combined with the source code to generate embedded software despite variations in the source code. Meanwhile, in some embodiments, the pre-built software may be updated or pre-built again based on the target board and the operating system to be executed on the target board. At this time, the pre-built software can efficiently source code based on information about the relationship between the source code and the target board, usage information of the source code on the target board, main functions of the source code used on the target board, etc. It can be pre-generated or pre-updated to be able to combine with.

  Here, utilization information about source code obtained in the simulation process for source code on the first virtual system 331 is shared in the process of generating the pre-build software on the second virtual system 332, When the virtual system 332 generates the next version of pre-built software, pre-built software can be generated that can more closely match the user's goal function. Such sharing is also possible because the first virtual system 331 and the second virtual system 332 run on the same host operating system. Information used by the user to simulate and verify the source code in the first virtual system 331, that is, utilization information such as a request for an objective function, a verification pattern of the source code, and an objective of utilizing the source code Can be used to improve pre-built software.

  The above mainly describes the process of generating the first embedded software for the first target board, but the process is common to the process of generating the second embedded software for another target board, for example, the second target board. Is applicable. That is, since the first virtual system 331 and the third virtual system 333 are executed on the same host operating system 360, information sharing is possible in the development process of the first virtual system 331 and the third virtual system 333. The pre-build process of the pre-build software and the application simulation process of the source code for the second target board can be improved.

  FIG. 4 is a diagram showing the overall software development process using a cloud service system or cloud computing system that automatically generates embedded software on a virtualized system according to an embodiment of the present invention.

  The system 400 of FIG. 4 may be a cloud service system or cloud computing system similar to the system 300 of FIG. 3 and may include at least one or more processors. The following system 400 operations may be performed by single or collective operations of at least one or more processors in system 400.

  The redundant description of the components common to FIGS. 3 and 4 will be omitted. For example, the first file system 441 and the second file system 442 of FIG. 4 are the same as the first file system 341 and the second file system 342 of FIG. 3, and the user interface tool 440 of FIG. It is identical to the user interface tool 340. The first virtual system 431, the second virtual system 432, the third virtual system 433, the container engine 450, and the host operating system 460 in FIG. 4 are the first virtual system 331, the second virtual system 332, and the third virtual system 333 in FIG. 3. , Container engine 350 and host operating system 360.

  The user can connect to the system 400 via the web browser (S410). At this time, it is the first virtual system 431 that actually provides the user with a simulation environment. The first virtual system 431 may be implemented, for example, in the form of an IDE container. Here, information sharing and environment sharing with the second virtual system 432 not provided by the conventional IDE container, which can only take the form of an IDE container for the implementation of the first virtual system 431, are unique features of the present invention Those skilled in the art will clearly understand that.

  Also, a simulator supported by the first virtual system 431 of FIG. 4 may be provided as a form of a known QEMU simulator. However, the QEMU simulator is a component for the interface with the user and the basic setting for the simulation, and is a unique feature that the first virtual system 431 of the present invention has, which is included as a part of the configuration of the present invention, For example, to the person skilled in the art, the performance improvement of the pre-built software and the improvement of the simulation process of the source code by information sharing and environment sharing with the second virtual system 432 are not features that can be achieved using only known QEMU simulators. Clearly understandable.

  Also, the QEMU simulator can be provided utilizing an IDE container. The QEMU simulator does not necessarily have to be included together with the IDE container, and it is also clearly understood by those skilled in the art that the QEMU simulator and the IDE container can be implemented in logically separated states. I will. The spirit of the present invention should not be understood in a limited manner by such embodiments.

  After the connection (S410), the user can develop source code and develop an application using the user interface tool 440 (S411). At this time, the system 400 generates the tool for user interface 440 and the first virtual system 431 and provides it to the user to support the application development process (S411) of the user.

  The system 400 can transmit (share) the developed application (source code) to containers 432 and 433 that can provide pre-built software pre-built for the target board (S413a, S413b). That is, the same source code may be transmitted to the second virtual system 432 for the first target board (S413a), and may be transmitted to the third virtual system 433 for the second target board (S413b). It will be apparent to those skilled in the art that if the first target board is a product of company A and the second target board is a product of company B, the binary output can be changed depending on the operating system of the target board even if the same source code is used. It will be understandable.

  The system 400 may generate a first binary output for the first target board on the second virtual system 432, and transmit the first binary output to the second file system 442 (S415a). Similarly, the system 400 may generate a second binary output for the second target board on the third virtual system 433 and transmit the second binary output to the second file system 442 (S 415 b).

  The user can finally download the completed binary outputs and execute them on the respective target boards (S416a, S416b). At this time, the system 400 may transmit the first binary output so that it can be executed on the first target board (S 416 a), and the second binary output may be executed on the second target board (S416b). Although steps S416a and S416b are represented by the term "transmission" in FIG. 4, this is merely an example, and the concept of the present invention should not be understood as limited thereto. In FIG. 4, items to be illustrated in steps S416a and S416b are expressed reflecting a part of the following technical idea. When the operation of the present invention is performed in a cloud or stand-alone system, the binary output must be downloaded via the computing system that the user connected (S410), and the user connected for the execution (S410) A process of image writing on the target board through the computing system or through another recording medium (eg, USB memory, portable hard disk, SSD drive, etc.) is required.

  According to the present invention, since the time required to build the final output of the embedded software for execution on each of the target boards can be reduced, the user can use the tool 440 for the user interface and the first virtual system. The simulator in the 431 allows you to try out various toolchains, so you can build them easily.

  According to the present invention, when using a cloud development environment, a user can conveniently develop an application without unnecessarily using the resources of the user's computing system.

  According to the present invention, even when a user develops embedded software by teamwork, time and resources can be saved by link sharing which is not file replication in the process of sharing build files among team members with each other.

  According to the present invention, when many team members proceed with development within the same cloud development environment, since all team members have the same configuration of development environment, all the build files of other team members are mutually Can be simulated by the simulator and can be executed in the environment between each other. In addition, since the result of simulation and execution by the team member A and the result of simulation and execution by the team member B are the same, the probability of error occurrence can be reduced and debugging time and resources can be saved.

  FIG. 5 is an operation flowchart illustrating a method of automatically generating embedded software on a virtualized system according to an embodiment of the present invention. The method of FIG. 5 may be performed alone or collectively by at least one or more processors in systems 300,400.

  The system 300, 400 provides user interface tools 340, 440 that allow the user to edit source code on a cloud development environment connectable via the web (S510).

  The system 300 400 executes a simulation on the source code edited using the user interface tool 340 440 on the first virtual system 331 431 (S520), and the system 300 400 operates on the source code The simulation result is fed back to the user using the user interface tools 340 and 440 (S530).

  The system 300, 400 may provide pre-built software generated in advance based on an operating system for operating embedded software on the target board on the second virtual system 332, 432 or the third virtual system 333, 433 (see FIG. S540).

  The system 300 400 can combine the source code with the pre-built software generated in advance for the target board to execute a binary pre-build on the second board 332, 432 or a third virtual system 333, 433 can be generated (S550).

  FIG. 6 is an operation flowchart illustrating a method of automatically generating embedded software on a virtualized system according to an embodiment of the present invention. The method of FIG. 6 may be performed alone or collectively by at least one or more processors in the systems 300,400.

  Of the steps shown in FIG. 6, steps S610, S620, S630, S640, and S650 are similar to the steps shown in FIG. 5 (S510, S520, S530, S540, and S550). The description is omitted.

  The system 300, 400 may generate pre-built software for the target board on the second virtual system 332, 432 or the third virtual system 333, 433 (S612). At this time, before the source code developed by the user interface tools 340 and 440 is transmitted to the second virtual systems 332 and 432 and the third virtual systems 333 and 433, the second virtual systems 332 and 432 and the third virtual systems 332 and 432 may be used. The first pre-build software and the second pre-build software may be pre-built in each of the systems 333, 433. At this time, as described above, the pre-built software may mean information in the form of pseudo binary image generated in advance including information such as an operating system associated with the target board, except for an application operating on the target board. .

  In operation S610, the user interface tools 340 and 440 are provided to allow the user to edit the source code on a cloud development environment connectable by the system 300 and 400 via the web. Can also be implemented.

  The system 300 400 may generate a first file system 341 441 for source code, and may store the first file system 341 441 for the source code on the cloud development environment (S 660).

  The system 300, 400 generates a second file system 342, 442 for at least one or more binary output, and stores the second file system 342, 442 for the at least one or more binary output on the cloud development environment. (S670).

  FIG. 6 shows that step (S660) is performed after step (S650) of generating binary output for each source code. Here, the source code is stored in the form of the first file system 341 or 441 when the user's development sequence has progressed to some extent and the final output is obtained. At this time, steps S660 and S670 may be performed substantially simultaneously or sequentially.

  According to another embodiment of the present invention not shown in FIG. 6, the storage of the first file system 341, 441 for the source code fed back the simulation execution (S620) for the source code and the simulation result to the user ( S630) can be performed immediately after. That is, backup may be performed on the source code at each intermediate settlement of the simulation process and at each examination time.

  Although the technique for automatically generating embedded software on the virtualized system of the present invention has been described on the premise that it is implemented on the cloud service system 300, 400, the idea of the present invention is not limited to this. In some embodiments, a stand-alone computing system and a system virtualized by the processor may be implemented to generate pre-built software and embedded software.

  A method of automatically generating embedded software according to an embodiment of the present invention may be implemented in the form of program instructions executable through various computer means and recorded on a computer readable medium. The computer readable medium may include program instructions, data files, data structures, etc. alone or in combination. The program instructions recorded on the medium may be specifically designed and configured for the present invention or may be known to and used by computer software skilled in the art. Examples of computer readable recording media include magnetic media such as hard disks, floppy disks and magnetic tapes, optical media such as CD-ROMs, DVDs, and floppy disks. Hardware specially configured to be able to store and execute program instructions such as magneto-optical media, and read only memory (ROM), RAM, flash memory, etc. Includes the device. Examples of program instructions include not only machine language code such as that produced by a compiler, but also high-level language code that can be executed by a computer via an interpreter or the like. Such hardware devices may be configured to operate as one or more software modules to perform the operations of the present invention, and vice versa.

  However, the present invention is not limited or limited by the examples. The same reference numerals as shown in the figures indicate the same parts. The lengths, heights, sizes, widths, etc. illustrated in the embodiments of the present invention and the drawings may be exaggerated for better understanding.

  As described above, the present invention has been described based on specific items such as specific components and the like and specific examples and drawings, which are provided to deepen the overall understanding of the present invention. The present invention is not limited to the above-described embodiment, and various modifications and variations can be made from such description by those skilled in the art to which the present invention belongs.

  Therefore, the spirit of the present invention should not be limited to the above-described embodiments, and all modifications that are equivalent to or equivalent to the claims and not the claims described below belong to the scope of the present invention. It can be said.

300, 400 Cloud service system or Cloud computing system 331, 431 First virtual system 332, 432 Second virtual system 333, 433 Third virtual system 340, 440 Tool for user interface 341, 441 First file system 342, 442 Second file system 350, 450 Container engine 360, 460 host operating system

Claims (14)

Providing a user interface tool that allows the user to edit the source code;
Performing simulation on the source code edited using the user interface tool on the first virtual system, and feeding back the simulation result on the source code to the user using the user interface tool ;
Providing on the second virtual system pre-generated pre-built software based on an operating system for operating embedded software on the target board; and said pre-built software previously generating the source code for the target board Generating a binary output that can be executed on said target board in combination with
How to automatically generate embedded software on a virtualized system, including:   The method of automatically generating embedded software on a virtualized system according to claim 1, wherein the first virtual system and the second virtual system are executed on the same host operating system hierarchy.   3. The virtualized system according to claim 2, wherein development environment information utilized in the process of generating the pre-built software on the second virtual system is shared in a simulation process executed on the first virtual system. How to automatically generate embedded software on a system.   The utilization information for the source code obtained in the simulation process for the source code on the first virtual system may be shared in the process of generating the pre-built software on the second virtual system. How to automatically generate embedded software on a virtualized system. Providing the user interface tool may include
The virtualized system according to claim 1, wherein the user interface tool is provided so that the user can edit the source code on a cloud development environment connectable via the web. How to automatically generate embedded software.   The embedded software is automatically generated on the virtualized system according to claim 5, further comprising the steps of: generating a file system for the source code; and storing the file system for the source code on the cloud development environment. Method.   The embedded software may be automatically generated on the virtualized system according to claim 5, further comprising: generating a file system for the binary output; and storing the file system for the binary output on the cloud development environment. How to generate. A computing system including a processor,
The processor is
Provide a tool for user interface that allows the user to edit source code,
A simulation is performed on the source code edited using the user interface tool on the first virtual system, and the simulation result for the source code is fed back to the user using the user interface tool.
Providing pre-built software generated in advance on the second virtual system based on the operating system for operating the embedded software on the target board,
Automatically generate embedded software on a virtualized system that combines the source code with the pre-built software previously generated for the target board to generate binary output that can be executed on the target board Computing system.   The computing system for automatically generating embedded software on a virtualized system according to claim 8, wherein the processor executes the first virtual system and the second virtual system on the same host operating system hierarchy.   10. The virtualization according to claim 9, wherein the processor shares development environment information utilized in the process of generating the pre-built software on the second virtual system in a simulation process executed on the first virtual system. Computing system that automatically generates embedded software on a distributed system.   10. The method according to claim 9, wherein the processor shares utilization information for the source code obtained in the simulation process for the source code on the first virtual system in a process of generating the pre-built software on the second virtual system. A computing system that automatically generates embedded software on the described virtualized system.   The virtualized server according to claim 8, wherein the processor provides the user interface tool so that the user can edit the source code on a cloud development environment connectable via web. A computing system that automatically generates embedded software on a system.   The computer system of claim 12, wherein the processor generates a file system for the source code and stores the file system for the source code on the cloud development environment. System.   The embedded software is automatically generated on the virtualized system according to claim 12, wherein the processor generates a file system for the binary output, and stores the file system for the binary output on the cloud development environment. Computing system.