Description:A SYSTEM AND A METHOD TO CONVERT RECIPE INTO EXECUTABLE COOKING INSTRUCTION

FIELD OF THE DISCLOSURE
[1] The present invention generally pertains to a system and method to convert recipe into executable cooking instruction.
BACKGROUND
[2] The subject matter discussed in the background section should not be assumed to be prior art merely as a result of its mention in the background section. Similarly, a problem mentioned in the background section or associated with the subject matter of the background section should not be assumed to have been previously recognized in the prior art. The subject matter in the background section merely represents different approaches, which in and of themselves may also correspond to implementations of the claimed technology.
[3] The art of cooking has evolved significantly over the years, driven by an increasing desire for home-cooked meals using fresh, minimally processed ingredients. This trend is fuelled by several factors, including the proliferation of cooking media, advancements in cooking technology, and a growing interest in self-sufficiency in food preparation. Despite these advancements, home cooks often face challenges in translating complex recipes into actionable steps, particularly when using modern cooking appliances that require precise inputs.
[4] Therefore, the present invention addresses the aforementioned limitations and unmet needs in the field of cooking instruction by providing a novel system and method for generating cooking instructions using a dual-layer translation system.

SUMMARY
[5] This summary is provided to introduce a selection of concepts that are further described below in the Detailed Description. It is not intended to identify key features or essential features of the claimed subject matter, nor is it intended to be used to limit the scope of the claimed subject matter.
[6] According to an aspect, the present embodiments disclose a system to convert recipe into executable cooking instruction. The system comprises a memory storing instructions and a processor coupled to the memory. The processor executing the instructions to upload the recipe information on the server, via the user device. The processor generating the high-level cooking instructions from the recipe information. The processor converting the high-level cooking instructions into the low-level instruction via the automated cooking hub. The processor generating the just in time status for the low-level cooking instruction via the just in time module. The processor prepares the recipe for the user via the automated cooking hub.
[7] In an embodiment, the server includes a large learning model to identify the ingredients of the recipe.
[8] In an embodiment, the processor concerts the recipe into a high-level cooking instructions which are a machine independent instructions.
[9] In an embodiment, the memory includes a recipe generator may utilize the large language model to generate the recipes from the information shared by the user device.
[10] In an embodiment, the memory includes a recipe store that may hold free recipes or commercially available recipes for the users to download into the automated cooking hub.
[11] In an embodiment, the processor generates high-level cooking instructions via the large language model.
[12] In an embodiment, the high-level cooking instructions are represented as action tag and parameters. The action tag indicates the action to be taken, and the parameters tag indicates the different parameters to be considered in performing that action associated to the action tag.
[13] In an embodiment, the automated cooking hub further comprises a one or more processors to convert the high-level cooking instructions into a low-level cooking instructions. The one or more processors executes these instructions on a plurality of workstations via a plurality of cooking robots there by performing the desired actions to cook the specified dish at least based on the recipe file.
[14] In an embodiment, low-level cooking instructions are represented as pneumonic and parameters. The pneumonic indicates a low-level action to be taken, and the parameters considered in performing the low-level action.
[15] In an embodiment, the one or more processors includes a just in time (JIT) module to interprets the high-level cooking instructions into low-level cooking commands. The JIT module provide a JIT status of the automated cooking hub such as availability of a plurality of workstations and a plurality of cooking robots. The JIT status is recorded in a machine data structure (MDS). The MDS status is continuously changed as the utensils are moved around, and peripherals are controlled, and robot is moved during the cooking progresses.
[16] In an embodiment, the automated cooking hub includes an input device to visually capture the information of the automated cooking hub. The automated cooking hub includes a look ahead method to optimize the cooking process by efficiently managing resources and utensil occupancy.
[17] In an embodiment, automated cooking hub (106) maintains a Look Ahead Memory (LAM), where MDS data is transferred prior to generating new instruction files. The cooking instruction generation cannot proceed due to inadequate resources, the LAM is reset to its original MDS status. The translation of cooking instruction is successful, the LAM is transferred to a different memory that retains the anticipated MDS.
[18] According to an aspect, the present embodiments disclose a method to convert recipe into executable cooking instruction. The method comprising steps of executing the instructions to upload the recipe information on the server, via the user device. The method comprising steps of generating the high-level cooking instructions from the recipe information. The method comprising steps of converting the high-level cooking instructions into the low-level instruction via the automated cooking hub. The method comprising steps of generating the just in time status for the low-level cooking instruction via the just in time module. The method comprising steps of preparing the recipe for the user via the automated cooking hub.
[19] It should be appreciated that the above one or more aspects comprise the features hereinafter fully described and particularly pointed out in the claims. The following description and the drawings set forth in detail certain illustrative features of the one or more aspects. These features are only indicative of the various ways in which the principles of various aspects may be employed, and this disclosure is intended to include all such aspects and their equivalents.

BRIEF DESCRIPTION OF DRAWINGS
[20] The accompanying drawings illustrate various embodiments of systems, methods, and embodiments of various other aspects of the disclosure. Any person with ordinary skills in the art will appreciate that the illustrated element boundaries 30 (e.g. boxes, groups of boxes, or other shapes) in the figures represent one example 6 of the boundaries. It may be that in some examples one element may be designed as multiple elements or that multiple elements may be designed as one element. In some examples, an element shown as an internal component of one element may be implemented as an external component in another, and vice versa. Furthermore, elements may not be drawn to scale. Non-limiting and non-exhaustive descriptions are described with reference to the following drawings. The components in the figures are not necessarily to scale, emphasis instead being placed upon illustrating principles.
[21] FIG. 1 illustrates a block diagram of a cooking instruction generation system (100), in accordance with an embodiment of the disclosure.
[22] FIG. 2 a block diagram of the server, in accordance with an embodiment of the present invention.
[23] FIG. 3 illustrates a block diagram of the automated cooking hub, in accordance with an embodiment of the disclosure.
[24] FIG. 4 illustrates a flowchart illustrating a look ahead method for generating cooking queue in the automated cooking hub, in accordance with an embodiment of the disclosure.
[25] FIG. 5 illustrates a sequence diagram is illustrated that depicts a method to convert recipe into executable instruction in the system, in accordance with an embodiment of the present invention

DETAILED DESCRIPTION
[26] Some embodiments of this disclosure, illustrating all its features, will now be discussed in detail. The words “comprising,” “having,” “containing,” and “including,” and other forms thereof, are intended to be equivalent in meaning and be open ended in that an item or items following any one of these words is not meant to be an exhaustive listing of such item or items or meant to be limited to only the listed item or items. It must also be noted that as used herein and in the appended claims, the singular forms “a,” “an,” and “the” include plural references unless the context clearly dictates otherwise.
[27] Although any systems and methods similar or equivalent to those described herein can be used in the practice or testing of embodiments of the present disclosure, the preferred, systems and methods are now described. Embodiments of the present disclosure will be described more fully hereinafter with reference to the accompanying drawings in which like numerals represent like elements throughout the several figures, and in which example embodiments are shown. Embodiments of the claims may, however, be embodied in many different forms and should not be construed as limited to the embodiments set forth herein. The examples set forth herein are non-limiting examples and are merely examples among other possible examples.
[28] In the following detailed description, references are made to the accompanying drawings that form a part hereof, and in which are shown by way of illustrations specific aspects or examples. These aspects may be combined, other aspects may be utilized, and structural changes may be made without departing from the spirit or scope of the present disclosure. The following detailed description is therefore not to be taken in a limiting sense, and the scope of the present disclosure is defined by the claims and their equivalents.
[29] The system and method for generating cooking instructions using a dual-layer translation layer provide a comprehensive solution for automating and optimizing cooking processes. The dual-layer approach ensures that high-level cooking instructions are accurately translated into machine-dependent low-level instructions, reducing errors in recipe execution. The system allows for easy modification of cooking instructions based on user preferences or ingredient availability, enhancing the flexibility of the cooking process. The system may be scaled up to handle complex recipes with multiple layers or components, such as layered cakes or lasagnas, by efficiently managing the translation and execution of instructions for each layer.
[30] FIG.1 illustrates a block diagram of a cooking instruction generation system (100), in accordance with an embodiment of the disclosure. The cooking instruction generation system (100A) may be referred as “system”. The system (100A) allows a user device (102) to input plain text or text with images. The user device may include, for example, a mouse, a keyboard, a touchscreen, a touchpad, a wearable input device (e.g., a haptics glove, a bracelet, a ring, an earring, a necklace, a watch, etc.), a camera (or other light-based input device, e.g., an infrared sensor), a microphone, voice commands, active transparent display or other user input devices. The user device (102) in the system (100), allowing users to upload the desired recipe images on the server (108),via a network (104). The sever (108) may convert the desired recipe data into a high-level cooking instruction that may be communicated with an automated cooking hub (106). The high-level cooking instruction may be communicated via the network (104). It may be noted that the users (102) may wirelessly connect to the network (104) via a computing device, mobile phone, laptop, or similar device etc. In additional embodiment, a plurality of user devices (not shown) may be connected to the network (104).
[31] In an embodiment, the user device (102) may be connected to a server (108) via a network (104). The server (108) may receive a set of information from the user device (102) for converting the recipe data into the high-level cooking instructions for the automated cooking hub (106). For example, the set of information may be a webpage with images, a pre-processor removes the images from HTML script and converts it into a plain text and then sends it to the large language model for conversion. Further, the server (108) includes a processor (110) to processes the recipe data at least based on the instructions stored in a memory (112). The sever (110) may utilize one or more processors (not shown) to execute the received recipe data from the user device (102).
[32] In an embodiment, the processor (110) may communicate the recipe data to a large language model (114). The large language model (114) may identify the ingredients of the recipe. The processor (110) may concert the recipe into high-level cooking instructions which are a machine independent instructions. For example, the automated cooking hub (106) may include three induction stoves, and another automated cooking hub (106) may include only two induction stoves. Thus, the high-level cooking instructions do not tell which induction stove to use. The high-level cooking instructions are logical, and describe the logical cooking process, and do not describe the physical address or location or type of the resource to be used. Further, the recipe file may be a canonical file that includes high level instructions about how to cook the dish. The recipe file includes these contents in encrypted format for security purposes. Such the recipe file may be sent through internet to any automated cooking hub (106) or copied or pushed from one machine to another machine through the network (104).
[33] In an embodiment, the server (108) may create a recipe store for the users on the user device (102) to download recipes into desired automated cooking hub (106) through an available over thew network (104). For example, the recipe store may hold free recipes or commercially available recipes for the users to download into the automated cooking hub (106). The user device (102) may include a mobile application to browse the recipe store. The recipes are encrypted for security, and distributed using a PKI infrastructure. Further, the recipe store is integrated with a payment gateway in order for users to be able to purchase the recipes that have a price tag.
[34] The server (108) may be a specialized computer or software system designed to deliver services, data, or resources to other computers, referred to as clients, over the network (104). It may function as a central hub or facilitator within a networked environment, performing various roles to enhance communication, data processing, and resource management. The server (108) may take the form of different types, such as a web server, file server, database server, email server, or application server. Additionally, the server (108) may be part of or accessible through a local area network (LAN), a mobile communications network, a satellite communications network, the Internet, a public or private cloud, a hybrid cloud, a server farm, or any combination of these.
[35] FIG. 2 illustrates a block diagram of the server (108), in accordance with an embodiment of the present invention. In another embodiment, the server (108) may include one or more processing units (110) (e.g., central processing units (CPUs), graphical processing units (GPUs), holographic processing units (HPUs), etc.) The one or more processing units (110) may be a single processing unit or multiple processing units that may be distributed across multiple cloud servers. Further, the one or more processing units (110) may be coupled with other hardware devices, for example, with the use of an internal or external bus, such as a PCI bus, SCSI bus, or wireless connection.
[36] In an exemplary embodiment, the one or more processing units (110) may be coupled to a communication device (124) capable of communicating wirelessly or via a wired connection with other local computing devices or cloud servers. The communication device (124) may communicate with another device or a server through a network using, for example, TCP/IP protocols. For example, the one or more processing units (110) may utilize the communication device (124) to distribute operations across cloud servers.
[37] In another embodiment, the one or more processing units (110) may have access to a memory (112) in a server (108) which may be contained in the user device (102) and the automated cooking hub (106) or may be distributed across cloud servers or other external devices. The memory (112) may include a dataset to store a pre-defined instruction for performing one or more tasks on behalf of the recipe generator (120) or the recipe store (122). The memory (124) may include internal storage, removable storage, and/or local storage, such as solid-state memory, a flash drive, a memory card, random access memory (RAM), read-only memory (ROM), etc. Further, the memory (112) includes one or more hardware devices for volatile or non-volatile storage and may include both read-only and writable memory. For example, the memory (112) may include one or more of: random access memory (RAM), various caches, CPU registers, read-only memory (ROM), and writable non-volatile memory, such as flash memory, hard drives, floppy disks, CDs, DVDs, magnetic storage devices, tape drives, and so forth. The memory (112) may include a program memory (116) that stores programs and software, such as an operating system (118), and the recipe generator (120). The operating system (118) may be configured to run the recipe generator (120) on the user device (102). The recipe generator (120) may utilize the large language model (114) to generate the recipes from the information shared by the user device (102). The memory (112) may also include a recipe store (122) that may hold free recipes or commercially available recipes for the users to download into the automated cooking hub (106).
[38] Together, these components facilitate an interactive experience where digital elements are aligned with real-world objects, allowing for a seamless blending of physical and digital realms without the need for special equipment, thereby enhancing user engagement and immersion in various applications.
[39] In an embodiment, the one or more processors (110) via the large language model (114), may be configured to generate the high-level cooking instructions that are represented as action tag and parameters. The action tag indicates the action to be taken, and the parameters tag indicate the different parameters to be considered in performing that action associated to the action tag.
[40] In an exemplary embodiment, the high-level cooking instructions may be represented as for the automated cooking hub:
Place Vessel Instruction:
Format:
Description: This instruction involves picking up a suitable vessel and placing it on a designated area.
Parameters:
Vessel#: A logical number for the vessel (e.g., #1, #2).
Vesseltype: Type of vessel (0-5), such as grinder, deep vessel, or pan.
Totalweight: Total weight of items to be filled in the vessel for one serving.
Area: Designated area where the vessel is placed (e.g., ip#1, ip#2, UA).
Heat Vessel Instruction:
Format: <0/l/m/h/nnn>
Description: This instruction heats a vessel placed on an induction pad.
Parameters:
Ip#: The induction pad where the vessel is located (e.g., ip#1, ip#2).
0/l/m/h/nnn: Temperature setting (0 for off, L for low, M for medium, H for high, or a specific temperature).
Fill Vessel Instruction:
Format:
Description: This instruction fills a specified vessel with ingredients.
Parameters:
Vessel#: Logical number of the vessel to fill.
Ingredient and weightlist: List of ingredients and their weights (e.g., ).
Watch Instruction:
Format:
Description: This instruction tells the vision system to wait for a specific event to occur.
Parameters: Watch_tag: A tag indicating a physical condition (e.g., ).
Timeout: Maximum time to wait for the event before proceeding.
[41] In an embodiment, the high-level cooking instructions which are machine independent instructions are shared with the automated cooking hub (106). The automated cooking hub (106) may include a plurality peripheral robots (not shown) and a plurality of workstations (not shown). The plurality of peripheral robots is configured to operate on the plurality of workstations.
[42] FIG. 3 illustrates a block diagram of the automated cooking hub (106), in accordance with an embodiment of the disclosure. The automated cooking hub (106) may include a one or more processors (302). The one or more processors (302) may be configured to convert the high-level cooking instructions into a low-level cooking instructions. The low-level cooking instructions are created as a temporary file. The one or more processors (302) executes these instructions on a plurality of workstations (304) via a plurality of cooking robots (306) there by performing the desired actions to cook the specified dish at least based on the recipe file.
[43] In an embodiment, the low-level cooking instructions may be represented as pneumonic and parameters, where a pneumonic indicates a low-level action to be taken, and the parameters considered in performing the low-level action. For example, the low-level cooking instructions may be expressed as:
Delay Instruction:

Format:
Description: This instruction tells the cooking range to wait for a specified delay.
Parameter: is the delay time in seconds.
Stir Instruction:
Format:
Description: This instruction commands to stir ingredients in a vessel using a spatula.
Parameters:
Tool: Type of tool to use (e.g., spatula).

Vessel#: Vessel to stir.

Delayinsecs: Time to stir in seconds.

Watchtag: Optional condition to stop stirring (e.g., until onions are brown).

Transfer Instruction:

Format:

Description: This instruction transfers contents from one vessel to another.

Parameters:

Vessel#src: Source vessel.

Vessel#dst: Destination vessel.

Close Lid Instruction:

Format:

Description: This instruction places a lid on a vessel.

Parameter: is the vessel to close.

Remove Lid Instruction:

Format:

Description: This instruction removes the lid from a vessel.

Parameter: is the vessel from which to remove the lid.

Grind Instruction:

Format:

Description: This instruction runs the grinder.

Parameters:

Speed: Grinder speed.

Delayinsecs: Grinding time in seconds.

Stop and Deliver Instruction:

Format:

Description: This instruction stops cooking and delivers the vessel to the delivery area.

Parameter: is the vessel to deliver.

Pick and Drop Instruction:

Format:

Description: This instruction picks contents from one vessel and drops them into another.

Parameters:

Tool#: Type of tool to use (e.g., batter spatula).

Vessel#src: Source vessel.

Vessel#dst: Destination vessel.

Drain and Drop Instruction:

Format:

Description: This instruction drains oil from cooked contents in a wok and drops them into another vessel.

Parameters:

Vessel#src: Source vessel (wok).

Vessel#dst: Destination vessel.

Repeat Until Instruction:

Format: REP UNTIL

Description: This instruction repeats a set of instructions until a condition is met.

Parameters:

Instr1, Instr2: Instructions to repeat.

Condition: Watch tag or number of repetitions.

Mash Instruction:

Format:

Description: This instruction mashes contents in a vessel.

Parameter: is the vessel to mash.

Flip Instruction:

Format: or

Description: This instruction flips contents in a vessel.

Parameters:

Vessel#: Vessel to flip.

Watch_tag: Optional condition to stop flipping.

Timeout: Maximum flipping time.

Time1, Time2: Cooking times for each side.

Spread Instruction:

Format:

Description: This instruction spreads contents in a vessel circularly.

Parameters:

Vessel#: Vessel to spread contents in.

Radius: Radius to spread contents to.

[44] In an embodiment, the one or more processors (302) may be configured to change the temporary file at least based on a just in time (JIT) module (310). The JIT module (310) provide a JIT status of the automated cooking hub such as availability of workstation (304) and cooking robot (306). It may be noted that the low-level cooking instructions are not needed to be generated every time the high-level cooking instructions are fed to the one or more processors (302). Further, the low-level cooking instructions are the JIT interpreter, that interprets the high-level cooking instructions into low-level cooking commands with physical significance attached.
[45] In an exemplary embodiment, the JIT status may include variables such as the status of the induction pads. Each induction pad may indicate whether it is occupied or unoccupied, allowing for smart allocation of resources. Additionally, the pads may be either on or off, signalling whether they are actively heating or in a power-saving mode. Further, the JIT status may include variables such as organization of utensils is another vital component of the automated cooking hub (106). Utensils are methodically stored in designated areas, such as Rack1-Shelf1, Rack1-Shelf2, and Rack1-Shelf3, as well as in Rack2-Shelf1 and Rack2-Shelf2. For utensils in active preparation, the open area (OA) or specific induction pads (IP1 or IP2) are used to keep them accessible. The utensils can also be found in the delivery area (DA), awaiting service. Each utensil is categorized by size and type; medium utensils are labelled as M1, M2, and M3, while deep utensils may be designated as D1, D2, and D3. Further, the JIT status may include variables such as the positioning of robots (306) within the automated cooking hub (106) adds another layer of efficiency to the cooking process. The robots (306) are strategically placed to optimize their functionality, engaging in tasks like utensil retrieval, ingredient dispensing, and meal serving. Further, the JIT status may include variables such as the status of the dispensers is essential for maintaining a well-stocked kitchen. Each container within the dispenser is monitored for its ingredient type and quantity. This oversight ensures that the necessary ingredients—ranging from spices to sauces—are readily available when required. Further, the JIT status may include variables such as keeping track of utensil racks is essential for ensuring that all required cooking tools are on hand. The utensil rack status provides a comprehensive overview of which utensils are present and available for use, helping chefs and robots alike to locate the necessary equipment without delay.
[46] Inan embodiment, the JIT status may be recorded in a machine data structure (MDS) (308). The MDS status is continuously changed as the utensils are moved around, and peripherals are controlled, and robot (306) is moved during the cooking progresses. For example, when first induction pad of the workstation (304) is occupied, if the JIT interpretation happens it will use second induction pad of the automated cooking hub (106). Similarly, the first induction pad is not occupied, the robot (306) may choose to use the first induction pad, in the low-level cooking instructions.
[47] In an embodiment, the automated cooking hub (106) may include an input device (312) to visually capture the information of the automated cooking hub (106). The input device (312) further may include a camera to validate the JIT status. The processor (302) may update the JIT status in the MDS (308). Further, the input device (312) is not limited to camera.
[48] FIG. 4 illustrates a flowchart illustrating a look ahead method (400) for generating cooking queue in the automated cooking hub (106), in accordance with an embodiment of the disclosure. FIG. 4 is explained in conjunction with FIG. 3. The look ahead method (400) may optimize the cooking process by efficiently managing resources and utensil occupancy. The automated cooking hub (106) may convert a high-level recipe file into a low-level instruction file, which is essential for executing the respective cooking tasks. The look ahead method (400) may synchronize and coordinate the resource usage. For example, if a dish requires three utensils and only one has been utilized, the machine must anticipate the need for the remaining two utensils when a new low-level cooking instruction occurs. Failing to account for these resources could lead to one of two undesirable outcomes: the current dish may face delays due to a shortage of utensils, or the preparations for the new dish may interfere with those of the current dish. To mitigate these risks, the automated cooking hub (106) may employ the look ahead mechanism to proactively reserve utensils and resources required for each low-level cooking instruction. If the new low-level cooking instruction does not have enough resources, then the automated cooking hub (106) may raise an alert indicating that enough resources are not available.
[49] As the automated cooking hub (106) generates the low-level instruction set, calculate the changing Machine Data Structures (MDS) or resource status in a proactive manner. The MDS configuration is computed with foresight, accommodating the processing of multiple recipes. The transformation of high-level instruction files into low-level instructions occurs using a Just-In-Time (JIT) methodology. The actual changes to the MDS and resource status are realized during the execution phase of the low-level cooking instructions. To facilitate this dynamic process, the automated cooking hub (106) maintains a Look Ahead Memory (LAM), where MDS data is transferred prior to generating new instruction files. With each instruction generated, the LAM updates to reflect the current state of resources, thus ensuring that the next instruction executed is based on the most up-to-date information. This cycle continues until the complete instruction file is established. If, at any point, the cooking instruction generation cannot proceed due to inadequate resources, the current process is aborted, and the LAM is reset to its original MDS status. Conversely, if the translation of cooking instruction is successful, the LAM is transferred to a different memory that retains the anticipated MDS.
[50] Upon the successful completion of the translation process, the instruction file is passed to the processor (302), which executes the instructions utilizing the assistance of workstations (304) and robotic (306) components. Once the processor (302) concludes, the low-level cooking instruction is promptly deleted, as there is no need for storage. As the subsequent translations of the same recipe is inherently differ based on the evolving resource status of the machine, ensuring that each cooking session is tailored to the current operational context. This entire mechanism not only enhances efficiency but also maintains the integrity of the cooking process, guaranteeing that dishes are prepared without conflict or resource shortages.
[51] FIG. 5 illustrates a sequence diagram is illustrated that depicts a method (500) to convert recipe into executable instruction in the system (100), in accordance with an embodiment of the present invention. FIG. 5 is explained in conjunction with elements of FIG. 1, FIG. 2 and FIG. 3. The system (100), as depicted in FIG. 1, FIG. 2 and FIG. 3, may be configured to implement the method 500 as shown in FIG. 5.
[52] At step S502, uploading the recipe information on the server (108), via the user device (102). The recipe may be in the form of text, image or webpage.
[53] At step S504, generating the high-level cooking instructions from the recipe information. The high-level cooking instructions are represented as action tag and parameters. Further, the high-level cooking instructions are machine independent instructions. Further, the recipe may be selected from the recipe store. The recipe store is integrated with a payment gateway in order for users to be able to purchase the recipes that have a price tag.
[54] At step S506, converting the high-level cooking instructions into the low-level instruction via the automated cooking hub (106). low-level cooking instructions may be represented as pneumonic and parameters, where a pneumonic indicates a low-level action to be taken, and the parameters considered in performing the low-level action.
[55] At step S508, generating the just in time status for the low-level cooking instruction via the just in time module (310). The JIT module (310) provide a JIT status of the automated cooking hub such as availability of workstation (304) and cooking robot (306). The JIT status may be recorded in the machine data structure (MDS) (308). The MDS status is continuously changed as the utensils are moved around, and peripherals are controlled, and robot (306) is moved when the cooking progresses.
[56] At step S310, preparing the recipe for the user via the automated cooking hub.
[57] Embodiments of the present disclosure, for example, are described above with reference to block diagrams and/or operational illustrations of methods, systems, and computer program products according to aspects of the disclosure. The functions/acts noted in the blocks may occur out of the order as shown in any flowchart. For example, two blocks shown in succession may in fact be executed substantially concurrently or the blocks may sometimes be executed in the reverse order, depending upon the functionality/acts involved.
[58] This disclosure described some embodiments of the present technology with reference to the accompanying drawings, in which only some of the possible aspects were described. Other aspects can, however, be embodied in many different forms and the specific embodiments disclosed herein should not be construed as limited to the various aspects of the disclosure set forth herein. Rather, these exemplary aspects were provided so that this disclosure was thorough and complete and fully conveyed the scope of the other possible aspects to those skilled in the art. For example, aspects of the various embodiments disclosed herein may be modified and/or combined without departing from the scope of this disclosure.
[59] Although specific aspects were described herein, the scope of the technology is not limited to those specific aspects. One skilled in the art will recognize other aspects or improvements that are within the scope and spirit of the present technology. Therefore, the specific structure, acts, or media are disclosed only as illustrative aspects. The scope of the technology is defined by the following claims and any equivalents therein.
 
, C , Claims:We Claim:
1. A system (100) to convert recipe into executable cooking instruction, the system (100) comprises:
a memory (112) storing instructions; and
a processor (110, 302) coupled to the memory (112), the processor executing the instructions to:
uploading the recipe information on the server (108), via the user device (102);
generating the high-level cooking instructions from the recipe information;
converting the high-level cooking instructions into the low-level instruction via the automated cooking hub (106);
generating the just in time status for the low-level cooking instruction via the just in time module (310); and
preparing the recipe for the user via the automated cooking hub (106).
2. The system (100) as claimed in claim 1, wherein the server (108) includes a large learning model (114) to identify the ingredients of the recipe.
3. The system (100) as claimed in claim 1, wherein the processor (110) concerts the recipe into a high-level cooking instructions which are a machine independent instructions.
4. The system (100) as claimed in claim 1, wherein the memory (112) includes a recipe generator (120) may utilize the large language model (114) to generate the recipes from the information shared by the user device (102).
5. The system (100) as claimed in claim 1, wherein the memory (112) includes a recipe store (122) that holds free recipes or commercially available recipes for the users to download into the automated cooking hub (106).
6. The system (100) as claimed in claim 1, wherein the processor (110) generates high-level cooking instructions via the large language model (114).
7. The system (100) as claimed in claim 6, wherein the high-level cooking instructions are represented as action tag and parameters,
wherein the action tag indicates the action to be taken, and
wherein the parameters tag indicates the different parameters to be considered in performing that action associated to the action tag.
8. The system (100) as claimed in claim 1, wherein the automated cooking hub (106) further comprises:
a one or more processors (302) to convert the high-level cooking instructions into a low-level cooking instructions,
wherein the one or more processors (302) executes these instructions on a plurality of workstations (304) via a plurality of cooking robots (306) there by performing the desired actions to cook the specified dish at least based on the recipe file.
9. The system (100) as claimed in claim 8, the low-level cooking instructions are represented as pneumonic and parameters,
wherein the pneumonic indicates a low-level action to be taken, and
wherein the parameters considered in performing the low-level action.
10. The system (100) as claimed in claim 8, wherein the one or more processors (302) includes a just in time (JIT) module (310) to interprets the high-level cooking instructions into low-level cooking commands.
11. The system (100) as claimed in claim 11, wherein the JIT module (310) provide a JIT status of the automated cooking hub such as availability of a plurality of workstations (304) and a plurality of cooking robots (306).
12. The system (100) as claimed in claim 11, wherein the JIT status is recorded in a machine data structure (MDS) (308),
wherein the MDS status is continuously changed as the utensils are moved around, and peripherals are controlled, and robot (306) is moved during the cooking progresses.
13. The system (100) as claimed in claim 1, wherein the automated cooking hub (106) includes an input device (312) to visually capture the information of the automated cooking hub (106).
14. The system (100) as claimed in claim 1, wherein the automated cooking hub includes a look ahead method (400) to optimize the cooking process by efficiently managing resources and utensil occupancy.
15. The system (100) as claimed in claim 1, wherein the automated cooking hub (106) maintains a Look Ahead Memory (LAM), where MDS data is transferred prior to generating new instruction files,
wherein the cooking instruction generation cannot proceed due to inadequate resources, the LAM is reset to its original MDS status, and
wherein the translation of cooking instruction is successful, the LAM is transferred to a different memory that retains the anticipated MDS.
16. A method (500) to convert recipe into executable cooking instruction, the method (500) comprising:
uploading the recipe information on the server (108), via the user device (102);
generating the high-level cooking instructions from the recipe information;
converting the high-level cooking instructions into the low-level instruction via the automated cooking hub (106);
generating the just in time status for the low-level cooking instruction via the just in time module (310); and
preparing the recipe for the user via the automated cooking hub.
17. The method (500) as claimed in claim 16, wherein the server (108) includes a large learning model (114) to identify the ingredients of the recipe.
18. The method (500) as claimed in claim 16, wherein the processor (110) concerts the recipe into a high-level cooking instructions which are a machine independent instructions.
19. The method (500) as claimed in claim 16, wherein the memory (112) includes a recipe generator (120) may utilize the large language model (114) to generate the recipes from the information shared by the user device (102).
20. The method (500) as claimed in claim 16, wherein the memory (112) includes a recipe store (122) that may hold free recipes or commercially available recipes for the users to download into the automated cooking hub (106).
21. The method (500) as claimed in claim 16, wherein the processor (110) generates high-level cooking instructions via the large language model (114).
22. The method (500) as claimed in claim 21, wherein the high-level cooking instructions are represented as action tag and parameters,
wherein the action tag indicates the action to be taken, and
wherein the parameters tag indicates the different parameters to be considered in performing that action associated to the action tag.
23. The method (500) as claimed in claim 16, wherein the automated cooking hub (106) further comprises:
a one or more processors (302) to convert the high-level cooking instructions into a low-level cooking instructions,
wherein the one or more processors (302) executes these instructions on a plurality of workstations (304) via a plurality of cooking robots (306) there by performing the desired actions to cook the specified dish at least based on the recipe file.
24. The method (500) as claimed in claim 23, the low-level cooking instructions are represented as pneumonic and parameters,
wherein a pneumonic indicates a low-level action to be taken, and
wherein the parameters considered in performing the low-level action.
25. The method (500) as claimed in claim 23, wherein the one or more processors (302) include a just in time (JIT) module (310) to interprets the high-level cooking instructions into low-level cooking commands.
26. The method (500) as claimed in claim 25, wherein the JIT module (310) provide a JIT status of the automated cooking hub such as availability of a plurality of workstations (304) and a plurality of cooking robots (306).
27. The method (500) as claimed in claim 26, wherein the JIT status is recorded in a machine data structure (MDS) (308),
Wherein the MDS status is continuously changed as the utensils are moved around, and peripherals are controlled, and robot (306) is moved during the cooking progresses.
28. The method (500) as claimed in claim 16, wherein the automated cooking hub (106) includes an input device (312) to visually capture the information of the automated cooking hub (106).
29. The method (500) as claimed in claim 16, wherein the automated cooking hub includes a look ahead method (400) to optimize the cooking process by efficiently managing resources and utensil occupancy.
30. The method (500) as claimed in claim 1, wherein the automated cooking hub (106) maintains a Look Ahead Memory (LAM), where MDS data is transferred prior to generating new instruction files,
wherein the cooking instruction generation cannot proceed due to inadequate resources, the LAM is reset to its original MDS status, and
wherein the translation of cooking instruction is successful, the LAM is transferred to a different memory that retains the anticipated MDS.

Dated this 3rd day of July, 2025

[VIVEK SINGH- IN/PA 2786]
OF SAGACIOUS RESEARCH
AGENT FOR THE APPLICANT