Cooking guide device and recipe provision method using cooking guide device

Abstract

A cooking guide device and a recipe provision method using the cooking guide device are provided. The cooking guide device comprises: one or more sensors; a memory for storing one or more instructions; and one or more processors for executing the one or more instructions stored in the memory, wherein the one or more processors execute the one or more instructions so as to: acquire sensing data by sensing, through the one or more sensors, the taste of an object to be cooked; identify whether the sensing data corresponds to the preferred taste intensity of a pre-stored recipe; and provide guide information so that the sensing data does not deviate from the preferred taste intensity of the pre-stored recipe.

Description

Cooking guide device and recipe providing method using the cooking guide device

[0001] One embodiment of the present disclosure relates to a cooking guide device, a recipe providing method using the cooking guide device, and a recording medium.

[0002] With technological advancements, kitchen appliances are providing a variety of services for user convenience. For example, appliances can provide recipe guidance services, guiding users through recipes for their desired dishes.

[0003] Users can cook food according to recipes provided by their home appliances. However, even when following the recipe, users may find it difficult to achieve the desired taste.

[0004] Accordingly, there is a growing need for appliances that can provide users with feedback on the food they are cooking and guide them in reproducing the food to their desired taste.

[0005] A cooking guide device according to one embodiment of the present disclosure includes one or more sensors for sensing the taste of a cooking object, a memory for storing instructions, and a processor for executing the instructions stored in the memory.

[0006] A processor according to one embodiment of the present disclosure acquires sensing data by sensing the taste of the cooking object through the one or more sensors by executing the instructions.

[0007] According to one embodiment of the present disclosure, the sensing data identifies whether it corresponds to a preferred taste intensity of a previously stored recipe.

[0008] According to one embodiment of the present disclosure, the sensing data provides guide information so that it does not deviate from the preferred taste intensity of the previously stored recipe.

[0009] A recipe providing method according to one embodiment of the present disclosure includes a step of obtaining sensing data by sensing the taste of a cooking object through one or more sensors, a step of identifying whether the sensing data corresponds to a preferred taste intensity of a previously stored recipe, and a step of providing guide information so that the sensing data does not deviate from the preferred taste intensity of the previously stored recipe.

[0010] A computer-readable recording medium having recorded thereon a program for performing a recipe providing method according to one embodiment of the present disclosure on a computer may be provided.

[0011] The present disclosure can be readily understood by the combination of the following detailed description and the accompanying drawings, wherein reference numerals refer to structural elements.

[0012] FIG. 1 is a drawing for explaining a cooking system according to one embodiment of the present disclosure.

[0013] FIG. 2 is a drawing for explaining a cooking system according to one embodiment of the present disclosure.

[0014] FIG. 3 is a block diagram of a cooking guide device according to one embodiment of the present disclosure.

[0015] FIG. 4a is a flowchart illustrating a recipe providing method according to one embodiment of the present disclosure.

[0016] FIG. 4b is a flowchart illustrating a recipe providing method according to one embodiment of the present disclosure.

[0017] FIG. 5 is a detailed flowchart illustrating a recipe providing method according to one embodiment of the present disclosure.

[0018] FIG. 6 is a diagram for explaining an operation of setting a user preference taste according to one embodiment of the present disclosure.

[0019] FIG. 7 is a table showing an example of taste intensity information according to one embodiment of the present disclosure.

[0020] FIG. 8 is a diagram for explaining an operation of generating a recipe according to one embodiment of the present disclosure.

[0021] FIG. 9 is a diagram for explaining an operation of providing a recipe according to one embodiment of the present disclosure.

[0022] FIG. 10 is a diagram illustrating an operation of providing a guide for a recipe so as not to deviate from a user's preferred taste intensity according to one embodiment of the present disclosure.

[0023] FIG. 11 is a drawing for explaining an operation of controlling a cooking appliance so that the cooking guide device does not deviate from a user's preferred taste intensity according to one embodiment of the present disclosure.

[0024] FIG. 12 is a diagram illustrating an AI model for inferring whether sensing data deviates from a user's preferred taste intensity according to one embodiment of the present disclosure.

[0025] FIG. 13 is a flowchart illustrating a recipe providing method of a cooking system according to one embodiment of the present disclosure.

[0026] FIG. 14 is a flowchart illustrating a recipe providing method of a cooking system according to one embodiment of the present disclosure.

[0027] FIG. 15 is a drawing for explaining a cooking system according to one embodiment of the present disclosure.

[0028] FIG. 16 is a flowchart illustrating a recipe providing method of a cooking system according to one embodiment of the present disclosure.

[0029] FIG. 17 is an example showing a user interface screen of a user terminal according to one embodiment of the present disclosure.

[0030] In this disclosure, the expression “at least one of a, b or c” may refer to “a”, “b”, “c”, “a and b”, “a and c”, “b and c”, “all of a, b and c”, or variations thereof.

[0031] Below, embodiments of the present disclosure are described in detail with reference to the attached drawings so that those skilled in the art can easily implement the present disclosure. However, the present disclosure may be implemented in various different forms and is not limited to the embodiments described herein.

[0032] The terms used in this disclosure are described as currently common terms, taking into account the functions mentioned herein. However, these terms may mean various other terms depending on the intentions of those skilled in the art, precedents, the emergence of new technologies, etc. Therefore, the terms used in this disclosure should not be interpreted solely based on their names, but rather based on the meanings of the terms and the overall content of this disclosure.

[0033] Additionally, the terminology used in this disclosure is for the purpose of describing specific embodiments only and is not intended to limit the present disclosure.

[0034] Throughout the specification, when a part is said to be "connected" to another part, this includes not only the cases where it is "directly connected" but also the cases where it is "electrically connected" with another element in between.

[0035] As used herein, and particularly in the claims, the terms "above" and "above" and similar referents may refer to both the singular and the plural. Furthermore, unless the order of steps in a method according to the present disclosure is explicitly specified, the steps described may be performed in any appropriate order. The present disclosure is not limited by the order in which the steps are described.

[0036] The appearances of phrases such as “in some embodiments” or “in an embodiment” in various places throughout this specification are not necessarily all referring to the same embodiment.

[0037] Some embodiments of the present disclosure may be represented by functional block configurations and various processing steps. Some or all of these functional blocks may be implemented by various hardware and / or software configurations that perform specific functions. For example, the functional blocks of the present disclosure may be implemented by one or more microprocessors or by circuit configurations for a given function. Furthermore, for example, the functional blocks of the present disclosure may be implemented in various programming or scripting languages. The functional blocks may be implemented by algorithms that execute on one or more processors. Furthermore, the present disclosure may employ conventional techniques for electronic configuration, signal processing, and / or data processing. Terms such as “mechanism,” “element,” “means,” and “configuration” may be used broadly and are not limited to mechanical and physical configurations.

[0038] Additionally, the connecting lines or connecting members between components depicted in the drawings are merely exemplary representations of functional connections and / or physical or circuit connections. In an actual device, connections between components may be represented by various functional connections, physical connections, or circuit connections that may be replaced or added.

[0039] Additionally, terms such as “part”, “module”, etc. described in the specification mean a unit that processes at least one function or operation, which may be implemented as hardware or software, or a combination of hardware and software.

[0040] In the present disclosure, functions related to 'artificial intelligence' are operated through a processor and memory. The processor may be composed of one or more processors. In this case, one or more processors may be a general-purpose processor such as a CPU, AP, or DSP (Digital Signal Processor), a graphics-only processor such as a GPU or VPU (Vision Processing Unit), or an artificial intelligence-only processor such as an NPU. One or more processors control the processing of input data according to predefined operation rules or artificial intelligence models stored in memory. Alternatively, if one or more processors are artificial intelligence-only processors, the artificial intelligence-only processor may be designed with a hardware structure specialized for processing a specific artificial intelligence model.

[0041] Below, embodiments of the present disclosure are described in detail with reference to the attached drawings so that those skilled in the art can easily implement the present disclosure. However, the present disclosure may be implemented in various different forms and is not limited to the embodiments described herein.

[0042] Hereinafter, embodiments of the present disclosure will be described in detail with reference to the drawings.

[0043] FIG. 1 is a drawing for explaining a cooking system according to one embodiment of the present disclosure.

[0044] Referring to FIG. 1, a cooking system (1000) according to one embodiment may include a cooking guide device (100) and a cooking appliance (200). However, not all of the illustrated components are essential components. The cooking system (1000) may be implemented with more components than the illustrated components, or may be implemented with fewer components. For example, the cooking system (1000) may be implemented with the cooking guide device (100). In addition, the cooking system (1000) may be implemented with the cooking guide device (100), the cooking appliance (200), and the kitchen hood (vent hood) (300). In addition, the cooking system (1000) may be implemented with the cooking guide device (100), the cooking appliance (200), the kitchen hood (300), and the server (400). Additionally, the cooking system (1000) may be implemented with a cooking guide device (100), a cooking appliance (200), a kitchen hood (300), a server (400), and a user terminal (500).

[0045] FIG. 1 illustrates an example of a cooking system (1000) according to one embodiment of the present invention sensing a cooking object (10) using a cooking guide device (100). The cooking object (10) can be cooked in a cooking device (200). Referring to FIG. 1, a cooking system (1000) including a cooking guide device (100) will be described, and the cooking device (200), kitchen hood (300), and server (400) will be described with reference to FIG. 2. The user terminal (500) will be described with reference to FIG. 15.

[0046] A cooking guide device (100) according to one embodiment may be a device for sensing the taste or temperature of a cooking object (10). Here, the cooking object (10) may represent food, ingredients, seasoning, etc. to be cooked during the cooking process. For example, the cooking guide device (100) may include one or more sensors. The one or more sensors may sense at least one of salty, sweet, or sour tastes of the cooking object (10). For example, the one or more sensors may sense the temperature of the cooking object (10). The cooking guide device (100) may acquire sensing data by sensing the taste or temperature of the cooking object (10).

[0047] A cooking guide device (100) according to one embodiment may include a body and a sensor unit (102). The body of the cooking guide device (100) may include a display (101) and a speaker (103). The sensor unit (102) may include one or more sensors for sensing the taste or temperature of a cooking object. In the present disclosure, the body of the cooking guide device (100) is exemplified as having a columnar shape with a larger diameter than the sensor unit (102), but the shape of the cooking guide device (100) is not limited to that exemplified.

[0048] For example, the display (101) may be placed on one side of the body of the cooking guide device (100). The display (101) may output various notifications, messages, information, etc. related to the recipe. For example, the display (101) may output a graphical user interface (GUI) including a recipe for the cooking object (10).

[0049] For example, the speaker (103) may be located on the body of the cooking guide device (100). The speaker (103) may output various notifications, messages, information, etc. related to the recipe. For example, the speaker (103) may output voice information including a recipe for the cooking object (10).

[0050] For example, the sensor unit (102) may be connected to one end (e.g., the top or bottom) of the body. The sensor unit (102) may include a taste sensor that senses the taste of the food to be cooked (10). The sensor unit (102) may include a temperature sensor that senses the temperature of the food to be cooked. The taste sensor and the temperature sensor may be implemented as a single integrated sensor, or each may be implemented as a single sensor.

[0051] A cooking system (1000) according to one embodiment can provide a customized recipe to a user using a cooking guide device (100). The cooking system (1000) can obtain information about a user's preferred taste and provide a recipe that can be reproduced with the user's preferred taste. For example, the cooking system (1000) can obtain information about the user's preferred taste (hereinafter, "preferred flavor information of the user") by receiving a user input requesting a recipe for food with a salt content of 0.9%. The cooking system (1000) can provide a recipe for food based on the user's preferred taste information.

[0052] A cooking system (1000) according to one embodiment can sense a food item (10) being cooked according to a recipe through a cooking guide device (100). For example, the cooking system (1000) can sense at least one of taste and temperature of the food through the cooking guide device (100). For example, the cooking guide device (100) can measure the salinity of the food being cooked. The cooking guide device (100) can measure that the salinity of the food being cooked is 1.1%.

[0053] A cooking system (1000) according to one embodiment can identify whether the taste of food being cooked corresponds to a taste preferred by a user by sensing a cooking object (10) through a cooking guide device (100). The cooking system (1000) can provide a user with guidance on cooking operations by periodically sensing a cooking object (10) through the cooking guide device (100).

[0054] A cooking system (1000) according to one embodiment may provide guidance to prevent the user from deviate from the user's preferred taste when the food being cooked does not have a taste preferred by the user. For example, the cooking guide device (100) may provide guidance such as "The current salinity is 1.1%. Add 120 ml more water and boil it" through the display (101) or speaker (103). The cooking guide device (100) may update and provide a recipe so that the salinity of the food does not exceed "salinity of 0.9%," which corresponds to the user's preferred taste.

[0055] A cooking system (1000) according to one embodiment can reproduce a user's preferred taste by obtaining information about the food being cooked in real time through a cooking guide device (100). For example, the cooking system (1000) can provide a recipe so that food can be cooked according to the user's preferred taste, such as salty, sweet, or sour.

[0056] In one embodiment, the cooking system (1000) acquires a preferred taste intensity for a user. The cooking system (1000) generates a recipe for a cooking object (10) based on the acquired preferred taste intensity. The cooking system (1000) acquires sensing data by sensing the taste of the cooking object (10) according to the recipe. The cooking system (1000) identifies whether the sensing data corresponds to the acquired preferred taste intensity. For example, the cooking system (1000) can identify whether the sensed data of the taste of the cooking object (10) matches the intensity of the user's preferred taste, has a value higher than the intensity of the user's preferred taste, or has a value lower than the intensity of the user's preferred taste. The cooking system (1000) provides guide information for the recipe so that the sensed data does not deviate from the acquired preferred taste intensity. For example, the cooking system (1000) can provide guide information for the recipe so that the sensed data of the taste of the cooking object (10) matches the intensity of the user's preferred taste.

[0057] The cooking system (1000) according to the present disclosure can facilitate the reproduction of food with the desired taste by providing real-time feedback to the user about the food being cooked.

[0058] FIG. 2 is a drawing for explaining a cooking system according to one embodiment of the present disclosure.

[0059] Referring to FIG. 2, a cooking system (1000) according to one embodiment may include a cooking guide device (100), a cooking appliance (200), a kitchen hood (300), and a server (400). The cooking guide device (100) is omitted as it has been described above in FIG. 1.

[0060] A cooking device (200) may be a device for cooking a cooking object. For example, the cooking device (200) may include an induction cooker, an electric range, a microwave oven, etc. In the present disclosure, the cooking device (200) is exemplified as an induction cooker that cooks a cooking object by heating the cooking object located on the top plate.

[0061] A cooking device (200) according to one embodiment may include a weight sensor that senses the weight of a cooking object positioned on a cooking surface. The cooking device (200) may measure the weight of food or ingredients positioned on the cooking surface through the weight sensor. The cooking device (200) may obtain weight data of the food or ingredients. The cooking device (200) may transmit the weight data of the food or ingredients to a cooking guide device (100). The cooking device (200) may also transmit the weight data of the food or ingredients to a server (400).

[0062] A kitchen hood (300) according to one embodiment may include a camera (301). The camera (301) may acquire an image of the surroundings of the kitchen hood (300). While FIG. 2 illustrates an example where the camera (301) is attached to the kitchen hood (300), the present invention is not limited thereto. For example, at least one camera (301) may be located in various locations, such as a living room, a kitchen wall, a lighting system, a refrigerator, or a shelf.

[0063] According to one embodiment, a camera (301) is attached to the bottom of a kitchen hood (300) to capture images of the surroundings of a cooking device (200). When a user places ingredients or food being cooked on the cooking device (200), the camera (301) can capture images of the ingredients. The camera (301) can transmit the images of the ingredients to the cooking guide device (100). The camera (301) can also upload the images of the ingredients to a server (400).

[0064] In one embodiment, when a camera (301) is included in a kitchen hood (300), the kitchen hood (300) may acquire an image of an ingredient image through the camera (301) and transmit it to a cooking guide device (100) or a server (400). The cooking guide device (100) or the server (400) may acquire ingredient information by performing object recognition on the ingredient image.

[0065] Meanwhile, if a camera (not shown) is included in the refrigerator (not shown), the camera can capture images of the refrigerator's surroundings. For example, if a user opens the refrigerator door and takes out food, the camera can capture images of the food. Depending on the door opening, the refrigerator can capture images of the food through the camera and transmit them to the cooking guide device (100) or server (400).

[0066] According to one embodiment of the present disclosure, the cooking system (1000) may include a communication module for communicating with an external device. For example, the cooking guide device (100) may communicate with a cooking appliance (200), a kitchen hood (300), or a server (400) through the communication module. The communication module may include a short-range communication module (e.g., an NFC communication module, a Bluetooth communication module, etc.), a long-range communication module, etc.

[0067] According to one embodiment of the present disclosure, the cooking system (1000) can obtain information on the user's preferred taste as well as information on ingredients (e.g., weight information and images of ingredients). The cooking system (1000) can generate a recipe based on the user's preferred taste information and ingredient information. For example, the cooking system (1000) can generate a customized recipe based on information on the user's preferred taste and the amount of ingredients the user has. The cooking system (1000) can provide the customized recipe to the user through the cooking guide device (100).

[0068] For example, if a recipe is stored based on 500 g of ingredients and the user has 300 g of ingredients, the cooking system (1000) can guide the user to the calculated recipe by calculating the recipe based on 300 g of ingredients.

[0069] For example, if a recipe is usually stored based on saltiness and the user prefers a slightly salty taste, the cooking system (1000) can generate a recipe with a reduced amount of salt or an increased amount of water and guide the user.

[0070] According to one embodiment of the present disclosure, the cooking system (1000) can improve cooking convenience for a user by providing a user-customized recipe.

[0071] FIG. 3 is a block diagram of a cooking guide device according to one embodiment of the present disclosure.

[0072] Referring to FIG. 3, the cooking guide device (100) may include a processor (110), a sensor (120), an input interface (130), an output interface (140), a communication module (150), and a memory (160). However, not all of the illustrated components are essential components. The cooking guide device (100) may be implemented with more components than the illustrated components, or may be implemented with fewer components.

[0073] The processor (110) is a component that controls a series of processes to operate the cooking guide device (100), and may be composed of one or more processors. The one or more processors included in the processor (110) may be circuitry such as a System on Chip (SoC), an Integrated Circuit (IC), etc. The one or more processors included in the processor (110) may be a general-purpose processor such as a Central Processing Unit (CPU), a Micro Processor Unit (MPU), an Application Processor (AP), a Digital Signal Processor (DSP), a graphics-only processor such as a Graphics Processing Unit (GPU), a Vision Processing Unit (VPU), an artificial intelligence-only processor such as a Neural Processing Unit (NPU), or a communication-only processor such as a Communication Processor (CP). When the one or more processors included in the processor (110) are artificial intelligence-only processors, the artificial intelligence-only processor may be designed with a hardware structure specialized for processing a specific artificial intelligence model.

[0074] The processor (110) controls the overall operation of the cooking device (100). For example, the processor (110) can control the sensor (120), the input interface (130), the output interface (140), and the communication module (150). The processor (110) can analyze information acquired through the sensor (120). The processor (110) can control the communication module (150) to transmit or receive data. The processor (110) can control the input interface (130) to receive information. The processor (110) can also control the output interface (140) to output information.

[0075] The processor (110) can record data in the memory (160) or read data stored in the memory (160), and in particular, process data according to predefined operation rules or artificial intelligence models by executing a program or at least one instruction stored in the memory (160). Accordingly, the processor (110) can perform operations of the cooking guide device (100), and operations described as being performed by the cooking guide device (100) or detailed components included in the cooking guide device (100) can be regarded as being performed by the processor (110) unless otherwise specifically described.

[0076] The sensor (120) may include a taste sensor (121) and a temperature sensor (122). The sensor (120) may include one or more sensors. The taste sensor (121) and the temperature sensor (122) may be implemented as individual sensors or as an integrated sensor.

[0077] The taste sensor (121) may be a sensor that measures the taste of the food being cooked. The taste sensor (121) may sense at least one of salty, sweet, and sour tastes of the food being cooked. The taste sensor (121) may also sense spiciness, umami, and bitter tastes of the food being cooked.

[0078] The taste sensor (121) can obtain taste-related sensing data by measuring the taste of the cooking object. The taste-related sensing data may be raw data measured by the taste sensor (121) or data processed and analyzed by the processor (110). For example, the taste sensor (121) can obtain at least one of salinity data, sugar content data, or acidity data for the cooking object.

[0079] For example, a salinity sensor can measure salinity by using the electrical conductivity and resistance that occur when salt is dissolved in water and separated into sodium ions (Na+) and chloride ions (Cl-). The salinity sensor measures the chloride ion component by placing a + electrode rod and a - electrode rod into a sample, measures the resistance value of the sample using Ohm's law, converts the resistance value and the capacitor value charged by the current flow into a frequency, and calculates the salt concentration in the sample using the frequency, thereby measuring the salt concentration. However, the operation of the salinity sensor is not limited to this.

[0080] For example, a sugar sensor can measure sugar content by measuring the concentration of a liquid using the principle of light refraction. For example, a sugar sensor can measure sugar content using a non-destructive measurement technique. A non-destructive measurement technique is a technique that measures the wavelength of light reflected when light is shined on a fruit. If the wavelength of the reflected light has a low near-infrared component, it may mean that the fruit has a lot of sugar. Or, for example, a sugar sensor can measure sugar content using a refractive measurement technique. A refractive measurement technique is a technique that drops a fruit solvent into a measuring device and reads the concentration value with an eyepiece. However, the operation of a sugar sensor is not limited to this.

[0081] For example, a pH sensor can measure pH by amplifying the current generated by the potential difference between the reference electrode and the indicator electrode when they are immersed in a solution. The current strength can be directly proportional to the pH of the solution. However, the operation of the acidity sensor is not limited to this.

[0082] The sensing principle of each taste sensor is merely an example for convenience of explanation and is not limited to the examples described above.

[0083] The temperature sensor (122) may be a sensor that measures the temperature of the cooking object. The temperature sensor (122) can acquire temperature-related sensing data by sensing the temperature of the cooking object.

[0084] The input interface (130) may include a touchscreen, a touchpad, keys, buttons, etc. The input interface (130) receives user input and transmits it to the processor (110). For example, the input interface (130) may receive user input for selecting a menu, user input for a preferred flavor intensity, user input for requesting a recipe, etc.

[0085] For example, the input interface (130) may receive a user input for entering a taste value. For example, the input interface (130) may receive a user input for requesting previously stored taste intensity information.

[0086] The output interface (140) may include a display, a speaker, and the like. The output interface (140) may output various notifications, messages, information, and the like generated by the processor (110). For example, the output interface (140) may output a graphical user interface (GUI) providing a recipe to the display. For example, the output interface (140) may output voice information providing a recipe to the speaker.

[0087] Meanwhile, the input interface (130) and the output interface (140) may be implemented as a single device. For example, they may be provided as a combination of a display and keys, or as a touch screen.

[0088] The communication module (150) may include one or more components that enable communication between the cooking guide device (100) and the cooking appliance (200), the cooking guide device (100) and the kitchen hood (300), the cooking guide device (100) and the server (400), and the cooking guide device (100) and the user terminal.

[0089] The communication module (150) may include at least one of a short-range communication module or a long-range communication module, or a combination thereof. The communication module (150) may include at least one antenna for wirelessly communicating with another device. The short-range wireless communication module may include, but is not limited to, a Bluetooth communication module, a BLE (Bluetooth Low Energy) communication module, a near field communication module, a WLAN (Wi-Fi) communication module, a Zigbee communication module, an IrDA (infrared Data Association) communication module, a WFD (Wi-Fi Direct) communication module, an UWB (ultrawideband) communication module, an ANT+ communication module, a microwave (uWave) communication module, and the like. The long-range communication module may be used to communicate with a server device when the cooking guide device (100) is remotely controlled by a server (400) in an IoT (Internet of Things) environment. A remote communication module may include, but is not limited to, the Internet, a computer network (e.g., a LAN or WAN), or a mobile communication unit.

[0090] The memory (160) is a configuration for storing various programs or data, and may be configured as a storage medium or a combination of storage media, such as a ROM (Read-Only Memory), a RAM (Random Access Memory), a flash memory type, a hard disk type, a multimedia card micro type, a card type memory (e.g., an SD or XD memory, etc.). The memory (160) may not exist separately and may be configured to be included in the processor (110). The memory (160) may be configured as a volatile memory, a non-volatile memory, or a combination of a volatile memory and a non-volatile memory. A program or at least one instruction for performing operations described below may be stored in the memory (160). The memory (160) may also provide stored data to the processor (110) at the request of the processor (110).

[0091] In one embodiment, the memory (160) may include a taste database (DB). The taste DB may include taste intensity information in which the intensity of a user's preferred taste is set for each type. For example, the taste DB may include 'user-customized taste' data, 'Chef A's taste' data, and 'recommended intake standard' data. Each of the 'user-customized taste' data, 'Chef A's taste' data, and 'recommended intake standard' data may include an intensity or value for at least one of salty, sweet, or sour taste (see FIG. 7).

[0092] In one embodiment, the memory (160) may include at least one of recipe information for reproducing the intensity of a 'customized taste', recipe information for reproducing the intensity of a 'Chef A's taste', or recipe information for reproducing the intensity of a 'recommended intake standard' taste.

[0093] In one embodiment, the processor (110) acquires a preferred taste intensity for a user. The processor (110) generates a recipe for a cooking object based on the acquired preferred taste intensity. The processor (110) acquires sensing data by sensing the taste of the cooking object according to the recipe. The processor (110) identifies whether the sensing data corresponds to the acquired preferred taste intensity to identify the cooking state of the cooking object. The processor (110) provides guidance for the recipe so as not to deviate from the acquired preferred taste intensity based on the identified cooking state.

[0094] In the present disclosure, the cooking state of a cooking object may refer to the state of the taste of the food being cooked and the state of the temperature. For example, the cooking state may indicate the saltiness, sweetness, sourness, etc. of the cooking object. For example, the cooking state may indicate whether the taste intensity of the cooking object matches the taste intensity preferred by the user, is weaker than the taste intensity preferred by the user, or is stronger than the taste intensity preferred by the user. For example, the cooking state may indicate whether the sensing data sensing the taste of the cooking object matches the taste intensity preferred by the user, has a value higher than the taste intensity preferred by the user, or has a value lower than the taste intensity preferred by the user.

[0095] In one embodiment, the processor (110) may receive a user input for selecting a menu to be cooked. The processor (110) may obtain information regarding the user's preferred flavor intensity. For example, the processor (110) may receive information regarding the menu to be cooked and the user's preferred flavor intensity for the cooking object.

[0096] In one embodiment, the processor (110) may receive user input for entering a numerical value corresponding to the user's preferred flavor intensity. For example, the processor (110) may receive numerical inputs for salinity, sweetness, etc., via an input interface (130) (e.g., a touch screen, a microphone, etc.).

[0097] In one embodiment, the processor (110) may receive a user input requesting information on the user's preferred flavor intensity. Based on the user input requesting the flavor intensity information, the processor (110) may retrieve flavor intensity information previously stored in the flavor DB. For example, the processor (110) may obtain the flavor intensity information based on a user input requesting at least one of "customized flavor" data, "Chef A's flavor" data, and "recommended intake standard" data. Alternatively, for example, the processor (110) may retrieve recipe information for reproducing the requested flavor intensity.

[0098] In one embodiment, the processor (110) may generate a recipe for a cooking object based on the acquired preferred flavor intensities. The recipe may be a recipe in which the ingredient content, cooking order, heat, cooking time, etc. are adjusted to suit the user's preferred saltiness, sweetness, sourness, spiciness, etc.

[0099] In one embodiment, the processor (110) may provide guidance based on the generated recipe. For example, the processor (110) may output the guidance as a GUI through a display or output the guidance as a voice through a speaker.

[0100] In one embodiment, the processor (110) can sense the taste of a food being cooked based on a recipe. For example, the processor (110) can periodically provide guidance, such as "Please measure the taste using the cooking guide device," to identify the cooking status of the food being cooked in real time. The user can periodically sense the taste of the food being cooked using the cooking guide device (100) according to the guidance.

[0101] In one embodiment, the processor (110) can acquire sensing data by sensing the taste of the food to be cooked. The processor (110) can identify whether the sensing data corresponds to the acquired preferred taste intensity. For example, the processor (110) can identify whether the sensing data is identical to or similar to the acquired preferred taste intensity, or is within a preferred taste intensity range. Here, the preferred taste intensity range may be a range in which at least one of an upper limit or a lower limit of the taste intensity is set. For example, if the processor (110) identifies that the sensing data corresponds to the acquired preferred taste intensity, it can provide guidance as is according to the recipe.

[0102] For example, if the processor (110) identifies that the sensing data does not correspond to the acquired preferred flavor intensity, the processor (110) may update the recipe and guide the updated recipe. For example, if the processor (110) identifies that the cooking target deviates from the preferred flavor intensity, the processor (110) may update the recipe to adjust the flavor of the cooking target.

[0103] The processor (110) can guide the user to reproduce the taste preferred by sensing the cooking object in real time through the sensor (120). The processor (110) can guide the recipe so that the taste of the food being cooked does not deviate from the range of the user's preferred taste by sensing the taste of the food being cooked.

[0104] FIG. 4a is a flowchart illustrating a recipe providing method according to one embodiment of the present disclosure.

[0105] Referring to FIG. 4A, a recipe providing method according to one embodiment may include operations 410 to 430. Operations 410 to 430 may be performed by the cooking guide device (100) (or the processor (110) of the cooking guide device (100). However, the present invention is not limited thereto, and operations 410 to 430 may be performed by the server (400) or the user terminal (500), or may be performed by various components included in the cooking system (1000).

[0106] The recipe providing method according to one embodiment is not limited to that illustrated in FIG. 4a, and any one of the steps illustrated in FIG. 4a may be omitted, or additional steps not illustrated in FIG. 4a may be included.

[0107] In operation 410, the cooking guide device (100) can obtain sensing data by sensing the taste of the cooking object.

[0108] In one embodiment, the cooking guide device (100) can sense the taste of the food to be cooked. The cooking guide device (100) can obtain sensing data regarding the taste of the food to be cooked by sensing the food to be cooked through the taste sensor (121).

[0109] For example, the cooking guide device (100) can obtain taste-related sensing data by sensing at least one of salty, sweet, or sour tastes of the cooking object. For example, the cooking guide device (100) can obtain salinity data by measuring the salinity of the cooking object. For example, the cooking guide device (100) can obtain sugar content data by measuring the sugar content of the cooking object.

[0110] In one embodiment, the cooking guide device (100) may sense the temperature of the cooking object. The cooking guide device (100) may acquire temperature-related sensing data by sensing the temperature of the cooking object through the temperature sensor (122).

[0111] In one embodiment, the sensing data for the cooking object acquired by the cooking guide device (100) may include at least one of sensing data regarding taste or sensing data regarding temperature.

[0112] In one embodiment, the cooking guide device (100) may periodically provide guidance, such as "Please measure the taste using the cooking guide device," to identify the cooking status of the cooking object in real time. The user may periodically sense the taste of the cooking object using the cooking guide device (100) according to the guidance.

[0113] In operation 420, the cooking guide device (100) can identify whether the sensing data corresponds to the preferred taste intensity of a previously stored recipe.

[0114] In the present disclosure, the preferred flavor intensity of a recipe may represent the intensity of saltiness, sweetness, sourness, spiciness, etc. set for the cooking object. The recipe may be a recipe for reproducing the intensity of saltiness, sweetness, sourness, spiciness, etc. set for the cooking object. For example, the recipe may vary at least one of the ingredient content, cooking order, heat power, or cooking time depending on the intensity of saltiness, sweetness, sourness, spiciness, etc. set for the cooking object.

[0115] In one embodiment, the preferred flavor intensity of a recipe may be obtained by user input or by retrieving information previously stored in memory. In one embodiment, the cooking guide device (100) may receive user input regarding a previously stored recipe and the preferred flavor intensity of the previously stored recipe.

[0116] In one embodiment, the cooking guide device (100) may store recipe information regarding a cooking object in memory. For example, the memory may store recipe information in which a preferred taste intensity is set according to a user type. For example, the preferred taste intensity according to a user type may include at least one of user-customized taste intensity information, taste intensity information for food previously sensed through one or more sensors, or taste intensity information that complies with a recommended intake standard. For example, the memory may include at least one of recipe information for reproducing a user-customized taste intensity, recipe information for reproducing a taste intensity for food previously sensed, and recipe information for reproducing a taste intensity that complies with a recommended intake standard.

[0117] In one embodiment, the cooking guide device (100) can identify the cooking status of a food item using sensing data. In the present disclosure, the cooking status of a food item may refer to the taste and temperature of the food item being cooked. For example, the cooking status may indicate whether the intensity of the taste of the food item matches the intensity of the taste preferred by the user, is weaker than the intensity of the taste preferred by the user, or is stronger than the intensity of the taste preferred by the user.

[0118] In one embodiment, the cooking guide device (100) can identify whether the taste of the food being cooked is weaker, stronger, or corresponding to the intensity of the taste preferred by the user.

[0119] In one embodiment, the cooking guide device (100) can identify whether the sensing data sensing the taste of the cooking object corresponds to the intensity of the taste preferred by the user, has a value higher than the intensity of the taste preferred by the user, or has a value lower than the intensity of the taste preferred by the user.

[0120] Here, the meaning of sensing data corresponding to the intensity of taste may mean that the sensing data is identical or similar to the data corresponding to the intensity of taste, or that the difference between the data is below a threshold value. For example, if the user sets the preferred intensity of taste to 'salinity 0.9%', the cooking guide device (100) can identify whether the sensing data for the cooking target corresponds to 'salinity 0.9%'.

[0121] In addition, the meaning of the sensing data corresponding to the intensity of taste may mean that the sensing data is within the intensity range of the taste. For example, the cooking guide device (100) can identify whether the sensing data is within the preferred intensity range of the taste. Here, the preferred intensity range of the taste may be a range in which at least one of the upper limit or lower limit of the intensity of the taste is set. For example, if the user sets the preferred intensity of the taste to 'salinity 0.9% or less', the cooking guide device (100) can identify whether the sensing data for the cooking object has a salinity of 0.9% or less.

[0122] Meanwhile, in the present disclosure, the fact that the sensing data corresponds to the intensity of the taste can be re-expressed as the sensing data matches the intensity of the taste.

[0123] In one embodiment, the cooking guide device (100) may utilize a trained AI model to infer whether the sensing data deviates from the preferred flavor intensity. For example, the cooking guide device (100) may input the sensing data acquired in operation 410 into the trained AI model, thereby obtaining an inference result regarding whether the data corresponds to the preferred flavor intensity of a previously stored recipe. This is described in detail in FIG. 12 .

[0124] In operation 430, the cooking guide device (100) can provide guide information so that the sensing data does not deviate from the preferred taste intensity of the previously stored recipe.

[0125] In one embodiment, if the cooking guide device (100) identifies that the sensing data corresponds to the preferred flavor intensity of a previously stored recipe, it can provide guidance based on the previously stored recipe. For example, if the cooking guide device (100) identifies that the cooking target can be cooked without exceeding the preferred flavor intensity, it can sequentially guide the recipe to complete the cooking according to the cooking order.

[0126] In one embodiment, if the cooking guide device (100) identifies that the sensing data does not correspond to the preferred flavor intensity of a previously stored recipe, the cooking guide device (100) may update the recipe and provide updated recipe information. For example, if the cooking guide device (100) identifies that the cooking object falls outside the preferred flavor intensity, the cooking guide device (100) may update the recipe to adjust the flavor of the cooking object. For example, the cooking guide device (100) may generate an updated recipe by updating at least one of the ingredient content, cooking order, heat power, or cooking time so that the cooking object corresponds to the preferred flavor intensity.

[0127] For example, in a situation where the saltiness level set in the recipe is 'salinity 0.9%', if the cooking guide device (100) measures the saltiness level of the current cooking target as 'salinity 1.1%', it can provide guidance such as 'Add more water to adjust the saltiness.'

[0128] Meanwhile, in one embodiment, the cooking guide device (100) may control the connected cooking device (200) based on the updated recipe. For example, the cooking guide device (100) may transmit a heat control command to the cooking device (200) to increase the heat of the cooking device (200) from 5 to 9. The cooking guide device (100) may transmit the heat control command directly to the cooking device (200) or may transmit the heat control command through the server (400).

[0129] The cooking guide device (100) can guide the user to reproduce the taste he or she prefers by sensing the cooking object in real time through a sensor (120).

[0130] FIG. 4b is a flowchart illustrating a recipe providing method according to one embodiment of the present disclosure.

[0131] Referring to FIG. 4B, a recipe providing method according to one embodiment may include operations 450 to 490. Operations 450 to 490 may be performed by the cooking guide device (100) (or the processor (110) of the cooking guide device (100). However, the present invention is not limited thereto, and operations 450 to 490 may be performed by the server (400) or the user terminal (500), or may be performed by various components included in the cooking system (1000).

[0132] In operation 450, the cooking guide device (100) can obtain the intensity of the user's preferred flavor (hereinafter referred to as 'preferred flavor intensity of the user').

[0133] A user can request a recipe for a cooking object from the cooking guide device (100) and input a preferred flavor intensity for the cooking object. The cooking guide device (100) can set the preferred flavor intensity for the cooking object based on the user's input.

[0134] In the present disclosure, the cooking object may include at least one of salty, sweet, or sour tastes. The at least one taste may be expressed as a flavor intensity. For example, the at least one taste may be expressed as an intensity ranging from 0 to 10, or as an intensity such as strong / medium / weak.

[0135] Additionally, for example, at least one taste may be expressed as a numerical value representing the intensity of each taste type. For example, the intensity of saltiness may be expressed as a salt concentration (i.e., salinity). Salinity may be expressed as a percentage (%) and may represent the amount of salt contained in a solution or food. For example, the intensity of sweetness may be expressed as a sugar content and may be expressed in Brix units. For example, the intensity of sourness may be expressed as an acidity and may be expressed in pH units. The units expressing the numerical values ​​of the tastes are not limited to the examples described above.

[0136] In the present disclosure, 'intensity of taste' may be replaced with terms such as taste value, taste level, taste degree, etc.

[0137] In the present disclosure, the user's preferred flavor intensity may represent the user's preferred intensity of saltiness, sweetness, sourness, spiciness, etc. The user may request the cooking system (1000) to determine the preferred flavor intensity. The user's preferred flavor intensity may correspond to the flavor intensity requested by the user.

[0138] In one embodiment, the cooking guide device (100) can obtain information regarding the user's preferred flavor intensity. For example, the cooking guide device (100) can receive a user input for setting a value corresponding to the user's preferred flavor intensity. For example, the user can input the preferred flavor intensity (e.g., mild saltiness or intensity 3) into the input interface (130) of the cooking guide device (100) (e.g., touch screen, microphone, etc.), or directly input a flavor value corresponding to the preferred flavor intensity (e.g., salinity 0.9%).

[0139] Additionally, for example, the cooking guide device (100) may receive user input requesting information on the user's preferred flavor intensity. Based on the user's input requesting the flavor intensity information, the cooking guide device (100) may retrieve the requested flavor intensity information. The cooking guide device (100) may retrieve recipe information for reproducing the requested flavor intensity.

[0140] The taste intensity information may include various types of data in which the user's preferred taste intensity is set. For example, the taste intensity information may include 'user-customized taste' data, 'Chef A's taste' data, 'recommended intake standard' data, etc. The 'user-customized taste' data may include user-customized taste intensity information. For example, the cooking guide device (100) may store taste intensity information (e.g., salinity, sweetness, acidity) previously set by the user. The 'Chef A's taste' data may include sensing data for Chef A's dishes that the user previously sensed through the cooking guide device (100). For example, the user may sense the salinity, acidity, etc. of the dish using the portable cooking guide device (100) and store the sensing data under a name such as 'Chef A's taste' or 'Chef A's B menu.' The 'recommended intake standard' data may include taste intensity information that reflects the appropriate salt content for each food recommended by the Ministry of Food and Drug Safety, the recommended sodium intake for hypertension patients, or the recommended intake for diabetes patients.

[0141] The above-described taste intensity information can be stored in a taste DB, and the taste DB can be stored in the built-in memory (e.g., memory (160)) of the cooking guide device (100) or in an external database (e.g., server (400)). This is described in detail in FIG. 7.

[0142] In operation 460, the cooking guide device (100) can generate a recipe for a cooking object based on the acquired preferred taste intensity.

[0143] In one embodiment, the cooking guide device (100) can generate a recipe for a cooking object based on the acquired preferred flavor intensity. The cooking guide device (100) can include recipe information for the cooking object. The recipe information can include the food name, the amount of each ingredient, the cooking order, the heat, the cooking time, etc. The recipe information can be stored in the built-in memory of the cooking guide device (100) or in an external database.

[0144] For example, the cooking guide device (100) can update at least one of the ingredient content, cooking order, heat power, or cooking time of the recipe in response to the intensity of at least one of salty, sweet, or sour taste requested by the user.

[0145] For example, the cooking guide device (100) may update the basic recipe by increasing the salt content, reducing the amount of water, or increasing the heat based on a user input requesting a strong salty taste. The cooking guide device (100) may generate an updated recipe from the basic recipe.

[0146] In one embodiment, the cooking guide device (100) may obtain an image of an ingredient and weight information of the ingredient. The cooking guide device (100) may recognize the ingredient based on the image of the ingredient. Alternatively, for example, the cooking guide device (100) may obtain information about the ingredient recognized from the image of the ingredient. The cooking guide device (100) may generate a recipe according to the weight of each ingredient based on the recognized ingredient and the weight information of the ingredient. For example, the image of the ingredient placed in the cooking chamber may be received from a camera implemented separately from the cooking guide device (100). For example, the weight information of the ingredient placed in the cooking chamber may be obtained through a weight sensor. The weight sensor may be implemented within the cooking device (200), but is not limited thereto.

[0147] In one embodiment, the cooking guide device (100) can provide guidance based on a generated recipe. For example, the cooking guide device (100) can output the guidance as a GUI via a display. For example, the cooking guide device (100) can output the guidance as audible guidance via a speaker.

[0148] In operation 470, the cooking guide device (100) can acquire sensing data by sensing the taste of the food to be cooked according to the recipe. Operation 470 may correspond to operation 410 of FIG. 4A.

[0149] Meanwhile, in one embodiment, the cooking guide device (100) may also obtain weight information about the cooking object. Based on the weight information about the cooking object, the cooking guide device (100) can identify the amount of food in real time. The weight information about the food ingredients may be received from a cooking device (200) including a weight sensor, but is not limited thereto.

[0150] In operation 480, the cooking guide device (100) can identify whether the sensing data corresponds to the acquired preferred taste intensity. Operation 480 may correspond to operation 420 of FIG. 4A.

[0151] In operation 490, the cooking guide device (100) may provide guide information for the recipe so as not to deviate from the acquired preferred taste intensity based on the identified cooking state. Operation 490 may correspond to operation 430 of FIG. 4A.

[0152] In one embodiment, if the cooking guide device (100) identifies that the sensing data corresponds to the acquired preferred flavor intensity, it can provide guidance according to the recipe. For example, if the cooking guide device (100) identifies that the cooking target is cooked without exceeding the preferred flavor intensity, it can sequentially guide the recipe to complete the cooking according to the cooking order.

[0153] In one embodiment, if the cooking guide device (100) identifies that the sensing data does not correspond to the acquired preferred flavor intensity, it can update the recipe and guide the updated recipe. For example, if the cooking guide device (100) identifies that the cooking object is outside the preferred flavor intensity, it can update the recipe to adjust the flavor of the cooking object. For example, the cooking guide device (100) can generate an updated recipe by updating at least one of the ingredient content, cooking order, heat power, or cooking time so that the cooking object corresponds to the preferred flavor intensity.

[0154] FIG. 5 is a detailed flowchart illustrating a recipe provision method according to one embodiment of the present disclosure. FIG. 5, in conjunction with FIGS. 6 through 12, provides a detailed explanation of a recipe provision scenario according to one embodiment.

[0155] Referring to FIG. 5, in operation 510, the cooking guide device (100) can receive user input for a cooking menu.

[0156] The cooking guide device (100) can receive user input requesting a recipe for a cooking object. For example, a user can request a recipe for a cooking menu through the input interface (130) (e.g., a touch screen, microphone, etc.) of the cooking guide device (100).

[0157] The cooking guide device (100) can store recipe information for food. The recipe information may include the food name, ingredient content, cooking order, heat level, cooking time, etc. The cooking guide device (100) can retrieve recipe information having a food name corresponding to a cooking menu requested by a user. The recipe information may be stored in the cooking guide device's (100) built-in memory or an external database.

[0158] In one embodiment, the cooking guide device (100) may receive user input for selecting a cooking start time. For example, the user may manually set a cooking start time.

[0159] In one embodiment, the cooking guide device (100) can acquire an image of ingredients received from a camera in the refrigerator. When a user opens the refrigerator door and takes out ingredients or seasonings, the camera included in the refrigerator can acquire the image of the ingredients. The refrigerator can provide the image of the ingredients to the cooking guide device (100). Upon acquiring the image of the ingredients, the cooking guide device (100) can ask the user whether to begin cooking.

[0160] In one embodiment, the cooking guide device (100) may acquire an image of ingredients received from a camera within the cooking chamber (e.g., a camera (301) of a kitchen hood (300). When a user places ingredients or seasonings in the cooking chamber, the camera (301) may acquire an image of the ingredients. The camera (301) may provide the image of the ingredients to the cooking guide device (100). Upon acquiring the image of the ingredients, the cooking guide device (100) may ask the user whether to start cooking.

[0161] In one embodiment, the cooking guide device (100) can obtain food ingredient information through object recognition of food ingredient images. Object recognition may be performed in the cooking guide device (100) or in a server (400) connected to the cooking guide device (100).

[0162] In operation 520, the cooking guide device (100) can obtain the user's preferred taste intensity. Operation 520 will be described with reference to FIGS. 6 and 7 together.

[0163] FIG. 6 is a diagram illustrating an operation for setting a user preference taste according to one embodiment of the present disclosure. FIG. 7 is a table illustrating an example of taste intensity information according to one embodiment of the present disclosure.

[0164] The cooking guide device (100) can inquire about the user's preferred flavor intensity for the food to be cooked. For example, the cooking guide device (100) can inquire about the preferred flavor intensity through an output interface (140) (e.g., a display, a speaker, etc.).

[0165] The cooking guide device (100) can receive information regarding the user's cooking target and preferred flavor intensity. For example, the cooking guide device (100) can receive voice information including information regarding the user's cooking target and preferred flavor intensity via a microphone.

[0166] For example, referring to FIG. 6, a user can request (601) a soybean paste stew recipe (i.e., cooking menu) with a user-customized standard (i.e., preferred taste intensity) to the cooking guide device (100). Based on the request regarding the preferred taste intensity, the cooking guide device (100) can retrieve taste intensity information stored in the taste DB (610). For example, the cooking guide device (100) can retrieve 'user-customized' data stored in the taste DB (610) and obtain salinity information of the soybean paste stew stored in the 'user-customized' data.

[0167] In one embodiment, the taste DB (610) may include 'user-customized taste' data, 'Chef A's taste' data, 'recommended intake standard' data, etc.

[0168] For example, if a user requests a 'customized taste', the cooking guide device (100) can retrieve the taste intensity information preset by the user. For example, the user can input the taste intensity (e.g., salinity, sweetness, acidity, etc.) of a frequently used recipe into the cooking guide device (100). The cooking guide device (100) can store the taste intensity information of the recipe input by the user in the taste DB (610).

[0169] For example, referring to FIG. 7, the cooking guide device (100) can store the salinity value of the B menu of ‘customized taste’ as 0.9%.

[0170] For example, if a user requests 'Chef A's Taste', the cooking guide device (100) can retrieve the taste intensity information for Chef A's dish that the user previously analyzed using the cooking guide device (100).

[0171] For example, referring to FIG. 7, a user can store sensing data regarding the taste of food in a taste DB (610) using a portable cooking guide device (100). For example, the cooking guide device (100) can detect that the salinity of Chef A's B menu is 1.0% and the acidity is 0.2%, and store the salinity and acidity values ​​of 'Chef A's B menu' in the taste DB (610). The cooking guide device (100) can load Chef A's unique recipe from the taste DB (610) to reproduce the taste of Chef A's food that has been previously experienced.

[0172] For example, if a user requests a "recommended intake standard," the cooking guide device (100) can retrieve flavor intensity information based on the recommended intake standard. For example, the flavor DB (610) can include flavor intensity information based on the recommended intake for each food recommended by the Ministry of Food and Drug Safety, the recommended sodium intake for hypertensive patients, or the recommended intake for diabetic patients.

[0173] For example, the recommended intake levels recommended by the Ministry of Food and Drug Safety (MFDS) may vary for each food. Furthermore, recommended intake levels may vary for each user. For example, patients with high blood pressure may require lower sodium intake levels than the general population. For example, the MFDS recommends appropriate salt levels for each food: 0.8% or less for soups, stews, and broths; 2% for kimchi; and 8-10% for soybean paste.

[0174] Meanwhile, although not shown, cooking temperature information for each menu may also be stored in the taste DB (610). For example, in Fig. 7, in the case of 'user-customized taste', information indicating that the cooking temperature of menu B is 45 degrees may be stored in the taste DB (610).

[0175] Meanwhile, in the present disclosure, various types of taste intensity information are exemplified as being stored in the taste DB (610) using the cooking guide device (100), but are not limited thereto. For example, the taste intensity information may be stored in the taste DB (610) using any of the cooking device (200), camera (301), server (400), and user terminal (500) included in the cooking system (1000).

[0176] Meanwhile, the types of flavors in the present disclosure are not limited to the examples described above. For example, the types of flavors may further include spiciness expressed on the Scoville scale, savory flavor expressed by the level of monosodium glutamate (MSG), or bitterness expressed by the content of minerals or caffeine.

[0177] Referring again to FIG. 5, at operation 530, the cooking guide device (100) can generate a recipe for a cooking object based on the food ingredient information and the intensity of the preferred taste.

[0178] The cooking guide device (100) can adjust at least one of the ingredient content, cooking order, heat power, or cooking time of the recipe in response to the intensity of at least one of salty, sweet, or sour taste requested by the user. For example, the cooking guide device (100) can generate a recipe for reproducing soybean paste stew with a salinity of 0.9% based on the user request. For example, the cooking guide device (100) can generate a user-customized recipe from a basic recipe for a soybean paste stew recipe with a salinity of 0.9%. For example, the user-customized recipe can be a recipe in which the intensity of taste is adjusted by adjusting the salt content in the basic recipe, adjusting the amount of water, or adjusting the cooking order, heat power, or cooking time.

[0179] Additionally, the cooking guide device (100) can also acquire information about ingredients, such as images of the ingredients and weight information about the ingredients. This will be described with reference to FIG. 8. FIG. 8 is a diagram illustrating the operation of generating a recipe according to one embodiment of the present disclosure.

[0180] Referring to FIG. 8, the cooking guide device (100) can obtain an image of food ingredients (80) placed in a cooking chamber (e.g., a cooking device (200)) and weight information of the food ingredients (80). For example, the camera (301) of the kitchen hood (300) can obtain an image of the surroundings of the kitchen hood (300). When a user places food ingredients or food being cooked on the cooking device (200), the camera (301) can obtain an image of the food ingredients. The camera (301) can transmit the image of the food ingredients to the cooking guide device (100). The cooking guide device (100) can obtain food ingredient information by performing object recognition on the food ingredient image. Alternatively, the cooking guide device (100) can also receive food ingredient information recognized as an object for the food ingredient image.

[0181] For example, a cooking device (200) can measure the weight of food or ingredients placed on a cooking surface using a weight sensor. The cooking device (200) can transmit weight data obtained by measuring the weight of the food or ingredients to a cooking guide device (100).

[0182] The cooking guide device (100) can generate recipes based on images of ingredients and weight information about the ingredients. For example, the cooking guide device (100) can generate a customized recipe from a basic recipe based on the ingredients currently available and the weight of each ingredient. For example, the cooking guide device (100) can calculate the ingredient content of a recipe based on the weight of the ingredient.

[0183] For example, if a basic recipe is stored based on 500 g of ingredients and the user has 300 g of ingredients, the cooking guide device (100) can create a user-customized recipe by adjusting at least one of the ingredient content, cooking order, heat power, or cooking time based on 300 g of ingredients.

[0184] In operation 540, the cooking guide device (100) can provide guide information to the user according to the generated recipe. Operation 540 will be described with reference to FIG. 9.

[0185] FIG. 9 is a diagram for explaining an operation of providing a recipe according to one embodiment of the present disclosure.

[0186] Referring to FIG. 9, the cooking guide device (100) can provide a recipe (900) via an output interface (140). For example, the cooking guide device (100) can output voice information including the recipe (900) via a speaker. For example, the cooking guide device (100) can output a GUI including the recipe (900) via a display (103).

[0187] The cooking guide device (100) can sequentially guide the recipe (900) in the cooking order. For example, the cooking guide device (100) can guide the next cooking order when a user inputs a request for the next cooking order.

[0188] The cooking guide device (100) can guide the ingredient content (901). The ingredient content (901) can include information on the user's preferred flavor intensity or ingredient content information adjusted based on ingredient information (e.g., ingredient and weight information of each ingredient). For example, the ingredient content (901) can include information on 1 potato (150 g), 1 onion (130 g), ... 3 tablespoons of soybean paste, 1 / 5 tablespoon of salt, and 1 liter of water.

[0189] The cooking guide device (100) can receive voice information (e.g., 'next' (910)) requesting the next cooking sequence from the user. As the cooking guide device (100) receives the voice information, it can sequentially guide the next cooking sequence.

[0190] The cooking guide device (100) can guide the cooking sequence (902, 903). The cooking sequence (902, 903) can include information about the cooking sequence, heat power, or cooking time. For example, the cooking guide device (100) can provide guidance such as, "Please cut xx into a size that fits on a spoon."

[0191] In one embodiment, the cooking guide device (100) can obtain cooking process information and guide cooking sequences (902, 903) based on the cooking process information. For example, the cooking guide device (100) can obtain cooking process information from the cooking device (200). A boiling sensor included in the cooking device (200) can sense whether the food to be cooked on the top plate of the cooking device (200) is boiling. When the food to be cooked on the top plate of the cooking device (200) boils, the cooking device (200) can transmit information indicating that the food to be cooked is boiling (i.e., cooking process information) to the cooking guide device (100). The cooking guide device (100) can guide cooking sequences (902, 903) based on the cooking process information received from the cooking device (200). For example, the cooking guide device (100) can provide guidance such as, 'It is boiling, so add 1 / 2 spoon of xx, cover the lid, and boil for 10 minutes.', 'After 10 minutes, add xx and boil for 3 more minutes on medium heat (heat power 6).'

[0192] In one embodiment, the cooking guide device (100) may provide a guide (904) that guides sensing of a cooking object to identify the cooking status of the object being cooked. For example, the cooking guide device (100) may provide a guide such as, "Insert the cooking guide device and measure the taste." Based on the guide (904), the user may use the cooking guide device (100) to sense the taste or temperature of the cooking object.

[0193] In operation 550, the cooking guide device (100) can obtain sensing data by sensing the taste of the cooking target according to the recipe.

[0194] The cooking guide device (100) can sense the taste of the food being cooked based on a recipe. For example, the cooking guide device (100) can provide a guide (904) that guides the user to periodically sense the food being cooked to identify the cooking status of the food in real time. The user can periodically sense the taste of the food being cooked using the cooking guide device (100) according to the guide (904).

[0195] The cooking guide device (100) can acquire sensing data regarding taste by sensing at least one of salty, sweet, or sour tastes of the cooking object. The cooking guide device (100) can acquire sensing data regarding temperature by sensing the temperature of the cooking object using a temperature sensor.

[0196] Meanwhile, the cooking guide device (100) can also obtain weight information of the cooking object. Based on the weight information of the cooking object, the cooking guide device (100) can identify the amount of food in real time.

[0197] At operation 560, the cooking guide device (100) can identify whether the sensing data corresponds to the acquired preferred taste intensity.

[0198] In one embodiment, the cooking guide device (100) can use sensing data to identify the cooking status of a cooking object. For example, the cooking guide device (100) can identify whether the taste of the cooking object is weaker, stronger, or matches the taste intensity preferred by the user.

[0199] For example, if the user sets the preferred taste intensity to 'salinity 0.9%', the cooking guide device (100) can identify whether the sensing data for the cooking target corresponds to a salinity of 0.9%.

[0200] For example, if the user sets the preferred taste intensity to 'salinity 0.8% or less', the cooking guide device (100) can identify whether the sensing data for the cooking target has a salinity of 0.8% or less.

[0201] In operation 570, if the cooking guide device (100) identifies that the sensing data corresponds to the acquired preferred taste intensity, it can provide the guide information as is according to the recipe.

[0202] For example, if the cooking guide device (100) identifies that the cooking target is cooked without exceeding the preferred taste intensity, it can sequentially guide the recipe to complete the cooking according to the cooking order.

[0203] In operation 580, if the sensing data is identified as not corresponding to the acquired preferred flavor intensity, the recipe may be updated and the updated recipe may be provided as guidance information. Operation 580 will be described with reference to FIGS. 10 to 12.

[0204] FIG. 10 is a diagram illustrating an operation of providing a guide for a recipe so as not to deviate from a user's preferred flavor intensity according to one embodiment of the present disclosure. FIG. 11 is a diagram illustrating an operation of a cooking guide device controlling a cooking appliance so as not to deviate from a user's preferred flavor intensity according to one embodiment of the present disclosure.

[0205] Referring to FIG. 10, if the cooking guide device (100) identifies that the cooking target deviates from the user's preferred flavor intensity, it can update the recipe to adjust the flavor of the target. For example, the cooking guide device (100) can provide guidance to ensure that the cooking target does not deviate from the user's preferred flavor intensity.

[0206] For example, in a situation where the user's preferred saltiness level is 'salinity 0.9%', if the cooking guide device (100) measures that the saltiness level of the current cooking object is 'salinity 1.1%', it can provide a guide (905) such as 'The current saltiness level is 1.1%. Add 120 ml more water and boil.'

[0207] The cooking guide device (100) can periodically provide guidance by periodically sensing the flavor intensity of the food being cooked. For example, the cooking guide device (100) can provide guidance such as "The salinity has increased. Please add water" whenever the salinity increases.

[0208] Additionally, the cooking guide device (100) can periodically provide guidance by periodically sensing the temperature of the cooking object. For example, the cooking guide device (100) can periodically provide guidance so that the temperature of the cooking object is maintained at 45 degrees (e.g., a user-customized temperature).

[0209] Referring to FIG. 11, the cooking guide device (100) can control the cooking device (200) so as not to deviate from the user's preferred flavor intensity. For example, the cooking guide device (100) can transmit a control command to the cooking device (200) based on an updated recipe. For example, the cooking guide device (100) can transmit a firepower control command to the cooking device (200) to increase the firepower of the cooking device (200) from 5 to 9. The cooking guide device (100) can transmit the firepower control command directly to the cooking device (200) or can transmit the firepower control command through the server (400).

[0210] For example, the cooking guide device (100) can provide guidance such as, 'When the desired taste is achieved, the heat will be automatically adjusted to 3.'

[0211] FIG. 12 is a diagram illustrating an AI model for inferring whether sensing data deviates from a user's preferred taste intensity according to one embodiment of the present disclosure.

[0212] Referring to FIG. 12, the cooking guide device (100) can obtain a result of inferring the cooking state of the cooking target by using an AI model (1200) learned using taste intensity information as learning data.

[0213] Referring to the training process (1210) of the AI ​​model (1200), the AI ​​model (1200) may be an artificial intelligence model trained using salinity data, sugar content data, acidity data, etc. as training data. The AI ​​model (1200) may receive taste intensity information as input and output an inference result. The inference result may include information such as whether the taste intensity information matches a preset taste intensity, is similar to a preset taste intensity, is outside the intensity range, or is within the intensity range. In addition, the inference result may include information such as the content of additional seasoning or ingredients required to adjust the taste intensity information to the preset taste intensity.

[0214] Referring to the application process (1220) of the AI ​​model (1200), the cooking guide device (100) can obtain an inference result by applying sensing data on the cooking target to the AI ​​model (1200).

[0215] The cooking guide device (100) can obtain information on whether the cooking target corresponds to the preferred taste intensity, information on the content of seasoning or ingredients required to adjust to the preferred taste intensity, etc. through the AI ​​model (1200).

[0216] Meanwhile, the AI ​​model (1200) is exemplified as being implemented in the cooking guide device (100), but is not limited thereto. The AI ​​model (1200) is implemented in the server (400), and the server (400) may transmit the inference results to the cooking guide device (100).

[0217] A cooking guide device (100) according to one embodiment can reproduce a user's preferred taste by acquiring the cooking status of food being cooked in real time. For example, the cooking system (1000) can provide a recipe so that food is cooked according to the user's preferred taste, such as salty, sweet, or sour.

[0218] A cooking guide device (100) according to one embodiment can provide a user-customized recipe by using information about the user's preferred taste and information about ingredients (e.g., weight information of ingredients and images of ingredients).

[0219] A cooking guide device (100) according to one embodiment can improve the user's cooking convenience by providing a user-customized recipe.

[0220] FIG. 13 is a flowchart illustrating a recipe provision method of a cooking system according to one embodiment of the present disclosure. Referring to FIG. 13 , a recipe provision operation performed by a cooking guide device (100) and a server (400) according to one embodiment will be described. In FIG. 13 , any content overlapping with FIGS. 4A, 4B, and 5 will be omitted.

[0221] In operation 1310, the cooking guide device (100) may acquire the user's preferred flavor intensity. For example, the cooking guide device (100) may receive a user's input for inputting information regarding the preferred flavor intensity for the cooking object.

[0222] For example, the cooking guide device (100) can receive a user's input setting a value corresponding to the user's preferred flavor intensity.

[0223] For example, the cooking guide device (100) may receive user input requesting information on the user's preferred flavor intensity. For example, the cooking guide device (100) may receive user input requesting "user-customized flavor" data, "Chef A's flavor" data, "recommended intake standard" data, etc.

[0224] In operation 1320, the cooking guide device (100) can transmit the user's preferred taste intensity to the server (400). The cooking guide device (100) can transmit the user's preferred taste intensity to the server (400) via the communication module (150). The server (400) can receive the user's preferred taste intensity from the cooking guide device (100).

[0225] For example, the cooking guide device (100) can transmit a numerical value corresponding to the user's preferred taste intensity to the server (400).

[0226] For example, the cooking guide device (100) can transmit the user's preferred taste intensity information to the server (400). The server (400) can retrieve the taste intensity information previously stored in the taste DB based on the user's input requesting the taste intensity information. The server (400) can obtain the user's preferred taste intensity information. For example, the server (400) can obtain any one of the following data: 'user-customized taste' data, 'Chef A's taste' data, and 'recommended intake standard' data.

[0227] In operation 1330, the server (400) may generate a recipe for a cooking object based on the user's preferred flavor intensity. For example, the server (400) may include recipe information for the cooking object. The recipe information may include the food name, the amount of each ingredient, the cooking order, the heat, the cooking time, etc. The recipe information may be stored in a database within the server (400).

[0228] For example, the server (400) may generate a recipe based on a numerical value corresponding to the user's preferred flavor intensity. For example, the server (400) may generate a recipe based on information about the user's preferred flavor intensity.

[0229] For example, the server (400) can adjust at least one of the ingredient content, cooking order, heat power, or cooking time of the recipe in response to the intensity of at least one of saltiness, sweetness, or sourness requested by the user.

[0230] For example, based on a user input requesting a strong salty taste, the server (400) may update the basic recipe by increasing the salt content, decreasing the amount of water, or increasing the heat. The server (400) may then generate an updated recipe from the basic recipe.

[0231] In operation 1340, the server (400) can transmit the generated recipe to the cooking guide device (100). The cooking guide device (100) can receive the recipe from the server (400) via the communication module (150).

[0232] In operation 1350, the cooking guide device (100) may provide guidance regarding a recipe. For example, the cooking guide device (100) may provide the recipe via the output interface (140). For example, the cooking guide device (100) may output voice information including the recipe via a speaker. For example, the cooking guide device (100) may output a GUI including the recipe via the display (103).

[0233] The cooking guide device (100) can sequentially guide a recipe in the cooking order. For example, the cooking guide device (100) can guide the next cooking order when a user inputs a request for the next cooking order.

[0234] In operation 1360, the cooking guide device (100) can acquire sensing data by sensing the taste of the food to be cooked according to the recipe. Operation 1360 may correspond to operation 410 of FIG. 4A.

[0235] In operation 1370, the cooking guide device (100) can transmit the acquired sensing data to the server (400).

[0236] At step 1380, the server (400) can identify whether the sensing data corresponds to the acquired preferred flavor intensity. Based on the identification result, the server (400) can decide whether to update the recipe.

[0237] The server (400) can use sensing data to identify the cooking status of the food to be cooked. For example, the server (400) can identify whether the taste of the food to be cooked is weaker, stronger, or matches the taste intensity preferred by the user.

[0238] For example, the server (400) can identify whether the sensing data is identical to or similar to the acquired preferred taste intensity. Or, for example, the server (400) can identify whether the sensing data is within a preferred taste intensity range.

[0239] For example, the server (400) may generate an updated recipe by updating the base recipe if the flavor of the cooking object is weaker or stronger than the user's preferred flavor intensity. For example, the server (400) may update at least one of the ingredient content, cooking order, heat power, or cooking time so that the cooking object corresponds to the preferred flavor intensity.

[0240] For example, the server (400) may keep the basic recipe as is if the flavor of the food being cooked matches the intensity of the flavor preferred by the user.

[0241] In one embodiment, the server (400) may utilize a trained AI model to infer whether the sensing data deviates from the preferred flavor intensity. For example, the server (400) may obtain an inference result regarding whether the sensing data corresponds to the preferred flavor intensity by inputting the sensing data into the trained AI model.

[0242] In operation 1390, the server (400) may transmit the identified cooking status and / or recipe to the cooking guide device (100).

[0243] For example, the server (400) can transmit information to the cooking guide device (100) about whether the taste of the food to be cooked is weaker, stronger, or matches the intensity of the taste preferred by the user.

[0244] For example, the server (400) can transmit an updated recipe to the cooking guide device (100).

[0245] For example, if the taste of the food to be cooked matches the intensity of the taste preferred by the user, the server (400) can transmit the basic recipe as is to the cooking guide device (100).

[0246] In operation 1395, the cooking guide device (100) can provide guidance for the recipe so as not to deviate from the preferred taste intensity.

[0247] For example, the cooking guide device (100) can sequentially guide recipes to complete cooking according to the cooking order. For example, the cooking guide device (100) can guide an updated recipe.

[0248] FIG. 14 is a flowchart illustrating a recipe provision method of a cooking system according to one embodiment of the present disclosure. Referring to FIG. 14, a recipe provision operation performed by a cooking guide device (100), a cooking appliance (200), a camera (301), and a server (400) according to one embodiment will be described. In FIG. 14, any content overlapping with FIGS. 4A, 4B, 5, and 13 will be omitted.

[0249] In operation 1410, the cooking guide device (100) may receive user input for a cooking menu. Operation 1410 may correspond to operation 510 of FIG. 5.

[0250] In operation 1420, the cooking guide device (100) can obtain the user's preferred taste intensity.

[0251] In operation 1430, the cooking guide device (100) can transmit the cooking menu and the user's preferred taste intensity to the server (400). The cooking guide device (100) can transmit the cooking menu and the user's preferred taste intensity to the server (400) via the communication module (150). The server (400) can receive the cooking menu and the user's preferred taste intensity from the cooking guide device (100).

[0252] In operation 1440, the cooking device (200) can sense the weight of the food ingredients through a weight sensor.

[0253] In operation 1445, the cooking device (200) can transmit weight information of the food ingredients sensed through the weight sensor to the server (400).

[0254] At step 1450, the camera (301) can photograph food ingredients in the kitchen.

[0255] In operation 1455, the camera (301) can transmit an image of the food material to the server (400).

[0256] In operation 1460, the server (400) can generate a recipe for a cooking menu based on the image of the ingredient, the weight of the ingredient, and the user's preferred flavor intensity.

[0257] For example, the server (400) may generate a recipe based on a numerical value corresponding to the user's preferred flavor intensity. For example, the server (400) may generate a recipe based on information about the user's preferred flavor intensity.

[0258] For example, the server (400) may adjust at least one of the ingredient content, cooking order, heat, or cooking time of a recipe based on the image of the ingredient, the weight of the ingredient, and the user's preferred flavor intensity. For example, the server (400) may calculate the ingredient content of a recipe based on the weight of the ingredient.

[0259] In operation 1470, the server (400) may transmit the generated recipe to the cooking guide device (100). The cooking guide device (100) may receive the recipe from the server (400) via the communication module (150). Operation 1470 may correspond to operation 1340 of FIG. 13.

[0260] In operation 1480, the cooking guide device (100) may provide guidance for a recipe. Operation 1480 may correspond to operation 1350 of FIG. 13.

[0261] In operation 1490, the cooking guide device (100) can acquire sensing data by sensing the taste of the food to be cooked according to the recipe. Operation 1490 may correspond to operation 1360 of FIG. 13.

[0262] In operation 1491, the cooking guide device (100) can transmit the acquired sensing data to the server (400). Operation 1491 can correspond to operation 1370 of FIG. 13.

[0263] In operation 1492, the server (400) can identify whether the sensing data corresponds to the acquired preferred flavor intensity. Based on the identification result, the server (400) can decide whether to update the recipe. Operation 1492 may correspond to operation 1380 of FIG. 13 .

[0264] In operation 1493, the server (400) may transmit the identified cooking status and / or recipe to the cooking guide device (100). Operation 1493 may correspond to operation 1390 of FIG. 13.

[0265] In operation 1494, the server (400) may transmit a cooking device control command to control the cooking device (200). The server (400) may directly control the cooking device (200) based on the updated recipe. For example, the server (400) may transmit a firepower control command to the cooking device (200).

[0266] In operation 1495, the cooking guide device (100) may provide guidance for the recipe so as not to deviate from the preferred flavor intensity. Operation 1495 may correspond to operation 1395 of FIG. 13.

[0267] In operation 1496, the cooking device (200) can control the cooking device (200) based on the cooking device control command so as not to deviate from the preferred taste intensity. For example, the cooking device (200) can control the firepower.

[0268] FIG. 15 is a drawing for explaining a cooking system according to one embodiment of the present disclosure.

[0269] Referring to FIG. 15, a cooking system (1000) according to one embodiment may further include a user terminal (500) in addition to a cooking guide device (100), a cooking appliance (200), a kitchen hood (300), and a server (400). Since the cooking guide device (100), the cooking appliance (200), the kitchen hood (300), and the server (400) have been described in FIGS. 1 and 2, the user terminal (500) will be described herein.

[0270] The user terminal (500) is connected to the server (400) and may be a device that displays information provided by the server (400). For example, the user terminal (500) may transmit and receive information to and from the server (400) through a specific application (e.g., a recipe guide application) installed on the user terminal (500).

[0271] The user terminal (500) may be a device connected with the same account information as the cooking guide device (100). The user terminal (500) may be directly connected to the cooking guide device (100) through a short-range wireless communication channel, or may be indirectly connected to the cooking guide device (100) through a server (400).

[0272] The user terminal (500) according to one embodiment of the present disclosure may be implemented in various forms. For example, the user terminal (500) described in the present disclosure may include, but is not limited to, a mobile terminal, a smart phone, a laptop computer, a tablet PC, a digital camera, an e-book terminal, a digital broadcasting terminal, a PDA (Personal Digital Assistant), a PMP (Portable Multimedia Player), a navigation device, an MP3 player, and the like. For example, the mobile terminal may be a wearable device that can be worn by a user.

[0273] The user terminal (500) can execute a specific application provided by the server (400) based on user input. The user terminal (500) can provide a recipe to the user through an application execution window and provide real-time sensing information on a cooking target sensed through the cooking guide device (100).

[0274] Fig. 16 is a flowchart illustrating a recipe providing method of a cooking system according to one embodiment of the present disclosure. Fig. 17 is an example illustrating a user interface screen of a user terminal according to one embodiment of the present disclosure. Referring to Figs. 16 and 17, a recipe providing operation performed by a cooking guide device (100), a user terminal (500), and a server (400) according to one embodiment will be described. In Fig. 15, any content overlapping with Figs. 4a, 4b, 5, and 13 will be omitted.

[0275] In operation 1610, the user terminal (500) can receive user input for a cooking menu.

[0276] In operation 1620, the user terminal (500) can obtain the user's preferred taste intensity.

[0277] In operation 1630, the user terminal (500) can transmit the cooking menu and the user's preferred taste intensity to the server (400).

[0278] For example, referring to FIG. 17, a user terminal (500) can transmit and receive information to and from a server (400) through a recipe guide application installed on the user terminal (500). The user terminal (500) can output an inquiry about a cooking menu through an application execution window. A user can select a cooking menu (1710) through the user terminal (500). The user terminal (500) can receive a user input or voice input for selecting the cooking menu (1710).

[0279] The user terminal (500) can output an inquiry regarding the user's preferred flavor through the application execution window. The user can input information (1720) regarding the preferred flavor through the user terminal (500). For example, the user terminal (500) can receive a user input or voice input selecting information (1720) regarding the preferred flavor.

[0280] For example, the user terminal (500) may obtain a user input selecting one of 'Chef A's recipe', 'recommended intake', 'my own taste (i.e., user-customized taste)', or 'direct input'. The user terminal (500) may transmit information (1720) regarding the preferred taste to the server (400).

[0281] At operation 1640, the server (400) may generate a recipe based on the user's preferred flavor intensity.

[0282] The server (400) can retrieve the taste intensity information of any one of 'Chef A's Recipe', 'Recommended Intake', or 'My Own Taste' stored in the taste DB based on the information (1720) about preferred taste.

[0283] The server (400) can also obtain numerical information on the taste directly input by the user.

[0284] The server (400) can adjust at least one of the ingredient content, cooking order, heat power, or cooking time of the recipe based on the user's preferred taste intensity.

[0285] At operation 1650, the server (400) can transmit the generated recipe to the user terminal (500).

[0286] In operation 1660, the user terminal (500) may provide a guide for the recipe.

[0287] For example, referring to FIG. 17, the user terminal (500) can output a recipe (1730) based on preferred flavor intensity through an application execution window. The user terminal (500) can provide a guide (1740) that guides the user to sense a cooking target using the cooking guide device (100).

[0288] In operation 1670, the cooking guide device (100) can acquire sensing data by sensing the taste of the food to be cooked according to the recipe. Operation 1670 may correspond to operation 1360 of FIG. 13.

[0289] In operation 1680, the cooking guide device (100) can transmit the acquired sensing data to the server (400). Operation 1680 can correspond to operation 1370 of FIG. 13.

[0290] At operation 1690, the server (400) can identify whether the sensing data corresponds to the acquired preferred flavor intensity. Based on the identification result, the server (400) can decide whether to update the recipe. Operation 1690 may correspond to operation 1380 of FIG. 13 .

[0291] In operation 1691, the server (400) may transmit the identified cooking status and / or recipe to the user terminal (500).

[0292] In operation 1692, the user terminal (500) may provide guidance on the recipe so as not to deviate from the preferred taste intensity.

[0293] A cooking guide device according to one embodiment of the present disclosure includes one or more sensors for sensing the taste of a cooking object, a memory for storing instructions, and a processor for executing the instructions stored in the memory.

[0294] A processor according to one embodiment of the present disclosure acquires sensing data by executing the instructions and sensing the taste of the cooking object through the one or more sensors.

[0295] According to one embodiment of the present disclosure, the sensing data identifies whether it corresponds to a preferred taste intensity of a previously stored recipe.

[0296] According to one embodiment of the present disclosure, the sensing data provides guide information so that it does not deviate from the preferred taste intensity of the previously stored recipe.

[0297] A cooking guide device according to one embodiment of the present disclosure may further include an input interface.

[0298] A processor according to one embodiment of the present disclosure can receive input regarding the pre-stored recipe and the preferred taste intensity of the pre-stored recipe through the input interface by executing the instruction.

[0299] A processor according to one embodiment of the present disclosure can provide recipe information based on the preferred taste intensity by executing the instruction.

[0300] According to one embodiment of the present disclosure, the processor can update the pre-stored recipe by executing the instruction, thereby adjusting at least one of the ingredient content, cooking order, heat power, or cooking time of the pre-stored recipe in response to the preferred taste intensity.

[0301] A processor according to one embodiment of the present disclosure can provide the updated recipe information by executing the instruction.

[0302] The above memory may include a recipe for the cooking object and information on the user's preferred taste intensity for the recipe.

[0303] The user type-specific preferred taste intensity information may include at least one of user-customized taste intensity information, taste intensity information for food sensed through one or more sensors, or taste intensity information that complies with the recommended intake standard.

[0304] A cooking guide device according to one embodiment of the present disclosure may further include a communication module.

[0305] A processor according to one embodiment of the present disclosure can control the communication module to obtain an image of a food ingredient and weight information of the food ingredient by executing the instruction.

[0306] A processor according to one embodiment of the present disclosure can generate a recipe with adjusted ingredient content from the previously stored recipe based on ingredient information in the ingredient image and weight information of the ingredient by executing the instruction.

[0307] A cooking guide device according to one embodiment of the present disclosure may further include an output interface.

[0308] A processor according to one embodiment of the present disclosure can control the output interface to provide guide information that guides sensing of the cooking object using the one or more sensors by executing the instructions.

[0309] A cooking guide device according to one embodiment of the present disclosure may further include a temperature sensor.

[0310] A processor according to one embodiment of the present disclosure can obtain a user's preferred temperature for the cooking object by executing the instruction.

[0311] A processor according to one embodiment of the present disclosure can obtain temperature-related sensing data by executing the instructions and sensing the temperature of the cooking object through the temperature sensor.

[0312] A processor according to one embodiment of the present disclosure can identify whether the sensing data regarding the temperature corresponds to the acquired preferred temperature by executing the instruction.

[0313] A processor according to one embodiment of the present disclosure can provide guidance for the recipe by executing the instruction so that the sensing data regarding the temperature does not deviate from the obtained preferred temperature.

[0314] A processor according to one embodiment of the present disclosure can identify whether the sensed data corresponds to the preferred taste intensity by using an AI model learned to infer whether the input data corresponds to the preferred taste intensity by executing the instruction.

[0315] According to one embodiment of the present disclosure, the processor can generate the updated recipe by executing the instruction, and when the sensing data is identified as not corresponding to the preferred taste intensity, by updating at least one of the ingredient content, cooking order, heat power, or cooking time of the previously stored recipe so that the cooking object corresponds to the preferred taste intensity.

[0316] A processor according to one embodiment of the present disclosure can control the communication module to transmit a cooking command to a cooking appliance in response to the updated recipe by executing the instruction.

[0317] A processor according to one embodiment of the present disclosure can control the output interface to provide guide information according to the recipe when the sensing data is identified as corresponding to the preferred taste intensity by executing the instruction.

[0318] According to one embodiment of the present disclosure, a processor may update the stored recipe by executing the instruction, when the sensing data is identified as not corresponding to the preferred taste intensity. The output interface may be controlled to provide the updated recipe information.

[0319] A recipe providing method according to one embodiment of the present disclosure includes a step of obtaining sensing data by sensing the taste of a cooking object through one or more sensors, a step of identifying whether the sensing data corresponds to a preferred taste intensity of a previously stored recipe, and a step of providing guide information so that the sensing data does not deviate from the preferred taste intensity of the previously stored recipe.

[0320] A recipe providing method according to one embodiment of the present disclosure may further include a step of receiving an input regarding the pre-stored recipe and a preferred taste intensity of the pre-stored recipe through an input interface, and a step of providing recipe information based on the preferred taste intensity.

[0321] A recipe providing method according to one embodiment of the present disclosure may further include a step of updating the pre-stored recipe by adjusting at least one of the type of ingredients, the amount of ingredients, the cooking order, the heat power, or the cooking time of the pre-stored recipe in response to the preferred taste intensity.

[0322] The step of providing recipe information based on the preferred taste intensity according to one embodiment of the present disclosure may include the step of providing the updated recipe information.

[0323] A recipe providing method according to one embodiment of the present disclosure may further include a step of acquiring an image of a food ingredient and weight information of the food ingredient, and a step of generating a recipe with an adjusted food ingredient content from the previously stored recipe based on the food ingredient information in the image of the food ingredient and the weight information of the food ingredient.

[0324] A recipe providing method according to one embodiment of the present disclosure may further include a step of controlling an output interface to provide guide information that guides sensing of the cooking object using the one or more sensors.

[0325] A recipe providing method according to one embodiment of the present disclosure may further include a step of obtaining a preferred temperature for the cooking object, a step of obtaining temperature-related sensing data by sensing the temperature for the cooking object through a temperature sensor, a step of identifying whether the temperature-related sensing data corresponds to the obtained preferred temperature, and a step of providing a guide for the recipe so that the temperature-related sensing data does not deviate from the obtained preferred temperature.

[0326] The step of providing guide information so as not to deviate from the preferred taste intensity of a previously stored recipe according to one embodiment of the present disclosure may include the step of generating the updated recipe by updating at least one of the ingredient content, cooking order, heat power, or cooking time so that the cooking object corresponds to the preferred taste intensity when the sensing data is identified as not corresponding to the preferred taste intensity.

[0327] A computer-readable recording medium having recorded thereon a program for performing a recipe providing method according to one embodiment of the present disclosure on a computer may be provided. The machine-readable storage medium may be provided in the form of a non-transitory storage medium. Here, the term "non-transitory storage medium" simply means a tangible device that does not contain a signal (e.g., electromagnetic waves), and this term does not distinguish between cases where data is stored semi-permanently and cases where data is stored temporarily. For example, a "non-transitory storage medium" may include a buffer in which data is temporarily stored.

[0328] According to one embodiment, the method according to various embodiments disclosed in the present document may be provided as included in a computer program product. The computer program product may be traded as a product between a seller and a buyer. The computer program product may be distributed in the form of a machine-readable storage medium (e.g., compact disc read-only memory (CD-ROM)), or may be distributed online (e.g., downloaded or uploaded) through an application store or directly between two user devices (e.g., smartphones). In the case of online distribution, at least a portion of the computer program product (e.g., a downloadable app) may be temporarily stored or temporarily generated in a machine-readable storage medium, such as the memory of a manufacturer's server, an application store's server, or an intermediary server.

Claims

1. One or more sensors for sensing the taste of the object to be cooked; Memory that stores instructions; and A processor that executes the instructions stored in the memory, The above processor executes the above instruction, By sensing the taste of the cooking object through one or more sensors, sensing data is obtained, Identify whether the above sensing data corresponds to the preferred flavor intensity of a previously stored recipe, A cooking guide device that provides guide information so that the sensing data does not deviate from the preferred taste intensity of the previously stored recipe.

2. In paragraph 1, The above cooking guide device, Including more input interfaces, The above processor executes the above instruction, Receiving input regarding the stored recipe and the preferred taste intensity of the stored recipe through the input interface, A cooking guide device that provides recipe information based on the above preferred taste intensity.

3. In paragraph 2, The above processor executes the above instruction, By adjusting at least one of the ingredient content, cooking order, heat power, or cooking time of the stored recipe in response to the preferred taste intensity, the stored recipe is updated, A cooking guide device providing the above updated recipe information.

4. In any one of paragraphs 1 to 3, The above memory includes a recipe for the cooking object and information on the user's preferred taste intensity according to the type of the recipe, A cooking guide device, wherein the user type-specific preferred taste intensity information includes at least one of user-customized taste intensity information, taste intensity information for food sensed through one or more sensors, or taste intensity information that complies with the recommended intake standard.

5. In any one of paragraphs 1 to 4, The above cooking guide device, Including more communication modules, The above processor executes the above instruction, Control the communication module to obtain food image and weight information of the food, A cooking guide device that generates a recipe with adjusted ingredient content from the previously stored recipe based on ingredient information and weight information of the ingredient in the image of the ingredient.

6. In any one of paragraphs 1 to 5, The above cooking guide device, Including more output interfaces, The above processor executes the above instruction, A cooking guide device that controls the output interface to provide guide information that guides sensing of the cooking object using the one or more sensors.

7. In any one of paragraphs 1 to 6, The above cooking guide device further includes a temperature sensor, The above processor executes the above instruction, Obtain the user's preferred temperature for the above cooking object, By sensing the temperature of the cooking object through the temperature sensor, sensing data regarding the temperature is obtained, Identifying whether the sensing data regarding the above temperature corresponds to the obtained preferred temperature, A cooking guide device that provides a guide for the recipe so that the sensing data regarding the above temperature does not deviate from the obtained preferred temperature.

8. In any one of paragraphs 1 to 7, The above processor executes the above instruction, A cooking guide device that identifies whether the sensing data corresponds to the preferred taste intensity by using an AI model learned to infer whether the input data corresponds to the preferred taste intensity.

9. In any one of paragraphs 1 to 8, The above processor executes the above instruction, A cooking guide device that generates the updated recipe by updating at least one of the ingredient content, cooking order, heat power, or cooking time of the previously stored recipe so that the cooking object corresponds to the preferred taste intensity when the sensing data is identified as not corresponding to the preferred taste intensity.

10. In paragraph 9, The above cooking guide device, Including more communication modules, The above processor executes the above instruction, A cooking guide device that controls the communication module to transmit a cooking command to a cooking appliance in response to the updated recipe.

11. In any one of paragraphs 1 to 10, The above cooking guide device, Including more output interfaces, The above processor executes the above instruction, When the sensing data is identified as corresponding to the preferred taste intensity, the output interface is controlled to provide guide information according to the recipe, A cooking guide device that controls the output interface to update the stored recipe and provide the updated recipe information when the sensing data is identified as not corresponding to the preferred taste intensity.

12. In the method of providing the recipe, A step of acquiring sensing data by sensing the taste of a cooking object through one or more sensors; A step of identifying whether the sensing data corresponds to the preferred taste intensity of a previously stored recipe; and A method comprising a step of providing guide information so that the sensing data does not deviate from the preferred taste intensity of the previously stored recipe.

13. In paragraph 12, The above method, A step of receiving input regarding the stored recipe and the preferred taste intensity of the stored recipe through an input interface; and A method further comprising the step of providing recipe information based on the preferred taste intensity.

14. In paragraph 13, The above method, Further comprising a step of updating the pre-stored recipe by adjusting at least one of the type of ingredients, the amount of ingredients, the cooking order, the heat power, or the cooking time of the pre-stored recipe in response to the preferred taste intensity, The step of providing recipe information based on the above preferred taste intensity is: A method comprising the step of providing the updated recipe information.

15. A computer-readable recording medium having recorded thereon a program for performing the method of any one of clauses 12 to 14 on a computer.

Images