Flexible code generation tool for software and hardware component configuration and content generation

Abstract

The invention relates to a flexible code generation tool for software and hardware component configuration and content generation. A system, method, and circuitry for generating content for a programmable computing device based on user-selected configuration information. The user selection configuration information comprises code generation strategy selection. A configuration store is generated based on the user's selection and includes a code generation policy parameter file. The configuration store and the user-selected configuration information are used to generate the content, such as code, data, parameters, settings, etc. When the content is provided to the programmable computing device, the content initializes, configures, or controls one or more software and hardware aspects of the programmable computing device.

Description

Technical Field

[0001] The present disclosure relates generally to electronic circuits, such as the type often used in embedded applications. More specifically, but not exclusively, the present disclosure relates to generating content for programming electronic circuits, such as general and special purpose microcontrollers and microprocessors, including content related to configuration of components of the electronic circuits. Background Art

[0002] Many programmable microcontroller and microprocessor architectures utilize specific code to initialize or configure the operation of the microcontroller and microprocessor in the manner desired by the user. This code may establish clock settings, the desired boot sequence, assign external peripherals, configure internal peripherals, embed software to be executed on the microcontroller or microprocessor, and prepare other software or hardware configuration settings. To generate such code, the user must be trained on the specific code or hardware nuances of the microcontroller or microprocessor that may vary from architecture to architecture. Some architectures include graphical tools that enable the user to visualize the configuration settings. Summary of the invention

[0003] Existing content generation tools are often rigid and do not provide users with much flexibility when generating content. Existing content tools are also often associated with specific devices, and each device may require a different content generation tool. It is with respect to these and other considerations that the embodiments described herein have been made.

[0004] Embodiments described herein utilize graphical user interface to enable the user to select and configure programmable computing device, so as to generate content (such as code, setting, parameter, option bit or byte, EEPROM data etc.) for programmable computing device. Embodiments described herein help to generate configurable content for programmable computing device based on the selection of the user, without the need for the user to write content specifically. In certain embodiments, the user can select the code generation strategy adopted.

[0005] In an embodiment, a method includes: presenting a list of components for a project to a user via a graphical user interface, the project being associated with a programmable computing device; receiving a first selection of a user-selected component for the project from the list of components via the graphical user interface; in response to the user-selected component being configurable: presenting user-selectable component configuration options for the user-selected component via the graphical user interface; receiving a component configuration option selection for the user-selected component via the graphical user interface; presenting user-selectable code generation policy options for the user-selected component via the graphical user interface; receiving a code generation policy option selection for the user-selected component via the graphical user interface; generating settings for the user-selected component based on the received component configuration option selection and the received code generation policy option selection for the user-selected component; and generating or updating a configuration store based on the settings for the user-selected component; and generating content for the programmable computing device based on the user-selected component and the configuration store, the generating content comprising: generating, updating or retrieving a code generation policy parameter file, and generating code associated with the user-selected component based on the code generation policy parameter file.

[0006] In an embodiment, a non-transitory computer-readable medium having content, the content configuring a processing device to implement a method, the method comprising: displaying a list of components for a project to a user via a graphical user interface, the project being associated with a programmable computing device; receiving, via the graphical user interface, a first selection of a user-selected component for the project from the list of components; in response to the user selecting that the component is configurable: displaying, via the graphical user interface, user-selectable component configuration options for the user-selected component; receiving, via the graphical user interface, a selection of component configuration options for the user-selected component; displaying, via the graphical user interface, a selection of component configuration options for the user-selected component; A user of a component can select a code generation policy option; receiving a code generation policy option selection for the user-selected component via the graphical user interface; generating settings for the user-selected component based on the received component configuration option selection and the received code generation policy option selection for the user-selected component; and generating or updating a configuration storage based on the settings for the user-selected component; and generating content for the programmable computing device based on the user-selected component and the configuration storage, the generated content including: generating, updating or retrieving a code generation policy parameter file, and generating code associated with the user-selected component based on the code generation policy parameter file.

[0007] In an embodiment, a computing device includes: a display device; a memory that stores computer instructions in operation; and at least one processor that executes the computer instructions in operation to: present a list of components for a project associated with a programmable computing device via the display device and to a user; receive a first selection of a user-selected component for the project from the list of components; in response to the user selecting that the component is configurable: display user-selectable component configuration options for the user-selected component via the display device; receive a component configuration option selection for the user-selected component; display user-selectable code generation policy options for the user-selected component; receive a code generation policy option selection for the user-selected component; based on the received component configuration option selection and the received code generation policy option selection for the user-selected component, generate settings for the user-selected component; and generate or update a configuration store based on the settings for the user-selected component; and generate content for the programmable computing device based on the user-selected component and the configuration store, the generating content comprising: generating, updating or retrieving a code generation policy parameter file, and generating code associated with the user-selected component based on the code generation policy parameter file.

[0008] In an embodiment, a system comprises: a programmable computing device; and a non-transitory computer-readable medium having content, the content causing a processor, in operation, to: present a list of components for a project to a user via a graphical user interface, the project being associated with the programmable computing device; receive, via the graphical user interface, a first selection of a user-selected component for the project from the list of components; in response to the user selecting that the component is configurable: display, via the graphical user interface, user-selectable component configuration options for the user-selected component; receive, via the graphical user interface, a selection of component configuration options for the user-selected component; display, via the graphical user interface, a user-selectable component configuration option for the user-selected component A code generation policy option can be selected; a code generation policy option selection for the user-selected component is received via the graphical user interface; settings are generated for the user-selected component based on the received component configuration option selection and the received code generation policy option selection for the user-selected component; and a configuration store is generated or updated based on the settings for the user-selected component; content is generated for the programmable computing device based on the user-selected component and the configuration store, the generated content comprising: generating, updating or retrieving a code generation policy parameter file, and generating code associated with the user-selected component based on the code generation policy parameter file; and providing the content to the programmable computing device.

[0009] In an embodiment, a method includes: presenting to a user, via a graphical user interface, a list of common components for a project associated with a programmable computing device; receiving, via the graphical user interface, a selection of a user-selected common component for the project from the list of common components; presenting, via the graphical user interface, user-selectable common component configuration options for the user-selected common component; receiving, via the graphical user interface, a common component configuration option selection for the user-selected common component; generating settings for a first instance of the user-selected common component based on the received common component configuration option selection; generating or updating a configuration store based on the generated settings for the first instance of the user-selected common component; and generating content for the programmable computing device based on the configuration store, wherein at least one of the generating settings for the first instance of the common component or the generating or updating the configuration store includes: associating the first instance of the user-selected common component with a software component of the programmable computing device, associating the first instance of the user-selected common component with a hardware component of the programmable computing device, or a combination thereof based on one or more of the received common component configuration option selections.

[0010] In an embodiment, a non-transitory computer-readable medium having content, the content configuring a processing device to implement a method, the method comprising: presenting to a user, via a graphical user interface, a list of common components for a project associated with a programmable computing device; receiving, via the graphical user interface, a first selection of a user-selected common component for the project from the list of common components; presenting, via the graphical user interface, user-selectable common component configuration options for the user-selected common component; receiving, via the graphical user interface, a common component configuration option selection for the user-selected common component; generating settings for a first instance of the user-selected common component based on the received common component configuration option selection; generating or updating a configuration store based on the settings for the first instance of the user-selected common component; and generating content for the programmable computing device based on the configuration store, wherein at least one of generating settings for the first instance of the common component or generating or updating the configuration store comprises: associating the first instance of the user-selected common component with a software component of the programmable computing device, associating the first instance of the user-selected common component with a hardware component of the programmable computing device, or a combination thereof, based on one or more of the received common component configuration option selections.

[0011] In an embodiment, a computing device comprises: a display device; a memory storing computer instructions in operation; and at least one processor executing the computer instructions in operation to: present a list of common components for a project to a user via a graphical user interface, the project being associated with a programmable computing device; receiving a first selection of a user-selected common component for the project from the list of common components via the graphical user interface; presenting user-selectable common component configuration options for the user-selected common component via the graphical user interface; receiving a selection of a common component configuration option for the user-selected common component via the graphical user interface; and selecting a common component configuration option based on the received selection. Generic component configuration option selections, generating settings for a first instance of the user-selected generic component; generating or updating a configuration store based on the settings for the first instance of the user-selected generic component; and generating content for the programmable computing device based on the configuration store, wherein at least one of the generating settings for the first instance of the generic component or the generating or updating the configuration store comprises: associating the first instance of the user-selected generic component with a software component of the programmable computing device, associating the first instance of the user-selected generic component with a hardware component of the programmable computing device, or a combination thereof based on one or more of the received generic component configuration option selections.

[0012] In an embodiment, a system includes: a programmable computing device; and a non-transitory computer-readable medium having content, the content causing a processor in operation to: present a list of common components for a project associated with the programmable computing device to a user via a graphical user interface; receive, via the graphical user interface, a first selection of a user-selected common component for the project from the list of common components; present, via the graphical user interface, user-selectable component configuration options for the user-selected common component; receive, via the graphical user interface, a component configuration option selection for the user-selected common component; based on the received component configuration option selection, generate settings for a first instance of the user-selected common component; generate or update a configuration store based on the settings for the first instance of the user-selected common component; and generate content for the programmable computing device based on the configuration store, wherein at least one of the generating settings for the first instance of the common component or the generating or updating the configuration store comprises: based on one or more of the received common component configuration option selections, associating the first instance of the user-selected common component with a software component of the programmable computing device, associating the first instance of the user-selected common component with a hardware component of the programmable computing device, or a combination thereof. BRIEF DESCRIPTION OF THE DRAWINGS

[0013] Non-limiting and non-exhaustive embodiments are described with reference to the following figures, wherein like labels refer to like parts in the various views unless the context indicates otherwise. The sizes and relative positions of elements in the figures are not necessarily drawn to scale. For example, the shapes of various elements are selected, enlarged, and positioned to improve drawing legibility. For ease of identification in the figures, specific shapes of the drawn elements have been selected. One or more embodiments are described below with reference to the figures, wherein:

[0014] Figure 1 is a block diagram illustrating an example computing environment for implementing some embodiments described herein.

[0015] Figure 2 is a block diagram illustrating an example conceptual structure for storing various aspects used in generating content according to some embodiments described herein.

[0016] Figure 3 A logical flow diagram of a process for generating content according to some embodiments described herein is shown.

[0017] Figure 4 A logic flow diagram of a process for updating a graphical user interface during a content generation process is shown according to some embodiments described herein.

[0018] Figure 5 is an illustrative example of a component parameter file according to some embodiments described herein.

[0019] Figure 6 According to some embodiments described herein, Figure 5 An illustrative example of a component parameter file that obtains values.

[0020] Figure 7 is an illustrative example of a graphical user interface that enables a user to select components for a project according to some embodiments described herein.

[0021] Figure 8 is an illustrative example of a graphical user interface that enables a user to select parameters for a user-selected component according to some embodiments described herein.

[0022] Fig. 9 A logical flow diagram of a process for customizing a code generation process associated with generating content is shown according to some embodiments described herein.

[0023] Fig.10 A conceptual diagram illustrating processes associated with generating content according to some embodiments described herein.

[0024] Fig.11 is a conceptual diagram of a content generation process that facilitates customizing a code generation strategy associated with a software component, according to some embodiments described herein.

[0025] Fig.12 is an illustrative example of a hook that may be used by a generation service according to some embodiments disclosed herein.

[0026] Fig.13 is a conceptual diagram illustrating the use of different hooks at different code generation stages according to some embodiments described herein.

[0027] Fig.14 A code example of a policy descriptor file according to some embodiments described herein is illustrated, which may be used to generate a code generation parameter file to be provided to a code generation service.

[0028] Fig.15 An example of a code generation parameter file according to some embodiments disclosed herein is illustrated, which may be generated in response to a call to a policy descriptor file by a code generation service.

[0029] Fig.16 An example structure of output code generated by a code generation service using a code generation parameter file according to some embodiments disclosed herein is illustrated.

[0030] Fig.17 An example of a code generation parameter file according to some embodiments disclosed herein is illustrated, which may be generated in response to a call to a policy descriptor file by a code generation service.

[0031] Fig.18 An example structure of output code generated by a code generation service using a code generation parameter file according to some embodiments disclosed herein is illustrated.

[0032] Fig.19 is a conceptual diagram illustrating an example of features of customizing a code generation strategy for a component according to some embodiments disclosed herein.

[0033] Fig. 20 is a flow chart illustrating an example process of generating code for a component according to some embodiments disclosed herein.

[0034] Fig.21 is a conceptual diagram illustrating that a code generation service generates code for a component of a programmable computing device using hooks according to user selections according to some embodiments disclosed herein.

[0035] Fig. 22Generating objects for configuration storage based on specific hardware and specific software configuration pairs of a programmable computing device is conceptually illustrated.

[0036] Fig.23 and 24 is a conceptual illustration of configuring generic components that can be flexibly associated with specific hardware and software components of a programmable computing device.

[0037] Fig.25 is a conceptual diagram illustrating a process for generating content that allows a user to select between configuring a hardware component (eg, a specific UART), configuring a specific software component (eg, a specific driver), or configuring a generic component (eg, a HW UxART).

[0038] Fig.26 is a logic flow diagram of a process for customizing a code generation process associated with generating content according to some embodiments described herein.

[0039] Fig. 27 An example graphical user interface that may be presented to a user to facilitate selecting a component to configure is illustrated.

[0040] Fig.28 is an illustrative example of a graphical user interface that enables a user to select parameters for a user-selected common component according to embodiments described herein. DETAILED DESCRIPTION

[0041] In the following description and accompanying drawings, certain details are stated to provide a comprehensive understanding of various embodiments of equipment, systems, methods and articles. However, it will be appreciated by those skilled in the art that other embodiments can be practiced without these details. In other examples, well-known structures and methods associated with, for example, circuits (such as transistors, multipliers, adders, dividers, comparators, integrated circuits, logic gates, finite state machines, accelerometers, gyroscopes, magnetic field sensors, memories, bus systems, etc.) are not shown or described in detail in some drawings to avoid unnecessarily confusing the description of the embodiments. Moreover, in order to avoid unnecessarily confusing the description of the embodiments, well-known structures or components associated with the environment of the present disclosure are not shown or described, including but not limited to communication systems and networks.

[0042] Throughout this specification and the following claims, the word "comprise" and variations such as "comprising" and "comprises" should be interpreted in an open, inclusive sense, i.e., as "including, but not limited to," unless the context dictates otherwise.

[0043] Throughout the specification, claims and drawings, unless the context indicates otherwise, the following terms adopt the meanings explicitly associated herein. The term "in this article" refers to the specification, claims and drawings associated with the current application. The phrases "in one embodiment", "in another embodiment", "in various embodiments", "in some embodiments", "in other embodiments" and other variations thereof refer to one or more features, structures, functions, limitations or characteristics of the present disclosure, and are not limited to the same or different embodiments, unless the context indicates otherwise. As used herein, the term "or" is an inclusive "or" operator and is equivalent to the phrase "A or B or both" or "A or B or C or any combination thereof", and lists with additional elements are treated similarly. The term "based on" is not exclusive and allows additional features, functions, aspects or limitations based on undescribed features, functions, aspects or limitations, unless the context indicates otherwise. In addition, throughout the specification, the meanings of "one", "an" and "the" include singular and plural references. In addition, specific features, structures or characteristics can be combined in any suitable manner in one or more embodiments to obtain further embodiments.

[0044] Figure 1 1 is a block diagram illustrating an example computing environment 100 for implementing the embodiments described herein. The environment 100 includes a programmable computing device 108 and a host computing device 150.

[0045] The programmable computing device 108 has one or more processors 110, input / output peripherals 112, and a programmable interface 119. As illustrated, the programmable computing device includes one or more systems on a chip (SoC) 109, each of which may include one or more processors 110, one or more input / output peripherals 112, and a programmable interface 119 that may be coupled to the input / output peripherals 112 and the programmable interface 119 of the programmable computing device 108.

[0046] Processor 110 may have one or more processing cores 114, one or more memories 116, and associated configuration pins, jumpers, or switches 118. The associated configuration pins, jumpers, or switches 118 may typically be at the level of SoC 109 rather than at the processor level. Figure 114, processor 110a includes processing cores 114a to 114n, and processor 110b includes processing core 114x. Computing device 108 may include other internal peripherals 132 (such as a graphics processing unit, a wireless network module, an analog-to-digital converter, a micro-electromechanical system, a sensor, etc.) and other general-purpose input / output (GPIO) interfaces 134. Internal peripherals 132 and GPIO 134 may be at various levels, such as processor 110 level, SoC 109 level, programmable computing device level 108, processing core 114 level (e.g., configurable components of processing core 114, for ease of illustration, Figure 1 not shown) or a combination thereof.

[0047] The programmable computing device 108 may be a microprocessor, a microcontroller, a system board, or other computer device that is or includes one or more integrated circuits having a programmable interface 119. In some embodiments, the programmable computing device 108 may include multiple SoCs (see SoC 109), each SoC having a programmable interface 119, and the programmable computing device 108 may include a common programmable interface 119 that, in operation, may be coupled to the programmable interface 119 of each SoC in the multiple SoCs.

[0048] In some embodiments, the processor 110 may include a state machine, a microprocessor, a programmable logic circuit, a discrete circuit system, logic gates, registers, etc. and various combinations thereof. In operation, the processor 110 may control the booting of the programmable computing device 108, the overall operation of the programmable computing device 108, the execution of application programs by the programmable computing device 108, the communication between the internal peripheral device 132 and an external device (such as the illustrated external peripheral device 170), etc.

[0049] The programmable computing device 108 also includes one or more memories 116, such as one or more volatile or non-volatile memories (such as flash memory) or a combination thereof, which can store, for example, all or part of instructions and data related to applications and operations performed by the programmable computing device 108. For example, one or more of the memories 116 can store computer instructions that, when executed by the processor 110, direct the programmable computing device 108 or cause the programmable computing device 108 to perform desired functions. The memories 116 can also store information used to configure the hardware of the programmable computing device 108. For example, Figure 1Option bytes 117 are shown to store information used to configure the hardware of the programmable computing device 108. Memory 116 may be included at various levels, such as the programmable computing device 108 or board level or board level, SoC 109 level, processor level 110, processing core 114 level, etc., and various combinations thereof.

[0050] As mentioned above, the programmable computing device 108 also includes one or more internal peripherals 132, such as a universal asynchronous receiver-transmitter (UART), a timer, an analog-to-digital (A / D) converter, a digital-to-analog (D / A) converter, an inter-integrated circuit (IC2) interface, a serial peripheral (SPI) interface, etc. As illustrated, the processor 110a includes one or more internal peripherals 132 separate from the processing cores 114a to 114n, the processor 110b includes one or more internal peripherals 132 separate from the processing core 114x, and the SoC 109 includes one or more internal peripherals 132 separate from the processors 110a, 110b. The internal peripherals 132 may also be included at the programmable computing device 108 or board level, and the processing cores may also have configurable components.

[0051] The input / output peripherals 112 may include one or more general purpose input / output (GPIO) interfaces 134, dedicated input or output interfaces (e.g., serial input / output ports), wireless interfaces, and the like. In some embodiments, the input / output peripherals 112 may be configured to receive input data from other computing devices, or may be configured to provide output data to other computing devices such as external peripherals 170. For example, the GPIO 134 may be configured to receive data from an external computing device and provide the data to an internal peripheral 132, receive data from an internal peripheral 132 and provide the data to an external computing device, or a combination thereof. As illustrated, the processing core 114a includes one or more GPIO interfaces 134, the processor 110a includes one or more GPIO interfaces 134 separate from the processing cores 114a to 114n, the processor 110b includes one or more GPIO interfaces 134 separate from the processing core 114x, and the programmable device 108 includes one or more GPIO interfaces 134 separate from the processors 110a, 110b. The GPIO interface 134 may be included at various levels, such as the programmable device 108 level, the SoC 119 level, etc., and various combinations thereof.

[0052] The programmable computing device 108 may also include one or more bus systems (not shown) at different levels, which may be configured so that the SoC 109, processor 110, input / output peripherals 112 (e.g., at the boundary between the board and the SoC), processing core 114, memory 116, configuration pins 118 (e.g., at the boundary between the board and the SoC), internal peripherals 132, GPIO 134, or other circuits or circuit systems (not shown) may be communicatively coupled to each other to send or receive data to or from the other components. The bus system may include one or more of, or some combination of, data, address, power, or control buses that are electrically coupled to the various components of the programmable computing device 108.

[0053] Host computing device 150 includes processor 152, input / output interface 154, memory 156 and display 158. Host computing device 150 is configured to use the embodiments described herein to generate a graphical user interface to present to a user, so that the user can select and configure components, and generate content from those components to program and configure the software or hardware or both of programmable computing device 108. Processor 152 may include one or more processing cores, which are configured to execute computer instructions to adopt the embodiments described herein. Although host computing device 150 can be implemented as an independent system, embodiments are not limited thereto. For example, a distributed embodiment (e.g., an application executed on a local host computing device can communicate with a remote server, which can provide all or part of the functionality of host computing device 150) may be adopted.

[0054] Memory 156 may include one or more different types of non-volatile and / or volatile storage technologies. Examples of memory 156 may include, but are not limited to, flash memory, hard drives, optical drives, solid-state drives, various types of random access memory (RAM), various types of read-only memory (ROM), other computer-readable storage media (also referred to as processor-readable storage media), the like, or any combination thereof. Memory 156 may be used to store information, including computer-readable instructions used by processor 152 to perform actions, including the embodiments described herein. Memory 152 may also store other information, which will be discussed below in conjunction with the description of the memory 156. Figure 2 Discuss this information in more detail.

[0055] The input / output interface 154 may include one or more other data input or output interfaces. For example, the input / output interface 154 may include or provide data to a display device 158, which may be used to present a graphical user interface to a user. The input / output interface 154 may accept input from a user to select and configure or customize components, as described herein. Moreover, the input / output interface 154 is configured to provide content generated as described herein to the programmable computing device 108.

[0056] Figure 1 Embodiments of the system 100 may include fewer components than shown, may include more components than shown, and may combine or separate components in various ways. For example, the programmable interface 119 of the programmable computing device 108 may be part of the input / output peripheral 112, multiple programmable interfaces may be used (e.g., for different SoCs 109, processors 110, or processing cores 114), the processing cores 114a to 114n of the processor 110a may have separate memories 116 and configuration pins 118, shared memories 116 and configuration pins 118, input peripherals 132, and the input / output peripherals 112 and GPIO interface 134 may be combined or split in various embodiments or various combinations thereof. In another example, in some embodiments, the display 158 may be part of the input / output interface 154 (e.g., a touch screen may be used as a display option and receive user input).

[0057] Figure 2 1 is a block diagram illustrating an example conceptual structure of a memory 156 for storing various aspects used in generating content according to embodiments described herein. The memory 156 may be from Figure 1 The memory 156 of the host computing device 150.

[0058] Memory 156 may store configurable components 204, ready-to-use components 220, a configuration store (e.g., a global map or settings registry) 222, and a settings structure for each configurable component 224. In some embodiments, configuration store 222 and settings files may be combined. Memory 156 may also store data generated by a processor (e.g., Figure 1 The processor 152 in the memory 156 can execute computer instructions 226 to implement the embodiments described herein. The data stored in the memory 156 can use a standard syntax, such as a JSON schema, which can enable the use of a standard library that uses or benefits from the syntax (e.g., JSON form).

[0059] Configurable components 204 include at least one configurable component 206a to 206c. Configurable components 206a to 206c include or describe a programmable computing device (such as Figure 1 108) in the programmable computing device 108. These configurable components 206a to 206c have one or more parameters (e.g., constraints or variables) that can be selected or set by a user.

[0060] Configurable components 206a to 206c may include parameter files, template files, or both. For example, configurable component 206a includes parameters 208 and template 210, configurable component 206b includes parameters 209 but does not include a template, and configurable component 206c includes template 211 but does not include parameters.

[0061] Parameters 208 and 209 may include one or more files storing parameters of configurable components that can be selected or set by a user. Parameters 208 and 209 may store possible values ​​that a user may select for one or more parameters. These values ​​may be direct values, high-level expressions, queries to a configuration store, or queries to other parameters (e.g., other parameters 208, 209) or a database (not shown). Parameters 208 and 209 may be used to configure or implement one or more software or hardware aspects associated with a programmable computing device. In various embodiments, parameters 208 and 209 may be written or generated using one or more general or custom grammatical structures. The grammar is a set of rules indicating how to express the configurability of a component or template.

[0062] In various embodiments, one or more of parameters 208 and 209 may be at least partially defined or limited by another parameter, component, or template. Thus, one or more parameters may depend on one or more other parameters, components, or templates, which may create various dependencies between the parameters.

[0063] Templates 210 and 211 may include one or more files storing previously generated templates. Templates 210 and 211 are configuration tools for programmable computing devices. Templates 210 and 211 may be files containing instrumented content that is used to generate content to initialize, configure, or control software or hardware aspects of programmable computing device 108. In some embodiments, templates 210 and 211 contain C code instrumented with Handlebars template language. During the content generation phase, the instrumented portion may be replaced by information from configuration storage 222, which will be described in more detail below.

[0064] In some embodiments, one or more of templates 210 and 211 may directly or indirectly depend on parameters selected by a user, such as through configuration storage 222. For example, configurable component 206a may include a single template 210 that uses global registry values ​​corresponding to four user-selectable parameters defined in parameters 208. In some embodiments, templates may be selected by a user or linked to each other, or a user may select whether to use a particular template during the content generation process, including selecting between mutually exclusive templates. In at least one embodiment, one or more templates 210 and 211 may depend on or obtain values ​​from other templates, other components, or other software or hardware items to be implemented on a programmable computing device.

[0065] Ready-to-go component 220 is a previously designed component that configures or directs one or more software or hardware aspects of a programmable computing device. In at least one embodiment, ready-to-go component 220 may also be referred to as a non-configurable component. In various embodiments, ready-to-go component 220 does not include any user-selectable features. On the contrary, ready-to-go component 220 is fully operable and can configure or implement one or more software or hardware aspects of a programmable computing device without further input or selection by the user. For example, ready-to-go component can be provided with C code, and can be a driver (such as HALCRC) or any other software. Ready-to-go component can be available in standalone mode. As discussed in more detail below, a graphical user interface can be presented to the user, in which the user can choose to add or remove the ready-to-go component from the project.

[0066] The settings of configurable components 224 are optional and store the results of the configuration selections of each of the configurable components, parameters, and templates selected by the user. For example, the specific settings of configurable components 224 can identify one or more templates from the templates 210 selected by the user. The settings of configurable components 224 can also contain values ​​associated with the parameters 208 selected by the user. In some embodiments, the settings of configurable components 224 can also store optional user settings for software or hardware aspects of the programmable computing device. In some embodiments, the settings of configurable components 224 can be used for debugging purposes.

[0067] In some embodiments, a single settings structure 224 is generated for each selected configurable component 204. In other embodiments, multiple settings structures 224 are generated for a single selected configurable component 204. In other embodiments, a single settings structure 224 may be generated for multiple selected configuration components 204. Also, multiple settings structures 224 may be generated for multiple selected configuration components 204. In some embodiments, these settings structures 224 may be stored as JSON files.

[0068] Configuration storage 222 is an in-memory object that centralizes all user selections and settings generated via user selections of configurable components 204, parameters, and templates. Configuration storage in-memory objects may also be stored and synchronized with files to facilitate their persistence. By extension, configuration storage 222 may also refer to a software component that provides a dictionary, getter / setter, or service to calculate or recalculate the contents of a programmable computing device based on an expression or dependency. In general, configuration storage 222 is a dictionary or database that memorizes software component settings and hardware platform settings for a programmable computing device. In some embodiments, separate global mappings or setting registries may be generated for various software and hardware aspects of a programmable computing device.

[0069] As described herein, the configuration store 222 is a software component that implements a set of services to retrieve, store, calculate, recalculate, or parse user-selected values. In various embodiments, the configuration store 222 may include a JSON object with a set of accessors (APIs) for components, templates, and parameter values ​​selected by the user. In some embodiments, the configuration store 222 may be a cascade of all settings for each configurable component 224. In other embodiments, the configuration store 222 may be updated directly by the user's selections without using or accessing the settings for each configurable component 224. In some embodiments, in addition to the JSON object, the configuration store 222 also includes or is associated with a service.

[0070] As discussed in more detail below, a host computing device (such as Figure 1 The host computing device 150 in the example embodiment utilizes the configuration storage 222 and the selected configurable components 204 and any selected ready-to-use components 220 to generate content that is provided to and used by the programmable computing device to implement, control, or configure one or more software aspects of the programmable computing device, one or more hardware aspects of the programmable computing device, or both.

[0071] Now it will be relative to Figure 3 and 4 The operation of one or more embodiments will be described and for convenience will be described with respect to the above Figure 1 and 2 In at least one embodiment of the various embodiments, respectively, in combination with Figure 3 and 4 The described processes 300 and 400 may be performed by or on one or more computing devices, such as a computer executing instructions. Figure 1 Host computing device 150 in, such as instructions 226 stored in memory 156 (see Figure 2 ).

[0072] Figure 3 1 shows a logical flow diagram of a process 300 for generating content according to an embodiment described herein. The process 300 begins at block 302 after a start block, where a project is initiated to generate content to be displayed on a programmable computing device such as Figure 1 In some embodiments, project initiation includes presenting a graphical user interface to a user. The graphical user interface requests or includes an input interface for a user to select a specific programmable computing device. Configuration storage is also provided for project initiation. Configuration storage may include a defined structure, which may be a predefined or initial setting for a specific programmable computing device.

[0073] In some embodiments, a single project for software and hardware is started for a programmable computing device. Therefore, a single configuration storage can be generated. In some embodiments, a first project can be started for the software of a programmable computing device, and a second project can be started for the hardware of a programmable computing device. Then, a separate global mapping or setting registry can be generated for a separate project, and these registry may have dependencies on each other. In at least one such embodiment, process 300 can be performed sequentially or in parallel for separate software and hardware projects. In some embodiments, process 300 can be performed to process software and hardware projects concurrently.

[0074] Process 300 proceeds to block 304, where a list of multiple components of the project is presented to the user in a graphical user interface. In at least one embodiment, the list of components can be generated for the user based on the specific programmable computing device selected for the project. These components can be those components designed for or compatible with the programmable computing device. In some embodiments, the list of components can be selected for presentation based on the execution context characteristics of the programmable computing device. In some architectures, the user can select the execution context of a particular processing core or a particular operating mode (e.g., TrustZone mode). The list of components presented to the user can depend on these user selections. The list of components can include configurable components, such as Figure 2 configurable component 204 in; or a non-configurable component such as Figure 2 The ready-to-use component 220 in; or some combination thereof.

[0075] Process 300 continues at frame 306, where a user selection of a component is received. In at least one embodiment, the user can select a component from a list via a graphical user interface. Although process 300 discusses the selection of a single component by the user at one time, embodiments are not limited thereto. In some embodiments, multiple components can be selected by the user.

[0076] The process 300 then proceeds to decision block 308, where it is determined whether the selected component is a configurable component or a non-configurable component. In some embodiments, the component may have a label or other identifier indicating whether the component is configurable by the user. In other embodiments, a database or other data structure of configurable and non-configurable components may be maintained and compared to the selected component. If the selected component is configurable, then the process 300 flows from block 308 to block 310; otherwise, the process 300 flows from block 308 to block 322.

[0077] As mentioned above, the user may select multiple components; if so, process 300 flows from block 308 to block 310 for any selected configurable components, and from block 308 to block 322 for any selected non-configurable components. In various embodiments, the user may be able to configure each selected component individually or in parallel via a graphical user interface.

[0078] At block 310, a list of one or more user-selectable templates for a user-selected configurable component is presented to the user via a graphical user interface. In some embodiments, the list of user-selectable templates may include one or more features of the template that may be set or selected by the user, such as if the template is linked to another template, component, or project.

[0079] The list of user-selectable templates can be customized or defined as the user interface element that utilizes the user's expectation. Therefore, the user interface can be customized for different user-selectable templates so that the user can select, define or set one or more characteristics of the template. In certain embodiments, this customization can allow the template to use data from a database, rather than listing all possible values. In certain embodiments, this customization can specify the user-selectable aspects of a template. In certain embodiments, the user can select between mutually exclusive templates, wherein only one template in the template is selected for the content generation process of the configurable component selected by the user.

[0080] In various embodiments, block 310 may be optional and may not be implemented. For example, in some embodiments, a template may be applied by default without user selection. In some embodiments, a template may not be used in the configuration of a configurable component.

[0081] From block 310, process 300 proceeds to block 312, where a user selection template for a configurable component is received. In some embodiments, the user selection template may include other information provided by the user that defines how the template is to be used.

[0082] In some embodiments, one or more configurable components may include user-selectable parameters, but not user-selectable templates. In such embodiments, blocks 310 and 312 may not be performed for those selected configurable components that do not include user-selectable templates.

[0083] Process 300 continues from frame 312 to frame 314, wherein a list of one or more user-selectable parameters of the configurable component for user selection is presented to the user via a graphical user interface. In some embodiments, the list of user-selectable parameters may include a list of parameters and possible values ​​of these parameters. In other embodiments, the list may identify the parameters and include an interface for receiving user-defined values. In other embodiments, the list may identify the parameters and include an interface for receiving user-defined values ​​limited to some boundaries. In some embodiments, the list of user-selectable parameters may include a list of parameters and possible values ​​of some of these parameters, and include an interface for receiving user-defined values ​​of other parameters, with or without boundaries.

[0084] The list of user-selectable parameters can be customized or defined as the user interface element that utilizes user's expectation.Therefore, user interface can be customized for different user-selectable parameters so that the user can select, define or set one or more parameters.In certain embodiments, this customization can allow parameter selection to be driven by data, expression, formula or dependency with other parameters from database, rather than listing all possible values.In other embodiments, this customization can specify the user-selectable aspect of parameter.In certain embodiments, this customization can specify the boundary of the user-defined value that is applicable to parameter.In various embodiments, parameter list can be the default list of its corresponding assembly.

[0085] In some embodiments, the list of user-selectable parameters may also include other information that may help the user understand the consequences of selecting a particular parameter. For example, the graphical user interface may include links to reference manuals, charts, tool tips, etc. that help explain the parameters and how different user selections may affect other components or parameters.

[0086] From block 314, process 300 proceeds to block 316, where user-selected parameters for configurable components are received. In at least one embodiment, values ​​for one or more parameters are received from a user. As mentioned above, a user can select a specific value from a list of possible values ​​for a parameter via a graphical user interface. Alternatively, if boundaries are specified, a user can enter a specific value for the parameter according to the boundaries. Unacceptable values ​​entered by the user may trigger a user warning or automatic adjustment (e.g., rounding down to a maximum value, etc.).

[0087] In some embodiments, the configurable components may include user-selectable templates, but not user-selectable parameters. In such embodiments, blocks 314 and 316 may not be implemented for those selected configurable components that do not include user-selectable parameters.

[0088] Process 300 continues from block 316 to block 318, where one or more settings structures are generated for the selected configurable component based on the user-selected parameters, the user-selected template, or some combination thereof. In some embodiments, the settings structure may be a list or other data structure identifying the user-selected parameters and the user-selected associated values, the user-selected template and any customizable features of the selected template, or other information indicating how the user can customize the configurable component.

[0089] In various embodiments, the setting structure can be updated by overwriting the user selection information of the user selection component to overwrite some values ​​of the component. In some embodiments, the component can overwrite the parameters from another component, such as when the components are dependent on each other for calculation. In other embodiments, the component can overwrite the query from another component, such as by changing the selection associated with the component that the user can make. Because some parameters can be set or defined by other templates or components, some parameter values ​​can be propagated or overwritten based on the dependency relationship between parameters, templates and components. For example, the application level value may overwrite the driver level value. In this way, the user selection and change of the application level can change the value or parameter of the driver level, and then these values ​​or parameters can be reflected in the global map or system registry. As mentioned above, in some embodiments, the setting structure 224 and the configuration storage 222 can be combined. Therefore, in some embodiments, the frame 318 can be combined with the next frame 320.

[0090] Process 300 proceeds from frame 318 to frame 320, wherein configuration storage 222 is updated based on the settings of each configurable component. As mentioned above, configuration storage is an object in memory that concentrates all user selections and settings generated via the user's selection of configurable components 204, parameters and templates. Therefore, the parameters, templates, values ​​and other information selected by the user for the configurable components selected by the user are added, updated or otherwise included in the configuration storage of the project based on the settings file. Configuration storage can be arranged so that the user selection value is a text that can be directly written into the hardware unit register by the driver software of the programmable computing device. In various embodiments, configuration storage can also retain any content that is used to update the results of expressions, formulas or dependencies based on the user's selection. In this way, when the value is updated, such as when changed by the user via a graphical user interface, all related values ​​are updated accordingly in the configuration storage.

[0091] although Figure 3It is shown that the configuration store is updated based on the settings structure generated by the user's selection, but the embodiments are not limited to this. In some embodiments, the configuration store can be updated in real time when the user selects components, parameters or templates. Therefore, in some embodiments, the use of the settings structure can be optional. In some embodiments, the images selected by the user can be maintained in a JSON file.

[0092] After block 320, or if in decision block 308, the selected component is not configurable, process 300 flows to block 322. In block 322, content for the programmable computing device is generated based on the selected component and the information stored in configuration storage 222. It should be noted that information stored in the global registry and associated with other components can be used to generate content. For example, information associated with a DMA associated with the selected component (e.g., a template associated with the DMA) can be used to generate content associated with the selected component.

[0093] Configuration storage 222 may operate as a merged database of values ​​that may be used to generate content from user-selected templates and user-selected components. The content may be, for example, pure code (e.g., C code) used by a programmable computing device to initialize, configure, or control software or hardware aspects of programmable computing device 108. Thus, the generated content may be initialization code, application code, configuration code, device tree blobs (hardware descriptions interpreted at runtime), etc. The content may also be other settings, parameters, or other information that initializes, configures, or controls software or hardware aspects of a programmable computing device. The content may also include associated documentation.

[0094] In various embodiments, overrides, Handlebars or similar template or replacement engines can be used to resolve dependencies or expressions (e.g., Handlebars expressions) in user-selected templates or configurable components by accessing values ​​stored in the configuration store. In other embodiments, the latter access value is stored in one or more settings files that contain the same information as the object in the configuration storage memory. The result of this step can generate actual code that can be compiled by a compiler for use in a programmable computing device. In various embodiments, the code generates source code that does not modify the selected component. Therefore, the component can be reused in its original form for the same project or other projects without modifying the component. In some embodiments, the system can also generate code that does not require compilation but can be interpreted by a virtual machine (e.g., micro-python, JavaScript). In other embodiments, the system can generate data structures used to adapt the behavior of programmable computing devices during runtime.

[0095] As described herein, a graphical user interface allows a user to select components and values. In other embodiments, this can be implemented by a command line interface without a graphical user interface.

[0096] In some embodiments, the graphical user interface can also present a preview of the content to the user based on the currently selected parameters. In this way, content generation can be triggered each time a parameter is set. When all components are configured, content can be finally generated for the programmable computing device because all values ​​can be used with expected values ​​(applied coverage, calculated expressions / formulas / dependencies).

[0097] From block 322, process 300 proceeds to decision block 324, where it is determined whether the user wants to select another component. If another component is selected, process 300 loops from block 324 to block 306 to receive the user selection of the other component; otherwise, process 300 flows from block 324 to block 326. As mentioned above, process 300 can also be implemented in the case where the user selects multiple components, which can then be configured by the user together or individually.

[0098] In box 326, the content generated for each user selected component is built into a binary image of the project. The binary image is information that a programmable computing device can use to initialize, configure, or control its hardware, software, or a combination thereof. In some embodiments, all of the generated content is used to build the binary image of the project. In other embodiments, a portion but not all of the generated content is used to build the binary image of the project. For example, in the case of an interpreted language, only the specific content (e.g., generated code) can be uploaded to a specific memory area of ​​the programmable computing device without regenerating a binary file that interprets it.

[0099] It is important to note that various code generation services may be called to generate the content for a user-selected component, and a combination of code generation services may be employed to generate the content for a single user-selected component. For example, the content may be generated by a default C code generation service, a device tree code generation service from the community, a proprietary third-party code generation service, a code generation service that generates Python code or any other language, etc., and various combinations thereof.

[0100] As illustrated, process 300 proceeds from box 326 to box 328, where the binary image is provided to the programmable computing device. In some embodiments, process 300 may sometimes return from box 326 to box 304, using the content generated at 326 as an intermediate input to the process. In some embodiments, process 300 may be performed multiple times to generate different content for different configurations of the programmable computing device. In this way, different configurations may be provided to separate programmable computing devices (even programmable computer devices of the same type), or different configurations may be provided to a single programmable computing device to allow a user of the programmable computing device to change between different configurations.

[0101] After block 328, process 300 terminates or otherwise returns to the calling process to perform other actions.

[0102] Figure 4 A logic flow diagram is shown of a process 400 for updating a graphical user interface during a content generation process according to embodiments described herein.

[0103] Process 400 begins at block 402 after a start block, where a user interface of a project is presented to a user. The project may be a software project, a hardware project, or various combinations thereof. In various embodiments, the user interface is the same as that described above with reference to FIG. Figure 3 A graphical user interface is described which is displayed to a user. The user interface may display components that may be selected for use with a programmable computing device, parameters that a user may select for a particular configurable component, templates that a user may select for a particular configurable component, and other information. Furthermore, the user interface may display values ​​for various parameters, settings, templates, and components, whether selected by a user, linked from one template to another, dependent on other values, or defined by templates or components that may be predefined.

[0104] Process 400 proceeds from block 402 to block 404 where a change in a configuration store value is received. As described above, the configuration store is updated in response to a user-selected configurable component, a user-selected parameter value, a user-selected template, etc. These user-selectable conditions may indicate a change in a configuration store value.

[0105] Process 400 continues from block 404 to block 406, where changes are propagated through the configuration store. Because parameters, templates, and components can depend on or depend on the values ​​of other parameters, templates, components, or projects, a change in one value may result in a change in another value. Therefore, changes to received configuration store values ​​are propagated through the configuration store according to these dependencies.

[0106] Process 400 then proceeds to frame 408 from frame 406, wherein the user interface is updated based on the change propagated in the configuration storage. The user interface can also be updated based on the generated content. In certain embodiments, the user interface queries the configuration storage, and any change that occurs when the configuration storage is updated is obtained and displayed in the user interface.

[0107] Process 400 then continues in decision block 410 where it is determined whether the project is associated with another project. If so, process 400 flows to block 412 where the change is propagated through the configuration store of the other project. Process 400 loops to block 404 to receive another change to the configuration store value library from the user.

[0108] Figure 3 The illustrated process 300 and Figure 4 The illustrated embodiment of process 400 may have more process blocks than illustrated, may have fewer process blocks than illustrated, and may modify the process flow in various ways. For example, process 300 may be modified to include a block (e.g., calling process 400) at 320 for presenting configuration update information to a user based on an updated configuration store.

[0109] Figure 5 is an illustrative example of a component parameter file according to embodiments described herein. In this example, the component parameters identify various different characteristics and possible values ​​of the parameters that can be selected by the user. For example, the parameter "DCH1" specifies the duty cycle of the channel 1 timer that can be selected by the user. In this example, the label such as for display to the user in the graphical user interface is "DutyCycleCH1". The type of the parameter is a number. Therefore, the value selected by the user is a number. The minimum value that the user can select is zero, and the maximum value that the user can select is 100. Finally, the parameter indicates that the unit of the parameter is a percentage.

[0110] Figure 6 According to the embodiments described herein, Figure 5 Illustrative example of an application-level component parameter file that obtains or reuses parameter values. The values ​​of the timer HAL driver are overwritten with values ​​calculated from application-level parameters (e.g., the timer period is calculated from the application frequency). In this example, the template builds an LED dimmer whose characteristics are obtained from Figure 5 For example, the characteristic "Source" is obtained from "From Figure 5 .json parameters", which depends on Figure 5An illustrative example of parameter values ​​in . The template defines a channel 1 timer as "CH1". The pulses of this timer are set to "(self.resources.pwm_led_dimmer.blocks.configs.%current_config%.fields.DCH1*%this%.Period) / 100". As mentioned, this definition depends on "DCH1", i.e., the channel 1 timer defined in the parameters. "this" is the current "object" or current level in the JSON object. In this particular example, "this" is the "field" stage, and "this.%Period%" refers to the period field at the current object level.

[0111] Figure 5 and 6 For illustrative purposes only and should not be considered limiting. According to the embodiments described herein, other information, data structures, and overlay or Handlebars techniques may be used to establish content for a programmable computing device through user-selected components, templates, and parameters.

[0112] Figure 7 It is an illustrative example of a graphical user interface 700 according to an embodiment described herein, and the graphical user interface 700 enables a user to select a component for a project. In this illustrative example, the graphical user interface 700 can display a "sample connection" collection of components: "middleware USB", "middleware BT" and "driver Wi-Fi". In this example, the sample connection is an application code component with three dependencies: two middleware components and a driver component. For this example case, these components are required for a complete project. In this example, a user can select which component of these components to open other components for selection. For example, a user can select "middleware BT", which allows the user to then select "driver BT" or "driver public". This type of user interface can enable a user to select a component suitable for his project by various component layers. Moreover, the graphical user interface tool can help end-users (end-users) resolve dependencies by proposing appropriate components or automatically selecting components when appropriate (for example, when only one component meets the criteria).

[0113] Figure 8 is an illustrative example of a graphical user interface 800 that enables a user to select parameters for a user-selected component according to embodiments described herein. The graphical user interface 800 may display different configurations and possible values ​​for multiple parameters, depending on which configurable components the user has selected.

[0114] Figure 7 and 8For illustrative purposes only, and should not be considered limiting.According to the embodiments described herein, other information or data may be displayed to a user via a graphical user interface.

[0115] Reference Figures 1 to 8 The method 300 may be used in various aspects of programming the programmable computing device 108. For example, content related to a boot sequence of the programmable computing device 108 may be generated, content related to configuration of internal peripherals or components, interfaces, external components, etc. may be generated, content related to system states and transitions between states may be generated, and the like, and various combinations thereof. Various checks may be performed as part of the content generation process, such as software consistency checks, electrical integrity checks, and the like, and various combinations thereof.

[0116] As mentioned above, the end user can select various code generation services to be called to generate the content of the user-selected component, and a combination of code generation services can be used to generate the content of a single user-selected component. For example, the content can be generated by the default C code generation service, the device tree code generation service from the community, a proprietary third-party code generation service, a code generation service that generates Python code or any other language, etc. and various combinations thereof.

[0117] However, the end user has limited control and flexibility over how the content is generated and produced. Existing mechanisms rely on a tight entanglement between the configuration tool and the components to be configured. The end user also has limited flexibility to adopt different approaches to the code generation process for different software components. For example, an all-in-one file approach or a split approach (e.g., separate files for initialization code for peripherals, with file names and locations imposed by the configuration tool) is imposed.

[0118] Embodiments described herein help to provide increased flexibility to control the generation and production of content to the end user. For example, the customization scope can be defined by the end user (e.g., global settings, project level settings, workspace level settings, software component level settings, software level settings in the component, resource level settings (templates, assistants, parts), etc.), and default and custom configurations can be applied to each level. In addition, templates, assistants, folders, file names, and file splits can be defined at each level to facilitate configuration of code generation strategies at each level.

[0119] In an embodiment, one or more code generation strategy descriptors can be used as file artifacts of various levels (e.g., at least one code generation file descriptor for each software component). As discussed in more detail below, the code generation strategy descriptor describes how a code generation service or routine uses an input artifact to produce an output file of a desired format. Description can be provided in various ways. For example, in various embodiments, a strategy descriptor can be JavaScript code, etc., which can include descriptions via text, JSON, YML, C code, etc., and various combinations thereof. Templates can be provided for end users to define a strategy and associate the strategy with a component (or other levels). In some embodiments, a wizard / editor can be provided to facilitate end users to define custom strategies.

[0120] The strategy to be applied selected by the end user can be configured and remembered by the system at the desired level, for example as a user setting in a workspace, project, or component settings. For example, the code generation file descriptor can be or include as described above with reference to Figures 1 to 8 Parameters configured and stored as described (e.g. using Figure 3 Method 300, modified to include receiving code generation strategy information and including a code generation file descriptor associated with the generator). Templates, parameters, and hooks can be used. For example, if there are commonly used code generation strategies (such as observed strategies), these strategies can be used as templates to facilitate acceleration and reduce the complexity of the configuration process. For advanced terminal users, personalized options can be used. The selection and memory process can be related to identification information associated with the code generation file descriptor (such as a user login ID or session ID, a workspace ID, user project preferences, etc.). In some embodiments, the terminal user can specify a unique memory process that is specific to the user or partially specific to the user.

[0121] In some embodiments, a wizard / editor may be provided to facilitate end-user definition of custom policy generation and storage policies. The wizard / editor may be configured to specify that code generation file descriptors may be configured (possibly at different levels), that the end-user may employ or specify a Common Microcontroller Software Interface Standard (CMSIS) or other application programming interface (API), a package manager API, a project manager API, a code generation API, etc. As mentioned above, templates may be used, and configuration details such as specific delimiters, specific region markers, specific generation modes (e.g., overwrite, append, etc.) may be proposed.

[0122] Fig. 9 A logical flow diagram of a process 900 for customizing a code generation process associated with generating content according to an embodiment described herein is shown. The process 900 is similar in some respects to the process described above with reference to Figure 3The process 300 is discussed above, and like reference numerals designate like blocks.

[0123] Process 900 begins at block 902 after a start block, where a process for generating a program to be executed on a programmable computing device such as Figure 1 The process 900 proceeds to block 904, where a list of multiple components of the project is presented to the user. For example, as described above with reference to Figure 3 As discussed above with respect to blocks 302 and 304 , blocks 902 and 904 may be implemented (eg, by presenting a graphical interface to a user).

[0124] Process 900 continues at block 906, where a user selection of a component is received (e.g., via a graphical interface). Process 900 then proceeds to decision block 908, where a determination is made as to whether the selected component is a configurable component or a non-configurable component. For example, blocks 906 and 908 may be performed as described above with reference to Figure 3 906 and 308 of . If the selected component is configurable, then process 900 flows from block 908 to block 910; otherwise, process 900 flows from block 908 to block 954. As previously mentioned, the user can select multiple components; if so, process 900 flows from block 908 to block 910 for any selected configurable components, and from block 908 to block 954 for any selected non-configurable components.

[0125] In block 910, a list of one or more user-selectable templates for a user-selected configurable component is optionally presented to the user via a graphical user interface. Process 900 proceeds from block 910 to block 912, where a user-selected template for a configurable component is received. Process 900 continues from block 912 to block 914, where a list of one or more user-selectable parameters for a user-selected configurable component is presented to the user via a graphical user interface. Process 900 proceeds from block 914 to block 916, where a user-selected parameter for a configurable component is received. For example, blocks 910 to 916 may be performed as described above with reference to Figure 3 310 to 316 of the discussion.

[0126] Process 900 continues from block 916 to block 940. In block 940, a list of one or more code generation strategy user selectable templates for a configurable component selected by the user is presented to the user via a graphical user interface. In some embodiments, the list of code generation strategy user selectable templates may include one or more features of the template that may be set or selected by the user, such as if the template is linked to another template, component, or project. For example, the selection of a code generation strategy for a component may be linked to a selected code generation strategy for another component.

[0127] The list of the selectable template of code generation strategy user can be customized or defined as the user interface element utilizing user's expectation.Therefore, can customize user interface for different code generation strategy user selectable template, make the user can select, define or set one or more characteristics of template.In certain embodiments, this customization can specify the user selectable aspect of code generation strategy template.In certain embodiments, the user can select between mutually exclusive templates, wherein only a template in the template is selected for the code generation strategy adopted in the content generation process of the configurable component selected by the user.Template can allow the user to select the hook to be adopted and configure selected hook, as discussed in more detail below.

[0128] In various embodiments, block 940 may be optional and may not be implemented. For example, in some embodiments, a code generation strategy template may be applied by default without user selection. In some embodiments, a template may not be used in the configuration of a code generation strategy for a configurable component.

[0129] From block 940, process 900 proceeds to block 942, where a code generation strategy user selection template for a configurable component is received. In some embodiments, the code generation strategy user selection template may include other information provided by a user that defines how the template is to be used.

[0130] In some embodiments, one or more configurable components may include code generation strategy user selectable parameters, but do not include code generation strategy user selectable templates. In such embodiments, blocks 940 and 942 may not be implemented for those selected configurable components that do not include code generation strategy user selectable templates.

[0131] Process 900 continues to frame 944 from frame 942, wherein presents to the user via a graphical user interface a list of one or more code generation strategy user selectable parameters of the configurable component selected by the user. In some embodiments, the list of code generation strategy user selectable parameters may include a parameter list and the possible values ​​of these parameters. In other embodiments, the list may identify parameters and include an interface for receiving user-defined values. In other embodiments, the list may identify parameters and include an interface for receiving user-defined values ​​that are limited to some boundaries or selections. In some embodiments, the list of code generation strategy user selectable parameters may include the possible values ​​of some parameters in a parameter list and these parameters, and include an interface for receiving user-defined values ​​of other parameters, the interface having or without boundaries. Parameters may include hooks, the characteristics of hooks, etc., so that the user selects the code generation process of the component and calls during the component.

[0132] The list of the optional parameters of the code generation strategy user can be customized or defined as the user interface element that utilizes the user's expectation.Therefore, the user interface can be customized for the optional parameters of different code generation strategy users, so that the user can select, define or set one or more parameters.In certain embodiments, this customization can allow parameter selection to be driven by the data, expression, formula or dependency with other parameters from the database, rather than listing all possible values.In other embodiments, this customization can specify the code generation strategy user of the parameter and can select aspects.In certain embodiments, this customization can specify the boundary of the user-defined value that is applicable to the parameter.In various embodiments, the code generation strategy parameter list can be the default list of its corresponding component or corresponding template.

[0133] In some embodiments, the list of code generation strategy user selectable parameters may also include other information that may help the user understand the consequences of selecting a particular parameter. For example, the graphical user interface may include links to reference manuals, diagrams, tool tips, etc. that help explain the parameters and how different user selections may affect other components or parameters.

[0134] Process 900 proceeds to frame 946 from frame 944, wherein receives the code generation strategy user selection parameter, template and hook for configurable component.In at least one embodiment, the value of one or more code generation strategy parameters, template or hook is received from the user.As mentioned above, the user can select a specific value from the possible value list of parameter via a graphical user interface.Alternatively, if a boundary is specified, the user can select the specific value of the input parameter according to the boundary or definition.The unacceptable value of the user input may trigger a user warning or automatic adjustment (e.g., select a default value or overwrite selection based on the selection of another parameter or template, etc.).

[0135] In some embodiments, configurable components may include code generation strategy user selectable templates, but do not include code generation strategy user selectable parameters. In such embodiments, blocks 944 and 946 may not be implemented for those selected configurable components that do not include code generation strategy user selectable parameters.

[0136] Process 900 continues to frame 948 from frame 946, wherein one or more settings structures are generated for the selected configurable component based on the user selection parameter for the configuration component, the user selection template for the configuration component, the code generation strategy parameter selected by the user, the code generation strategy template selected by the user, the user selection hook or some combination thereof. In some embodiments, the settings structure can be a list or other data structure of any customizable features of the parameters selected by the identification user and the associated values ​​selected by the user, the template selected by the user and the selected template, or other information indicating how the user customizes the configurable component, the code generation strategy or some combination thereof. In some embodiments, one or more code generation strategy descriptors can be generated for the component based on the code generation strategy settings in the selected component and configuration storage, as discussed in more detail below.

[0137] In various embodiments, the setting structure can be updated by covering the user selection information of the user selection component to overwrite some values ​​of the component. In some embodiments, the component can overwrite the parameters from another component, such as when the components are dependent on each other for calculation. In other embodiments, the component can overwrite the query from another component, such as by changing the selection associated with the component that the user can make. Because some parameters can be set or defined by other templates or components, some parameter values ​​can be propagated or overwritten based on the dependency relationship between parameters, templates and components. For example, the application level value may overwrite the driver level value. In this way, the user selection and change of the application level can change the value or parameter of the driver level, and then these values ​​or parameters can be reflected in the global map or system registry. As mentioned above, in some embodiments, the setting structure 224 and the configuration storage 222 can be combined. Therefore, in some embodiments, the frame 948 can be combined with the next frame 950.

[0138] Process 900 proceeds from box 948 to box 950, where the configuration store 222 is updated based on the settings of each configurable component and the settings of the code generation strategy of the configurable component. The configuration store is an in-memory object that collects all user selections and settings generated via the user's selection of configurable components 204, parameters and templates, including parameters and templates that define the code generation strategy for the user's selection of configurable components 204. Therefore, the parameters, templates, values ​​and other information selected by the user for the configurable components selected by the user are added, updated or otherwise included in the configuration store of the project based on the settings file. The configuration store can be arranged so that the user selection value is a literal that can be written directly into the hardware unit register by the driver software of the programmable computing device. In various embodiments, the configuration store can also retain any content that is used to update the results of expressions, formulas or dependencies based on the user's selection. In this way, when a value is updated, such as when it is changed by a user via a graphical user interface, all related values ​​are updated accordingly in the configuration store. Creating or updating the configuration store can include creating or updating a code generation strategy descriptor file for a component (such as a software component) of a programmable computing device.

[0139] although Fig. 9 It is shown that the configuration store is updated based on the settings structure generated by the user's selection, but the embodiments are not limited to this. In some embodiments, the configuration store can be updated in real time when the user selects components, parameters or templates. Therefore, in some embodiments, the use of the settings structure can be optional. In some embodiments, the images selected by the user can be maintained in a JSON file.

[0140] After box 950, or if in decision box 908, the selected component is not configurable, process 900 flows to box 954. At box 954, the content of the programmable computing device is generated based on the selected component and the information stored in the configuration storage 222, including the code generation policy settings or code generation policy descriptors in the configuration storage 222. It should be noted that information stored in the global registry and related to other components can be used to generate content. For example, information related to the DMA associated with the selected component (e.g., a template associated with the DMA) can be used to generate content associated with the selected component.

[0141] As described herein, a graphical user interface allows a user to select components and values. In other embodiments, this can be implemented by a command line interface without a graphical user interface.

[0142] In some embodiments, the graphical user interface can also present a preview of the content to the user based on the currently selected parameters. In this way, content generation can be triggered each time a parameter is set. When all components are configured, content can be finally generated for the programmable computing device because all values ​​can be used with expected values ​​(applied coverage, calculated expressions / formulas / dependencies, applied code generation strategies).

[0143] From block 954, process 900 proceeds to decision block 956, where it is determined whether the user wants to select another component. If another component is selected, process 900 loops from block 956 to block 906 to receive the user selection of the other component; otherwise, process 900 flows from block 956 to block 958. Process 900 can also be implemented in the case where the user selects multiple components, which can then be configured by the user together or individually.

[0144] At box 958, the content generated for each user-selected component is built into one or more binary images of the project. A binary image is information that a programmable computing device can use to initialize, configure, or control its hardware, software, or a combination thereof. In some embodiments, all of the generated content is used to build a binary image of the project. In other embodiments, a portion but not all of the generated content is used to build a binary image of the project. For example, in the case of an interpreted language, only the specific content (e.g., generated code) can be uploaded to a specific memory area of ​​the programmable computing device without regenerating a binary file that interprets it.

[0145] As illustrated, process 900 proceeds to frame 960 from frame 958, wherein (multiple) binary images are provided to programmable computing devices. In some embodiments, process 900 can sometimes return to frame 904 from frame 958, using the content generated in 958 as the intermediate input of the process. In some embodiments, process 900 can be performed multiple times to generate different content for different configurations of programmable computing devices. In this way, different configurations (even programmable computer devices of the same type) can be provided to separate programmable computing devices, or different configurations can be provided to a single programmable computing device to allow the user of the programmable computing device to change between different configurations. After frame 960, process 900 terminates or otherwise returns to the calling process to implement other actions.

[0146] Fig. 9The illustrated embodiment of process 900 may have more process boxes than illustrated, may have fewer process boxes than illustrated, and the process flow may be modified in various ways. For example, process 900 may be modified to include a box at 950 that presents configuration update information to the user based on the updated configuration storage (e.g., calling process 400). In another example, process boxes 910 and 940 and process boxes 912 and 942 may be combined in some embodiments (e.g., the template may include a template involving a configuration component, a template involving a code generation strategy for a configuration component, or a template involving a configuration component and a code generation strategy for the configuration component). Similarly, process boxes 914 and 944 and process boxes 916 and 946 may be combined in some embodiments (e.g., the parameters may include parameters involving a configuration component, parameters involving a code generation strategy for a configuration component, or parameters involving a configuration component and a code generation strategy for the configuration component). In another example, the process flow may include parallel processing of process boxes rather than the sequential process described. In some embodiments, generating a code generation strategy descriptor may be a separate processing box rather than part of the described box 948. In some embodiments, other variations may be adopted, such as the above reference Figures 1 to 8 Changes in discussion.

[0147] Fig.10 1 shows a conceptual diagram of a process 1000 associated with generating content according to some embodiments described herein. For example, the process 1000 may be performed by Fig. 9 The processing block 954 is adopted. For convenience, Fig.10 Will refer to Fig. 9 The content generation process 1002 includes a code generation routine or process 1004. The code generation routine 1004 processes a template 1006 associated with a component to be configured (e.g., for configuring a component in a Fig. 9 The code generation routine 1004 may include a template for the component selected at box 912 of the example program, a template for configuring the code generation strategy of the component selected at box 942, etc., or a combination thereof). The template may include code 1008 instrumented with Handlebars 1010. The code generation routine 1004 may call one or more Handlebars 1010 to access information in a global map or system registry 1012 to configure the component, the code generation strategy of the component, or a combination thereof. The accessed information may be used to generate a code portion 1014 of the content. The information may include, for example, information specifying how to use input information (e.g., templates 1008, settings, parameters, etc.), how to produce output results (e.g., combining templates, using variations of templates, etc.), and how to organize generated artifacts (e.g., the number of files, names, locations where artifacts are stored).

[0148] Fig.11is a conceptual diagram of a flexible content generation process flow 1100 associated with generating content according to some embodiments described herein, which facilitates customizing code generation strategies associated with software components. For example, process 1100 may be performed by Fig. 9 As illustrated in codegen.js, the content generation service 1102 hooks (see Fig.12 ) calls (illustrated action 1) to the policy descriptor service 1104, which can be included as a deliverable of the software component 1106. The selected code generation service can vary for different software components.

[0149] Policy descriptor service 1104 helps to provide information related to the code generation strategy selected by the user for software components to code generation service, such as templates to be processed, how to process templates, applicable parameters, applicable file names, etc. Other information related to the code generation strategy selected by the user can also be provided, such as a list of hardware resources used by the software component. Policy descriptor service 1104 can include code 1108 for generating an input list 1110 to code generation service, and code generation service 1102 uses this list to implement selected code generation strategy. As illustrated, policy descriptor service 1104 includes JS code (such as JavaScript code) 1108, and this JS code 1108 retrieves (illustrated action 2) at least some information related to the code generation strategy selected by the user from global mapping / system registry when executing. As illustrated, the information related to the code generation strategy selected by the user is provided (illustrated action 3) to code generation service 1102 in the form of an object (such as JSON code generation parameter file 1110). The code generation service uses the Handlebars engine 1112 on the selected template according to the provided information (e.g., parameters of the code generation parameter file 1110). In various embodiments, the provided information may include additional information. The scope of the hook call to the template may also be defined (e.g., before all, after all, before each, after each, etc.), and the resources to which the hook is applied may be defined (e.g., before each component process, before each template parsing, etc.). Different hooks may be used at different stages of the code generation process.

[0150] Fig.12 Illustrate code generation services such as Fig.11 Examples of hooks 1200 that can be used by the code generation service 1102 of FIG. 1 and 1203 are provided below and for convenience only. Fig.11The code generation service employs hook 1200 to call code generation policy parameter file 1110 and processes (illustrated action 4) templates, parameters, etc. associated with software component 1106 based on information related to the user-selected code generation policy provided (action 3) to code generation service 1102 in an object generated using a policy descriptor service (such as code generation parameter file 1110).

[0151] As mentioned above, different hooks can be employed at different stages of the code generation process. Fig.13 is a conceptual diagram illustrating example uses of different hooks at different code generation stages in a code generation process flow 1300 according to some embodiments described herein. As illustrated, a pre-generation hook 1302 is used in a pre-generation stage, e.g., to identify one or more components for which to generate code, hooks to be used in subsequent stages, etc. Parameters of the pre-generation hook 1302 include the component, and data associated with the code generation strategy for the component is collected, such as via a code generation strategy descriptor file.

[0152] For example, in the component mapping phase, a mapping hook 1304 is used to retrieve mapping data associated with a component. The parameters of the mapping hook 1304 include the component and the mapping data associated with the component (e.g., Fig. 9 For example, during the code generation phase, code generation hook 1306 is used to retrieve a mapping file associated with the component.

[0153] For example, the mapping file may indicate that the code is to be generated to produce code having the following order: i) global data declarations; ii) public functions; and iii) private functions. Post-generation hooks 1308 are employed in the post-generation phase, for example, to retrieve information associated with the post-code generation process, such as the location where the generated code may be stored. For example, the post-generation hook may be used to reconstruct the order of the code into: i) global data declarations; ii) private functions; and iii) public functions.

[0154] Fig.14 An example of code 1400 of a policy descriptor service is illustrated, which may be used to generate a code generation parameter file to be provided to a code generation service. Figures 10 to 12 , the code 1400 can be used as the code 1108 included in the policy descriptor service 1104 to generate a code generation parameter file 1110 to be provided to the code generation service 1102 according to the hook 1200 called by the code generation service. The code 1400 can be in the form of a JSON file, a YML file, a memory object, etc. Fig.14In the illustrated example, when the code 1400 is executed, a list of hardware resources for a software component is retrieved (HwInstanceList=getHWInstanceList('componentID:yyyID'), where the component ID is denoted by yyyID. A loop is performed on the list of hardware resources. For each template associated with the hardware resource, a loop is performed to define an output file based on a template file name (_template) customized with a hardware resource identifier (_hwinstance). An object 1402 (e.g., a map) is returned that associates each hardware resource with an output file name. In the code generation phase (e.g., see Fig.10 1004), processes the template with the resource as a parameter, and stores the result in the indicated file name.

[0155] Fig.15 1 illustrates an example of a code generation parameter file 1500 that may be generated in response to a call from a code generation service to a policy descriptor service. Fig.11 , the code generation parameter file 1500 can be generated as a code generation parameter file 1110 in response to a call to a policy descriptor service 1104 associated with a component (including the execution of code 1108 included in the policy descriptor service 1104). As illustrated, the code generation parameter file includes an "id" identifying a code generation policy and a generation parameter, which is set to mandatory as indicated. Identify a grouping of template file sets. Fig.16 Diagram showing the use of the code generation service Fig.15 An example structure 1600 of output code generated by the code generation parameter file 1500 is shown.

[0156] Fig.17 1700, which may be generated in response to a call from a code generation service to a policy descriptor service. Fig.11 , the code generation parameter file 1700 can be generated as a code generation parameter file 1110 in response to a call to a software descriptor service 1104 associated with a component (including the execution of code 1108 included in the policy descriptor service 1104). As illustrated, the code generation parameter file includes an "id" identifying a code generation policy and a generation parameter, which is set to mandatory as indicated. Identify a grouping of template file sets. Fig.18 Diagram showing the use of the code generation service Fig.17 An example structure 1800 of output code generated by the code generation parameter file 1700 is shown.

[0157] Fig.191 is a conceptual diagram illustrating an example of a feature of a custom code generation strategy for a component (such as a UART, as illustrated). At 1, the settings of the UART are selected by the user, for example, via the above reference Figure 3 and 9 User interface discussed. As illustrated, settings include code generation tracking type settings, code generation strategy output folders, and code flavor parameters for UART. A drop-down menu is presented to the user in the user interface to select a tracking type strategy for UART. A drop-down menu may be presented for other code generation strategy settings, and data entry fields (e.g., for identifying output folders) and the like and various combinations thereof may be provided. A default value may be adopted (e.g., if an output folder is not specified, a default output folder may be adopted). The illustrated selected strategy includes a tracking type strategy that generates a code file set for each hardware resource associated with the UART. The selection is stored in a global map (e.g., in a JSON file) as part of a code generation strategy descriptor. The user interface may present additional code generation options to the user and present them at a level other than the component level. For example, a user may be able to select settings to be applied at various granularities, such as project level granularity, component level granularity, etc. A range drop-down menu may be adopted to facilitate selection of a granularity level associated with a code generation strategy setting.

[0158] In the illustrated action 2, the generation of code for a component (e.g., UART) is triggered. The code generation service calls the component hook to retrieve the code generation settings selected by the user for the component, and provides the component generation parameter file to the code generation service to indicate how to generate the code. The code generation service generates code based on the objects provided based on the contents of the component generation parameter file.

[0159] Fig. 20 For example, in Fig. 9 The flowchart of the process 2000 of generating code by the components used in the process 900 and for convenience will be referred to as Figures 9 to 19 The code generation process 2000 begins with the application starting a 2002 code generation routine or box. For example, Fig. 9 The process 900 may start block 954. The code generation routine calls 2004 a hook, such as a hook (e.g. Fig.12 Hook 1200, Fig.13 Hooks 1302, 1304, 1306, 1308) to use policy descriptor services (such as Fig.11The hook can retrieve code generation policy information from the policy descriptor service 1104. For example, the hook can be a javascript function that is delivered as a file with the component for which code is being generated. The hook triggers the execution of code 1108 of the policy descriptor service 1104, which generates a mapping object that is returned 2006 by the hook to the code generation routine. For example, the code generation parameter file (see Fig.15 and 17 The code generation parameters 1500 and 1700 of the code generation routine can be returned to the code generation routine or service. The code generation service calls 2008 a template identified for the component (eg, in an object) that instructs the code generation routine how to process the information provided by the system registry for the component.

[0160] The specific code generation process can be specified by the hooks and templates used, and therefore may be different for different hooks and templates. In the illustrated example, the template uses the get_myctx command (as illustrated) to request 2010 information related to the current resource associated with the component. The information may include configuration information associated with the resource (e.g., signal coupling, etc.). The code generation service returns 2012 the requested information related to the current resource to the template. The template processes the information and generates 2014 configuration signal information associated with the resource.

[0161] Fig.21 is a conceptual diagram illustrating a code generation service using hooks to generate code for components of a programmable computing device based on user selections. The code generation service calls the hooks, which generate objects and provide the objects to the code generation service. These objects identify templates for generating programming code for the corresponding components and how to use these templates. The code generation service uses the objects to generate code using the templates based on the code generation strategy selected by the user.

[0162] Code generation configuration strategies help provide component designers with increased flexibility and control over configuring programmable computing devices. Designers can define options to be presented to users (e.g., templates to be presented, parameters, and hook options), such as by defining a parameters.json file. Designers can define hooks that define how user settings are handled. Designers can define templates that define how user selections (e.g., input objects) are handled to change the results of the code generation process.

[0163] At the same time, a general code generation service can be used. The code generation service obtains customized user selections by calling hooks. The hooks can be defined in a global registry (e.g., based on user input), or global hooks can be called to retrieve customized information based on user input (e.g., stored as settings in a global registry). The code generation service passes the input object returned by the hook to the identified template, and the template uses the object to implement the component's coding strategy.

[0164] Hooks can be declared in the component description (e.g., a pdsc file in the global registry), so hard coding can be avoided. The code generation service can discover the hook based on the component description. The use of hooks is optional for components, and in the absence of hooks, the default code generation strategy can be used. It also promotes flexibility in the selection of code generation services, because hooks can be called by the general coding service based on the component description.

[0165] Reference Figures 1 to 21 One approach is to present a list of specific components to the user for them to choose from for configuration. For example, see Figure 3 Box 304 and Fig. 9 Box 904. The user can start with a specific hardware component of the programmable device (e.g., a specific UART, such as UART4), and the specific hardware component can be configured relative to a specific software component (e.g., a software component that implements specific UART functionality, such as synchronous, asynchronous, smart card, or infrared (IrDa), with a specific driver or API (e.g., HAL, LL)). Similarly, the user can start with a specific software component, and the specific software component can be configured relative to the specific hardware component. The configuration options presented are tightly coupled to the specific hardware component and specific software component selected. A configuration file or object is generated for each specific hardware component and specific software component pair. This is conceptually like Fig. 22 Of course, the same hardware component (eg UART4) can have two different configurations, resulting in two pairs.

[0166] While this approach may be useful, for example when it is desired to use a specific hardware component or a specific software driver, it is not always very flexible. The user must know the specific hardware component or specific software component to start with and make setting selections for the configurable component after selecting the corresponding hardware or software component. Therefore, in order to make appropriate selections in an efficient manner, the user must understand the specific hardware components available and the specific software components available.

[0167] Additionally, configuration of a specific hardware component for use with multiple software components or configuration of a specific software component for use with multiple hardware components may generate a large number of separate configuration files or objects, and each of these files may be quite large. This may increase the complexity of the content generation process, including the refinement of conditions and the resolution of conflicts between selected configuration options. Moreover, conflicts with other component configurations may not be detected until after the configuration of multiple specific hardware component and specific software component pairs is completed. Therefore, when a conflict is detected, the configuration process needs to be restarted with respect to one or more pairs.

[0168] Similarly, if the user decides to select a different configurable hardware component (eg, to avoid conflicts, because another hardware component utilizes a more convenient pin location, etc.), the user must restart the configuration process for the configurable component from the beginning of the configuration process.

[0169] Instead of starting with a specific hardware component and a specific software component pair, a more flexible approach is to select and configure generic components (e.g., expose all features of a type of hardware IP) without having to specify a specific hardware component (e.g., a specific UART) and an associated configuration component dedicated to a specific feature of the hardware IP component at the beginning of the configuration process (e.g., without specifying a specific mode of a specific UART hardware component (e.g., UART1) configured with a specific software API, such as a synchronous UART protocol configured through the STM32HAL driver API). An object storing configuration information for the generic component is created and stored, and the object can be flexibly associated with specific hardware components and software components when it is convenient during the configuration process (e.g., during configuration of the generic component based on some initial selections, during creation or updating of a configuration store, during a content generation process, or a combination thereof). Fig.23 and 24 An example of a method for configuring a common component is conceptually illustrated in .

[0170] Reference Fig.23 and 24 As shown, the user selects the Generic Component to configure the Generic HW UxART Component. The user can create multiple configuration instances for the Generic Component, such as Fig.24 0, Inst#1, Inst#2, and Inst#3 in FIG. 1 . The user may be required to select a logical function or protocol for each instance of the generic component (e.g., synchronous communication, asynchronous communication, smart card functionality, IrDa functionality) and the type of API (e.g., HAL, LL, etc.). Based on the user-selected function or protocol and the user-selected API type, the configuration process may identify available specific hardware components and drivers to associate with the instance of the generic component configuration. The user does not need to know in advance which specific hardware components or software components (e.g., drivers) support the desired generic component configuration.

[0171] For example, refer to Fig.24 , the user can select a synchronous protocol with LL API for the generic component instance Inst#0. The code generation process knows that the available hardware component USART4 supports the requested configuration with the LL USART driver, and the generic component instance Inst#0 is associated with the hardware component USART4 and the software component LL USART driver. In some embodiments, more than one available hardware component may be able to provide the requested functionality, and a list of available hardware components may be presented to the user to provide the requested functionality. Similarly, more than one available software component may be able to provide the requested functionality, and a list of available software components may be presented to the user to provide the requested functionality. In some embodiments, the configuration process may automatically select one of the available components to provide the requested functionality, for example based on conflict analysis or selection criteria. A combination of user selection and automatic selection may be employed.

[0172] In another example, the user can select an asynchronous protocol with LL API for generic component instance Inst#1. The configuration process knows that the available hardware component USART4 supports the requested configuration with LL USART driver and that generic component instance Inst#1 is associated with hardware component USART4 and software component LL USART driver.

[0173] In another example, the user can select a synchronous protocol with HAL API for the general component instance Inst#2. The configuration process knows that the available hardware component USART1 supports the request configuration with the HAL USART driver, and the general component instance Inst#2 is associated with the hardware component USART1 and the software component HAL USART driver. As shown, the HALUSART driver depends on the LL USART driver. The configuration process knows the dependencies of the HAL USART driver and generates dependency conditions, which can be resolved in the subsequent dependency resolution process. However, this is an example, and the HAL USART driver of various embodiments may not depend on the LL driver. Similarly, the user can select an asynchronous protocol with HAL API for the general component instance Inst#2. The configuration process knows that the available hardware component USART1 supports the request configuration with the HAL USART driver, and the general component instance Inst#3 is associated with the hardware component USART1 and the software component HAL USART driver.

[0174] Fig.25is a conceptual diagram illustrating a process for generating content that allows a user to choose between selecting a hardware component (e.g., a specific UART) and then configuring a compatible generic component (a "start from HW" process), or selecting a software component (e.g., a UART driver) and then configuring a compatible generic component (a "start from SW" process), or selecting and configuring a generic component and then selecting appropriate hardware and software components to associate with the generic component.

[0175] A user who is familiar with the available hardware components (e.g., a hardware component that provides multiple functionalities) or a user who wants to use a specific hardware component may decide to start with a specific hardware component (e.g., UART4) 1, and may configure 2 a compatible generic component (e.g., HW UxART). A user who is familiar with the available software components (and their organization) may decide to start with a specific software component (e.g., a specific driver) 1, and may configure 2 a compatible generic component (e.g., HW UxART). Additionally, a user who is not familiar with the available hardware components and available software components or a user who simply wants a specific type of functionality may decide to start with a generic component instance (e.g., a logical HW UxART) that provides, for example, serial communication services, and may configure the generic component, for example, as described below with reference to Figures 26 to 28 The user can combine the three approaches by configuring some components by starting with specific hardware, by configuring some components by starting with specific software, and by configuring some components by starting with generic component instances.

[0176] In 3, the conditions associated with the various configurations can be refined, resulting in the generic component being associated with a complementary hardware component (in the "start from SW" flow), or with a complementary software component (in the "start from HW" flow), or both if the user starts with a generic component.

[0177] In 4, the dependency resolution mechanism selects hardware components, software components, or both based on the conditions refined in 3, and may generate content for the programmable computing device (e.g., as described above with reference to Figures 1 to 21 discussed).

[0178] It should be noted that the configuration files and objects generated from specific hardware components or specific software components can usually include more conditions that need to be stored in the configuration storage, refined and parsed. For example, UART4 can provide synchronous, asynchronous, smart card and IrDa functionality. The configuration file or object associated with the configuration generated from the physical hardware UART4 can contain all conditions associated with each of the functionalities provided by UART4, or as part of the conditional refinement or content generation process, it may be necessary to remove or parse these conditions. For example, during the configuration process 2 starting from the UART4 hardware, all conditions associated with the functionality can be set or selected (for example, default values ​​can be used). During the refinement condition process, these conditions can be transformed into conditions to be stored in the configuration storage. On the contrary, when generating a configuration file or object from a general component instance, during the configuration storage or object generation process, only the conditions associated with the selected functionality can be carried with the configuration information. This can greatly simplify the conditional refinement process in 3 and the dependency resolution process in 4.

[0179] Fig.26 2600 is a logic flow diagram of a process 2600 for customizing a code generation process associated with generating content by configuring common components according to embodiments described herein. Process 2600 begins at block 2604 after start block 2602, where a list of multiple components for a project is presented to a user. Block 2604 may be similar to the process described above with reference to Figure 3 The process is performed in the manner discussed in blocks 302 and 304 (eg, by presenting a graphical interface to a user) wherein the generic component instance is included in the list.

[0180] Fig. 27 An example graphical user interface 2700 is illustrated that may be presented to a user to facilitate selection of components to be configured, such as in Fig.26 In the box 2604 of . In this illustrative example, the graphical user interface 2700 can display a list of hardware components (such as the specific hardware UxART of the programmable device, the specific SPI, the specific I2C, etc.), a list of software components (such as a specific driver) and a list of general components for the project associated with the programmable computing device. As shown, the general component includes a function type (such as Wi-Fi and cellular, encryption, serial communication, etc.). As shown, the serial communication functionality includes multiple HW UxART configuration components to provide serial communication functionality. When the user knows what type of functionality is needed, but does not know or does not necessarily care which specific hardware components and software components (such as drivers) are used to provide the desired functionality, the function type may be useful. This facilitates the use of general component configurations to generate more than one general component instance. Each instance of the general component can then be associated with a specific hardware component and software component.

[0181] Process 2600 continues at block 2606, where a user selection of a component in the component list is received (e.g., via Fig. 27 2600). The process 2600 then proceeds to decision block 2608, where it is determined whether the selected component is a generic component. If the selected component is a generic component, then the process 2600 flows from block 2608 to block 2610; otherwise, the process 2600 flows from block 2608 to block 2622. The processing at block 2622 may generally be as described above with reference to Figure 3 Boxes 310 to 324 or reference Fig. 9 Process 2600 proceeds from block 2622 to block 2624 as described in blocks 910 to 950 of FIG.

[0182] At block 2610, configuration options for the selected generic component are presented to a user, such as via a graphical user interface. Fig.28 2800, which enables a user to select parameters for an instance of a user-selected generic component. The graphical user interface 2800 may display different configurations and possible values ​​for multiple parameters, depending on which configurable generic components the user has selected, according to embodiments described herein.

[0183] Fig. 27 and 28 The user interface type shown can enable users to select components suitable for their projects through various different component layers. Moreover, the graphical user interface tool can help end users resolve dependencies by proposing appropriate components or automatically selecting components when appropriate (e.g., when only one component meets the criteria). Fig. 27 and 28 For illustrative purposes only and should not be considered limiting. According to the embodiments described herein, other information or data may be displayed to a user via a graphical user interface. Templates and hooks may be employed, such as those described above with reference to Figure 3 and 9 discussed.

[0184] Process 2600 proceeds from block 2610 to block 2612, where a user-selected option selection for a selected generic component instance is received (e.g., referring to Fig.28 , selection of HW UxART Inst1). Process 2600 continues from block 2612 to block 2614, where settings for an instance of the selected generic component are generated based on the received generic component configuration option selection, which may include using templates and hooks. For example, as described above with reference to Fig. 9 This may be done as discussed in block 948 of FIG.

[0185] Process 2600 proceeds from box 2614 to box 2616, where the instance of the generic component is associated with a hardware component and a software component based on one or more of the received generic component configuration option selections or the generated settings for the generic component instance. For example, the received generic component configuration option selections for the generic component instance may be compatible only with a single hardware component (e.g., USART1), or with a single software component (e.g., an IrDa / HAL driver for USART1), or may be compatible with several hardware components or software components, and selection criteria may be employed (e.g., avoiding associating a low-speed function with a higher-speed UART than required for the function). In some embodiments, a graphical user interface may be employed to present available options to a user and receive user selections. The association of the generic component instance with a hardware component or a software component may be implemented using one or more hooks, as described above with respect to Figures 9 to 21 As discussed, this hook can be used during the content generation process.

[0186] Process 2600 continues from block 2616 to block 2618, where configuration store 222 is generated or updated based on the settings for the generic component instance and any settings for the code generation policy for the generic component instance, the associated hardware component, the associated software component, or a combination thereof. Fig. 9 This may be done as discussed in block 950 .

[0187] From block 2618, process 2600 proceeds to decision block 2620, where it is determined whether the user wants to select another component to configure. If another component is selected, process 2600 loops from block 2620 to block 2604 to present a list of components to be configured; otherwise, process 2600 flows from block 2620 to block 2624. Process 2600 may also be implemented in the case where the user selects multiple components, which may then be configured by the user together or individually.

[0188] In block 2624, the content generated for each user selected component is built into one or more binary images for the project. A binary image is information that a programmable computing device can use to initialize, configure, or control its hardware, software, or a combination thereof. In some embodiments, all of the generated content is used to build a binary image for the project. In other embodiments, a portion but not all of the generated content is used to build a binary image for the project. For example, in the case of an interpreted language, only the specific content (e.g., generated code) can be uploaded to a specific memory area of ​​the programmable computing device without regenerating a binary file that interprets it.

[0189] As illustrated, process 2600 proceeds from frame 2624 to frame 2626, wherein (multiple) binary images are provided to a programmable computing device. In some embodiments, process 2600 may sometimes return to frame 2626 from frame 2604, using the content generated in 2626 as an intermediate input of the process. In some embodiments, process 2600 may be performed multiple times to generate different content for different configurations of a programmable computing device. In this way, different configurations (even programmable computer devices of the same type) may be provided to separate programmable computing devices, or different configurations may be provided to a single programmable computing device to allow a user of the programmable computing device to change between different configurations. After frame 2626, process 2600 terminates in frame 2628 or otherwise returns to the calling process to perform other actions.

[0190] Fig.26 The illustrated embodiment of process 2600 may have more process blocks than illustrated, may have fewer process blocks than illustrated, and the process flow may be modified in various ways. For example, process 2600 may be modified to include a block for presenting configuration update information to a user based on the updated configuration store at 2618 (e.g., calling process 400). In another example, in some embodiments, associating an instance of a general component with a hardware or software component of process block 2616 may be combined in whole or in part with process block 2614, in whole or in part with process block 2618, in whole or in part with process block 2624, or split between process blocks 2614, 2618, and 2624 in various combinations. In another example, the process flow may include parallel processing of process blocks, rather than the sequential process described.

[0191] The embodiments described herein can be considered to employ two principles to generate content for programmable computing devices: componentization and the use of embedded software. The embedded software is organized in CMSIS packages and components. The embedded software uses tool decomposition and a data-centric tool architecture. The embedded software components provide the tools with the content needed for the tools to use the embedded software, which includes elements for configuring the software components.

[0192] Some users may utilize embodiments of the disclosed content generation system to generate content for programmable devices using the available tools and configuration possibilities. Other users may prefer a file-based approach rather than using configuration tools. Other users may prefer a hybrid approach. To facilitate different user preferences, and as mentioned above, components may be categorized into ready-to-use components and configurable components.

[0193] Ready-to-use components are usually not configurable and may provide, for example, pure C code, it may be a driver (e.g. HAL CRC) or any other software. Ready-to-use components can usually be used in standalone mode. Note that ready-to-use components may have limited configurability.

[0194] In an embodiment, configurable components may be categorized into subcategories: configurable components; self-contained configurable components; and hybrid components.

[0195] Configuration components are used to configure ready-to-use components. Configuration components are usually not used in standalone mode and rely on services provided by the ready-to-use component for configuration. For example, the CRC configuration component helps define the CRC parameters, but the actual code that directs the CRC IP is provided by the "ready-to-use" component (such as HAL CRC). Configuration components can generate initialization (respectively deinitialization), object retrieval and configuration code.

[0196] Self-sufficient configurable components contain code that implements the services they provide as well as elements for configuring those services. This is typically the case for middleware components, which provide both middleware code and configuration artifacts. For self-sufficient configurable components, the selection of each component can be used to determine whether configuration is mandatory or optional. Regardless of configuration, self-sufficient configurable components may have dependencies on other components.

[0197] A hybrid configurable component may be configured via a configuration component that generates code that calls an API of the hybrid configurable component and via a configuration mechanism of the hybrid component, which may typically use a compiler switch.

[0198] Configurable components can support different configuration techniques, such as the standard techniques defined by Open-CMSIS, which are usually based on the copy of files in the user control space. This can be supplemented by adding standard techniques such as wizard annotations.

[0199] Configurable components may also employ configuration techniques of the embodiments described herein. To the extent that the techniques of the described embodiments are not supported by Open-CMSIS-only compatible tools, these techniques may be described in valid Open-CMSIS syntax to avoid generating problems in such tools. Some users may also implement their own configuration techniques and integrate them into systems employing the disclosed embodiments. For example, user-defined configuration panels may be integrated as extensions in the defined user interfaces of the described embodiments; user-specified code generation services may be integrated into the content generation process of the described embodiments, etc.

[0200] In some embodiments, the components provided may be defined in accordance with OpenCMSIS technology and may facilitate the use and utilization of OpenCMSIS configuration technology. At the component level, some files may be defined as configuration files (see the 'attr=config' attribute of the file element), which may be copied to the project component area (RTE folder in the OpenCMSIS reference tool) and may become user-controlled files. At the component level, some files may be defined as template files and may be copied to the project user area (e.g., by the end user using the OpenCMSIS reference tool) and become user-controlled files. These files may be considered reference application code rather than ordinary configuration files. Components may be instantiable (see the 'maxInstances' attribute of the component element): the OpenCMSIS reference tool may make as many copies as file instances marked as 'config' (adding a numbered suffix to the file name).

[0201] The embodiments disclosed herein can be used by any software component (configuration component or configurable component) and can provide a component with, for example, (i) a description of how the component can be configured: possible parameters with values ​​and constraints; (ii) a description of how the user's configuration choices are applied in the project code: a generated code template; (iii) optionally, some specific procedures and fragments (e.g., sections, helpers) referenced in the code generation template file; (iv) (multiple) rules (also called "hooks") that tell the code generation tool how to generate output; (v) (multiple) references to the code generation tool to facilitate the conversion of the user's choices into code (also called "generators"); and (vi) a description of how to update the component definition and related conditions: a gpdsc template.

[0202] In an embodiment, an embedded software component may be implemented, for example, via: (i) JSON files (also called parameters.json) that describe the configurability of the component: these files may be processed by a software configurator; (ii) Handlebars template files that serve as templates for generated code: these files may be used by a code generation service; (iii) JavaScript helper functions and Handlebars sections as procedures and snippets: these files may be used by templates; (iv) JavaScript "hook" functions that are called by the code generation tool to determine the output to be produced (the default strategy may be to group all code that handles the same hardware instance in a single file): this hook may be used by a code generation service; (v) a script (e.g., .bat or .sh) that calls the code generation service: this script may be used by a project manager; and (vi) Handlebars template file for a .gpdsc file: this file may be used by a code generation service.

[0203] The configuration components mentioned above can be classified into two subcategories: standard configuration components disclosed herein and general configuration components. Both can be

[0204] - Expose several API layers (e.g. HAL and LL): 1 software instance uses only 1 layer.

[0205] - Supports instantiation: Software instances can be defined within these components. A software instance typically handles one hardware instance.

[0206] -Supports multiple configurations per software instance (and configurations associated with a software instance typically use the same API layer and the same hardware instance).

[0207] Configuration components can implement the mapping of software instances to hardware instances by relying on the instantiation possibilities provided by the OpenCMSIS specification. Therefore, configuration components are instantiable (their "maxInstances" attribute is greater than 1). This means that the user can create several software instances to configure the same hardware instance for different functionalities or the same functionality.

[0208] A standard configuration component provides a single functionality of a hardware IP. In contrast, a general configuration component can expose all functionality of a hardware IP: all functionality of a hardware instance can be managed by several software instances in the same general configuration component composition entity.

[0209] For standard configuration components, filters can be applied to propose compatible hardware instances for resource selection (e.g.: Sync UART standard component will propose USART hardware instance). A standard configuration component can have several software instances that handle the same unique functionality. As many standard components can be declared as there is functionality to be exposed:

[0210] -Standard component function A

[0211] -Standard component function B

[0212] -…

[0213] - Standard component function N

[0214] Each software instance is dedicated to one hardware instance.

[0215] For example:

[0216] - Standard configuration component for all asynchronous UARTs with UART1

[0217] - Standard configuration component for all synchronous UARTs with UART2

[0218] - Standard configuration components for all smart cards with UART3

[0219] - Standard configuration component for all irDA configurations with UART4

[0220] - Standard configuration components for all configurations UART (Local Interconnect Network) with UART5

[0221] The same hardware instance can be associated with several software instances from different standard configuration components through a single reference. A software instance can be active at a certain point in time.

[0222] The general configuration components disclosed herein facilitate the use of flexible content generation methods, such as Fig.25 and 26 As shown. A common configuration component can have several software instances. Each of these software instances handles the same unique functionality. One common configuration component can be declared for all functionality to be exposed:

[0223] - Common component PPP covers function A,

[0224] - The common component PPP also covers function B,

[0225] -…,

[0226] - The generic component PPP also covers function N.

[0227] Each software instance is dedicated to a hardware instance. For example:

[0228] - Common configuration component for all UxART software examples #1 that configure UART1

[0229] - Common configuration component for all UxART software examples #2 that configure UART2

[0230] - Common configuration component for all UxART software examples #3 that configure UART3

[0231] - Common configuration component for all UxART software examples #4 that configure UART4

[0232] - Common configuration component for all UxART software examples #5 that configure UART5

[0233] The same hardware instance can be associated with several software instances from the same common configuration component through a single reference. A software instance can be active at a certain point in time.

[0234] Typically, a generic configuration component with PPP=UART and another generic configuration component with PPP=USART will not be used. Instead, a generic configuration component covering PPP=UxART will be used. Of course, if the HW instance cannot provide functionality (e.g., UART1 cannot provide synchronization functions), then this functionality is not available to the software instance of the generic configuration component associated with the hardware instance.

[0235] In an embodiment, a method includes: presenting a list of components for a project to a user via a graphical user interface, the project being associated with a programmable computing device; receiving a first selection of a user-selected component for the project from the list of components via the graphical user interface; in response to the user-selected component being configurable: presenting user-selectable component configuration options for the user-selected component via the graphical user interface; receiving a component configuration option selection for the user-selected component via the graphical user interface; presenting user-selectable code generation policy options for the user-selected component via the graphical user interface; receiving a code generation policy option selection for the user-selected component via the graphical user interface; generating settings for the user-selected component based on the received component configuration option selection and the received code generation policy option selection for the user-selected component; and generating or updating a configuration store based on the settings for the user-selected component; and generating content for the programmable computing device based on the user-selected component and the configuration store, the generating content comprising: generating, updating or retrieving a code generation policy parameter file, and generating code associated with the user-selected component based on the code generation policy parameter file.

[0236] In an embodiment, said generating, updating or retrieving said code generation policy parameter file comprises calling a code generation policy descriptor service. In an embodiment, wherein said generating, updating or retrieving said code generation policy parameter file comprises executing code provided by said code generation policy descriptor service. In an embodiment, wherein said executing said code provided by said code generation policy descriptor service comprises generating an object, wherein said object specifies a code generation policy selected for said user selection component. In an embodiment, wherein said generating code associated with said user selection component based on said code generation policy parameter file comprises generating code based on said object. In an embodiment, wherein said executing said code provided by said code generation policy descriptor service comprises retrieving code generation policy settings associated with said selected user component from said configuration storage.

[0237] In an embodiment, the method comprises providing the content to the programmable computing device.

[0238] In an embodiment, presenting user-selectable component configuration options for the user selection component via the graphical user interface includes: presenting a first list of user-selectable templates for the user selection component via the graphical user interface; and presenting a second list of user-selectable parameters for the user selection component via the graphical user interface; and receiving component configuration option selections for the user selection component via the graphical user interface includes: receiving a second selection of at least one user selection template from the first list of user selectable templates via the graphical user interface; and receiving a third selection of at least one user selection parameter from the second list of user selectable parameters via the graphical user interface.

[0239] In an embodiment, said presenting, via said graphical user interface, user-selectable code generation policy options of said user selection component comprises invoking a code generation policy descriptor service.

[0240] In an embodiment, presenting user-selectable code generation policy options for the user-selected component via the graphical user interface includes: presenting a first list of user-selectable code generation policy templates for the user-selected component via the graphical user interface; and presenting a second list of user-selectable code generation policy parameters for the user-selected component via the graphical user interface; and receiving a selection of code generation policy options for the user-selected component via the graphical user interface includes: receiving a second selection of at least one user-selected code generation policy template from the first list of user-selectable templates via the graphical user interface; and receiving a third selection of at least one user-selected code generation policy parameter from the second list of user-selectable parameters via the graphical user interface.

[0241] In an embodiment, the method includes: presenting, via the graphical user interface, a first list of user-selectable configuration templates for the user-selected component; and receiving, via the graphical user interface, a second selection of a user-selected template from the first list of user-selectable configuration templates for the user-selected component, wherein the selected template defines: a component configuration option selection for the user-selected component; a code generation strategy option selection for the user-selected component; or a component configuration option selection for the user-selected component and a code generation strategy option selection for the user-selected component.

[0242] In an embodiment, generating the content includes: generating initialization code based on the code generation strategy parameter file, wherein the initialization code initializes software of the programmable computing device.

[0243] In an embodiment, generating the content includes: generating initialization code based on the code generation strategy parameter file, wherein the initialization code initializes hardware of the programmable computing device.

[0244] In an embodiment, generating the content includes generating application code based on the code generation policy parameter file, the application code controlling software of the programmable computing device.

[0245] In an embodiment, a non-transitory computer-readable medium having content, the content configuring a processing device to implement a method, the method comprising: displaying a list of components for a project to a user via a graphical user interface, the project being associated with a programmable computing device; receiving, via the graphical user interface, a first selection of a user-selected component for the project from the list of components; in response to the user selecting that the component is configurable: displaying, via the graphical user interface, user-selectable component configuration options for the user-selected component; receiving, via the graphical user interface, a selection of component configuration options for the user-selected component; displaying, via the graphical user interface, a selection of component configuration options for the user-selected component; A method of generating a programmable computing device for a component of a programmable computing device comprises: providing the generated content to the programmable computing device. In an embodiment, the content of the computer-readable medium comprises instructions executable by the processing device. In an embodiment, the generating, updating or retrieving the code generation policy parameter file comprises invoking a code generation policy descriptor service. In an embodiment, the generating, updating or retrieving the code generation policy parameter file comprises executing code provided by the code generation policy descriptor service. In an embodiment, said executing said code provided by said code generation policy descriptor service comprises generating an object, said object specifying a code generation policy selected for said user-selected component. In an embodiment, said generating code associated with said user-selected component based on said code generation policy parameter file comprises generating code based on said object. In an embodiment, said executing said code provided by said code generation policy descriptor service comprises retrieving code generation policy settings associated with said selected user component from said configuration store.

[0246] In an embodiment, a computing device includes: a display device; a memory that stores computer instructions in operation; and at least one processor that executes the computer instructions in operation to: present a list of components for a project associated with a programmable computing device via the display device and to a user; receive a first selection of a user-selected component for the project from the list of components; in response to the user selecting that the component is configurable: display user-selectable component configuration options for the user-selected component via the display device; receive a component configuration option selection for the user-selected component; display user-selectable code generation policy options for the user-selected component; receive a code generation policy option selection for the user-selected component; based on the received component configuration option selection and the received code generation policy option selection for the user-selected component, generate settings for the user-selected component; and generate or update a configuration store based on the settings for the user-selected component; and generate content for the programmable computing device based on the user-selected component and the configuration store, the generating content comprising: generating, updating or retrieving a code generation policy parameter file, and generating code associated with the user-selected component based on the code generation policy parameter file. In an embodiment, the at least one processor executes the computer instructions in operation to: provide the content to the programmable computing device. In an embodiment, the generating, updating or retrieving the code generation policy parameter file includes calling a code generation policy descriptor service. In an embodiment, the generating, updating or retrieving the code generation policy parameter file includes executing code provided by the code generation policy descriptor service. In an embodiment, generating the content includes: generating initialization code for initializing software of the programmable computing device based on the code generation policy parameter file; generating initialization code for initializing hardware of the programmable computing device based on the code generation policy parameter file; generating application code for controlling software of the programmable computing device based on the code generation policy parameter file; or a combination of the above.

[0247] In an embodiment, a system comprises: a programmable computing device; and a non-transitory computer-readable medium having content, the content causing a processor, in operation, to: present a list of components for a project to a user via a graphical user interface, the project being associated with the programmable computing device; receive, via the graphical user interface, a first selection of a user-selected component for the project from the list of components; in response to the user selecting that the component is configurable: display, via the graphical user interface, user-selectable component configuration options for the user-selected component; receive, via the graphical user interface, a selection of component configuration options for the user-selected component; display, via the graphical user interface, a user-selectable component configuration option for the user-selected component A code generation policy option may be selected; a code generation policy option selection for the user-selected component is received via the graphical user interface; settings are generated for the user-selected component based on the received component configuration option selection and the received code generation policy option selection for the user-selected component; and a configuration store is generated or updated based on the settings for the user-selected component; content is generated for the programmable computing device based on the user-selected component and the configuration store, the generating content comprising: generating, updating or retrieving a code generation policy parameter file, and generating code associated with the user-selected component based on the code generation policy parameter file; and providing the content to the programmable computing device. In an embodiment, the programmable computing device comprises: a microprocessor, the microprocessor executing the content in operation to initialize the software of the programmable computing device. In an embodiment, the programmable computing device comprises: a microprocessor, the microprocessor executing the content in operation to initialize the hardware of the programmable computing device. In an embodiment, the programmable computing device comprises: a microprocessor, the microprocessor executing the content in operation as a software application of the programmable computing device. In an embodiment, the generating, updating or retrieving the code generation policy parameter file comprises calling a code generation policy descriptor service. In an embodiment, said generating, updating or retrieving said code generation strategy parameter file comprises executing code provided by said code generation strategy descriptor service. In an embodiment, said executing said code provided by said code generation strategy descriptor service comprises generating an object, said object specifying a code generation strategy selected for said user selection component.

[0248] In an embodiment, a method includes: presenting to a user, via a graphical user interface, a list of common components for a project associated with a programmable computing device; receiving, via the graphical user interface, a selection of a user-selected common component for the project from the list of common components; presenting, via the graphical user interface, user-selectable common component configuration options for the user-selected common component; receiving, via the graphical user interface, a common component configuration option selection for the user-selected common component; generating settings for a first instance of the user-selected common component based on the received common component configuration option selection; generating or updating a configuration store based on the generated settings for the first instance of the user-selected common component; and generating content for the programmable computing device based on the configuration store, wherein at least one of the generating settings for the first instance of the common component or the generating or updating the configuration store includes: associating the first instance of the user-selected common component with a software component of the programmable computing device, associating the first instance of the user-selected common component with a hardware component of the programmable computing device, or a combination thereof based on one or more of the received common component configuration option selections.

[0249] In an embodiment, the method comprises providing the generated content to the programmable computing device.

[0250] In an embodiment, presenting user-selectable universal component configuration options for user selection of universal components via the graphical user interface includes: presenting a list of user-selectable functional options for user selection of universal components via the graphical user interface; and presenting a list of user-selectable application programming interface API options for user selection of universal components via the graphical user interface; and receiving a selection of universal component configuration options for the user selection of universal components via the graphical user interface includes: receiving a selection of one or more functional options from the list of user-selectable functional options via the graphical user interface; and receiving a selection of one or more API options from the list of user-selectable API options via the graphical user interface.

[0251] In an embodiment, the first instance of the user-selected generic component is associated with software components and hardware components of the programmable computing device based on one or more of the received generic component configuration option selections, and the method includes: generating a software component list based on the one or more of the received generic component configuration option selections; presenting the generated software component list via the graphical user interface; receiving a selection of a software component from the generated software component list via the graphical user interface; associating the first instance of the user-selected generic component with the selected software component; generating a hardware component list based on the one or more of the received generic component configuration option selections; presenting the generated hardware component list via the graphical user interface; receiving a selection of a specific hardware component from the generated hardware component list via the graphical user interface; and associating the first instance of the user-selected generic component with the selected hardware component. In an embodiment, the method includes generating the hardware component list based on the selected software component. In an embodiment, the method includes generating the software component list based on the selected hardware component. In an embodiment, generating the content includes: generating initialization code based on the configuration storage, the initialization code initializing software of the programmable computing device.

[0252] In an embodiment, generating the content includes: generating initialization code based on the configuration storage, the initialization code initializing the hardware of the programmable computing device. In an embodiment, generating the content includes: generating application code based on the configuration storage, the application code controlling the software of the programmable computing device.

[0253] In an embodiment, the first instance of the user-selected generic component is associated with a single hardware component of the programmable computing device. In an embodiment, the first instance of the user-selected generic component is associated with a single software component of the programmable computing device.

[0254] In an embodiment, the method includes associating a second instance of a user-selected generic component with the hardware component of the programmable computing device associated with the first instance of the user-selected generic component. In an embodiment, the method includes associating a second instance of a user-selected generic component with the software component of the programmable computing device associated with the first instance of the user-selected generic component.

[0255] In an embodiment, the method includes: presenting, via the graphical user interface, a user-selectable code generation policy option for the first instance of the user-selected generic component; receiving, via the graphical user interface, a code generation policy option selection for the first instance of the user-selected generic component; generating content for the programmable computing device based on the code generation policy option selection for the first instance of the user-selected generic component. In an embodiment, generating content includes invoking a code generation policy descriptor service.

[0256] In an embodiment, the code generation strategy option selection specifies a hardware component of the programmable computing device to be associated with the first instance of the user-selected general component; a software component of the programmable computing device to be associated with the first instance of the user-selected general component; or a hardware component of the programmable computing device to be associated with the first instance of the user-selected general component and a software component of the programmable computing device to be associated with the first instance of the user-selected general component.

[0257] In an embodiment, the method includes: updating the settings for the first instance of the user-selected common component based on the settings associated with the second instance of the user-selected common component; updating the association between the first instance of the user-selected common component and the software component based on the settings associated with the second instance of the user-selected common component; updating the association between the first instance of the user-selected common component and the hardware component based on the settings associated with the second instance of the user-selected common component; or a combination of the above.

[0258] In an embodiment, the method includes: updating the configuration store; and generating content for the programmable computing device based on the updated configuration store.

[0259] In an embodiment, a non-transitory computer-readable medium having content, the content configuring a processing device to implement a method, the method comprising: presenting to a user, via a graphical user interface, a list of common components for a project associated with a programmable computing device; receiving, via the graphical user interface, a first selection of a user-selected common component for the project from the list of common components; presenting, via the graphical user interface, user-selectable common component configuration options for the user-selected common component; receiving, via the graphical user interface, a common component configuration option selection for the user-selected common component; generating settings for a first instance of the user-selected common component based on the received common component configuration option selection; generating or updating a configuration store based on the settings for the first instance of the user-selected common component; and generating content for the programmable computing device based on the configuration store, wherein at least one of generating settings for the first instance of the common component or generating or updating the configuration store comprises: associating the first instance of the user-selected common component with a software component of the programmable computing device, associating the first instance of the user-selected common component with a hardware component of the programmable computing device, or a combination thereof, based on one or more of the received common component configuration option selections. In an embodiment, the method includes providing the generated content to the programmable computing device. In an embodiment, the content of the computer-readable medium includes instructions executable by the processing device. In an embodiment, the method includes calling a code generation policy descriptor service. In an embodiment, the method includes executing code provided by the code generation policy descriptor service. In an embodiment, the executing the code provided by the code generation policy descriptor service includes generating an object that specifies a code generation policy selected for the first instance of the user-selected general component. In an embodiment, the code generation policy selected for the first instance of the user-selected general component specifies a hardware component of the programmable computing device associated with the first instance of the user-selected general component; a software component of the programmable computing device associated with the first instance of the user-selected general component; or a hardware component of the programmable computing device associated with the first instance of the user-selected general component and a software component of the programmable computing device associated with the first instance of the user-selected general component.

[0260] In an embodiment, a computing device comprises: a display device; a memory storing computer instructions in operation; and at least one processor executing the computer instructions in operation to: present a list of common components for a project to a user via a graphical user interface, the project being associated with a programmable computing device; receiving a first selection of a user-selected common component for the project from the list of common components via the graphical user interface; presenting user-selectable common component configuration options for the user-selected common component via the graphical user interface; receiving a selection of a common component configuration option for the user-selected common component via the graphical user interface; and selecting a common component configuration option based on the received selection. Generic component configuration option selection, generating settings for a first instance of the user-selected generic component; generating or updating a configuration store based on the settings for the first instance of the user-selected generic component; and generating content for the programmable computing device based on the configuration store, wherein at least one of the generating settings for the first instance of the generic component or the generating or updating the configuration store comprises: associating the first instance of the user-selected generic component with a software component of the programmable computing device based on one or more of the received generic component configuration option selections, associating the first instance of the user-selected generic component with a hardware component of the programmable computing device, or a combination thereof. In an embodiment, the at least one processor is operative to execute the computer instructions to: provide the generated content to the programmable computing device. In an embodiment, the objects in the configuration store specify: a hardware component of the programmable computing device to be associated with the first instance of the user-selected generic component; a software component of the programmable computing device to be associated with the first instance of the user-selected generic component; or a hardware component of the programmable computing device to be associated with the first instance of the user-selected generic component, and a software component of the programmable computing device to be associated with the first instance of the user-selected generic component.

[0261] In an embodiment, a system includes: a programmable computing device; and a non-transitory computer-readable medium having content, the content causing a processor in operation to: present a list of common components for a project associated with the programmable computing device to a user via a graphical user interface; receive, via the graphical user interface, a first selection of a user-selected common component for the project from the list of common components; present, via the graphical user interface, user-selectable component configuration options for the user-selected common component; receive, via the graphical user interface, a component configuration option selection for the user-selected common component; based on the received component configuration option selection, generate settings for a first instance of the user-selected common component; generate or update a configuration store based on the settings for the first instance of the user-selected common component; and generate content for the programmable computing device based on the configuration store, wherein at least one of the generating settings for the first instance of the common component or the generating or updating the configuration store comprises: based on one or more of the received common component configuration option selections, associating the first instance of the user-selected common component with a software component of the programmable computing device, associating the first instance of the user-selected common component with a hardware component of the programmable computing device, or a combination thereof. In an embodiment, the programmable computing device comprises: a microprocessor, the microprocessor being operable to execute at least a portion of the generated content to initialize software of the programmable computing device. In an embodiment, the programmable computing device comprises: a microprocessor, the microprocessor being operable to execute at least a portion of the generated content to initialize hardware of the programmable computing device. In an embodiment, the programmable computing device comprises: a microprocessor, the microprocessor being operable to execute at least a portion of the generated content as a software application of the programmable computing device. In an embodiment, the objects in the configuration store specify: a hardware component of the programmable computing device for associating with the first instance of the user-selected generic component; a software component of the programmable computing device for associating with the first instance of the user-selected generic component; or a hardware component of the programmable computing device for associating with the first instance of the user-selected generic component and a software component of the programmable computing device for associating with the first instance of the user-selected generic component.

[0262] The titles and abstracts of the disclosure provided herein are for convenience only and do not limit or interpret the scope or meaning of the embodiments.

[0263] The various embodiments described above can be combined to provide further embodiments. Aspects of the embodiments can be modified, if necessary to employ concepts of the various patents, applications and publications to provide further embodiments.

[0264] In light of the above detailed description, these and other changes can be made to the embodiments. Generally, in the following claims, the terms used should not be interpreted as limiting the claims to the specific embodiments disclosed in the specification and claims, but should be interpreted to include all possible embodiments and the full range of equivalents to which such claims are given. Therefore, the claims are not limited by the present disclosure.

Claims

1. A method comprising: presenting to a user, via a graphical user interface, a list of components for a project, the project being associated with a programmable computing device; receiving, via the graphical user interface, a first selection of a user-selected component for the item from the list of components; In response to the user selection the component is configurable: presenting, via the graphical user interface, user-selectable component configuration options for the user to select a component; receiving, via the graphical user interface, a selection of a component configuration option for the user-selected component; presenting, via the graphical user interface, user-selectable code generation strategy options for the user selection component; receiving, via the graphical user interface, a code generation strategy option selection for the user-selected component; generating settings for the user-selected component based on the received component configuration option selection and the received code generation strategy option selection for the user-selected component; as well as generating or updating a configuration store based on the settings for the user-selected component; as well as Generating content for the programmable computing device based on the user selection component and the configuration storage includes generating, updating or retrieving a code generation policy parameter file, and generating code associated with the user selection component based on the code generation policy parameter file. 2 . The method of claim 1 , wherein said generating, updating or retrieving said code generation strategy parameter file comprises invoking a code generation strategy descriptor service. 3 . The method of claim 2 , wherein said generating, updating or retrieving said code generation strategy parameter file comprises executing code provided by said code generation strategy descriptor service. 4 . The method of claim 3 , wherein said executing said code provided by said code generation policy descriptor service comprises generating an object specifying a code generation policy selected for said user-selected component. 5 . The method of claim 4 , wherein said generating code associated with said user-selected component based on said code generation policy parameter file comprises generating code based on said object. 6 . The method of claim 3 , wherein the executing the code provided by the code generation policy descriptor service comprises retrieving code generation policy settings associated with the selected user component from the configuration store.

7. The method according to claim 1, comprising: The content is provided to the programmable computing device.

8. The method according to claim 1, wherein: The presenting, via the graphical user interface, user-selectable component configuration options for the user-selected component comprises: presenting, via the graphical user interface, a first list of user-selectable templates for the user selection component; and presenting, via the graphical user interface, a second list of user-selectable parameters for the user selection component; and The receiving, via the graphical user interface, a selection of a component configuration option for the user-selected component comprises: receiving, via the graphical user interface, a second selection of at least one user-selected template from the first list of user-selectable templates; and A third selection of at least one user-selected parameter is received from the second list of user-selectable parameters via the graphical user interface.

9. The method of claim 1, wherein the presenting, via the graphical user interface, user-selectable code generation policy options of the user selection component comprises invoking a code generation policy descriptor service.

10. The method according to claim 1, wherein: The presenting, via the graphical user interface, user-selectable code generation strategy options for the user-selectable component comprises: presenting, via the graphical user interface, a first list of user-selectable code generation policy templates for the user selection component; and presenting, via the graphical user interface, a second list of user-selectable code generation policy parameters for the user selection component; and The receiving, via the graphical user interface, a code generation strategy option selection for the user-selected component comprises: receiving, via the graphical user interface, a second selection of at least one user-selected code generation policy template from the first list of user-selectable templates; and A third selection of at least one user-selected code generation strategy parameter is received from the second list of user-selectable parameters via the graphical user interface.

11. The method according to claim 1, comprising: presenting, via the graphical user interface, a first list of user-selectable configuration templates for the user-selection component; as well as Receiving, via the graphical user interface, a second selection of a user-selection template from the first list of user-selectable configuration templates for the user-selection component, wherein the selected template defines: selection of component configuration options for said user-selected component; selection of a code generation strategy option for said user-selected component; or A component configuration option selection for the user-selected component and a code generation strategy option selection for the user-selected component.

12. The method of claim 1, wherein generating the content comprises: Initialization code is generated based on the code generation strategy parameter file, and the initialization code initializes software of the programmable computing device.

13. The method of claim 1, wherein generating the content comprises: Initialization code is generated based on the code generation strategy parameter file, and the initialization code initializes hardware of the programmable computing device.

14. The method of claim 1, wherein generating the content comprises: Application code is generated based on the code generation policy parameter file, the application code controlling software of the programmable computing device.

15. A non-transitory computer-readable medium having content, the content configuring a processing device to perform a method, the method comprising: displaying, via a graphical user interface, to a user a list of components for a project, the project being associated with a programmable computing device; receiving, via the graphical user interface, a first selection of a user-selected component for the item from the list of components; In response to the user selection the component is configurable: displaying, via the graphical user interface, user-selectable component configuration options for the user to select a component; receiving, via the graphical user interface, a selection of a component configuration option for the user-selected component; displaying, via the graphical user interface, user-selectable code generation strategy options for the user selection component; receiving, via the graphical user interface, a code generation strategy option selection for the user-selected component; generating settings for the user-selected component based on the received component configuration option selection and the received code generation strategy option selection for the user-selected component; as well as generating or updating a configuration store based on the settings for the user-selected component; as well as Generating content for the programmable computing device based on the user selection component and the configuration storage includes generating, updating or retrieving a code generation policy parameter file, and generating code associated with the user selection component based on the code generation policy parameter file.

16. The non-transitory computer readable medium of claim 15, wherein the method comprises: The generated content is provided to the programmable computing device.

17. The non-transitory computer-readable medium of claim 15, wherein the contents of the computer-readable medium include instructions executable by the processing device. 18 . The non-transitory computer-readable medium of claim 15 , wherein said generating, updating, or retrieving the code generation strategy parameter file comprises invoking a code generation strategy descriptor service.

19. The non-transitory computer-readable medium of claim 18, wherein said generating, updating, or retrieving the code generation strategy parameter file comprises executing code provided by the code generation strategy descriptor service.

20. The non-transitory computer-readable medium of claim 19, wherein the executing the code provided by the code generation policy descriptor service comprises generating an object that specifies the code generation policy selected for the user-selection component.

21. The non-transitory computer readable medium of claim 20, wherein the generating code associated with the user-selection component based on the code generation policy parameter file comprises generating code based on the object.

22. The non-transitory computer-readable medium of claim 19, wherein the executing the code provided by the code generation policy descriptor service comprises retrieving code generation policy settings associated with the selected user component from the configuration store.

23. A computing device comprising: Display devices; a memory operable to store computer instructions; as well as at least one processor operable to execute the computer instructions to: presenting, via the display device and to a user, a list of components for a project, the project being associated with a programmable computing device; receiving a first selection of a user-selected component for the item from the list of components; In response to the user selection the component is configurable: displaying, via the display device, user-selectable component configuration options for the user-selected component; receiving a component configuration option selection for said user-selected component; displaying user-selectable code generation strategy options for the user-selected component; receiving a code generation strategy option selection for said user-selected component; generating settings for the user-selected component based on the received component configuration option selection and the received code generation strategy option selection for the user-selected component; as well as generating or updating a configuration store based on the settings for the user-selected component; as well as Generating content for the programmable computing device based on the user selection component and the configuration storage includes generating, updating or retrieving a code generation policy parameter file, and generating code associated with the user selection component based on the code generation policy parameter file.

24. The computing device of claim 23, wherein the at least one processor is operative to execute the computer instructions to: The content is provided to the programmable computing device.

25. The computing device of claim 23, wherein said generating, updating, or retrieving the code generation policy parameter file comprises invoking a code generation policy descriptor service.

26. The computing device of claim 25, wherein the generating, updating, or retrieving the code generation policy parameter file comprises executing code provided by the code generation policy descriptor service.

27. The computing device of claim 23, wherein generating the content comprises: generating, based on the code generation strategy parameter file, initialization code for initializing software of the programmable computing device; generating initialization code for initializing hardware of the programmable computing device based on the code generation strategy parameter file; generating application code for software controlling the programmable computing device based on the code generation policy parameter file; or A combination of the above.

28. A system comprising: Programmable computing devices; as well as A non-transitory computer-readable medium having contents operable to cause a processor to: presenting to a user, via a graphical user interface, a list of components for a project, the project being associated with the programmable computing device; receiving, via the graphical user interface, a first selection of a user-selected component for the item from the list of components; In response to the user selection the component is configurable: displaying, via the graphical user interface, user-selectable component configuration options for the user to select a component; receiving, via the graphical user interface, a selection of a component configuration option for the user-selected component; displaying, via the graphical user interface, user-selectable code generation strategy options for the user selection component; receiving, via the graphical user interface, a code generation strategy option selection for the user-selected component; generating settings for the user-selected component based on the received component configuration option selection and the received code generation strategy option selection for the user-selected component; as well as generating or updating a configuration store based on the settings for the user-selected component; generating content for the programmable computing device based on the user selection component and the configuration storage, the generating content comprising: generating, updating or retrieving a code generation policy parameter file, and generating code associated with the user selection component based on the code generation policy parameter file; as well as The content is provided to the programmable computing device.

29. The system of claim 28, wherein the programmable computing device comprises: A microprocessor is operable to execute the content to initialize software of the programmable computing device.

30. The system of claim 28, wherein the programmable computing device comprises: A microprocessor is operable to execute the contents to initialize hardware of the programmable computing device.

31. The system of claim 28, wherein the programmable computing device comprises: A microprocessor is operable to execute the content as a software application of the programmable computing device.

32. The system of claim 28, wherein said generating, updating or retrieving said code generation strategy parameter file comprises invoking a code generation strategy descriptor service.

33. The system of claim 32, wherein said generating, updating or retrieving said code generation strategy parameter file comprises executing code provided by said code generation strategy descriptor service.

34. The system of claim 33, wherein the executing the code provided by the code generation policy descriptor service comprises generating an object specifying the code generation policy selected for the user selection component.

Images