Graphical user interface engine for embedded systems

Abstract

In an embedded system, for instance in a household appliance, in addition to the usual embedded microprocessor/microcontroller there is provided another processor which actually executes a user interface HTML document for accepting user input, for instance from a keypad and controlling the display device, for instance an LCD. The embedded microprocessor hosts the user interface document, responds to requests from the other processor, keeps track of changes in variables shared with the other processor, and executes the control device functionality. The other processor renders the graphical user interface to the display and interacts with the user by executing local functions to operate on the memory and i/o resources of the embedded processor as described by the user interface document served to it.

1 - 17 . (canceled)  
   
   
       18 : A method for programming a graphic user interface (“GUI”) implemented by a first controller for a device independently from a second controller that monitors and controls the device, the method comprising: 
 creating a HTML page defining an appearance of the GUI, said creating comprising: 
 selecting an applet code of a GUI object and arranging the applet code on the HTML page;  
 setting a source or a destination of a parameter of the GUI object;  
   compiling the HTML page, comprising 
 replacing the applet code with an operation code (“opcode”) identifying the GUI object;  
 setting an operand identifying the source or the destination of the parameter of the GUI object;  
   loading the compiled HTML page into at least one memory in the device, wherein in response to the opcode and the operand, the GUI controller executes executable codes in at least one memory to communicate the parameter with the source or the destination and to render the GUI object in response to the parameter.    
   
   
       19 : The method of  claim 18 , wherein said communicating the parameter with the source comprises receiving a status of the device from the second controller.  
   
   
       20 : The method of  claim 18 , wherein said communicating the parameter with the destination comprises sending a user command to the second controller.  
   
   
       21 : The method of  claim 20 , further comprising executing the executable codes to receive the user command from an input device.  
   
   
       22 : A first controller providing a graphical user interface (“GUI”) for a device independently from a second controller that monitors and controls the device, the first controller comprising: 
 at least one memory comprising: 
 a document buffer storing a document, the document comprising an operation code (“opcode”) identifying a GUI object in the GUI and an operand identifying a parameter of the GUI object, the GUI object being a graphical presentation of the parameter, the parameter being from the second controller;  
 a frame buffer for storing at least one complete frame of the GUI including the GUI object;  
 a GUI object library storing executable codes defining an appearance and a functionality of the GUI object, the executable codes comprising instructions for receiving non-graphical data of the parameter from the second controller and rendering the GUI object in response to any change to the parameter;  
   a processor coupled to the second controller and the at least one memory, wherein the processor (1) reads the opcode and the operand, (2) reads the executable codes, (3) executes the executable codes to (a) receive the non-graphical data of the parameter from the second controller and (b) render the GUI object in response to any change to the parameter independently from the second controller, and (4) saves the rendered GUI object in the frame buffer.    
   
   
       23 : The first controller of  claim 22 , further comprising an output device coupled to the frame buffer to receive the GUI, the output device displaying the GUI to the user.  
   
   
       24 : The first controller of  claim 23 , wherein the output device is a liquid crystal display (“LCD”).  
   
   
       25 : The first controller of  claim 24 , further comprising a pixel serializer coupled between the frame buffer and the LCD, the pixel serializer outputting each line of the GUI in the frame buffer to the LCD.  
   
   
       26 : The first controller of  claim 22 , wherein the parameter is a status of the device from the second controller to the user.  
   
   
       27 : The first controller of  claim 26 , wherein the GUI object is a text field.  
   
   
       28 : The first controller of  claim 22 , further comprising another memory coupled to the processor, the another memory storing the document, the processor loading the document from the another memory to the at least one memory.  
   
   
       29 : The first controller of  claim 22 , wherein the second controller further comprises another memory storing the document, the second controller reading the document from the another memory and sending the document to the first controller, the first controller loading the document in the at least one memory.  
   
   
       30 : A method for a first controller to generate a graphic user interface (“GUI”) for a device independently from a second controller that monitors and controls the device, the method comprising: 
 loading a document into a document buffer in at least one memory, the document defining an appearance of the GUI, the document comprising an operation code (“opcode”) identifying a GUI object and an operand identifying a parameter of the GUI object, the GUI object being a graphical presentation of the parameter, the parameter being from the second controller;    in response to the opcode and the operand, retrieving executable codes of the GUI object from a GUI object library stored in the at least one memory, the executable codes defining an appearance and a functionality of the GUI object, the executive code comprising instructions for receiving non-graphical data of the parameter from the second controller and rendering the GUI object in response to any change to the parameter;    independently from the second controller, executing the instructions to receive the non-graphical data of the parameter from the second controller and to render the GUI object in response to any change to the parameter;    writing the rendered GUI object in a frame buffer in the at least one memory; and    sending the rendered GUI object from the frame buffer to an output device, wherein the output device displays the GUI to a user.    
   
   
       31 : The method of  claim 30 , wherein the output device is a liquid crystal display (“LCD”).  
   
   
       32 : The method of  claim 30 , wherein the parameter is a status of the device from the second controller to the user.  
   
   
       33 : The method of  claim 32 , wherein said rendering the GUI object comprises drawing a text field.  
   
   
       34 : The method of  claim 30 , further comprising reading the document from another memory prior to said loading the document into the at least one memory.  
   
   
       35 : The method of  claim 30 , further comprising receiving the document from the second controller prior to said loading the document into the at least one memory.  
   
   
       36 : A first controller providing a graphical user interface (“GUI”) for a device independently from a second controller that monitors and controls the device, the first controller comprising: 
 at least one memory comprising: 
 a document buffer storing a document, the document comprising: 
 an operation code (“opcode”) identifying a GUI object in the GUI, the GUI object being a graphical presentation of a user input, the user input being from an input device; and  
 an operand identifying a destination of the user input, the destination being the second controller;  
 
 a frame buffer for storing at least one complete frame of the GUI including the GUI object;  
 a GUI object library storing executable codes defining an appearance and a functionality of the GUI object, the executable codes comprising instructions for (1) receiving the user input from the input device, (2) rendering the GUI object in response to any change to the user input, and (3) sending non-graphical data of the user input to the second controller;  
   a processor coupled to the input device, the second controller, and the at least one memory, wherein the processor (1) reads the opcode and the operand, (2) reads the executable codes, (3) executes the executable codes to (a) receive the user input from the input device, (b) render the GUI object in response to any change to the user input independently from the second controller, and (c) send the non-graphical data of the user input to the second controller, and (4) saves the rendered GUI object in the frame buffer.    
   
   
       37 : The first controller of  claim 36 , further comprising an output device coupled to the frame buffer to receive the GUI, the output device displaying the GUI to the user.  
   
   
       38 : The first controller of  claim 37 , wherein the output device is a liquid crystal display (“LCD”).  
   
   
       39 : The first controller of  claim 38 , further comprising a pixel serializer coupled between the frame buffer and the LCD, the pixel serializer outputting each line of the GUI in the frame buffer to the LCD.  
   
   
       40 : The first controller of  claim 36 , wherein the input device is one of a touch screen, a key pad, an infrared remote, and a voice decoder.  
   
   
       41 : The first controller of  claim 40 , wherein the GUI object is one of a button and a list.  
   
   
       42 : The first controller of  claim 36 , further comprising another memory coupled to the processor, the another memory storing the document, the processor loading the document from the another memory to the at least one memory.  
   
   
       43 : The first controller of  claim 36 , wherein the second controller further comprises another memory storing the document, the second controller reading the document from the another memory and sending the document to the first controller, the first controller loading the document in the at least one memory.  
   
   
       44 : A method for a first controller to generate a graphic user interface (“GUI”) for a device independently from a second controller that monitors and controls the device, the method comprising: 
 loading a document in a document buffer in at least one memory, the document defining an appearance of the GUI, the document comprising: 
 an operation code (“opcode”) identifying a GUI object in the GUI, the GUI object being a graphical presentation of a user input, the user input being from an input device; and  
 an operand identifying a destination of the user input, the destination being the second controller;  
   in response to the opcode and the operand, retrieving executable codes of the GUI object from a GUI object library stored in the at least one memory, the executable codes defining an appearance and a functionality of the GUI object, the executable codes comprising instructions for (1) receiving the user input from the input device, (2) rendering the GUI object in response to any change to the user input, and (3) sending non-graphical data of the user input to the second controller;    independently from the second controller, executing the instructions to (1) receive the user input from the input device, (2) render the GUI object in response to any change to the user input, and (3) send the non-graphical data of the user input to the second controller;    writing the rendered GUI object in a frame buffer in the at least one memory; and    sending the rendered GUI object from the frame buffer to an output device, wherein the output device displays the GUI to a user.    
   
   
       45 : The method of  claim 44 , wherein the output device is a liquid crystal display (“LCD”).  
   
   
       46 : The method of  claim 44 , wherein the input device is one of a touch screen, a key pad, an infrared remote, and a voice decoder.  
   
   
       47 : The method of  claim 46 , wherein said rendering the GUI object comprises drawing one of a button and a list.  
   
   
       48 : The method of  claim 44 , further comprising reading the document from another memory and loading the document in the at least one memory.  
   
   
       49 : The method of  claim 44 , further comprising receiving the document from the second controller and loading the document in the at least one memory.