Self-determining behavior node for use in creating a graphical program

• US 20030172369A1
• Filed: 03/08/2002
• Published: 09/11/2003
• Est. Priority Date: 03/08/2002
• Status: Active Grant

• Current Assignee: National Instruments Corporation (Emerson Electric Company)
• Original Assignee: National Instruments Corporation (Emerson Electric Company)
• Inventors: Kodosky, Jeffrey L., Rogers, Steven W., Gabbert, Adam
• Granted Patent: US 7,216,334 B2
• Time in Patent Office: Days
• US Class Current: 717/113
• CPC Class Codes: G06F 8/34 Graphical or visual programming

Abstract

A system and method for creating a graphical program utilizing one or more self-determining behavior (SDB) nodes. An SDB node may include associated generation code for programmatically generating execution-time code associated with the SDB node. The generation code associated with the SDB node may programmatically generate or modify the execution-time code based on or in response to any of various factors.

Claims

1. A method for creating a first graphical program, the method comprising:

displaying a first node in the first graphical program, wherein the first node includes associated generation code for programmatically generating execution-time code associated with the first node;

receiving first input to edit the first graphical program; and

the generation code associated with the first node executing to programmatically generate first execution-time code based on the first input, wherein the programmatically generated first execution-time code is associated with the first node in the first graphical program.

2. The method of claim 1,

wherein said generation code executing to programmatically generate the first execution-time code comprises the generation code executing to programmatically generate the first execution-time code prior to execution of the first graphical program.

3. The method of claim 1,

wherein the generation code is operable to programmatically generate different types of execution-time code having different functionality for the first node.

4. The method of claim 3,

wherein the programmatically generated first execution-time code implements first functionality;

wherein the generation code is operable to generate the first execution-time code implementing the first functionality in response to the first input.

5. The method of claim 3, further comprising:

receiving second input to edit the first graphical program;

the generation code associated with the first node programmatically generating second execution-time code based on the second input;

wherein the second execution-time code is associated with the first node in the first graphical program in place of the first execution-time code;

wherein the programmatically generated second execution-time code implements second functionality.

6. The method of claim 1, further comprising:

executing the first graphical program, wherein said executing the first graphical program includes executing the first execution-time code.

7. The method of claim 6,

wherein during execution of the first graphical program, code associated with each of a plurality of nodes in the first graphical program executes when scheduled by the first graphical program, wherein the plurality of nodes includes the first node;

wherein said executing the first graphical program includes the first execution-time code executing when the first node is scheduled to execute.

8. The method of claim 1,

wherein the generation code executes to programmatically generate the first execution-time code in response to input received to edit the first graphical program.

9. The method of claim 1,

wherein the generation code executes to programmatically generate the first execution-time code when compiling the graphical program.

10. The method of claim 1,

wherein the first node does not have any associated execution-time code when the first node is displayed in the first graphical program;

wherein said programmatically generating the first execution-time code comprises creating execution-time code for the first node.

11. The method of claim 1,

wherein the first node has initial associated execution-time code when the first node is displayed in the first graphical program;

wherein said programmatically generating the first execution-time code comprises replacing the initial execution-time code with the first execution-time code.

12. The method of claim 1,

wherein the first node has initial associated execution-time code when the first node is displayed in the first graphical program;

wherein said programmatically generating the first execution-time code comprises modifying the initial execution-time code.

13. The method of claim 1,

wherein said programmatically generating the first execution-time code comprises programmatically generating an execution-time block diagram, wherein the execution-time block diagram is associated with the first node in the first graphical program.

14. The method of claim 1,

wherein said programmatically generating the first execution-time code comprises programmatically generating first graphical code, wherein the firs t graphical code is associated with the first node in the first graphical program.

15. The method of claim 1,

wherein said programmatically generating the first execution-time code comprises programmatically generating first text-based code, wherein the first text-based code is associated with the first node in the first graphical program.

16. The method of claim 1,

wherein the generation code is included in a first block diagram.

17. The method of claim 16, further comprising:

executing the first block diagram;

wherein the first block diagram is operable to perform said programmatically generating the first execution-time code.

18. The method of claim 1,

wherein the generation code comprises graphical code.

19. The method of claim 1,

wherein the generation code comprises text-based code.

20. The method of claim 1, further comprising:

displaying a configuration user interface for configuring the first node;

wherein said receiving first input to edit the first graphical program comprises receiving user input to the configuration user interface to configure the first node;

wherein said programmatically generating first execution-time code based on the first input comprises programmatically generating first execution-time code based on the user input to the configuration user interface.

21. The method of claim 20,

wherein the configuration user interface displays information to guide a user in specifying desired execution functionality for the first node;

wherein said receiving user input to the configuration user interface to configure the first node comprises receiving user input to the configuration user interface to specify execution functionality for the first node;

wherein said programmatically generating first execution-time code based on the user input to the configuration user interface comprises programmatically generating first execution-time code to implement the specified execution functionality for the first node.

22. The method of claim 20,

wherein the configuration user interface displays information to guide a user in configuring the first node to perform one or more operations from a plurality of operations;

wherein said receiving user input to the configuration user interface to configure the first node comprises receiving user input to the configuration user interface to specify one or more desired operations for the first node from the plurality of operations;

wherein said programmatically generating first execution-time code based on the user input to the configuration user interface comprises programmatically generating first execution-time code to implement the one or more desired operations, such that the node is operable to perform the one or more desired operations during execution of the graphical program.

23. The method of claim 1,

wherein said receiving first input to edit the first graphical program comprises receiving input to a block diagram of the graphical program.

24. The method of claim 23,

wherein said receiving input to the block diagram of the graphical program comprises connecting the first node to one or more other nodes in the graphical program.

25. The method of claim 23,

wherein said receiving input to the block diagram of the graphical program comprises connecting an input to an input terminal of the first node.

26. The method of claim 25,

wherein said programmatically generating the first execution-time code comprises programmatically generating the first execution-time code based on a data type of the input.

27. The method of claim 23,

wherein said receiving input to the block diagram of the graphical program comprises connecting an output from an output terminal of the first node to an input terminal of a second node in the first graphical program.

28. The method of claim 23,

wherein said receiving input to the block diagram of the graphical program comprises receiving input to the first node.

29. The method of claim 1,

wherein said receiving first input to edit the first graphical program comprises receiving input requesting to perform said displaying the first node in the first graphical program.

30. The method of claim 1,

wherein said receiving first input to edit the first graphical program comprises receiving input to edit a user interface of the graphical program.

31. The method of claim 1, further comprising:

creating the first node prior to said displaying the first node in the first graphical program;

wherein said creating the first node comprises creating the generation code associated with the first node.

32. The method of claim 31,

wherein the first graphical program is associated with a first graphical programming development environment;

wherein the method further comprises deploying the first node in the first graphical programming development environment;

wherein said deploying the first node in the first graphical programming development environment comprises making the first node available for display in graphical programs developed using the first graphical programming development environment.

33. The method of claim 1,

wherein the first graphical program includes a plurality of interconnected nodes that visually indicate functionality of the first graphical program.

34. The method of claim 1,

wherein said creating the first graphical program comprises:

arranging a plurality of nodes on a display; and

interconnecting the plurality of nodes in response to user input.

35. The method of claim 1,

wherein the first graphical program comprises a block diagram portion and a user interface portion.

36. The method of claim 1,

wherein the graphical program comprises a graphical data flow program.

37. The method of claim 1,

wherein the first input comprises user input.

38. The method of claim 1,

wherein said programmatically generating the first execution-time code based on the first input comprises programmatically creating the first execution-time code at edit-time of the first graphical program.

39. The method of claim 1, further comprising:

displaying the first node in a second graphical program;

receiving second input to edit the second graphical program;

the generation code associated with the first node programmatically generating second execution-time code in response to the second input, wherein the second execution-time code is associated with the first node in the second graphical program;

wherein the programmatically generated second execution-time code has functionality that is different from functionality of the programmatically generated first execution-time code.

40. The method of claim 1,

wherein the first node further includes associated design-time behavior code operable to affect design-time behavior of the first node.

41. The method of claim 40, further comprising:

receiving second input to edit the first graphical program; and

the design-time behavior code associated with the first node executing to affect design-time behavior of the first node in response to the second input.

42. The method of claim 40, further comprising:

the design-time behavior code associated with the first node executing to affect design-time behavior of the first node in response to the first input.

43. The method of claim 40,

wherein the design-time behavior code is operable to affect the appearance of the node within the graphical program in response to receiving input to edit the graphical program.

44. The method of claim 40,

wherein the design-time behavior code is operable to affect a user'"'"'s experience of interacting with the first node when editing the first graphical program.

45. The method of claim 40,

wherein the first node includes associated node behavior characterization code, wherein the node behavior characterization code includes:

the generation code; and

the design-time behavior code.

46. The method of claim 1, further comprising:

displaying the programmatically generated first execution-time code.

47. The method of claim 1,

wherein a graphical programming development environment is used in creating the first graphical program;

wherein the graphical programming development environment does not allow a user to view the programmatically generated first execution-time code.

48. The method of claim 1,

wherein said displaying the first node in the first graphical program comprises displaying a first instance of the first node in the first graphical program;

wherein the programmatically generated first execution-time code is associated with the first instance of the node in the first graphical program;

wherein the method further comprises;

displaying a second instance of the first node in the first graphical program, wherein the second instance of the first node includes associated generation code for programmatically generating execution-time code associated with the second instance of the first node;

receiving second input to edit the first graphical program; and

the generation code associated with the second instance of the first node programmatically generating second execution-time code in response to the second input, wherein the programmatically generated second execution-time code is associated with the second instance of the first node in the first graphical program.

49. The method of claim 48,

wherein the programmatically generated second execution-time code is different than the programmatically generated first execution-time code.

50. The method of claim 1,

wherein the first node is stored on a memory medium;

wherein the generation code associated with the first node is stored together with the first node on the memory medium.

51. A method for creating a first graphical program, the method comprising:

displaying a first node in the first graphical program, wherein the first node includes associated generation code for programmatically generating execution-time code, wherein the generation code is operable to programmatically generate different types of execution-time code;

receiving input to edit the first graphical program; and

executing the generation code associated with the first node to programmatically generate first execution-time code for the first graphical program, wherein the first execution-time code implements first functionality, wherein the first execution-time code is programmatically generated based on the input.

52. The method of claim 51,

wherein the programmatically generated first execution-time code is associated with the first node in the first graphical program.

53. The method of claim 51, further comprising:

executing the first graphical program, wherein said executing the first graphical program includes executing the first execution-time code.

54. A method for creating a first graphical program, the method comprising:

displaying a first node in the first graphical program, wherein the first node includes associated generation code for programmatically generating execution-time graphical code associated with the first node;

receiving first input to edit the first graphical program; and

the generation code associated with the first node programmatically generating first execution-time graphical code in response to the first input, wherein the first execution-time graphical code is associated with the first node in the first graphical program, wherein the first execution-time graphical code comprises a plurality of interconnected nodes.

55. The method of claim 54,

wherein said generating the first execution-time graphical code comprises generating a block diagram, wherein the block diagram is associated with the first node in the first graphical program, wherein the block diagram comprises the plurality of interconnected nodes.

56. A method for creating a first graphical program, the method comprising:

displaying a first node in the first graphical program, wherein the first node includes an associated node behavior characterization block diagram, wherein the node behavior characterization block diagram includes generation code for programmatically generating execution-time code associated with the first node;

receiving first input to edit the first graphical program; and

the generation code associated with the first node programmatically generating first execution-time code in response to the first input, wherein the first execution-time code is associated with the first node in the first graphical program.

57. The method of claim 56,

wherein the generation code comprises a plurality of interconnected nodes visually indicating functionality of the generation code.

58. A method for creating a graphical program, the method comprising:

displaying a first node in the graphical program, wherein the first node includes associated generation code for programmatically generating execution-time code, wherein the generation code is operable to programmatically generate different types of execution-time code;

connecting one or more input terminals of the first node to receive one or more outputs from one or more other nodes in the graphical program;

determining one or more data types of data provided by the one or more outputs connected to the one or more input terminals of the first node;

executing the generation code associated with the first node to programmatically generate first execution-time code, wherein the first execution-time code is programmatically generated based on the one or more data types; and

executing the graphical program, wherein said executing the graphical program includes executing the first execution-time code.

59. A computer-implemented method for creating a node for inclusion in a graphical program, the method comprising:

creating an iconic appearance for the node; and

creating generation code associated with the node;

wherein when the node is included in a first graphical program being developed, the generation code is executable at design-time of the first graphical program to programmatically generate execution-time code for the node, wherein the execution-time code for the node executes during execution of the first graphical program.

60. The method of claim 59,

wherein said creating the generation code associated with the node comprises creating the generation code in response to user input.

61. The method of claim 59,

wherein said creating the generation code associated with the node comprises creating a block diagram in response to user input.

62. The method of claim 59,

wherein the generation code associated with the node comprises graphical code.

63. The method of claim 59, further comprising:

storing program instructions and data on a first memory medium, wherein the program instructions and data represent the first node.

64. The method of claim 63,

wherein the first graphical program is created using a first graphical programming development environment installed on a first computer system;

wherein the method further comprises deploying the node in the first graphical programming development environment installed on the first computer system;

wherein said deploying the node in the first graphical programming development environment installed on the first computer system comprises transferring the program instructions and data representing the first node from the first memory medium to a memory medium of the first computer system.

65. The method of claim 59, further comprising:

creating design-time behavior code associated with the node;

wherein when the node is included in the first graphical program being developed, the design-time behavior code is operable to affect design-time behavior of the node.

66. The method of claim 65,

wherein the design-time behavior code comprises graphical code.

67. The method of claim 59,

wherein the generation code associated with the node is not operable to execute during execution of the first graphical program.

68. The method of claim 59,

wherein the generation code is executable at design-time of the first graphical program to programmatically generate different types of execution-time code for the node;

wherein the different types of execution-time code have different functionality.

69. The method of claim 68,

wherein the type of execution-time code actually generated for the node depends on input received to one or more of:

the first graphical program;

a graphical programming development environment used to create the first graphical program.

70. The method of claim 68, further comprising:

determining code generation dependency information;

wherein the type of execution-time code actually generated for the node depends on the code generation dependency information.

71. The method of claim 70,

wherein said determining the code generation dependency information comprises determining information associated with one or more of:

a state of the node;

a state of the first graphical program;

a state of a graphical programming development environment application used to create the first graphical program.

72. The method of claim 70,

wherein said determining the code generation dependency information comprises determining information external to the first graphical program and external to a graphical programming development environment application used to create the first graphical program.

73. The method of claim 72,

wherein said determining the code generation dependency information comprises determining information from a second application external to the graphical programming development environment application used to create the first graphical program.

74. The method of claim 72,

wherein said determining the code generation dependency information comprises receiving information from a computer server via a network.

75. A method for creating a first graphical program, the method comprising:

displaying a first node in the first graphical program, wherein the first node includes associated generation code executable at design-time of the first graphical program to programmatically generate execution-time code associated with the first node, wherein the generation code is operable to programmatically generate different types of execution-time code for the first node;

determining code generation dependency information at design-time of the first graphical program; and

executing the generation code associated with the first node to programmatically generate first execution-time code, wherein the first execution-time code is associated with the first node in the first graphical program, wherein the programmatic generation of the first execution-time code depends on the code generation dependency information.

76. The method of claim 75, further comprising:

executing the first graphical program, wherein said executing the first graphical program includes executing the first execution-time code.

77. The method of claim 75,

wherein said programmatically generating the first execution-time code comprises programmatically generating an execution-time block diagram, wherein the execution-time block diagram is associated with the first node in the first graphical program.

78. The method of claim 75,

wherein said determining the code generation dependency information comprises determining information associated with one or more of:

a state of the first node;

a state of the first graphical program;

a state of a graphical programming development environment application used to create the first graphical program.

79. The method of claim 75,

wherein said determining the code generation dependency information comprises determining information external to the first graphical program and external to a graphical programming development environment application used to create the first graphical program.

80. The method of claim 79,

wherein said determining the code generation dependency information comprises determining information from a second application external to the graphical programming development environment application used to create the first graphical program.

81. The method of claim 79,

wherein said determining the code generation dependency information comprises receiving information from a computer server via a network.

82. The method of claim 75,

wherein said determining the code generation dependency information at design-time of the first graphical program comprises determining the code generation dependency information while compiling the first graphical program;

wherein said programmatically generating the first execution-time code comprises programmatically generating the first execution-time code while compiling the first graphical program.

83. The method of claim 75, further comprising:

launching a graphical programming development environment used to create the first graphical program;

wherein said determining the code generation dependency information at design-time of the first graphical program comprises determining the code generation dependency information in response to said launching the graphical programming development environment;

wherein said programmatically generating the first execution-time code comprises programmatically generating the first execution-time code when the graphical programming development environment is launched.

84. A memory medium comprising program instructions and data to implement:

a node for inclusion in a graphical program;

wherein the node has a first associated block diagram for execution during creation of the graphical program; and

wherein the node has a second associated block diagram for execution during execution of the graphical program.

85. A self-determining behavior (SDB) node for use in a graphical program, the self-determining behavior node comprising:

data specifying an iconic appearance, wherein the data is useable to display an iconic appearance representing the node in response to including the node in the graphical program;

one or more input and/or output terminals for connecting the node to other nodes in the graphical program; and

associated generation code, wherein the generation code is operable to programmatically generate execution-time code associated with the node in the graphical program.