WO2020187843A1 - Vorrichtung und verfahren zur fernprogrammierung - Google Patents

Vorrichtung und verfahren zur fernprogrammierung Download PDF

Info

Publication number
WO2020187843A1
WO2020187843A1 PCT/EP2020/057130 EP2020057130W WO2020187843A1 WO 2020187843 A1 WO2020187843 A1 WO 2020187843A1 EP 2020057130 W EP2020057130 W EP 2020057130W WO 2020187843 A1 WO2020187843 A1 WO 2020187843A1
Authority
WO
WIPO (PCT)
Prior art keywords
sequence
executable
action
node
course
Prior art date
Legal status (The legal status is an assumption and is not a legal conclusion. Google has not performed a legal analysis and makes no representation as to the accuracy of the status listed.)
Ceased
Application number
PCT/EP2020/057130
Other languages
English (en)
French (fr)
Inventor
Jan Sören EMMERICH
Michael Ten Hompel
Christian Hammermeister
Current Assignee (The listed assignees may be inaccurate. Google has not performed a legal analysis and makes no representation or warranty as to the accuracy of the list.)
Fraunhofer Gesellschaft zur Foerderung der Angewandten Forschung eV
Original Assignee
Fraunhofer Gesellschaft zur Foerderung der Angewandten Forschung eV
Priority date (The priority date is an assumption and is not a legal conclusion. Google has not performed a legal analysis and makes no representation as to the accuracy of the date listed.)
Filing date
Publication date
Application filed by Fraunhofer Gesellschaft zur Foerderung der Angewandten Forschung eV filed Critical Fraunhofer Gesellschaft zur Foerderung der Angewandten Forschung eV
Publication of WO2020187843A1 publication Critical patent/WO2020187843A1/de
Anticipated expiration legal-status Critical
Ceased legal-status Critical Current

Links

Classifications

    • GPHYSICS
    • G06COMPUTING OR CALCULATING; COUNTING
    • G06FELECTRIC DIGITAL DATA PROCESSING
    • G06F8/00Arrangements for software engineering
    • G06F8/30Creation or generation of source code
    • G06F8/34Graphical or visual programming
    • GPHYSICS
    • G05CONTROLLING; REGULATING
    • G05BCONTROL OR REGULATING SYSTEMS IN GENERAL; FUNCTIONAL ELEMENTS OF SUCH SYSTEMS; MONITORING OR TESTING ARRANGEMENTS FOR SUCH SYSTEMS OR ELEMENTS
    • G05B19/00Program-control systems
    • G05B19/02Program-control systems electric
    • G05B19/04Program control other than numerical control, i.e. in sequence controllers or logic controllers
    • G05B19/042Program control other than numerical control, i.e. in sequence controllers or logic controllers using digital processors
    • G05B19/0426Programming the control sequence
    • GPHYSICS
    • G06COMPUTING OR CALCULATING; COUNTING
    • G06FELECTRIC DIGITAL DATA PROCESSING
    • G06F9/00Arrangements for program control, e.g. control units
    • G06F9/06Arrangements for program control, e.g. control units using stored programs, i.e. using an internal store of processing equipment to receive or retain programs
    • G06F9/46Multiprogramming arrangements
    • G06F9/50Allocation of resources, e.g. of the central processing unit [CPU]
    • G06F9/5005Allocation of resources, e.g. of the central processing unit [CPU] to service a request
    • G06F9/5027Allocation of resources, e.g. of the central processing unit [CPU] to service a request the resource being a machine, e.g. CPUs, Servers, Terminals
    • G06F9/5038Allocation of resources, e.g. of the central processing unit [CPU] to service a request the resource being a machine, e.g. CPUs, Servers, Terminals considering the execution order of a plurality of tasks, e.g. taking priority or time dependency constraints into consideration

Definitions

  • the present invention relates to an apparatus and a method for remote programming.
  • the present invention relates in particular to a remote-programmable device for rule-based applications or to a remote-programmable device with Turing-complete parameter set for rule-based applications (FPGRA).
  • loT devices or loT devices can be used in a wide variety of flexible ways.
  • One and the same hardware configuration can have different use cases and also switch between them.
  • a device whose application changes must be reprogrammed.
  • a new program code is loaded onto the device and written to the permanent memory (EEPROM).
  • Radio-based devices that can be used flexibly with little energy consumption would therefore be desirable.
  • the object of the present invention is therefore to create devices which can be used or programmed flexibly by means of data communication with little expenditure of energy.
  • the inventors have recognized that it is particularly advantageous to store and keep the functionalities to be implemented by a device in the form of sequence parts, which each describe at least one operating instruction.
  • a function or functionality to be implemented later by the device can be determined by receiving a configuration signal which merely specifies the sequence and linking of the sequence parts already stored in the device.
  • the device can thus be reprogrammed by re-sorting the predefined and already stored sequence parts, which is possible with little energy expenditure and at the same time enables a very high degree of flexibility.
  • a device comprises an input interface which is designed to receive a configuration signal.
  • the device comprises a data memory in which a plurality of executable process parts is stored, each process part describing at least one operating instruction.
  • a generator is designed to create a course of action which comprises a sequence of sequence parts of the plurality of stored sequence parts, which are specified in the configuration signal.
  • An interface of the device is designed to communicate with a periphery.
  • a processor is designed to address the peripherals in accordance with the course of action.
  • a device comprises an output interface that is designed to send a configuration signal, a signal generator that is designed to provide the configuration signal, so that the configuration signal describes a sequence of executable sequence parts of a plurality of executable sequence parts.
  • the sequence of executable process parts clearly describes a course of action with a plurality of instructions.
  • FIG. 1 shows a schematic block diagram of a device according to an embodiment
  • FIG. 2 shows a schematic block diagram of a data memory according to an exemplary embodiment
  • FIG. 3 shows a schematic block diagram of a device according to an exemplary embodiment that has interfaces in order to provide both wireless communication and wired communication;
  • FIG. 4 shows a schematic representation of an exemplary course of action according to an exemplary embodiment
  • FIG. 5 shows a schematic block diagram of part of a rule tree according to a
  • 6a shows a schematic block diagram of an interconnection of a process node in a rule tree according to an exemplary embodiment
  • 6b shows a schematic representation of a linkage of a process node in one
  • Rule tree the implemented operation being an arithmetic operation according to one embodiment
  • 6c shows a schematic representation of a link of the process node in the
  • 6d shows a schematic representation of the process node according to an exemplary embodiment, in which information inputs obtained by means of links, according to an exemplary embodiment, result in an action to be carried out; 7 shows an exemplary representation of computer-implemented instructions according to an exemplary embodiment for the exemplary representation of different functions implemented by nodes;
  • FIG. 8 shows an exemplary illustration of code according to an exemplary embodiment of
  • 9a-c show examples of code according to an exemplary embodiment for
  • FIG. 10a shows an exemplary code according to an exemplary embodiment in which a maximum number of nodes in the course of action is defined
  • 10b shows an exemplary code according to an exemplary embodiment, which indicates that a node number is run through in full up to a maximum number of nodes or actions;
  • 10c shows an exemplary code according to an exemplary embodiment for executing a course of action by a processor
  • 10d shows an exemplary illustration of code according to an exemplary embodiment of
  • 10e shows exemplary code according to an embodiment that instructs a processor to determine the next node to be executed
  • FIG. 11 shows a schematic block diagram of a device according to an exemplary embodiment, which comprises inputs, outputs and an internal logic
  • FIG. 12 shows a schematic block diagram of a device in accordance with an exemplary embodiment, the peripherals being connected to the outputs in the form of a switch by wire or wirelessly;
  • 13 shows a schematic block diagram of a device according to an exemplary embodiment, in which the inputs are connected to any number of sensors in order to receive sensor signals;
  • FIG. 14 shows a schematic block diagram of a device according to an exemplary embodiment, which is connected to the periphery and which is configured as a sensor / actuator logic or as a transmitter and receiver, for example for a smart home device;
  • FIG. 15 shows a schematic block diagram of a system in accordance with an exemplary embodiment, which comprises the device from FIG. 1 by way of example;
  • 16 shows a schematic block diagram of a system in accordance with an exemplary embodiment, which comprises devices which are designed to exchange a data flow for exchanging logic and / or parameters or setpoint values;
  • FIG. 17 shows a schematic flow diagram of a method according to an exemplary embodiment, which can be carried out, for example, by a remotely programmable device described herein, such as the device;
  • FIG. 19 shows a schematic block diagram of a device according to an exemplary embodiment, which can function as a movement tracker
  • FIG. 20 shows a schematic block diagram of a device in accordance with an exemplary embodiment, which can function as an anti-theft device
  • FIG. 21 shows a schematic block diagram of a device in accordance with an exemplary embodiment that can provide an intelligent heart rate monitor.
  • Some of the exemplary embodiments described below are implemented using or on the basis of an exemplary programming language, i. H. described by code. Details of these exemplary embodiments, which result, for example, on the basis of the semantics and / or on the basis of the specific command implementations, are only to be understood as examples and inserted for better understanding.
  • the selected code implementations do not restrict the exemplary embodiments either to the selected programming language or to the specific command sequence or the designation of variables, unless this is explicitly stated otherwise.
  • the exemplary embodiments explained herein relate to alternative or additional exemplary embodiments with the same, similar and, in particular, equivalent technical effect.
  • loT denotes the term “Internet of Things” and stands for devices that are connected via a usually narrow-band channel communicate with other facilities, both direct connections (peer-to-peer) and infrastructure-based networks can be used for this purpose.
  • the exemplary embodiments described here are not restricted to this, in particular since the advantages of flexibility and energy savings can also be obtained with broadband channels. From this it is also clear that the exemplary embodiments described here can be used in the field of classic mobile communications (e.g. 3G / 4G / LTE - Long Term Evolution - or 5G), but that other wireless communication protocols can be implemented, such as local wireless networks (WLAN ), large area wireless networks (WMAN) or any other wireless communication protocols that the advantages described can also be obtained in the field of wired communication.
  • WLAN local wireless networks
  • WMAN large area wireless networks
  • the following exemplary embodiments relate to the use of integer numbers, ie, whole-number values, for example for the results of nodes of courses of action or their graphic representation. Although this is in terms of storage efficiency is advantageous, the present exemplary embodiments are not limited thereto. Rather, it is possible that operations of a node use other values, such as floating point values (e.g. data type "float").
  • floating point values e.g. data type "float”
  • the one data field which is designated with "res”, for example, and can represent the result of the node, can even remain an integer, since the information (i.e. the bits) in the "res" field is represented by what is known as " cast “(evaluate) can simply be interpreted as float (floating point number!) without suffering any loss of information.
  • the device 10 comprises an input interface 12 which is designed to receive a configuration signal 14.
  • the input interface 12 can be a wireless or wired communication interface or interface, so that the configuration signal can accordingly be a wired signal or a wireless signal.
  • the device 10 comprises a data memory in which a multiplicity of executable sequence parts 18 are stored, which are represented by way of example as “a”, “b”, “c”, “d”, or “e”, although any number is arbitrary, for example at least three, at least four, at least 10, at least 50 or higher, approximately at least 100.
  • Each process part 18i to 185 can be understood as a code segment or code section that describes at least one operating instruction, for example processing or manipulation of an input variable to an output variable, whereupon will be discussed in detail later.
  • the sequence parts 181 to 18 5 can, however, be clearly distinguished from one another and represent, for example, partial programs or partial codes.
  • the device 10 comprises a generator 22 which is designed to create a course of action 24.
  • the course of action 24 can be a combination of several sequence parts 181 to 185, each sequence part 181 to 185 optionally being able to occur in the course of action 24, which includes the possibility of multiple occurrences.
  • the sequence of actions 24 comprises a number of four sequence parts 183, 181, 184 and 182 in the order mentioned, which can be represented as c, a, d, b. Both the selected sequence and the number of process parts 181 to 184 in the course of action 24 are selected here by way of example.
  • a number of M sequence parts in the action sequence 24 can also have any value, the number of M sequence parts 18 in the action sequence 24 being a subset of the N sequence parts stored in the data memory 16, whereby within the subset M one sequence part can occur multiple times.
  • the process parts implemented in the course of action are a subset of the stored course of action.
  • the course of action 24 can thus comprise at least a subset of the plurality of executable sequence parts stored in the data memory.
  • the processor 31 can be designed to run through the subset of executable process parts according to the course of action 24 in order to address the periphery 32 and to process at least one input variable in a first process part in order to obtain an output variable and to use the output variable as an input variable of a second process part to be used, as is explained in more detail, for example, with reference to FIG.
  • the generator 22 is designed to read the sequence parts to be used for the action sequence 24 from the data memory 16 and to link them to the action sequence 24, which includes both the implementation of a sequence of the sequence parts 18i to 18 and a linking of the individual sequence parts.
  • an output variable of a first sequence part, for example 18i can be an input variable of a subsequent sequence part, for example 184, so that the parameters can be transferred by means of corresponding memory references.
  • the applicable rule with regard to the links can be part of the configuration signal 14, which can have information 26i to 264 indicated, for example, as c, a ‘, d‘ or b ‘.
  • information 263 (c ′) can reproduce an instruction for using the sequence part 183 in the action sequence 24.
  • the presence of an item of information 26 1 (a ′) can reproduce an instruction for using the sequence part I81 in the sequence of actions 24.
  • Information 264 (d ') and 262 (b') can similarly include instructions for using sequence parts 1 84 and 182 in action sequence 24.
  • a sequence of the sequence parts 18 1 to 18 4 in the action sequence 24 can be specified explicitly in the configuration signal 14, but can also be implicitly contained in a sequence of the information 263, 26i, 264 and 262, which enables an additional reduction in transmitted data.
  • the generator 22 is designed to evaluate the configuration signal 14 for the information 26 and to create the course of action 24 in such a way that it comprises a sequence of sequence parts 18 indicated in the configuration signal by the information 26, which are stored in the data memory 16.
  • the processor 22 can be designed to create a new or first course of action upon receipt of a possibly first configuration signal.
  • the processor 22 can be designed to replace the course of action 24 with a new, further or different course of action that is in accordance with the updated configuration signal 14 when a new, further or different configuration signal 14 is received. This means that the device 10 is reprogrammed without the need for new program code.
  • the data memory 34 for example as a volatile data memory, a small amount of energy can be used in order to obtain the reprogramming.
  • the configuration signal 14 can have a sequence of information that contains an identifier for each node to be used ( Node number) as well as a type and memory areas for inputs and outputs, so that a node of the course of action 24 can be clearly identified by a total of six parameters and can be reprogrammed via the specified parameters, so that individual nodes as well as the entire course of action can be reprogrammed using the configuration signal 14 is possible to get a new, second course of action.
  • Node number an identifier for each node to be used
  • type and memory areas for inputs and outputs
  • the generator can be designed to redefine at least one executable sequence part of the first course of action based on the second configuration signal in order to obtain a second course of action, that is to say an updated or redefined course of action.
  • the redefinition of the course of action can be Turing-complete as well as the first course of action.
  • the generator can be designed to evaluate the second configuration signal for the six parameters mentioned, which determine the at least one executable sequence part for the redefinition.
  • the device 10 comprises an interface 28, which enables a wired or wireless connection to a peripheral 32.
  • the periphery 32 can include any number, ie, zero or more in each case, but one or more in total, of sensors, actuators, motors, data output devices, data processing devices, such as servers, switches and / or data input devices.
  • the sensors include, for example, temperature sensors, humidity sensors, rotation rate sensors or any other sensors.
  • Actuators can be, for example, control elements that are used in the field of fluid control, generate any other movements, such as switches or Motors or the like, while data input devices include scanners, keys, keyboards or touchpads, data output devices can be displays, lights or displays, for example.
  • the device 10 comprises a processor 32 which is designed to address the peripherals 32 in accordance with the course of action 24.
  • the processor 31 is configured to execute the process parts 18i to 18 4 in the sequence defined by the process process 24, the process process 24 being able to relate to the interaction with the periphery as well as intermediate or intermediate processing steps.
  • the generator 22 and the processor 31 are shown as separate elements, the generator 22 and the processor 31 can also be part of a common control unit implemented, for example, as a processor, micro-controller, field-programmable gate array (FPGA) or the like is. Alternatively, each of the elements 22 and 31 can be implemented in this way by itself.
  • FPGA field-programmable gate array
  • the course of action 24 can be stored in a data memory 34, which can be separate from the data memory 16.
  • the data memories 16 and 34 can be memory areas of the same data memory.
  • MRAM magnetoresistive main memory
  • the data memory 34 can be a volatile or non-volatile memory, since with knowledge of the configuration signal 14 the course of action 24 can be restored by accessing the data memory. Exemplary embodiments can provide for information of the configuration signal 14 to be stored in the data memory 16 and / or the data memory 34.
  • the device 10 enables a high degree of flexibility in applications to be obtained and, depending on the implementation of the data memory 34, of writing a new program code can be dispensed with for reprogramming the device 10 Codes in a read-only memory such as an EEPROM can be dispensed with, which is particularly advantageous for the ultra-low-power range, but the exemplary embodiments are not limited to this.
  • Embodiments are based on the knowledge that the The device activity specified by the user / programmer is only a small part of the total program code. In simplified terms, a very large part is only used to control and integrate the hardware / peripherals.
  • loT devices especially in the ultra-low-power segment, are of a fairly simple nature; recursive programs on calls or complex nested loops are only used in rare cases, which is partly due to hardware limitations.
  • a certain proportion or a high proportion can be represented with concepts according to "If X, then Y, otherwise Z", where X can definitely be the result of a more complex operation and Y and Z a function call or another logic query.
  • FIG. 2 shows a schematic block diagram of a data memory 36, which acts as a common data memory for the data memories 16 and 34.
  • a common data memory is not restricted to the fact that the data memories 16 and 34, which act as a first memory section and second memory section, are based on the same memory principles.
  • the memory section or data memory 16 is designed to store the multiplicity of executable sequence parts 18, that is, the prefabricated or predefined code sections.
  • the data memory or memory section 34 can be designed to store the course of action 24.
  • the generator 22 can be designed to store the created course of action 24 in the memory section 34.
  • the data memory 16 is formed as a non-volatile memory and the data memory 34 is formed as a volatile memory.
  • FIG. 3 shows a schematic block diagram of a device 30 according to an exemplary embodiment, which has interfaces 12i and 12 2 in order to provide both wireless communication via interface 12i and wired communication via interface 12 2 .
  • the interfaces 12i and / or 12 2 can enable bidirectional communication, as can the interface 12 of the device 10. For example, a result of internal calculations or evaluated sensors or nodes can be reported back.
  • the device 30 comprises a control device 38, for example a central processing unit (CPU, a micro-controller or the like), which is connected to the exemplary non-volatile data memory 16 and the exemplary volatile data memory 34 and both the generator 22 and the also the processor 31 of the Device 10 implemented.
  • the control device 38 can be connected to any number> 1 clock generators (real-time clock - RTC).
  • a cut 28i can be configured to detect a number of 0,... V inputs, where V is any number> 0.
  • the v inputs of the interface 28i can provide any information or data.
  • An optional further interface 282 can be connected to a number of 0,...
  • W sensors so that when sensors are connected, corresponding sensor signals can reach the control device 38, that is, the control device 38 can access the optional inputs and the have optional sensors. It is pointed out that preferably at least one of the values v or w> 0 and the device 30 or the periphery has at least one input or at least one sensor.
  • Other systems can be controlled via an interface 28 3 , for example via a communication bus or an energy transmission bus.
  • the device 30 can have an optional interface 284 for parallel (Par) and / or serial (Ser) communication.
  • An interface 28 5 can optionally be provided and provide a number of outputs that are connected, for example, to a display device and / or an actuator and / or provide control signals for sensors or the like.
  • the device 30 can be designed to receive the configuration signal via the interface 12i and / or the interface 12 2 , that is to say via a wired or wireless communication network.
  • the configuration signal is preferably received via a wireless network, since this offers a high degree of flexibility for the device 30, in particular with regard to the positioning of the same.
  • the interface 12 2 can provide a connection to a wireless or wired network.
  • the wireless network can comprise a radio network, which is understood to mean cellular radio applications, for example 3G, 4G or 5G.
  • the configuration signal is designed in such a way that a sequence of executable process parts is displayed or contained in the configuration signal and both indicates the subset of the process parts stored in the data memory 16 and clearly defines a sequence of the selected process parts in the action process 24. This means that the sequence of executable process parts and thus the course of action are clearly defined in the configuration signal, even if the program code to be executed itself is not necessarily part of the configuration signal.
  • Components connected to inputs 28i to 28 can also belong to the periphery, as can the components connected to outputs 28s.
  • the course of action 24 can have one or more rule trees 44i and 44 2 or be represented by the rule trees, the number of rule trees 441 and / or 44 2 in the course of action 24 being any number of 1 can be.
  • the rule trees 44i and 44 2 can be processed in parallel or one after the other, ie sequentially, and can relate, for example, to different functions of the device implementing the course of action 24.
  • one of the rule trees can describe a sensor evaluation and another rule tree can describe an actuator control or a data display or data transmission.
  • the rule trees 44i and 44 2 comprise at least one start node 46i or 46 2 and in each case at least one end node (NULL) 48i and 48 2 or 48 3 .
  • Process nodes or execution nodes 52 are arranged between the start node 46 and the end node 48, each rule tree 44i and 44 2 comprising at least one process node 52.
  • At least each of the execution nodes 52, optionally the start node 46 and also optionally the end node 48 can implement one of the executable process parts 18, so that the nodes 52, 46 and possibly 48 shown can be viewed as representations of the process parts.
  • Each node may implement or represent one of the executable flow parts included in the storyline. Alternatively or additionally, a node can also represent a combination of several executable process parts.
  • Each execution node 52 is linked to at least one preceding node by a corresponding link 52 and is linked to at least one subsequent node via a corresponding link 54.
  • the execution node 52i of the rule tree 44i is linked to the start node 46i via the link 54i, which indicates that an output of the node refers to a subsequent node, for example using a pointer / pointer.
  • This subsequent node can in turn access a memory area in which a result of the preceding node can be stored.
  • Different outputs can have values for different pointers, so that, for example, depending on which output of the node is reached (e.g. true or false, larger or smaller, etc.) different pointers take effect, ie different subsequent nodes are called.
  • a node has, for example, two outputs, each output being able to be linked to an execution node 522 or 52s via a corresponding link 54 2 or 54 3 .
  • the outputs can be results of an OR link, so that an input variable is output to the execution node 52 2 or 52 a based on the respective result of the OR link.
  • start nodes 46 have no link to a preceding node, for example, while end nodes 48 can be executed without a link to a subsequent node.
  • Execution nodes 52 preferably have at most two inputs and at most two outputs.
  • Each execution node 52, optionally each start node 46 and optionally each end node 48 can be assigned a predefined identifier, such as a node number, within the action sequence 24, via which the sequence part that can be executed by the node 52, 46 or 48 can be clearly addressed.
  • the processor of the device can be designed to address each executable sequence part of the plurality of executable sequence parts via this predefined node number.
  • the node number can, for example, indicate a memory area in which the instructions to be implemented and / or the variables to be processed are stored.
  • rule trees 44i and 44 2 are shown in such a way that a predecessor node always references a successor node, the present exemplary embodiments are not restricted to this. Rather, nodes can also enter a direct or indirect predecessor node as successors or reference them by means of a link.
  • the execution node 52 2 could reference the node 46i or the execution node 52i, which means that an output of the node could point to an input of the node or to the node itself.
  • Such constructs can be used, for example, to implement loops and counters.
  • the evaluation of the graph can be ended by returning from the function. For example, starting from node 48i or 48 2, it is possible to jump to the next rule tree 44 2 .
  • the processor can be configured to execute the plurality of executable process parts of the course of action from the starting point of the course of action to an end of the course of action.
  • the configuration signal can contain information for this. sen, which defines the at least one starting node of the course of action.
  • the processor can evaluate the configuration signal for these variables.
  • the starting point can be the starting node 46i or 46 2 , but can alternatively also be any other node of a rule tree 44i or 44 2 or of the course of action 24.
  • the course of action can be implemented by one or more individual graphs or rule trees.
  • a single graph can be a start node (first layer) from which the evaluation of the rule tree begins.
  • a single node has a maximum of two outputs that can be implemented in the form of pointers that point to the next node to be executed. As soon as a selected output points to 0, e.g. a zero pointer, the evaluation of the graph can be finished.
  • the program, the course of action can consist of more than one graph.
  • Each graph can have its own start node assigned to the graph, with the graphs being able to be completely separate but also connected to one another, for example having a common subgraph. Alternatively, this can also be understood to mean that a rule tree can have more than one start node.
  • the start nodes of all graphs or rule trees can, for example, be called up one after the other in a kind of main function of the program code implemented as constant or unchangeable.
  • the course of action (graph) or a part of it, the rule tree, can consist of different nodes that perform different tasks and / or represent modes of operation.
  • the graph does not have to be connected, but rather all linked nodes form a rule tree that is processed.
  • the complete course of action can consist of several rule trees that work independently of one another or be represented by them.
  • the so-called start nodes or first-layer nodes can be evaluated periodically, possibly triggered by different timers. Which nodes are the starting nodes can be communicated to the device via a corresponding interface, for example the input interface 12.
  • the further course of the program can be determined based on events by the nodes themselves, since each individual node clearly points to the next node to be evaluated and thus specifies the sequence.
  • the evaluation of a rule tree terminates when the pointer of the next node to be evaluated is set to a null ID, an end node 48.
  • 5 shows a schematic block diagram of part of a rule tree 44 according to an exemplary embodiment, two executable process parts 18i (a) and 18 2 (b) being represented by process nodes 52i and 52 2 , respectively.
  • the execution node 52i has two inputs 56i and 66 2 , via which input quantities or input information from preceding nodes can be obtained by means of corresponding links 54i and 54 2, respectively.
  • the execution node 52i on two outputs 58i and 682 which may be connected via respective links 54s and 54 4 with subsequent nodes.
  • the output 58 2 is connected to an input 56s of the execution node 52 2 by means of the link 54.
  • the process node 52 2 can also have a further input 56 4 , which is linked to another node via a link 54 s .
  • the drain node 52 2 may have one or two output node 58 3 and / or 4 comprise 58 to corresponding outputs via links 54 e and 54 provide. 7
  • the outputs of 58i to 58 4 each may be understood as the starting pointer of the respective nodes and, for example, as a pointer subsequent nodes are implemented on the index numbers, which eg. In, in conjunction with FIGS. 9a-explained "next_t / f'field of the Nodes are saved.
  • the pointers can indicate the next node to be executed. In the exemplary embodiments explained here, all connections which represent the output of a node can therefore be understood as pointers.
  • a node number 62i can be uniquely assigned to the process node 52i.
  • a node number 62 2 can be uniquely assigned to the process node 52 2 , so that the process nodes 52i and 52 2 can both be distinguished and addressed separately, even with the same or identical function.
  • FIG. 6a shows a schematic block diagram of an interconnection of a process node 52 in a rule tree according to an exemplary embodiment.
  • Inputs 56i and 56 2 can be connected to different memory areas 64i and 64 2 via links 54i and 54 2 , whereby memory areas 64i and 64 2 can be any areas in data memories 16, 34 or 36 that provide corresponding input variables for node 52 .
  • Nodes of a graph can implement a function that defines a processing of at least one input variable of the corresponding executable sequence part.
  • compare an operator of node 52 may be 641 and 64 2 stored values.
  • Pointers can be output at the outputs 58i and 58 2 , which point to a subsequent node by means of the corresponding links 54s or 54 4 , in the event that the result of the operator is fulfilled (true) or not fulfilled ( false).
  • the control flow, i.e. H. the next node to be evaluated is influenced by the result of the comparison.
  • FIG. 6b shows a schematic representation of a link of a process node 52 in a rule tree, the implemented operation being an arithmetic operation. These include, for example, addition, subtraction, multiplication or division.
  • the values in the memory areas 64i and 64 2 can be linked so that a result can be made available to a subsequent node by means of the link 54a.
  • the result can be stored in a further memory area and a pointer to this memory area can be transmitted by means of the link 54a.
  • Fig. 6b shows an arithmetic node. Arithmetic or mathematical operations can be carried out with values in two memory areas, e.g. B. +, -, x, /, modulo, amount and the like. The result is made available in a separate memory area assigned to the node and externally addressable. A single pointer indicates the control flow, i.e. the next node to be evaluated. It is pointed out once again that each node, if necessary, can be assigned a memory area where the assigned result can be stored, for example the “res” -Fe! D in the structure according to FIG. 9a.
  • Exactly this memory area can be set as an input in another node in order to pass on the result, which occurs, for example, when the index number of the node is set as the input of another node.
  • the inputs and outputs of the nodes can thus be completely independent of one another.
  • 6c shows a schematic representation of a link of the process node 52 in the rule tree, in which the implemented function is a memory operation, that is, the node 52 stores a value of the memory area 64i and / or 64 2 in another memory area and transmits it using the Link 54a at output 58 has a pointer which points to the memory area in which the value is stored.
  • An input variable can be written to the memory area of the other input variable or to the output node.
  • Fig. 6c shows a storage node.
  • the value from memory area 1 is stored in a dedicated memory area assigned to the node and externally addressable.
  • the value from memory area 1 can be written to the address of memory area 2, regardless of the value it contains. Both memory operations can also be carried out combinatorially. Saving in memory area 2 can be used to carry out comparisons with old values.
  • a single pointer can indicate the control flow, i.e. the next node to be evaluated.
  • 6d shows a schematic representation of the process node 52 according to an exemplary embodiment in which information inputs obtained by means of links 54i and 54 2 , for example directly or through access to memory areas 64, result in an action to be carried out, for example an activation of the peripherals via the output 58 is issued.
  • Fig. 6d shows an action node.
  • An action node can differ from the other main groups of nodes in that there is no evaluation here of operations on memory areas takes place.
  • This node can be used to call functions in the program code from a list of possible selectable functions, the selection of functions which the device has can be hardware-specific or device-specific.
  • the interface can be used to ensure that the selectable action nodes match the device functions.
  • the functions called up in the program code are so-called normal implemented functions and can therefore be used for all possible functions, such as controlling actuators, setting variables and memories, external communication and the like.
  • a single pointer can specify the control flow, i.e. the next node to be evaluated.
  • FIG. 7 shows an exemplary representation of computer-implemented instructions, that is to say code, for the exemplary representation of different functions implemented by nodes.
  • 15 different arithmetic functions are defined using two input variables a, b, which can be distinguished from one another by a function identification 661 to 6615.
  • the arithmetic functions include, for example, addition, subtraction, multiplication, division, the absolute sum of the individual amounts of a, b, the semi-absolute sum using the amount value of the operator a or b, the absolute -Difference as the difference between the absolute values, the semi-absolute difference using only one amount, the digit 1 standard sum as the amount of addition, the digit 1 standard difference as the amount of the difference, the absolute multiplication, that means the magnitude of the multiplication, the half-absolute multiplication using only one magnitude value of the operators a or b, the absolute division, i. H. the amount of division and the modulo operator mod.
  • 12 comparison functions with the function IDs 16 to 27 are defined as an example, which include an equal comparison, a non-equal comparison (unequal), a smaller comparison, a less than or equal comparison, an equal value comparison , a half-amount-equal comparison, a not-amount-equal comparison, an amount-not-equal comparison, an amount-less-amount comparison, an amount-less comparison, may include an amount less than or equal to amount comparison and / or an amount less than or equal to comparison.
  • 9 logic functions which can also be assigned to the comparison operations, can be defined as examples.
  • the function IDs 6628 to 66 36 (previously 66 «to 66 27 ) describe functions of the link as logical And, logical Or, logical exclusive Or (XOR), one-sided negative And, one-sided negative Or, one-sided negative exclusive-Or, Both sides denied And, both sides denied Or, and both sides denied Exclusive Or.
  • a negation (! A) setting to the value true (true) by a && 1 or setting to the value false (false) by a && 0 can be carried out .
  • Such functions or logic operations can also be carried out for operator b.
  • the function IDs 66 3 7, 663s and 66 3 9 can exemplarily describe functions that take place using only one input variable and are thus assigned to nodes that only have one input.
  • a type or function of the executable sequence part of the large number of executable sequence parts can be clearly defined by five parameters. These parameters can be contained in the configuration signal. The use of integer numbers is advantageous because they have a small memory area and at the same time have a sufficiently high range of values. According to alternative exemplary embodiments, at least one of the parameters can be defined differently than an integer number. The five parameters can be sufficient to clearly define the type of process part that can be executed. One of the parameters, such as the function ID, can define the function of the executable process part. A second and a third parameter can define a first and second memory area, respectively, which is associated with the first and second input of the executable sequence part, respectively.
  • a fourth and fifth parameter can define corresponding memory areas which are associated with the outputs 58i and / or 58 2 and 58, respectively.
  • the generator 22 can be designed to contain the integer numbers that represent the five or six parameters of the
  • Play node each uniquely associated with a memory area of the data memory. This makes it possible to ensure that each node accesses a data storage area assigned to it in order to receive input variables or to store output variables
  • Unnecessary parameters e.g. if only one of the outputs is required, can be left out or set to 0.
  • the generator can be designed to check the configuration signal for the corresponding parameters.
  • the corresponding parameters in particular the integer numbers, can each be uniquely associated with a memory area of the data memory 16, so that it is sufficient to only specify the memory area which specifies the further information to be implemented.
  • the information 26 contained in the configuration signal can have a sequence of integer numbers, which represents a small amount of data that has to be transmitted.
  • FIG. 7 shows an exemplary assignment of node types or functions to function IDs 66.
  • FIG. 8 shows an exemplary representation of code which reproduces instructions which instruct the generator 22 of the device 10 or the control device 38 of the device 30 to send the configuration signal 14 to the function ID 66, which is described in connection with FIG. 7 to evaluate.
  • the generator can be designed to evaluate the parameters contained in the configuration signal and to configure the graph as a function of their value.
  • the node with ID i can be evaluated as which node type it is configured as, here conf_typ [i] specifies the type, see line 6.
  • Further properties of the node, such as inputs and / or outputs and / or memory areas for storage of results can also be specified, see line 7ff.
  • 9a shows an exemplary illustration of code for defining a node structure and thus a structure which the executable process parts 18 follow.
  • “Int16_t” or “uint16_t” can be used to designate signed or unsigned 16-bit integer numbers that are used to generate a result (res), input variables (inp_1, inp_2) and references or pointers to define subsequent nodes for the case of a positive (true) or negative (false) result (next_t, next_f), which has already been discussed in connection with FIG.
  • “type” it is possible to specify the type of nodes it is the present node. It becomes clear that the respective memory requirements can be adapted to the number of different values, for example the parameter type can be adequately writable with 8-bit integer numbers, while otherwise signed or unsigned, i.e.
  • a node can be uniquely defined or determined by only five of these properties.
  • the sixth parameter in the node structure which is not required for the unambiguous definition, can describe the result of the operation by the node and is indicated, for example, by the "res" field. The result does not have to be specified externally when defining the graph can arise, for example, when the node is executed, so only five parameters are required for definition, even if there are six variables in the node structure.
  • the nodes of the graph can be represented as a structure (struct) in the program.
  • the structure can contain the variable "type” or equivalent, which defines the type of node.
  • the variable "res” saves, for example, the result of an arithmetic operation or a comparison and the variables "input_1 / input_2" and “next_t / next_f” basically act as pointers for the input variables and the next node to be executed.
  • memory efficiency An integer value can be used instead of a pointer. This is possible because the maximum number of nodes and variables that can be used is limited and is defined a priori, ie is predefined.
  • the zero pointer can be represented by the largest representable number in the data system.
  • the data type "node” can be defined in such a way that it is made up of
  • Arithmetic, action and storage nodes can only use one of the two outputs, e.g. out_t, so that, for example, out_f can be set to NULL-ID.
  • a predefined number of nodes, variables and actions can exist. All of them can be organized in the form of arrays and arranged one behind the other in the memory. This enables unique addressing via an integer number, which can be referred to as an index number.
  • the index numbers can be used like general pointers and can generally be seen as such. This type of implementation only saves resources when addressing memory areas. Similar to a zero pointer, a zero ID can exist.
  • the maximum number of nodes (MAX_KNOTS), the maximum number of variables (MAX_VARS), the number of sensors (N_SENSORS), the number of actions (N_ACTIONS), the number of nodes of a first layer or layer , so for example. Entry node in a graph or rule tree, (N_First_Layer), NULLJD, d. H. the null pointer, and any other variables can be defined, such as distinctions as to whether it is an arithmetic node for performing an arithmetic operation (IS_ARI) and / or whether it is a comparison node for performing a comparison operation (IS_VGL).
  • IS_ARI arithmetic node for performing an arithmetic operation
  • IS_VGL comparison node for performing a comparison operation
  • a corresponding pointer can also require 32 bits in the memory.
  • 32 bits By implementing it as an integer value with 16 bits, for example, 4 * 16 bits, ie 8 bytes, can be saved in each node. This is particularly advantageous when fewer than 2 16 nodes, variables and actions are used.
  • the advantage can also be achieved if a data reduction of another category is carried out, for example when using a 64-bit controller for which 32-bit variables are used.
  • the first inputs are dereferenced as nodes, for example (or the memory area of the "res" field of a node), everything above or after are then sensors, then actions, everything above is treated as variables.
  • This can result from the sequence shown in FIG. 9b, in which the nodes, variables (VARS), sensors and actions one after the other.
  • the order shown is arbitrary or arbitrary. However, it is necessary that it is defined once and then remains identical or adhered to. The information gained in this way can thus be saved within the configuration signal 14, since the structure is known on both sides.
  • T_SEN node types below the previously defined value
  • T_SEN nodes.
  • Values are T_SEN nodes.
  • Values ä T_SEN and ⁇ T_AKT are sensors. Starting from this value, all values of a T_AKT and ⁇ T_THR are actions. Anything beyond this, that means a T_THR, are variables.
  • T_MAX indicates the maximum possible number in the system.
  • the "type" variable in the node struct can determine what exactly the node has to do as soon as it is called.
  • This can also be used to define the type of node, for example as an arithmetic node in which the ID 661 to 6615 is used, which is explained in connection with FIG.
  • the type of node can be divided into different groups.
  • arithmetic nodes can be implemented that are used for arithmetic operations such as B. "+” or " * " is set up. The values of the two input memory areas, the inputs, are used and the result of the operation is saved in the "res" field of the node struct.
  • the values of the two input memory areas can also be used here and the result of the operation can be saved in the "res" field.
  • this also allows exceptions, for example a negation or a comparison to “true” or “false” (true / false), since these only use one input variable.
  • one or more storage nodes can be defined that use the value at the address of one of the inputs and write this, for example, to the address of the other input or in a “res” field specially provided for this purpose, as is the case with the Fig. 6c is described.
  • Storage nodes can be used, for example, to store sensor values (which can change over time).
  • action nodes can be provided which can be used to call up previously implemented functions in the program code.
  • the two input variables can be used as transfer parameters for the called function, although this is optional.
  • Action nodes can be relevant to enable more complex program structures. For example, sending a value can be represented via an action node.
  • the available actions are partly hardware-dependent, since a device for sending a WLAN message requires a WLAN module.
  • the action nodes can accordingly be specially implemented or set up for the hardware used. All functions that can be called up by the user in the program code can be linked to a respectively assigned action node and numbered, for example using a corresponding identifier that is comparable to the function ID. An action with a certain number then always corresponds to the same function in the actual program code and this is called as soon as an action node with the corresponding identifier, which can be represented via the "type" field, is called or triggered in the graph.
  • 10a shows an exemplary code in which a maximum number of nodes in the course of action is defined in line 2, which means that the list of nodes always has the same length within this configuration.
  • Line 5 defines a list of actions for the node.
  • Line 8 defines a list of nodes in a first layer, which will be discussed later.
  • different variables such as threshold values or buffers, are defined.
  • Sensor values are defined in line 14.
  • the maximum number of possible nodes and actions as well as sensors and variables is specified a priori. Therefore, before the start of the main function, the memory area for the corresponding structures can be allocated, i.e. associated.
  • the first-layer nodes or start nodes just mentioned can be an important element for evaluating the courses of action implemented on the device.
  • a list of pointers to the node structure can be used to define the starting nodes, as described in line 8 of the code in FIG. 10a.
  • the start node can, for example, be a node 46 of the respective rule tree 44, as described in connection with FIG. 4.
  • 10b shows an exemplary code which indicates that a node number i up to a maximum number N_ACTIVE_FL of nodes or actions is run through the graph and the corresponding node is executed (doKnot).
  • the generator of a device can be designed to create the course of action in such a way that it comprises at least one start node at which the course of action is started by the processor.
  • the course of action comprises several rule trees
  • such a start node can be provided for each rule tree.
  • the processor is designed to periodically evaluate the at least one start node in order to obtain an evaluation result. This means that each rule tree is started periodically at the correspondingly assigned start node.
  • the processor can be designed to process the multiplicity of executable process parts of the course of action from the starting point, d. H. the start node of the course of action, to be carried out to an end of the course of action, as is shown, for example, in FIG. 4.
  • FIG. 10c shows exemplary code for execution by the processor.
  • a received value k is evaluated, the value k representing, for example, a pointer to the node which is currently to be executed.
  • the values can be read from the associated node.
  • the expression “k-> type” can, for example, return the type of the node, ie in lines 3, 7 and 12, for example, the type of the node is evaluated.
  • the expression "k->inp_1" in line 14 is an example of containing the index number of the first input.
  • the value of the input can be provided by the “getlnput provided” function in lines 14 and 15, which transfers the index numbers of the inputs to the associated values.
  • the "getPointer defined" function in line 10 can work in the same way; this takes the index number of the output ("k->next_t” or "k->next_f") and delivers the associated pointer to the next node. If the “type” variable in “k” determines that it is an action, the associated action is not called up via the value “k”, but via the value “k-> type”, since each action is unique is determined by the type numbers.
  • a corresponding embodiment can be obtained, for example, in that, in accordance with the explanations in connection with FIGS. 7 and 10d, nodes are defined in such a way that values of k of 64 and larger define actions to be carried out.
  • the check carried out in line 7 thus differentiates whether it is an action if the value k is at least 64, with any other configurations being possible.
  • the return value of the function (which is linked to the action) is not considered here as an example.
  • the pointer that is returned in the specified line 10 is the pointer to the next node, which is provided by the mechanism described above.
  • Line 17 shows that a node intended as a storage node can be treated as a special case in which the value 1 is written into the "res" field, see line 19, or into the storage area of the other input value, see lines 21 and 22 .
  • the start nodes can be evaluated one after the other in the main function of the program code.
  • This routine can always be identical, regardless of the graphs that then provide the actual functionality of the device. This ensures that the program code in the EEPROM, i. H. the data memory 16, can remain unchanged even if the device is reprogrammed.
  • the function that evaluates the nodes is also always identical and firmly encapsulated in the program code, which means stored in the data memory 16. It can, for example, be called initially by the main function for the start nodes and then cling to the output pointers of the individual nodes until the end of the graph (zero pointer or node 48) is reached.
  • the processor can be designed to evaluate a node to be executed according to which type it is and then to execute the corresponding operation linked to the node, as is described with reference to FIG. 10d.
  • FIG. 10d shows an exemplary representation of code which reproduces instructions which instruct the processor 31 of the device 10 or the control device 38 of the device 30 to forward the result of the evaluation of the node type (k-> type) from FIG. 10c. to lead.
  • k-> type node type
  • the expression “k-> res” indicates that a result res is obtained based on the function defined below.
  • control device 38 or the processor 31 can evaluate the node or the function to determine what type it is and then carry out the corresponding operation linked to the node.
  • the results of the node or the function can be stored in the "res" field of the structure. If a node is set as an input by another node, the node behind it reads the memory area of the "res” field from the input node. This allows results to be passed on by simply linking nodes in the graph.
  • the successor is dependent on the result of the “res” field of the previous node, in particular in the case of comparisons and logical operations, which is illustrated in FIG. 10e, which shows an exemplary code in which for the case of the node type as an arithmetic node (IS_ARI) the pointer for the next node is retrieved, see line 4.
  • IS_ARI arithmetic node
  • the pointer is received depending on the result obtained true / false, see lines 9 to 12. This means the next one to be executed Knot determined.
  • Embodiments of the present invention are based on the knowledge that the graph can be reconfigured while the device is running in order to represent any functions or programs, that is, to maintain flexibility of the device. Since the structures for the nodes, actions and variables for a piece of hardware can be fixed and are stored in volatile memory at runtime, it can be sufficient to correctly link and configure them one after the other in order to represent a new program. Such information can be indicated in the configuration signal. For example, all nodes can be initialized to type 0, ie not initialized, set. This can, for example, be controlled or triggered via a suitable event, that is, a corresponding instruction, for example from a central control device or a server. Each node of a rule tree can be addressable via an integer number.
  • Each node can also be clearly defined using five integer numbers. Two values for input and output and one for the type. So six integer values can be used per node used, namely the five integer numbers mentioned for the configuration of the node and a sixth value for the node number.
  • the configuration signal can have the six integer values. It is possible, but not required, to send one message per node. It is possible to use six consecutive values in the message for a node and to define any number of nodes within a configuration signal.
  • the configuration signal or a further configuration signal it can be defined which node or which nodes function as start nodes.
  • This information can in principle also be part of the configuration message of the nodes, for example it can be placed at the end, but is preferably clearly separated from the other integer values.
  • 256 * 16 bits when using 16-bit integrators for the consecutive numbering of nodes and variables
  • 512 bytes of information are transmitted and optionally a few more bytes depending on the number of starting nodes used. After successful configuration by the generator, the graph can be used immediately.
  • Fig. 1 1 shows a schematic block diagram of a device 110 according to one embodiment, the inputs (interface 28i), "Outputs" (interface 28 5) and an internal logic which comprises the act outlet 24.
  • inputs for. B. serve sensors, switches / buttons or other controls.
  • the inner logic can implement the program to be run, which the user has previously specified through the interface. This can for example be carried out in a continuous loop in normal operation.
  • Outputs can include, for example, actuators of various types, switches, motors, external communication, for example send value XY to server N, but can alternatively or additionally also set / change timers and interrupts on the hardware of the device and / or change Include memory areas in the volatile memory of the hardware.
  • An algorithm or a program or a sequence of machine-readable instructions can be represented by the internal logic, which inputs ge and outputs but also variables, timers and internal elements of the microprocessor. Any program can be represented and set up by the structure according to the invention.
  • FIG. 12 shows a schematic block diagram of a device 120 according to an exemplary embodiment, which can be formed similarly to the device 10 or the device 30 or the device 110, the peripherals 32 being connected to the outputs 28s in the form of a switch by wire or wirelessly, which can be controlled in different states, either "anVaus" or the like.
  • Control signals 68 1 and / or 68 2 can be received from external devices 72i and / or 72 2 , such as servers or the like, via inputs 28i.
  • the control signals 68 1 and / or 68 2 can have an instruction for switching on or off the switch of the peripherals 32.
  • the course of action implemented in the device 120 can be implemented such that the peripherals are controlled in accordance with the control signals 68 1 and 68 2 .
  • FIG. 12 shows an example of how the logic in the device links inputs and outputs with one another and for which exemplary embodiments can be used.
  • the device 120 is designed, for example, as a pure actuator.
  • the internal logic can be designed in such a way that in the event that the external device 72i instructs to switch on the switch or, if the external device 72 2 instructs to switch the switch 32 on, the device 120 then controls the peripherals 32 accordingly. Otherwise the switch at output 28 5 is switched to "off".
  • FIG. 13 shows a schematic block diagram of a device 130 according to an exemplary embodiment, in which the inputs 28i are connected to sensors 74 t and 74 2 in any number, 1 in order to receive sensor signals 76i and 76 2 with corresponding sensor values.
  • the device 130 can be designed to evaluate the sensor signals 76 t and 76 2 and to control the peripherals by means of an output signal 78, which include a server, for example, in order to store the evaluated data there.
  • FIG. 13 shows a configuration of the device 130 as a pure sensor with communication.
  • the internal logic can be designed, for example, in such a way that a new value is stored by the sensor 74i regularly, approximately every 60 minutes. A new value is stored by the sensor 74 2 in an identical or different time interval, approximately every 120 minutes.
  • the internal logic can be designed in such a way that, if, for example, a certain number of measured values, for example 100, are present, a minimum and a maximum of the values from sensor 74i and / or a mean value of the values from sensor 74 2 is calculated. A corresponding result is sent to the server. Alternatively or additionally, the old values can be deleted and a new series of measurements can be started.
  • the sensor 74 can be set up, for example, to detect a temperature; a server 82 can control, for example, an additional switch or valve or heating valve 84, the device 140 being designed to control various switches 86 1 and / or 86 2 to open or close the heating valve 84 and thereby receive information from switches 86 1 , sensors 74 and / or servers 82.
  • the sensor 74 can be set up as a temperature sensor in order to measure a temperature, any other configuration also being implementable.
  • the internal logic can e.g. B. be designed so that if the value of the switch 86 1 is changed or the temperature is changeable, for example has changed by more than 10 degrees, then a new state is sent to the server 82 and the corresponding values are stored. If, for example, the server 82 sets the controller 68 to “on”, the temperature can for example be checked and compared with a setpoint value; if the temperature is below the setpoint value, then the heating valve 84 can be opened, otherwise closed . If the server sets the control to "on”, a state of the input switch 861 can be passed on to the output switch 86 2 , for example, otherwise the output can be switched to "off".
  • Figures 12, 13 and 14 describe different configurations of devices. It should be noted that these configurations can be implemented by one and the same device, for example by reconfiguration or reconfiguration or reconfiguration by means of a configuration signal. If the device is implemented in such a way that all configurations can be mapped by the hardware, each of the examples can thus only be reconfigured into the other configuration by means of the configuration signal. If the graph, ie the course of action, is to be changed, a message with the structure described below can be sent for each node used and / or a combinatorial message with information relating to several or all nodes is sent, either all nodes in total or all to changing knot. The length of the message can be designed depending on the communication protocol used. A node can be redefined using six numerical values each.
  • Either only individual nodes can be changed / redefined or the device can be informed via a special delete message that it should completely reset its current graph.
  • the six numerical values that define a node can, for example, be arranged in a defined manner, whereby an order can be configured as desired, as long as it is known to the device in order to enable correct decoding:
  • index number Since all nodes and variables can be uniquely addressed by their index number, four numbers can be sufficient to describe the structure of the graph, i.e. H. to change the link between the nodes and with variables by changing the index numbers of the memory areas of the inputs and outputs.
  • a further index number can indicate which node is to be redefined and the type of node can be changed with an additional sixth integer value.
  • the most naive method is to send the complete program over the communication interface. This method offers the greatest flexibility, since hardware drivers can be exchanged here.
  • the biggest disadvantage is that, on the one hand, the program code is very large and, on the other hand, the microprocessor has to be re-programmed. has to be programmed or flashed.
  • the flash process during operation is extremely complex and very energy-intensive (which makes the process unusable on hardware with limited resources / energy harvesting) and also represents a risk if it cannot be completed in full (in this case the device may then be “bricked” and no longer accessible from the outside, unless the processor is reconnected to a PC via a debugger for the processor family).
  • the scenario / parameterization variant tries to "pre-program" a selection of possible programs that the user wants to use - that is, there are several small sub-programs on the device, all of which exist on the hardware when it is compiled for delivery change its functionality, it can be told that it should now select a different scenario / program.
  • An interpreter is a program that is able to convert code in the so-called "interpreter language” into a high-level language equivalent (e.g. C ++). The conversion takes place line by line; d.
  • Interpreters tend to be very complex programs, but they provide maximum flexibility thanks to their 1-to-1 conversion into high-level program code.
  • the disadvantage here analogous to the method of reflashing, is that the transmitted program code (despite the interpreter language) is very large. Furthermore, this variant requires a great deal of memory, since the code to be interpreted must be kept permanently in memory, as well as the elements of the program to be executed.
  • Interpreters are generally used on “fixed hardware” (desktop PCs etc.).
  • FPGRA embodiments according to the invention allow a high degree of flexibility, little transmission and do not require an energy-consuming flash process. These advantages can possibly go hand in hand with a somewhat poorer execution efficiency of the program, since, to put it simply, the detour via the graph and the node data type is always taken, which, however, is less important for the area of application. For example, sending or receiving a message over the air consumes far more energy than executing code on the main processor - the flash process and other advantages are also obtained. As a result, the described concept is ideally suited to be used on hardware with limited resources in the form of energy and devices with energy harvesting.
  • Every GOTO program can be represented by nodes, which means that every Turing-complete program can be represented by the node structure.
  • Some exemplary embodiments are described below.
  • One embodiment relates to a loT-based heating thermostat in which the periphery has a temperature sensor and an actuator or actuator around the positions of a heating valve.
  • a generator or part of a control device is designed to create a course of action based on a configuration signal received from the loT-based heating thermostat, the graphic representation of which has a first graph that causes a repeated, possibly cyclical query of the temperature sensor.
  • the sensor signals read out can be saved locally and / or transmitted to a server.
  • the course of action causes the actuator to be controlled as a function of the determined temperature, for example to close a valve if a target temperature is reached or exceeded and / or to open the valve if the temperature falls below this.
  • a device can also be used for cooling devices, for example air conditioning systems, the valve then being opened when a target temperature is exceeded and closed when the target temperature is reached or below.
  • 15 shows a schematic block diagram of a system 150 according to an exemplary embodiment, which by way of example includes device 10, but alternatively or additionally can also include other devices described herein, for example device 30, 110, 120, 130 or 140.
  • the system 150 further includes a device 155 that has an output interface that is configured to send the configuration signal 14 to the device 10.
  • the device 155 comprises a signal generator 92 which is designed to provide the configuration signal, at least in a baseband version thereof.
  • the configuration signal 14 is preferably provided by the signal generator 92 in such a way that it describes a sequence of executable process parts of a plurality of executable process parts, i.e. selects a subset of the executable process parts stored in the device 10 and specifies their interconnection.
  • the specified sequence of executable process parts clearly describes a course of action, for example the course of action 24.
  • the device 155 can be designed to receive a user input 94 which describes the course of action to be created.
  • a graphic representation 96 of the course of action 24 can be provided, which the user can create or configure on a device 98 provided for this purpose.
  • the device 98 can be part of the device 155, but can also use access to a web interface 102 of the device 155, so that the user input 94 can be received via a network connection from the device 98 connected via the network connection.
  • the graphic representation 96 is only one of several possible configurations, which alternatively or additionally can also include programming in text form.
  • a workflow can include the following: a) Compiling the logic / graph to be run or the course of action on a computer via, for example, a web interface or a program:
  • the system 160 can comprise the devices 98 (block B) and 155 (block C), which are designed to exchange a data flow for the exchange of logic and / or parameters or setpoint values, as is indicated by the letter a.
  • the device 155 i.e. the encoder, can be connected to one or more devices 10i and / or IO2 via a communication network (block D), such as the Internet, as can the device 98.
  • the peripheral 32 (block E) can are also in communication with the devices 10i and / or IO2 via the communication network 104.
  • meta information for the periphery can also be created, for example a name or virtual addresses, as is represented by the letter e.
  • Further information such as hardware-specific information such as IDs (identifications), specifications and / or hardware-related assignments, can be exchanged between the devices 10i and IO2 and the device 98, as shown by the letter b.
  • the devices 10i and I O2 can exchange output values, sensor values or actual parameters (letter c) and / or setpoint parameters (letter b) with the periphery 32 using the communication network 104.
  • An exchange of logic information or parameterizations can take place between the devices 98 and 155 and using the communication network 104 with the devices 10i and IO2, as shown by the letter a. This includes the configuration signal, for example.
  • the periphery 32 can adapt any type of data receivers / sinks, actuators, control devices for parameterization, including mobile devices such as smartphones.
  • a numerical code that, for example, reproduces a sequence of parameters (in the data flow graph (a) - the parameters which later control the program sequence are coded in the numbers) can be converted into executable program logic, which then runs in a continuous loop the device (in the data flow graph (A)).
  • a compiler which translates program code (e.g. C ++) into machine language, which can then be executed on hardware.
  • the difference between the FRGRA and a compiler is that no executable machine code is generated.
  • the FPGRA is also not an interpreter, since the code is not converted directly into a high-level language equivalent and executed. As with the compiler, no “build-up phase” is necessary.
  • a logic is built up in the existing program code by means of skillful pointer arithmetic and class structures which are able to control the program sequence and which is kept in the volatile memory.
  • This procedure means that the energy-intensive flash process for changing structures in the non-volatile memory (EEPROM) can be dispensed with, and it is still possible to reprogram the device completely Turing.
  • the user defines the program sequence that the device should follow later. This can be done by "clicking together" a graph that contains the rules and courses of action; but also z. E.g. using a kind of scripting language with which the process rules can be defined ("If X, then Y, otherwise Z -> Then A").
  • the interface also defines the possible actions of the device or the outputs.
  • An action can, for example, be a hardware function ("Send XY", "Set Time N to X”), but also simply a function call in the software. This preselection is necessary because, on the one hand, the number of action nodes (which make the available actions in the device available in the device) is technically limited - since in reality the available memory is always limited - and, on the other hand, the outputs and actions that can be carried out are hardware-specific ( For example, a device that does not have an actuator may not be provided with a set of rules that ultimately wants to operate an actuator).
  • a graph that evaluates a temperature sensor in the input may only be transferred to devices that have such a sensor, or WiFi communication only to WiFi-enabled devices.
  • Exemplary embodiments are based on representing the part of the instructions (program code) to be executed that is relevant for the specific application of the device as a rule tree, which means that the implemented functions can be represented as a rule tree.
  • a graph can be represented by a special structure in the program code and can be reassembled at any time by means of a configuration message, which contains considerably less information for transmission than normal program code, in order to represent a different program.
  • this type of representation can be Turing-complete, whereby effectively any program can be represented as long as it can be stored in memory. Nodes of the graph can be understood as something like the smallest possible subroutines that are possible on the hardware.
  • a step 1710 comprises storing a plurality of executable process parts in a data memory, each process part describing at least one operating instruction.
  • a step 1720 includes receiving a configuration signal with an input interface.
  • a step 1730 comprises creating a course of action which comprises a sequence of sequence parts of the plurality of stored sequence parts that are specified in the configuration signal.
  • a step 1740 comprises addressing a periphery in accordance with the course of action using an interface which is designed to communicate with the periphery.
  • FIG. 18 shows a schematic flow diagram of a method 1800 for providing a configuration signal that can be carried out using device 155, for example.
  • a step 1810 includes providing a configuration signal using a signal generator, so that the configuration signal describes a sequence of executable process parts from a plurality of executable process parts, the sequence of process parts clearly describing a course of action with a plurality of operational regulations.
  • a step 1820 includes sending the configuration signal with an output interface.
  • FIG. 19 shows a schematic block diagram of a device 190 according to an exemplary embodiment in which the inputs 28i are set up for connection to a loT modem 108, for example for communication via the resource-limited medium 106.
  • the loT modem 108 can alternatively also be an internal device.
  • the inputs can be configured to be connected to one or more sensors 74, for example a MEMS sensor. This can be set up, for example, as an acceleration sensor.
  • the output 28s can be set up for communication with a server of the peripherals 32.
  • the device can be designed to create the course of action in response to a received configuration signal in such a way that, in response to a corresponding signal from sensor 74, what a movement or a lack of movement or may be a corresponding acceleration, a message is sent to the server which indicates a position of the device 190, for example specifying a radio cell used by the modem 108 in which the device is currently located.
  • the device 190 can function as a movement tracker, for example for goods to be transported by a logistics company.
  • An acceleration sensor (“MEMS") and the currently received radio cell of the NB-loT modem serve as inputs.
  • MEMS acceleration sensor
  • the user could, for example, configure the device in such a way that after a movement was initially detected via the MEMS, the device falls into a “transport state” (which is solved via an internal variable).
  • the device checks at regular intervals whether it is still moving. As soon as no movement is detected n times, the "transport status" is ended and the device sends the currently connected radio cell to a server.
  • the threshold values can of course be freely selected and can be set using the configuration signal or changed using new configuration signals. More complex nesting with other states is also possible.
  • FIG. 20 shows a schematic block diagram of a device 200 according to an exemplary embodiment, in which the inputs 28i are set up for connection to a mobile device 112, for example a smartphone / mobile phone, a tablet computer or the like.
  • the mobile device 112 can have a positioning device 114 via which a position can be determined, for example by means of a Global Positioning System (GPS), Galileo or Glonass.
  • GPS Global Positioning System
  • Galileo Galileo
  • Glonass Alternatively, a corresponding positioning device can also be provided as an independent device and can be connected to the device 200 via the inputs 28i.
  • the device 200 can be designed to create the course of action in response to a configuration signal in such a way that one or more devices or components are addressed via the outputs 28s.
  • a derver 32i can receive a message with a position of the device 200, for example at predetermined intervals and / or if the position received by means of the positioning device 114 deviates from a predetermined position or area stored in the device 200 or received externally.
  • the mobile device 112 can be informed accordingly, for example an application (application; App) that runs there.
  • the device 200 can be designed to control a display device 32 2 in order to display a status.
  • the device 200 can function as an anti-theft device, for example for bicycles or vehicles.
  • the backup is activated, for example, via an app in the mobile phone 1 12 (the status in the app is sent to the device and is stored internally in a variable that can be set as an input for the course of action); this is also visualized via a connected LED .
  • the device notes its current position via a GPS module 114. This is updated at a regular interval specified by the user. In the event of a change, the device immediately reports its current position back to the user's smartphone 112 and / or a server 32i at a regular interval.
  • FIG. 21 shows a schematic block diagram of a device 210 in accordance with an exemplary embodiment which is configured to be connected to different devices or devices via the inputs 28i in order to receive input signals.
  • a wireless interface 116 such as Bluetooth® or another wireless technology
  • a timer or clock 118 a signal generator for user input, such as a switch or button 122 and / or other sensors such as a heart rate monitor 124.
  • LCD Liquid Crystal Display
  • the device 210 can be designed to switch, for example, based on the user input between two or more operating modes in which different information is displayed on the display device 126, for example information received via the interface 116, a time of the timer 118 and / or information from the Sensors 124 and / or information derived therefrom. This information can be transmitted via the outputs 28s, for example using the interface 116, and alternatively or additionally be displayed.
  • the device 210 can provide a type of intelligent heart rate watch.
  • a button 122 can be used to switch over what the LCD display 126 is to show.
  • the device can receive information from other devices (for example the associated chest strap for differential pulse measurement or the speedometer of a bicycle or a smartphone) or send it to other devices.
  • the via bluetooth 116 received information can be used, for example, to display an alarm on the display 126 if a value set by the user is exceeded.
  • the devices described herein can be programmed or reprogrammed using configuration signals. Corresponding partial courses of action can be stored in the device and re-linked or configured by means of the configuration signal.
  • the drainage parts can be different according to the hardware belonging to the device or provided or possible, but the configuration of the generator can be the same or have the same effect.
  • Sequence parts described here can be understood as predefined and / or parameterizable and / or adaptable code modules that can be combined to form an overall code, the course of action, in a selection and / or property and / or sequence determined by the configuration signal.
  • aspects have been described in connection with a device, it goes without saying that these aspects also represent a description of the corresponding method, so that a block or a component of a device is also to be understood as a corresponding method step or as a feature of a method step. Analogously, aspects that have been described in connection with or as a method step also represent a description of a corresponding block or details or features of a corresponding device.
  • embodiments of the invention can be implemented in hardware or in software.
  • the implementation can be carried out using a digital storage medium such as a floppy disk, a DVD, a Blu-ray disc, a CD, a ROM, a PROM, an EPROM, an EEPROM or a FLASH memory, a hard disk or other magnetic memory or optical memory, on which electronically readable control signals are stored, which can interact or cooperate with a programmable computer system in such a way that the respective method is carried out. Therefore, the digital storage medium can be computer readable.
  • Some embodiments according to the invention thus include a data carrier that has electronically readable control signals that are able to communicate with a programmable com to cooperate computer system in such a way that one of the methods described herein is carried out.
  • exemplary embodiments of the present invention can be implemented as a computer program product with a program code, the program code being effective to carry out one of the methods when the computer program product runs on a computer.
  • the program code can for example also be stored on a machine-readable carrier.
  • exemplary embodiments include the computer program for carrying out one of the methods described herein, the computer program being stored on a machine-readable carrier.
  • an exemplary embodiment of the method according to the invention is thus a computer program which has a program code for carrying out one of the methods described here when the computer program runs on a computer.
  • a further exemplary embodiment of the method according to the invention is thus a data carrier (or a digital storage medium or a computer-readable medium) on which the computer program for performing one of the methods described herein is recorded.
  • a further exemplary embodiment of the method according to the invention is thus a data stream or a sequence of signals which represents or represents the computer program for performing one of the methods described herein.
  • the data stream or the sequence of signals can, for example, be configured to be transferred via a data communication connection, for example via the Internet.
  • Another exemplary embodiment comprises a processing device, for example a computer or a programmable logic component, which is configured or adapted to carry out one of the methods described herein.
  • a processing device for example a computer or a programmable logic component, which is configured or adapted to carry out one of the methods described herein.
  • Another exemplary embodiment comprises a computer on which the computer program for performing one of the methods described herein is installed.
  • a programmable logic component for example a field-programmable gate array, an FPGA
  • a field-programmable gate array can interact with a microprocessor in order to carry out one of the methods described herein.
  • the methods are performed by any hardware device. This can be universally applicable hardware such as a computer processor (CPU) or hardware specific to the method such as an ASIC.

Landscapes

  • Engineering & Computer Science (AREA)
  • Software Systems (AREA)
  • Theoretical Computer Science (AREA)
  • Physics & Mathematics (AREA)
  • General Physics & Mathematics (AREA)
  • General Engineering & Computer Science (AREA)
  • Automation & Control Theory (AREA)
  • Stored Programmes (AREA)

Abstract

Eine Vorrichtung umfasst eine Eingangsschnittstelle, die ausgebildet ist, um ein Konfigurationssignal zu empfangen, einen Datenspeicher, in dem eine Vielzahl ausführbarer Ablaufteile gespeichert ist, wobei jeder Ablaufteil zumindest eine Handlungsvorschrift beschreibt, einen Generator, der ausgebildet ist, um einen Handlungsablauf zu erstellen, der eine Abfolge von in dem Konfigurationssignal angegebenen Ablaufteilen der Vielzahl von gespeicherten Ablaufteilen umfasst, eine Schnittstelle, die ausgebildet ist, um mit einer Peripherie zu kommunizieren, und einen Prozessor, der konfiguriert ist, um die Peripherie gemäß dem Handlungsablauf anzusprechen.

Description

Vorrichtung und Verfahren zur Fernprogrammierung
Beschreibung
Die vorliegende Erfindung bezieht sich auf eine Vorrichtung und auf ein Verfahren zur Fernprogrammierung. Die vorliegende Erfindung bezieht sich insbesondere auf ein Fern- Programmierbares Gerät für Regel-basierte Anwendungen bzw. auf ein Fern- Programmierbares Gerät mit T uring-vollständigem Parametersatz für Regel-basierte Anwendungen (FPGRA). loT-Devices oder loT-Vorrichtungen (loT = Internet of Things, Internet der Dinge) haben verschiedenste, flexible Einsatzmöglichkeiten. Dabei kann ein und dieselbe Hardware- Konfiguration verschiedene Anwendungsfälle besitzen und auch zwischen diesen wechseln. Im Standardfall muss ein Gerät, dessen Anwendung sich ändert, neu programmiert werden. Hierfür wird ein neuer Programmcode auf das Device gespielt und in den Festspeicher (EEPROM) geschrieben. Dieser Prozess ist verhältnismäßig energieaufwendig, da zum einen für das Flashen oder Programmieren des Festspeichers sehr viel Energie benötigt wird, darüber hinaus im Live-Betrieb auch mit einigen Risiken verbunden ist, und zum anderen ein recht großer Programmcode meist über Funk übertragen wird und eine derartige Funkkommunikation ebenfalls recht energieaufwendig ist. Insofern ist diese Vorgehensweise eher ungeeignet für loT-Devices im Ultra-Low-Power-Bereich (Niedrigenergiebereich).
In diesem Bereich beschränkt man sich bisher darauf, einige wenige vorprogrammierte „Szenarien“ im Festspeicher des Devices zu halten, zwischen denen dann gewechselt werden kann. Beispielsweise kann so der Schwellwert einer Abfrage ausgetauscht werden oder der Zeitpunkt/das Intervall, in dem sich das Gerät beim Server meldet, per Funknachricht geändert werden. Hierbei büßt man viel Flexibilität ein, denn wenn ein Anwendungsfall nicht exakt in die vorprogrammierten Szenarien passt, ist es dennoch wieder erforderlich, das Gerät via Funkkommunikation neu zu programmieren.
Wünschenswert wären demnach funkbasierte Vorrichtungen, die mit geringem Energieaufwand flexibel eingesetzt werden können. Die Aufgabe der vorliegenden Erfindung besteht deshalb darin, Vorrichtungen zu schaffen, die mittels Datenkommunikation unter geringem Energieaufwand flexibel eingesetzt oder programmiert werden können.
Diese Aufgabe wird durch die Gegenstände der unabhängigen Patentansprüche gelöst.
Die Erfinder haben erkannt, dass es von besonderem Vorteil ist, die durch ein Gerät zu implementierenden Funktionalitäten in Form von Ablaufteilen, die jeweils zumindest eine Handlungsvorschrift beschreiben, in dem Gerät zu hinterlegen und vorzuhalten. Eine später von dem Gerät zu implementierende Funktion oder Funktionalität, das bedeutet ein Handlungsablauf, kann durch Empfang eines Konfigurationssignals festgelegt werden, welches lediglich die Reihenfolge und Verknüpfung der bereits im Gerät hinterlegten Ablaufteile angibt. Die Vorrichtung kann somit durch Neusortierung der vordefinierten und bereits hinterlegten Ablaufteile neu programmiert werden, was mit geringem Energieaufwand möglich ist und gleichzeitig eine sehr hohe Flexibilität ermöglicht.
Gemäß einem Ausführungsbeispiel umfasst eine Vorrichtung eine Eingangsschnittstelle, die ausgebiidet ist, um ein Konfigurationssignal zu empfangen. Die Vorrichtung umfasst einen Datenspeicher, in dem eine Vielzahl ausführbarer Ablaufteile gespeichert ist, wobei jeder Ablaufteil zumindest eine Handlungsvorschrift beschreibt. Ein Generator ist ausgebildet, um einen Handlungsablauf zu erstellen, der eine Abfolge von in dem Konfigurationssignal angegebenen Ablaufteilen der Vielzahl von gespeicherten Ablaufteilen umfasst. Eine Schnittstelle der Vorrichtung ist ausgebildet, um mit einer Peripherie zu kommunizieren. Ein Prozessor ist ausgebildet, um die Peripherie gemäß dem Handlungsablauf anzusprechen.
Gemäß einem Ausführungsbeispiel umfasst eine Vorrichtung eine Ausgangsschnittstelle, die ausgebildet ist, um ein Konfigurationssignal zu senden, einen Signalgenerator, der ausgebildet ist, um das Konfigurationssignal bereitzustellen, so dass das Konfigurationssignal eine Abfolge von ausführbaren Ablaufteilen einer Vielzahl von ausführbaren Ablaufteilen beschreibt. Die Abfolge von ausführbaren Ablaufteilen beschreibt einen Handlungsablauf mit einer Mehrzahl von Handlungsvorschriften eindeutig.
Weitere Ausführungsbeispieie sind auf ein System mit erfindungsgemäßen Vorrichtungen und auf Verfahren sowie auf ein Computerprogramm gerichtet. Vorteilhafte Weiterbildungen sind in den abhängigen Patentansprüchen definiert.
Bevorzugte Ausführungsbeispiele der vorliegenden Erfindung werden nachfolgend bezugnehmend auf die beiliegenden Zeichnungen erläutert. Es zeigen:
Fig. 1 ein schematisches Blockschaltbild einer Vorrichtung gemäß einem Ausführungsbeispiel;
Fig. 2 ein schematisches Blockschaltbild eines Datenspeichers gemäß einem Ausführungsbeispiel;
Fig. 3 ein schematisches Blockschaltbild einer Vorrichtung gemäß einem Ausführungsbeispiel, die Schnittstellen aufweist, um sowohl eine drahtlose Kommunikation als auch eine drahtgebundene Kommunikation bereitzustellen;
Fig. 4 eine schematische Repräsentation eines beispielhaften Handlungsablaufs gemäß einem Ausführungsbeispiel;
Fig. 5 ein schematisches Blockschaltbild eines Teils eines Regelbaums gemäß einem
Ausführungsbeispiel, wobei beispielhaft zwei ausführbare Ablaufteile und durch Ablaufknoten repräsentiert werden;
Fig. 6a ein schematisches Blockschaltbild einer Verschaltung eines Ablaufknotens in einem Regelbaum gemäß einem Ausführungsbeispiel;
Fig. 6b eine schematische Darstellung einer Verknüpfung eines Ablaufknotens in einem
Regelbaum, wobei die implementierte Operation gemäß einem Ausführungsbeispiel eine Arithmetik-Operation ist;
Fig. 6c eine schematische Darstellung einer Verknüpfung des Ablaufknotens in dem
Regelbaum, bei dem die implementierte Funktion gemäß einem Ausführungsbeispiel eine Speicheroperation ist;
Fig. 6d eine schematische Darstellung des Ablaufknotens gemäß einem Ausführungsbeispiel, bei dem mittels Verknüpfungen erhaltene Informationseingänge gemäß einem Ausführungsbeispiel in einer auszuführenden Aktion münden; Fig. 7 eine beispielhafte Darstellung von Computer-implementierten Instruktionen gemäß einem Ausführungsbeispiel zur beispielhaften Darstellung unterschiedlicher durch Knoten implementierter Funktionen;
Fig. 8 eine beispielhafte Darstellung von Code gemäß einem Ausführungsbeispiel, der
Instruktionen wiedergibt, die ein Generator einer erfindungsgemäßen Vorrichtung anweisen, ein Konfigurationssignal auf eine Funktions-ID auszuwerten;
Fig. 9a-c beispielhafte Darstellungen von Code gemäß einem Ausführungsbeispiel zur
Definition einer Knotenstruktur;
Fig. 10a einen beispielhaften Code gemäß einem Ausführungsbeispiel, bei dem eine maximale Anzahl von Knoten des Handlungsablaufs definiert wird;
Fig. 10b einen beispielhaften Code gemäß einem Ausführungsbeispiel, der anzeigt, dass eine Knotennummer bis zu einer maximalen Anzahl von Knoten oder Aktionen vollständig durchlaufen wird;
Fig. 10c einen beispielhaften Code gemäß einem Ausführungsbeispiel zum Ausführen eines Handlungsablaufs durch einen Prozessor;
Fig. 10d eine beispielhafte Darstellung von Code gemäß einem Ausführungsbeispiel, der
Instruktionen wiedergibt, die ein Prozessor einer erfindungsgemäßen Vorrichtung anweisen, einen Knotentyp auszuwerten;
Fig. 10e einen bespielhaften Code gemäß einem Ausführungsbeispiel, der einen Prozessor instruiert, um den nächsten auszuführenden Knoten zu bestimmen;
Fig. 11 ein schematisches Blockschaltbild einer Vorrichtung gemäß einem Ausfüh rungsbeispiel, die Eingänge, Ausgänge und eine innere Logik umfasst;
Fig. 12 ein schematisches Blockschaltbild einer Vorrichtung gemäß einem Ausführungsbeispiel, wobei an den Ausgängen die Peripherie in Form eines Schalters drahtgebunden oder drahtlos angeschlossen ist; Fig. 13 ein schematisches Blockschaltbild einer Vorrichtung gemäß einem Ausführungsbeispiel, bei der die Eingänge mit Sensoren in beliebiger Anzahl verbunden sind, um Sensorsignale zu empfangen;
Fig. 14 ein schematisches Blockschaltbild einer Vorrichtung gemäß einem Ausführungsbeispiel, die mit der Peripherie verbunden ist und die als Sensor/Aktor- Logik bzw. als Sender und Empfänger, etwa für eine Smart-Home-Einrichtung, konfiguriert ist;
Fig. 15 ein schematisches Blockschaltbild eines Systems gemäß einem Ausführungsbeispiel, das beispielhaft die Vorrichtung aus Fig. 1 umfasst;
Fig. 16 ein schematisches Blockschaltbild eines Systems gemäß einem Ausführungs beispiel, das Vorrichtungen umfasst, die ausgebildet sind, um einen Datenfluss zum Austausch von Logik und/oder Parametern oder Soll-Werten auszutauschen;
Fig. 17 ein schematisches Ablaufdiagramm eines Verfahrens gemäß einem Ausführungsbeispiel, das beispielsweise von einer hierin beschriebenen fernprogrammierbaren Vorrichtung, etwa der Vorrichtung ausgeführt werden kann;
Fig. 18 ein schematisches Flussdiagramm eines Verfahrens zum Bereitstellen eines
Konfigurationssignals gemäß einem Ausführungsbeispiel;
Fig. 19 ein schematisches Blockschaltbild einer Vorrichtung gemäß einem Ausführungsbeispiel, die als Bewegungstracker fungieren kann;
Fig. 20 ein schematisches Blockschaltbild einer Vorrichtung gemäß einem Ausführungsbeispiel, die als Diebstahl-Sicherung fungieren kann; und
Fig. 21 ein schematisches Blockschaltbild einer Vorrichtung gemäß einem Ausführungsbeispiel, die eine intelligente Puls-Uhr bereitstellen kann.
Bevor nachfolgend Ausführungsbeispiele der vorliegenden Erfindung im Detail anhand der Zeichnungen näher erläutert werden, wird darauf hingewiesen, dass identische, funktionsgleiche oder gleichwirkende Elemente, Objekte und/oder Strukturen in den unter- schiedlichen Figuren mit den gleichen Bezugszeichen versehen sind, so dass die in unterschiedlichen Ausführungsbeispielen dargestellte Beschreibung dieser Elemente untereinander austauschbar ist bzw. aufeinander angewendet werden kann.
Manche der nachfolgend beschriebenen Ausführungsbeispiele sind unter Verwendung oder anhand einer beispielhaften Programmiersprache, d. h. anhand von Code beschrieben. Details dieser Ausführungsbeispiele, die sich beispielsweise aufgrund der Semantik und/oder anhand der konkreten Befehlsimplementierungen ergeben, sind dabei lediglich beispielhaft zu verstehen und zum besseren Verständnis eingefügt. Die gewählten Codeimplementierungen beschränken die Ausführungsbeispiele dabei weder auf die gewählte Programmiersprache noch auf die konkrete Befehlsabfolge oder die Bezeichnung von Variablen, sofern dies nicht explizit anders angegeben ist. Insbesondere beziehen sich die hierin erläuterten Ausführungsbeispiele auf alternative oder zusätzliche Ausführungsbeispiele mit gleicher, ähnlicher und insbesondere äquivalenter technischer Wirkung.
Nachfolgende Ausführungsbeispiele werden im Zusammenhang mit loT-Vorrichtungen oder IoT-Devices, was ein Synonym ist, beschrieben, wobei„loT“ den Begriff„Internet of Things“ (Internet der Dinge) bezeichnet und für Geräte steht, die über einen üblicherweise schmalbandigen Kanal mit anderen Einrichtungen kommunizieren, wobei hierfür sowohl Direktverbindungen (Peer-to-Peer) als auch Infrastruktur-basierte Netzwerke verwendet werden können.
Obwohl im Bereich der schmalbandigen Kommunikation besondere technische Vorteile erhalten werden, sind die hierin beschriebenen Ausführungsbeispiele nicht hierauf beschränkt, insbesondere da die Vorteile der Flexibilität und Energieeinsparung auch bei breitbandigeren Kanälen erhalten werden kann. Daraus wird ebenfalls deutlich, dass die hierin beschriebenen Ausführungsbeispiele zwar im Bereich des klassischen Mobilfunks (etwa 3G/4G/LTE - Long Term Evolution - oder 5G) eingesetzt werden können, dass aber sowohl andere drahtlose Kommunikationsprotokolle implementiert werden können wie etwa lokale Drahtlosnetzwerke (WLAN), großflächige Drahtlosnetzwerke (WMAN) oder beliebige andere drahtlose Kommunikationsprotokolle, dass die beschriebenen Vorteile aber auch im Bereich der drahtgebundenen Kommunikation erhalten werden können.
Nachfolgende Ausführungsbeispiele beziehen sich auf die Verwendung von Integer- Zahlen, d. h., ganzzahliger Werte, bspw. für Ergebnisse von Knoten von Handlungsabläufen bzw. deren graphischer Repräsentanz. Obwohl dies im Hinblick auf Speichereffizienz vorteilhaft ist, sind die vorliegenden Ausführungsbeispiele nicht hierauf beschränkt. Es ist vielmehr möglich, dass Operationen eines Knoten andere Werte, etwa Fließkomma- Werten (bspw. Datentyp„float“) verwenden. Hierfür kann in der Implementierung das ein Datenfeld, das bspw. mit„res“ bezeichnet ist, und das Ergebnis des Knotens repräsentieren kann, sogar weiterhin ein Integer bleiben, da die Information (also die Bits) im„res“- Feld durch sogenanntes„casten“ (auswerten) einfach als float (Fließkommazah!) interpretieren kann ohne Informationsverlust zu erleiden.
Fig. 1 zeigt ein schematisches Blockschaltbild einer Vorrichtung 10 gemäß einem Ausführungsbeispiel. Die Vorrichtung 10 umfasst eine Eingangsschnittstelle 12, die ausgebildet ist, um ein Konfigurationssignal 14 zu empfangen. Die Eingangsschnittstelle 12 kann eine drahtlose oder drahtgebundene Kommunikationsschnittstelle oder Interface sein, so dass das Konfigurationssignal dementsprechend ein drahtgebundenes Signal oder ein drahtloses Signal sein kann.
Die Vorrichtung 10 umfasst einen Datenspeicher, in dem eine Vielzahl ausführbarer Ablaufteile 18 gespeichert ist, die beispielhaft als„a“,„b“,„c“,„d“, oder„e“ dargestellt sind, obwohl eine Anzahl beliebig ist, etwa zumindest drei, zumindest vier, zumindest 10, zumindest 50 oder höher, etwa zumindest 100. Jeder Ablaufteil 18i bis 185 kann als Codesegment oder Codeabschnitt verstanden werden, der zumindest eine Handlungsvorschrift beschreibt, beispielsweise eine Verarbeitung oder Manipulation einer Eingangsgröße hin zu einer Ausgangsgröße, worauf später noch detailliert eingegangen wird. Die Ablaufteile 181 bis 185 sind jedoch eindeutig voneinander unterscheidbar und stellen beispielsweise Teilprogramme oder Teilcodes dar.
Die Vorrichtung 10 umfasst einen Generator 22, der ausgebildet ist, um einen Handlungsablauf 24 zu erstellen. Der Handlungsablauf 24 kann dabei eine Kombination mehrerer Ablaufteile 181 bis 185 sein, wobei jeder Ablaufteil 181 bis 185 optional in dem Handlungsablauf 24 Vorkommen kann, was eine Möglichkeit zum mehrfachen Vorkommen mitein- schließt. Beispielhaft umfasst der Handlungsablauf 24 eine Anzahl von vier Ablaufteilen 183, 181 , 184 und 182 in der genannten Reihenfolge, die als c, a, d, b darstellbar ist. Sowohl die gewählte Reihenfolge als auch die Anzahl der Ablaufteile 181 bis 184 in dem Handlungsablauf 24 sind hierbei beispielhaft gewählt.
Die Anzahl voneinander unterscheidbarer unterschiedlicher Ablaufteile 18, kann mit i = 1 , ... N mit N > 1 , > 2, > 3, > 4, > 5, > 10, > 50 oder mehr, etwa > 100 beliebig skalierbar sein. Eine Anzahl von M Ablaufteilen in dem Handlungsablauf 24 kann ebenfalls einen beliebigen Wert aufweisen, wobei die Anzahl von M Ablaufteilen 18 in dem Handlungsablauf 24 eine Teilmenge der N in dem Datenspeicher 16 hinterlegten Ablaufteile ist, wobei innerhalb der Teilmenge M ein Ablaufteil mehrfach Vorkommen kann. Das bedeutet, die in dem Handlungsablauf implementierten Ablaufteile sind eine Teilmenge der gespeicherten Handlungsabläufe. Der Handlungsablauf 24 kann somit zumindest eine Teilmenge der in dem Datenspeicher gespeicherten Vielzahl von ausführbaren Ablaufteilen umfassen. Der Prozessor 31 kann ausgebildet sein, um zum Ansprechen der Peripherie 32 die Teilmenge von ausführbaren Ablaufteilen gemäß dem Handlungsablauf 24 zu durchlaufen und in einem ersten Ablaufteil zumindest eine Eingangsgröße zu verarbeiten, um eine Ausgangsgröße zu erhalten, und um die Ausgangsgröße als Eingangsgröße eines zweiten Ablaufteils zu verwenden, wie es beispielsweise anhand der Fig. 4 näher erläutert ist.
Der Generator 22 ist ausgebildet, um die für den Handlungsablauf 24 zu verwendenden Ablaufteile aus dem Datenspeicher 16 zu lesen und zu dem Handlungsablauf 24 zu verknüpfen, was sowohl die Implementierung einer Reihenfolge der Ablaufteile 18i bis 18, umfasst als auch eine Verknüpfung der einzelnen Ablaufteile. So kann eine Ausgangsgröße eines ersten Ablaufteils, etwa 18i, eine Eingangsgröße eines darauffolgenden Ablaufteils, etwa 184, sein, so dass durch entsprechende Speicherverweise eine Übergabe der Parameter erfolgen kann. Die anzuwendende Vorschrift bezüglich der Verknüpfungen kann Teil des Konfigurationssignals 14 sein, das beispielsweise als c‘, a‘, d‘ oder b‘ angedeutete Informationen 26i bis 264 aufweisen kann.
So kann eine Information 263 (c‘) eine Instruktion zur Verwendung des Ablaufteils 183 in dem Handlungsablauf 24 wiedergeben. Ähnlich kann die Präsenz einer Information 261 (a‘) eine Instruktion zur Verwendung des Ablaufteils I81 in dem Handlungsablauf 24 wiedergeben. Informationen 264 (d‘) sowie 262 (b‘) können in ähnlicher Weise Instruktionen zur Verwendung der Ablaufteile 1 84 und 182 in dem Handlungsablauf 24 aufweisen. Eine Reihenfolge der Ablaufteile 181 bis 184 in dem Handlungsablauf 24 kann in dem Konfigurationssignal 14 explizit angegeben sein, kann aber auch implizit durch eine Reihenfolge der Information 263, 26i, 264 und 262 enthalten sein, was eine zusätzliche Reduktion übertragener Daten ermöglicht. Der Generator 22 ist ausgebildet, um das Konfigurationssignal 14 auf die Informationen 26 auszuwerten und um den Handlungsablauf 24 so zu erstellen, dass eine Abfolge von in dem Konfigurationssignal durch die Informationen 26 angegebenen Ablaufteilen 18, die in dem Datenspeicher 16 gespeichert sind, umfasst. Der Prozessor 22 kann ausgebildet sein, um bei Erhalt eines ggf. ersten Konfigurationssignals einen neuen oder ersten Handlungsablauf zu erstellen. Der Prozessor 22 kann ausgebildet sein, um bei Erhalt eines neuen, weiteren oder anderen Konfigurationssignals 14 den Handlungsablauf 24 durch einen neuen, weiteren bzw. anderen Handlungsablauf zu ersetzen, der in Übereinstimmung mit dem aktualisierten Konfigurationssignal 14 ist. Dadurch wird eine Umprogrammierung der Vorrichtung 10 erhalten, ohne dass hierfür neuer Programmcode erforderlich ist. Gleichzeitig kann bei einer Ausgestaltung des Datenspeichers 34 beispielsweise als flüchtiger Datenspeicher ein geringes Maß an Energie eingesetzt werden, um die Umprogrammierung zu erhalten.
Ausgehend von einem Initialzustand, bei dem beispielsweise alle Knoten des Handlungsablaufs 24 unkonfiguriert oder auf einen Standardwert konfiguriert sind, oder zum Um programmieren eines zuvor erstellten Handlungsablaufs 24, kann das Konfigurationssignal 14 eine Abfolge von Informationen aufweisen, die für jeden zu verwendenden Knoten eine Kennung (Knotennummer) sowie einen Typ und Speicherbereiche für Ein- und Ausgänge angibt, so dass durch insgesamt sechs Parameter ein Knoten des Handlungsablaufs 24 eindeutig identifizierbar ist und über die angegebenen Parameter umprogrammierbar ist, sodass mittels des Konfigurationssignals 14 eine Umprogrammierung einzelner Knoten als auch des gesamten Handlungsablaufs möglich ist, um einen neuen, zweiten Handlungsablauf zu erhalten. Der Generator kann ausgebildet sein, um basierend auf dem zweiten Konfigurationssignal eine Neudefinition zumindest eines ausführbaren Ablaufteils des ersten Handlungsablaufs auszuführen, um einen zweiten Handlungsablauf zu erhalten, also einen aktualisierten oder neudefinierten Handlungsablauf. Die Neudefinition des Handlungsablaufs kann dabei ebenso Turing-vollständig sein wie der erste Handlungsablauf. Zur Neudefinition kann der Generator ausgebildet sein, um das zweite Konfigurationssignal auf die erwähnten sechs Parameter auszuwerten, die den zumindest einen ausführbaren Ablaufteil für die Neudefinition bestimmen.
Die Vorrichtung 10 umfasst eine Schnittstelle 28, die eine drahtgebundene oder drahtlose Verbindung mit einer Peripherie 32 ermöglicht. Die Peripherie 32 kann eine beliebige Anzahl, d. h., jeweils null oder mehr, insgesamt jedoch eines oder mehr, von Sensoren, Aktuatoren, Motoren Datenausgabegeräten Datenverarbeitungsgeräten, etwa Server, Schalter und/oder Dateneingabegeräten umfassen. Zu den Sensoren gehören beispielsweise Temperatursensoren, Feuchtigkeitssensoren, Drehratensensoren oder beliebige andere Sensoren. Aktuatoren können beispielsweise Stellglieder sein, die im Bereich der Fluidsteuerung genutzt werden, beliebige andere Bewegungen erzeugen, etwa Schalter oder Motoren oder dergleichen, während zu Dateneingabegeräten Scanner, Tasten, Tastaturen oder Touchpads gehören, Datenausgabegeräte können beispielsweise Anzeigen, Leuchten oder Displays sein.
Die Vorrichtung 10 umfasst einen Prozessor 32, der ausgebildet ist, um die Peripherie 32 gemäß dem Handlungsablauf 24 anzusprechen. Das bedeutet, der Prozessor 31 ist konfiguriert, um die Ablaufteile 18i bis 184 in der durch den Handlungsablauf 24 festgelegten Reihenfolge auszuführen, wobei sich der Handlungsablauf 24 auf die Interaktion mit der Peripherie sowie zwischengeschaltete oder zwischengeordnete Verarbeitungsschritte beziehen kann.
Obwohl der Generator 22 und der Prozessor 31 als separate Elemente dargestellt sind, können der Generator 22 und der Prozessor 31 auch Teil einer gemeinsamen Steuereinheit sein, die beispielsweise als Prozessor, Micro-Controller, feldprogrammierbares Gat- ter-Array (FPGA) oder dergleichen implementiert ist. Alternativ kann jedes der Elemente 22 und 31 für sich derartig implementiert sein.
Der Handlungsablauf 24 kann in einem Datenspeicher 34 hinterlegt sein, der von dem Datenspeicher 16 separat sein kann. Alternativ ist es ebenfalls möglich, dass die Datenspeicher 16 und 34 Speicherbereiche eines gleichen Datenspeichers sind. Bevorzugt ist der Datenspeicher 16 als nicht-flüchtiger Speicher ausgebildet, wobei zu dem nichtflüchtigen Speichern auch MRAMs gezählt werden (MRAM = magnetoresistive Arbeitsspeicher) und andere Speicher, die einen zumindest kurzfristigen Zustand ohne Energieversorgung ohne Datenverlust überstehen. Der Datenspeicher 34 kann ein flüchtiger oder nicht-flüchtiger Speicher sein, da in Kenntnis des Konfigurationssignals 14 der Handlungsablauf 24 durch Zugriff auf den Datenspeicher wiederherstellbar ist. Ausführungsbeispiele können vorsehen, Informationen des Konfigurationssignals 14 in dem Datenspeicher 16 und/oder dem Datenspeicher 34 zu hinterlegen.
In anderen Worten ermöglicht die Vorrichtung 10 vor der oben genannten Zielsetzung, dass ein hohes Maß an Flexibilität an Anwendungen erhalten werden und für eine Neuprogrammierung der Vorrichtung 10 auf eine Übertragung neuen Programmcodes verzichtet werden kann, je nach Implementierung des Datenspeichers 34, auf ein Schreiben eines Codes in einem Festspeicher wie einem EEPROM, verzichtet werden kann, was insbesondere für den Ultra-Low-Power-Bereich vorteilhaft ist, die Ausführungsbeispiele aber nicht hierauf beschränkt. Ausführungsbeispiele basieren auf der Erkenntnis, dass die vom Anwender/Programmierer vorgegebene Tätigkeit des Geräts nur ein kleiner Teil des gesamten Programmcodes ist. Ein sehr großer Teil dient, vereinfacht betrachtet, nur der Ansteuerung und Einbindung der Hardware/Peripherie. Außerdem sind die meisten loT- Vorrichtungen, insbesondere im Ultra-Low-Power-Segment, von recht einfacher Natur, nur in seltenen Fällen werden rekursive Programm auf rufe oder komplex verschachtelte Schleifen eingesetzt, was zum Teil auch an den Hardware-Begrenzungen liegt. Ein gewisser Anteil bzw. ein hoher Anteil lässt sich mit Konzepten gemäß„Wenn X, dann Y, sonst Z“ darstellen, wobei hier X durchaus das Ergebnis einer komplexeren Operation sein kann und Y sowie Z ein Funktionsaufruf oder eine weitere Logikabfrage.
Fig. 2 zeigt ein schematisches Blockschaltbild eines Datenspeichers 36, der als gemeinsamer Datenspeicher für die Datenspeicher 16 und 34 wirkt. Ein gemeinsamer Datenspeicher ist jedoch nicht darauf beschränkt, dass die Datenspeicher 16 und 34, die als erster Speicherabschnitt bzw. zweiter Speicherabschnitt wirken, auf den gleichen Speicherprinzipien basieren. Der Speicherabschnitt oder Datenspeicher 16 ist dabei ausgebildet, um die Vielzahl ausführbarer Ablaufteile 18 zu speichern, das bedeutet, die vorgefertigten oder vordefinierten Codeabschnitte. Der Datenspeicher oder Speicherabschnitt 34 kann ausgebildet sein, um den Handlungsablauf 24 zu speichern. Insbesondere kann der Generator 22 ausgebildet sein, um den erstellten Handlungsablauf 24 in dem Speicherabschnitt 34 zu speichern.
Gemäß einem Ausführungsbeispiel ist der Datenspeicher 16 als nicht-flüchtiger Speicher gebildet und der Datenspeicher 34 als flüchtiger Speicher.
Fig. 3 zeigt ein schematisches Blockschaltbild einer Vorrichtung 30 gemäß einem Ausführungsbeispiel, die Schnittstellen 12i und 122 aufweist, um sowohl eine drahtlose Kommunikation über die Schnittstelle 12i als auch eine drahtgebundene Kommunikation über die Schnittstelle 122 bereitzustellen. Die Schnittstellen 12i und/oder 122 können dabei eine bidirektionale Kommunikation ermöglichen, ebenso wie die Schnittstelle 12 der Vorrichtung 10. So kann beispielsweise ein Ergebnis interner Berechnungen oder ausgewerteter Sensoren oder Knoten zurückgemeldet werden.
Die Vorrichtung 30 umfasst eine Steuereinrichtung 38, beispielsweise eine zentrale Recheneinheit (central Processing unit - CPU, ein Micro-Controller oder dergleichen), die mit dem beispielhaft nicht-flüchtigen Datenspeicher 16 und dem beispielhaft flüchtigen Datenspeicher 34 verbunden ist und sowohl den Generator 22 als auch den Prozessor 31 der Vorrichtung 10 implementiert. Die Steuereinrichtung 38 kann mit einer beliebigen Anzahl > 1 Taktgebern (real-time clock - RTC) in Verbindung stehen. Zur Kommunikation mit der Peripherie kann eine Schnitt 28i konfiguriert sein, um eine Anzahl von 0, ... v Eingängen zu erfassen, wobei V eine beliebige Anzahl > 0 ist. Die v Eingänge der Schnittstelle 28i können beliebige Informationen oder Daten bereitstellen. Eine optionale weitere Schnittstelle 282 kann mit einer Anzahl von 0, .... w Sensoren verbunden sein, so dass bei Konnektierung von Sensoren entsprechende Sensorsignale an die Steuereinrichtung 38 gelangen können, das bedeutet, die Steuereinrichtung 38 kann Zugriff auf die optionalen Eingänge und die optionalen Sensoren aufweisen. Es wird darauf hingewiesen, dass bevorzugt zumindest einer der Werte v oder w > 0 ist und die Vorrichtung 30 bzw. die Peripherie zumindest einen Eingang oder zumindest einen Sensor aufweist. Über eine Schnittstelle 283 können andere Systeme angesteuert werden, beispielsweise über einen Kommunikationsbus oder einen Energieübertragungsbus. Die Vorrichtung 30 kann eine optionale Schnittstelle 284 zur parallelen (Par) und/oder seriellen (Ser) Kommunikation aufweisen. Eine Schnittstelle 285 kann optional vorgesehen sein und eine Anzahl von £ 0 Ausgängen bereitstellen, die beispielsweise mit einer Anzeigeeinrichtung und/oder einem Aktuator verbunden sind und/oder Steuersignale für Sensoren oder dergleichen bereitstellen.
Die Vorrichtung 30 kann ausgebildet sein, um das Konfigurationssignal über die Schnittstelle 12i und/oder die Schnittstelle 122, das bedeutet über ein drahtgebundenes oder drahtloses Kommunikationsnetzwerk zu empfangen. Bevorzugt wird das Konfigurationssignal über ein drahtloses Netzwerk empfangen, da dies ein hohes Maß an Flexibilität für die Vorrichtung 30, insbesondere in Hinblick auf die Positionierung derselben, bietet. Die Schnittstelle 122 kann insofern eine Verbindung zu einem drahtlosen oder drahtgebundenen Netzwerk bereitstellen. Das drahtlose Netzwerk kann ein Funknetzwerk umfassen, worunter Mobilfunkanwendungen verstanden werden, beispielsweise 3G, 4G oder 5G.
Nachfolgend wird Bezug genommen auf die Erstellung des Handlungsablaufs aus dem Konfigurationssignal. Das Konfigurationssignal ist dabei so ausgestaltet, dass eine Abfolge von ausführbaren Ablaufteilen in dem Konfigurationssignal angezeigt oder enthalten ist und sowohl die Teilmenge der in dem Datenspeicher 16 hinterlegten Ablaufteile angibt als auch eine Reihenfolge der ausgewählten Ablaufteile in dem Handlungsablauf 24 eindeutig festlegt. Das bedeutet, die Abfolge von ausführbaren Ablaufteilen und damit der Handlungsablauf sind in dem Konfigurationssignal eindeutig festgelegt, auch wenn der auszuführende Programmcode selbst nicht zwingend Teil des Konfigurationssignals ist. An den Eingängen 28i bis 28 verbundene Komponenten können ebenso zur Peripherie gehören, wie die an den Ausgängen 28s verbundene Komponenten.
Fig. 4 zeigt eine schematische Repräsentation eines beispielhaften Handlungsablaufs 24. Der Handlungsablauf 24 kann einen oder mehrere Regelbäume 44i und 442 aufweisen oder durch die Regelbäume repräsentiert werden, wobei die Anzahl der Regelbäume 441 und/oder 442 in dem Handlungsablauf 24 eine beliebige Anzahl von ä 1 sein kann. Die Regelbäume 44i und 442 können dabei parallel oder zeitlich nacheinander, d. h. sequenziell, abgearbeitet werden und sich beispielsweise auf unterschiedliche Funktionen der den Handlungsablauf 24 implementierenden Vorrichtung beziehen. So kann beispielsweise einer der Regelbäume eine Sensorauswertung beschreiben und ein anderer Regelbaum eine Aktuatoransteuerung oder eine Datenanzeige oder Datenübermittlung.
Die Regelbäume 44i und 442 umfassen zumindest einen Startknoten 46i bzw. 462 und jeweils zumindest einen Endknoten (NULL) 48i und 482 bzw. 483. Zwischen den Startknoten 46 und den Endknoten 48 sind Ablaufknoten oder Ausführknoten 52 angeordnet, wobei jeder Regelbaum 44i und 442 zumindest einen Ablaufknoten 52 umfasst. Zumindest jeder der Ausführungsknoten 52, optional der Startknoten 46 und ferner optional der Endknoten 48 kann einen der ausführbaren Ablaufteile 18 implementieren, so dass die dargestellten Knoten 52, 46 und möglicherweise 48 als Repräsentationen der Ablaufteile angesehen werden können. Jeder Knoten kann einen der ausführbaren Ablaufteile implementieren oder repräsentieren, die in dem Handlungsablauf enthalten sind. Alternativ oder zusätzlich kann ein Knoten auch eine Kombination mehrerer ausführbarer Ablaufteil repräsentieren.
Jeder Ausführknoten 52 ist mit zumindest einem vorangehenden Knoten durch eine entsprechende Verknüpfung 52 verknüpft und ist mit zumindest einem nachfolgenden Knoten über eine entsprechende Verknüpfung 54 verknüpft. So ist beispielsweise der Ausführungsknoten 52i des Regelbaums 44i mit dem Startknoten 46i über die Verknüpfung 54i verknüpft, was andeutet, dass ein Ausgang des Knotens auf einen nachfolgenden Knoten verweist, etwa unter Verwendung eines Pointers/Zeigers. Dieser nachfolgende Knoten kann seinerseits auf einen Speicherbereich zugreifen, in welchem ein Ergebnis des vo rangehenden Knotens hinterlegt werden kann. Unterschiedliche Ausgängen können Werte für unterschiedliche Pointer aufweisen, so dass bspw. in Abhängigkeit davon, welcher Ausgang des Knotens erreicht wird (bspw. wahr oder falsch, größer oder kleiner, etc.) unterschiedliche Pointer wirksam werden, d. h., unterschiedliche nachfolgende Knoten aufge rufen werden. Ein Knoten weist bspw. zwei Ausgänge auf, wobei jeder Ausgang über eine entsprechende Verknüpfung 542 bzw. 543 mit einem Ausführungsknoten 522 bzw. 52s verknüpft sein kann. Beispielsweise können die Ausgänge Ergebnisse einer O- der-Verknüpfung sein, so dass basierend auf dem jeweiligen Ergebnis der Oder- Verknüpfung eine Eingangsgröße an den Ausführungsknoten 522 oder 52a ausgegeben wird. Anders als Ausführungsknoten 52 weisen Startknoten 46 beispielsweise keine Verknüpfung zu einem vorangehenden Knoten auf, während Endknoten 48 ohne Verknüpfung zu einem nachfolgenden Knoten ausgeführt sein können. Bevorzugt weisen Ausführungsknoten 52 höchstens zwei Eingänge und höchstens zwei Ausgänge auf.
Jedem Ausführungsknoten 52, optional jedem Startknoten 46 und optional jedem Endknoten 48 kann dabei innerhalb des Handlungsablaufs 24 eine vordefinierte Kennung, etwa eine Knotennummer, zugeordnet sein, über die der durch den Knoten 52, 46 bzw. 48 ausführbare Ablaufteil eindeutig adressierbar ist. Der Prozessor der Vorrichtung kann ausgebildet sein, um jeden ausführbaren Ablaufteil der Vielzahl ausführbarer Ablaufteile über diese vordefinierte Knotennummer zu adressieren. Die Knotennummer kann beispielsweise einen Speicherbereich angeben, in dem die zu implementierenden Instruktionen und/oder die zu verarbeitenden Größen hinterlegt sind.
Obwohl die Regelbäume 44i und 442 so dargestellt sind, dass ein Vorgängerknoten stets einen Nachfolgerknoten referenziert, sind die vorliegenden Ausführungsbeispiele nicht hierauf beschränkt. Vielmehr können Knoten als Nachfolger auch einen direkten oder indirekten Vorgängerknoten eintragen oder mittels einer Verknüpfung referenzieren. Beispielsweise könnte der Ausführungsknoten 522 den Knoten 46i oder den Ausführungsknoten 52i referenzieren, das bedeutet, ein Ausgang des Knotens könnte auf einen Eingang des Knotens weisen oder auf den Knoten selbst. Über solche Konstrukte können sich beispielsweise Schleifen und Zähler (counter) realisieren lassen. Sobald ein Knoten als Ausgang einen Nullpointer aufweist, wie es beispielsweise für die Ausführungsknoten 522, 52b und 525 dargestellt ist, kann die Auswertung des Graphen durch einen Rücksprung aus der Funktion beendet werden. Beispielsweise kann ausgehend von den Knoten 48i oder 482 zum nächsten Regelbaum 442 gesprungen werden.
Der Prozessor kann konfiguriert sein, um die Vielzahl ausführbarer Ablaufteile des Handlungsablaufs von dem Startpunkt des Handlungsablaufs bis zu einem Ende des Handlungsablaufs auszuführen. Hierfür kann das Konfigurationssignal eine Information aufwei- sen, die den zumindest einen Startknoten des Handlungsablaufs definiert. Der Prozessor kann das Konfigurationssignal auf diese Größen auswerten. Der Startpunkt kann dabei der Startknoten 46i oder 462 sein, kann aber alternativ auch ein beliebiger anderer Knoten eines Regelbaums 44i oder 442 bzw. des Handlungsablaufs 24 sein.
In anderen Worten kann der Handlungsablauf durch einen oder mehrere Einzelgraphen oder Regelbäume implementiert sein. Ein einzelner Graph kann dabei einen Startknoten (First-Layer), von dem aus die Auswertung des Regelbaums beginnt. Ein einzelner Knoten weist dabei maximal zwei Ausgänge auf, die in Form von Pointern implementiert werden können, welche auf den nächsten auszuführenden Knoten zeigen. Sobald ein gewählter Ausgang auf 0, etwa ein Nullpointer, zeigt, kann die Auswertung des Graphen beendet sein. Das Programm, der Handlungsablauf, kann dabei aus mehr als einem Graphen bestehen. Jeder Graph kann einen eigenen, dem Graphen zugeordneten, Startknoten aufweisen, wobei die Graphen komplett separat aber auch miteinander verbunden sein können, etwa einen gemeinsamen Teilgraphen aufweisen können. Dies kann alternativ auch so verstanden werden, dass ein Regelbaum mehr als einen Startknoten aufweisen kann. Die Startknoten aller Graphen oder Regelbäume können beispielsweise in einer Art Main-Funktion des als konstant implementierten oder unveränderlichen Programmcodes nacheinander aufgerufen werden.
In anderen Worten kann der Handlungsablauf (Graph) oder ein Teil hiervon, der Regelbaum, aus unterschiedlichen Knoten bestehen, die verschiedene Aufgaben erfüllen und/oder Funktionsweisen repräsentieren. Der Graph muss dabei nicht zusammenhängend sein, vielmehr bilden alle miteinander verknüpften Knoten einen Regelbaum, der abgearbeitet wird. Der vollständige Handlungsablauf kann dabei aus mehreren unabhängig voneinander arbeitenden Regelbäumen bestehen bzw. hiervon repräsentiert werden. Im von der Vorrichtung ausgeführten Programmcode können periodisch, durch gegebenenfalls unterschiedliche Timer getriggert, die sogenannten Startknoten oder First-Layer- Knoten ausgewertet werden. Welche Knoten die Startknoten sind, kann dem Gerät durch ein entsprechendes Interface, etwa die Eingangsschnittstelle 12, mitgeteilt werden. Der weitere Ablauf des Programms kann ereignisbasiert von den Knoten selber bestimmt werden, da jeder einzelne Knoten eindeutig auf den als nächsten auszuwertenden Knoten zeigt und somit den Ablauf vorgibt. Die Auswertung eines Regelbaums terminiert, wenn der Zeiger des nächsten auszuwertenden Knotens auf eine Null-ID gesetzt wird, einen Endknoten 48. Fig. 5 zeigt ein schematisches Blockschaltbild eines Teils eines Regelbaums 44 gemäß einem Ausführungsbeispiel, wobei beispielhaft zwei ausführbare Ablaufteile 18i (a) und 182 (b) durch Ablaufknoten 52i bzw. 522 repräsentiert werden. Der Ausführungsknoten 52i weist zwei Eingänge 56i und 662 auf, über die mittels entsprechender Verknüpfungen 54i bzw. 542 Eingangsgrößen oder Eingangsinformationen von vorangehenden Knoten erhalten werden können. Ferner weist der Ausführungsknoten 52i zwei Ausgänge 58i und 682 auf, die über entsprechende Verknüpfungen 54s und 544 mit nachfolgenden Knoten verbunden sein können. So ist beispielsweise der Ausgang 582 mittels der Verknüpfung 54 mit einem Eingang 56s des Ausführungsknotens 522 verbunden. Der Ablaufknoten 522 kann darüber hinaus einen weiteren Eingang 564 aufweisen, der über eine Verknüpfung 54s mit einem anderen Knoten verknüpft ist. Der Ablaufknoten 522 kann einen oder zwei Ausgangsknoten 583 und/oder 584 aufweisen, um entsprechend Ausgangsgrößen über Verknüpfungen 54e bzw. 547 bereitzustellen.
Die Ausgänge 58i bis 584 können jeweils als Ausgangspointer der jeweiligen Knoten verstanden werden und bspw. als Pointer zu den Index-Nummern nachfolgender Knoten implementiert werden, welche bspw. im, in Zusammenhang mit Fig. 9a erläuterten „next_t/f‘-Feld des Knoten gespeichert sind. Die Pointer können den nächsten Auszuführenden Knoten angeben. In den hierein erläuterten Ausführungsbeispielen können deshalb sämtliche Verbindungen, welche den Ausgang eines Knotens repräsentieren als Pointer verstanden werden.
Die Ausführungsknoten 52i und 522 können voneinander verschiedene aber auch gleiche oder identische Funktionen implementieren, etwa indem im vorliegenden Fall gilt, dass a = b, das bedeutet, die Ablaufteile 181 und 182 sind von gleicher Art oder dem gleichen Typ zugehörig. Dem Ablaufknoten 52i kann eine Knotennummer 62i eindeutig zugeordnet sein. Ebenso kann eine Knotennummer 622 dem Ablaufknoten 522 eindeutig zugeordnet sein, so dass auch bei gleicher oder identischer Funktion der Ablaufknoten 52i und 522 beide unterscheidbar und separat adressierbar sind.
Es können mehrere Arten von Knoten implementiert sein, die Obergruppen von Knoten definieren. Von jeder Art kann es unterschiedliche Ausführungen mit spezifischen Funktionen geben, die anhand der Fig. 6a bis 6d beispielhaft und nicht erschöpfend beschrieben sind. Fig. 6a zeigt ein schematisches Blockschaltbild einer Verschaltung eines Ablaufknotens 52 in einem Regelbaum gemäß einem Ausführungsbeispiel. Eingänge 56i und 562 können mit unterschiedlichen Speicherbereichen 64i und 642 über Verknüpfungen 54i und 542 verbunden sein, wobei die Speicherbereiche 64i und 642 beliebige Bereiche in den Datenspeichern 16, 34 oder 36 sein können, die entsprechende Eingangsgrößen für den Knoten 52 bereitstellen. Knoten eines Graphen können eine Funktion implementieren, die eine Verarbeitung mindestens einer Eingangsgröße des entsprechenden ausführbaren Ablaufteils definiert. Der Ablaufknoten 52 der Fig. 6a ist dabei so ausgeführt, dass die Funktion eine Vergleichsoperation ist, das bedeutet, ein Operator des Knotens 52 kann in den Speicherbereichen 641 und 642 hinterlegte Werte vergleichen. Der Vergleichsoperator kann beispielsweise einen Größer-Vergleich (x>y), einen Kleiner-Vergleich (x<y), einen Gleich-Vergleich (x=y bzw. x==y), einen Ungleich-Vergleich (x<>y bzw. x!=y), weitere Vergleiche oder Kombinationen hieraus umfassen.
An den Ausgängen 58i und 582 können Zeiger (Pointer) ausgegeben werden, die mittels der entsprechenden Verknüpfungen 54s bzw. 544 auf einen nachfolgenden Knoten weisen, für den Fall, dass das Ergebnis des Operators erfüllt ist (true) oder nicht erfüllt ist (false).
In anderen Worten zeigt Fig. 6a einen Vergleichsknoten. Werte in zwei Speicherbereichen können mit logischen Operatoren (UND, ODER, XODER) und/oder mit Negationen derselben oder mathematischen Operatoren, etwa <, s, ==, ... , verglichen werden. Der Kon- trollfluss, d. h. der nächste auszuwertende Knoten, wird durch das Ergebnis des Vergleichs beeinflusst.
Fig. 6b zeigt eine schematische Darstellung einer Verknüpfung eines Ablaufknotens 52 in einem Regelbaum, wobei die implementierte Operation eine Arithmetik-Operation ist. Hierzu gehören beispielsweise Addition, Subtraktion, Multiplikation oder Division. Mittels des implementierten Operators können die Werte in den Speicherbereichen 64i und 642 verknüpft werden, so dass ein Ergebnis mittels der Verknüpfung 54a einem nachfolgenden Knoten bereitgestellt werden kann. Beispielsweise kann das Ergebnis in einem weiteren Speicherbereich hinterlegt werden und mittels der Verknüpfung 54a ein Zeiger auf diesen Speicherbereich übermittelt werden.
In anderen Worten zeigt Fig. 6b einen Arithmetik-Knoten. Mit Werten in zwei Speicherbereichen können arithmetische oder mathematische Operationen ausgeführt werden, z. B. +, -, x, /, Modulo, Betrag und dergleichen. Das Ergebnis wird in einem separaten, dem Knoten zugeordneten und von außen adressierbaren Speicherbereich bereitgestellt. Ein einzelner Pointer gibt hier den Kontrollfluss, sprich den nächsten auszuwertenden Knoten, an. Es wird noch einmal darauf hingewiesen, dass jedem Knoten, sofern es erforderlich ist, ein Speicherbereich zugewiesen sein kann, wo das zugeordnete Ergebnis gespeichert werden kann, bspw. das„res“-Fe!d in der Struktur gemäß Fig. 9a. Genau dieser Speicherbereich kann in einem anderen Knoten als Eingang gesetzt werden, um das Ergebnis weiterzureichen, was bspw. dann erfolgt, wenn die Index-Nummer des Knotens als Input eines anderen Knotens gesetzt wird. Die Eingänge und Ausgänge der Knoten können damit vollständig unabhängig voneinander sein.
Fig. 6c zeigt eine schematische Darstellung einer Verknüpfung des Ablaufknotens 52 in dem Regelbaum, bei dem die implementierte Funktion eine Speicheroperation ist, das bedeutet, der Knoten 52 speichert einen Wert des Speicherbereichs 64i und/oder 642 in einem anderen Speicherbereich und übermittelt mittels der Verknüpfung 54a an dem Ausgang 58 einen Zeiger, der auf den Speicherbereich verweist, in dem der Wert gespeichert ist. Eine Eingangsgröße kann in den Speicherbereich der anderen Eingangsgröße oder in den Ausgangsknoten geschrieben werden.
In anderen Worten zeigt Fig. 6c einen Speicherknoten. Der Wert aus dem Speicherbereich 1 wird in einem dedizierten, dem Knoten zugeordneten und von außen adressierbaren Speicherbereich gespeichert. Alternativ kann der Wert aus Speicherbereich 1 an die Adresse von Speicherbereich 2 geschrieben werden, ohne Rücksichtnahme auf den darin enthaltenen Wert. Beide Speicheroperationen können auch kombinatorisch ausgeführt werden. Ein Speichern in dem Speicherbereich 2 kann dafür genutzt werden, um Vergleiche mit alten Werten durchzuführen. Ein einzelner Pointer kann den Kontrollfluss angeben, sprich den nächsten auszuwertenden Knoten.
Fig. 6d zeigt eine schematische Darstellung des Ablaufknotens 52 gemäß einem Ausführungsbeispiel, bei dem mittels Verknüpfungen 54i und 542 erhaltene Informationseingänge, etwa direkt oder durch Zugriff auf Speicherbereiche 64, in einer auszuführenden Aktion münden, beispielsweise einer Ansteuerung der Peripherie, die über den Ausgang 58 ausgegeben wird.
In anderen Worten zeigt Fig. 6d einen Aktionsknoten. Ein Aktionsknoten kann sich von den anderen Obergruppen an Knoten dadurch unterscheiden, dass hier keine Auswertung von Operationen auf Speicherbereichen stattfindet. Dieser Knoten kann dazu genutzt werden, Funktionen im Programmcode aus einer Liste von möglichen wählbaren Funktionen aufzurufen, wobei die Auswahl an Funktionen, die das Gerät aufweist, hardwarespezifisch oder gerätespezifisch sein kann. Über das Interface kann sichergestellt werden, dass die wählbaren Aktionsknoten zu den Device-Funktionen passen. Die im Programmcode aufgerufenen Funktionen sind sogenannte normale implementierte Funktionen und können demnach für alle möglichen Funktionen genutzt werden, etwa das Steuern von Aktuatoren, das Setzen von Variablen und Speicher, eine Kommunikation nach außen und dergleichen. Ein einzelner Pointer kann den Kontrollfluss vorgeben, sprich den nächsten auszuwertenden Knoten.
Fig. 7 zeigt eine beispielhafte Darstellung von Computer-implementierten Instruktionen, das bedeutet Code, zur beispielhaften Darstellung unterschiedlicher durch Knoten implementierter Funktionen. So sind beispielhaft 15 unterschiedliche Arithmetik-Funktionen unter Verwendung zweier Eingangsgrößen a, b definiert, die durch eine Funktions- Identifikation 661 bis 6615 voneinander unterscheidbar sind. Zu den Arithmetik-Funktionen gehört beispielhaft die Addition, die Subtraktion, die Multiplikation, die Division, die Abso- lut-Summe der Einzelbeträge von a, b, die Halb-Absolut-Summe unter Verwendung des Betragswerts des Operators a oder b, die Absolut-Differenz als Differenz der Betragswerte, die Halb-Absolut-Differenz unter Verwendung lediglich eines Betragswerts, die Ziffer 1- Norm-Summe als Betrag der Addition, die Ziffer 1 -Norm-Differenz als Betrag der Differenz, die Absolut-Multiplikation, das bedeutet der Betrag der Multiplikation, die Halb- Absolut-Multiplikation unter Verwendung lediglich eines Betragswerts der Operatoren a oder b, die Absolut-Division, d. h. der Betrag der Division sowie der Modulo-Operator mod.
Es wird deutlich, dass jeder Knoten, unabhängig davon, welche Funktion implementiert wird, eine Handlungsvorschrift beschreibt, wie mit Eingangsgrößen und/oder Ausgangsgrößen umzugehen ist.
Darüber hinaus werden beispielhaft 12 Vergleichsfunktionen mit den Funktions-IDs 16 bis 27 definiert, die einen Gleich-Vergleich, einen Nicht-Gleich-Vergleich (Ungleich), einen Kleiner-Vergleich, einen Kleiner-Gleich-Vergleich, einen Betrags-Gleich-Vergleich, einen Halb-Betrags-Gleich-Vergleich, einen Nicht-Betrags-Gleich-Vergleich, einen Betrag-Nicht- Gleich-Vergleich, einen Betrag-Kleiner-Betrag-Vergleich, einen Betrag-Kleiner-Vergleich, einen Betrag-Kleiner-Gleich-Betrag-Vergleich und/oder einen Betrag-Kleiner-Gleich- Vergleich umfassen können.
Darüber hinaus können beispielhaft 9 Logik-Funktionen, die auch den Vergleichs- Operationen zugerechnet werden können, definiert werden. Die Funktions-IDs 6628 bis 6636 (vorher 66« bis 6627) beschreiben dabei Funktionen der Verknüpfung als logisches Und, logisches Oder, logisches Exklusiv-Oder (XOR), einseitig verneintes Und, einseitig verneintes Oder, einseitig verneintes Exklusiv-Oder, beidseitig verneintes Und, beidseitig verneintes Oder sowie beidseitig verneintes Exklusiv-Oder.
Alternativ oder zusätzlich können weitere Funktionen definiert werden. Beispielhaft können, wie es für die Funktions-IDs 6637 bis 6639 dargestellt ist, eine Negation (!a), das Setzen auf den Wert wahr (true) durch a&&1 bzw. Setzen auf den Wert falsch (false) durch a&&0 ausgeführt werden. Derartige Funktionen oder Logik-Operationen können auch für den Operator b ausgeführt werden. Die Funktions-IDs 6637, 663s und 6639 können beispielhaft Funktionen beschreiben, die unter Verwendung lediglich einer Eingangsgröße erfolgen und somit Knoten zugeordnet sind, die lediglich einen Eingang aufweisen. Ebenso können die Arithmetik-Funktionen mit den IDs 661 bis 66« lediglich einen Ausgang aufweisen.
Eine Art oder Funktion des ausführbaren Ablaufteils der Vielzahl ausführbarer Ablaufteile kann durch fünf Parameter eindeutig definiert werden. Diese Parameter können in dem Konfigurationssignal enthalten sein. Vorteilhaft stellt sich die Verwendung von Integer- Zahlen dar, da diese einen geringen Speicherbereich aufweisen und gleichzeitig einen ausreichend hohen Wertebereich aufweisen. Gemäß alternativen Ausführungsbeispiele kann zumindest einer der Parameter anders als eine Integer-Zahl definiert werden. Die fünf Parameter können ausreichen, um die Art des ausführbaren Ablaufteils eindeutig zu definieren. Einer der Parameter, etwa die Funktions-ID, kann die Funktion des ausführbaren Ablaufteils definieren. Ein zweiter und ein dritter Parameter kann einen ersten bzw. zweiten Speicherbereich, der mit dem ersten bzw. zweiten Eingang des ausführbaren Ablaufteils assoziiert ist, definieren. Beispielsweise kann in dem Konfigurationssignal angegeben werden, welche der Speicherbereiche 64i und/oder 642 mit dem jeweiligen durch den Ablaufknoten 52 implementierten Ablaufteil durch die entsprechenden Verknüpfungen 54i bzw. 542 verknüpft sind, etwa durch Ausgestaltung der Verknüpfungen 54 als Zeiger (Pointer). Ein vierter und fünfter Parameter können entsprechende Speicherbereiche definieren, die mit den Ausgängen 58i und/oder 582 bzw. 58 assoziiert sind. Der Generator 22 kann ausgebildet sein, um die Integer-Zahlen, die die fünf bzw. sechs Parameter des
Knotens wiedergeben, jeweils mit einem Speicherbereich des Datenspeichers eindeutig zu assoziieren. Dies ermöglicht die Sicherstellung, dass jeder Knoten auf einen ihm zugewiesenen Datenspeicherbereich zugreift, um Eingangsgrößen zu erhalten oder Ausgangsgrößen zu hinterlegen
Unbenötigte Parameter, etwa wenn nur einer der Ausgänge benötigt wird, können ausgelassen werden oder zu 0 gesetzt werden. Der Generator kann ausgebildet sein, um das Konfigurationssignal auf die entsprechenden Parameter zu überprüfen. Die entsprechenden Parameter, insbesondere die Integer-Zahlen, können jeweils mit einem Speicherbereich des Datenspeichers 16 eindeutig assoziiert werden, so dass es hinreichend ist, lediglich den Speicherbereich anzugeben, der die weiteren zu implementierenden Informationen angibt. Insofern kann die in dem Konfigurationssignal enthaltene Information 26 eine Sequenz von Integer-Zahlen aufweisen, was eine geringe Datenmenge darstellt, die zu übertragen ist.
In anderen Worten zeigt Fig. 7 eine beispielhafte Zuweisung von Knotentypen oder Funktionen an Funktions-IDs 66.
Fig. 8 zeigt eine beispielhafte Darstellung von Code, der Instruktionen wiedergibt, die den Generator 22 der Vorrichtung 10 oder die Steuereinrichtung 38 der Vorrichtung 30 anweisen, das Konfigurationssignal 14 auf die Funktions-ID 66, die im Zusammenhang mit der Fig. 7 beschrieben ist, auszuwerten. Der Generator kann ausgebildet sein, um die in dem Konfigurationssignal enthaltenen Parameter auszuwerten und abhängig von deren Wert den Graphen zu konfigurieren. So kann bspw. der Knoten mit ID i darauf ausgewertet werden als welcher Knotentyp er konfiguriert wird, hier gibt conf_typ[i] den Typen an, siehe Zeile 6. Weitere Eigenschaften des Knotens, etwa Eingänge und/oder Ausgänge und/oder Speicherbereiche zum Speichern von Ergebnissen können ebenfalls festgelegt werden, siehe Zeile 7ff. Fig. 9a zeigt eine beispielhafte Darstellung von Code zur Definition einer Knotenstruktur und somit einer Struktur, der die ausführbaren Ablaufteile 18 folgen. Mit„int16_t“ bzw.„uint16_t“ können vorzeichenbehaftete bzw. ohne Vorzeichen versehene 16-Bit-wertige Integer-Zahlen bezeichnet werden, die dazu verwendet werden, ein Ergebnis (res), Eingangsgrößen (inp_1 , inp_2) sowie Verweise oder Pointer/Zeiger auf nachfolgende Knoten für den Fall eines positiven (true) oder negativen (false) Ergebnisses (next_t, next_f) zu definieren, worauf bereits im Zusammenhang mit Fig. 5 eingegangen wurde. Alternativ oder zusätzlich kann unter„typ“ angegeben werden, um welche Art von Knoten es sich bei dem vorliegenden Knoten handelt. Es wird deutlich, dass die jeweiligen Speicherbedarfe an die Anzahl unterschiedlicher Werte anpassbar ist, so kann beispielsweise der Parameter typ mit 8-Bit-lnteger-Zahlen hinreichend beschreibbar sein, während anderenfalls vorzeichenbehaftete bzw. vorzeichenunbehaftete, d. h., vorzeichenneutrale 16-Bit-l nteger-Zahlen verwendet werden können. Prinzipiell kann eine Zuweisung eines Speicherbereichs für den entsprechenden Parameter an den tatsächlichen Bedarf angepasst sein. Obwohl in Fig. 9a insgesamt sechs Eigenschaften definiert werden, kann ein Knoten eindeutig durch lediglich fünf dieser Eigenschaften definiert oder festgelegt werden. Der sechste, für die eindeutige Definition nicht erforderliche Parameter in der Knotenstruktur kann das das Ergebnis der Operation durch den Knoten beschreiben und ist beispielhaft durch das„res"-Feld angegeben. Das Ergebnis muss bei der Definition des Graphen nicht von außen vorgegeben werden, es kann sich bspw. bei der Ausführung des Knotens ergeben. Von daher werden nur fünf Parameter zur Definition benötigt, auch wenn in der Knoten Struktur sechs Variablen vorhanden sind.
In anderen Worten können die Knoten des Graphen (Regelbaums) als Struktur (struct) im Programm repräsentiert werden. Die Struktur kann die Variable„typ“ oder gleichbedeutend enthalten, welche die Art des Knotens festlegt. Die Variable„res" speichert beispielsweise das Ergebnis einer Rechenoperation oder eines Vergleichs und die Variablen „input_1/input_2“ sowie„next_t/next_f“ fungieren im Grunde genommen als Pointer für die Eingangsvariablen und den nächsten auszuführenden Knoten. In der Implementierung kann hier aus Speichereffizienz anstelle eines Pointers ein Integer-Wert verwendet werden. Dies ist möglich, weil die Anzahl der maximal verwendbaren Knoten und Variablen begrenzt ist und a priori festgelegt wird, d. h. vordefiniert ist. Der Nullpointer kann hierbei durch die größte darstellbare Zahl des Datensystems repräsentiert sein.
Der Datentyp„Knoten“ kann so definiert werden, dass er sich zusammensetzt aus
• uint typ; eine Zahl, die die Art des Knotens festlegt;
• int res; ein Ergebnis der Berechnung, falls vorhanden oder erzeugt;
• uint Snpi ; eine Index-Nummer für einen ersten Eingang;
• uint inp2; eine Index-Nummer für den zweiten Eingang;
• uint out ; eine Index-Nummer für einen ersten Ausgang des Knotens; und
• uint out_f; eine Index-Nummer für den zweiten Ausgang. Arithmetik, Aktions- und Speicherknoten können lediglich einen der beiden Ausgänge verwenden, etwa out_t, so dass beispielsweise out_f auf NULL-ID gesetzt werden kann.
Da der Speicherbereich der Vorrichtung begrenzt ist, kann eine vordefinierte Anzahl von Knoten, Variablen und Aktionen existieren. Alle können in Form von Arrays organisiert vorliegen und hintereinander im Speicher angeordnet sein. Dies ermöglicht eine eindeutige Adressierung über eine Integer-Zahl, die als Index-Nummer bezeichnet werden kann. Die Index-Nummern lassen sich verwenden wie allgemeine Pointer und können allgemein als solche gesehen werden, diese Art der Implementierung spart lediglich Ressourcen am Adressieren von Speicherbereichen. Analog zu einem Nullpointer kann eine Null-ID existieren.
Bezugnehmend auf Fig. 9b kann beispielsweise die maximale Anzahl von Knoten (MAX_KNOTS), die maximale Anzahl von Variablen (MAX_VARS), die Anzahl von Sensoren (N_SENSOREN), die Anzahl von Aktionen (N_AKTIONEN), die Anzahl von Knoten einer ersten Schicht oder Layer, also bspw. Einsprungsknoten in einen Graphen oder Regelbaum, (N_First_Layer), NULLJD, d. h. der Nullpointer, und beliebige andere Variablen definiert werden, etwa Unterscheidungen, ob es sich um einen Arithmetikknoten zum Ausführen einer Arithmetikoperation handelt (IS_ARI) und/oder ob es sich um einen Vergleichsknoten zum Ausführen einer Vergleichsoperation (IS_VGL) handelt.
Bei der beispielhaften Verwendung eines Micro-Controller als Prozessor 31 oder Steuereinrichtung 38 in einer 32-Bit-Konfiguration kann ein entsprechender Pointer ebenfalls 32 Bit im Speicher benötigen. Durch die Implementierung als Integer-Wert mit beispielsweise 16 Bit können so in jedem Knoten 4*16 Bit, d. h. 8 Byte eingespart werden. Dies ist insbesondere dann von Vorteil, wenn insgesamt weniger als 216 Knoten, Variablen und Aktionen verwendet werden. Der Vorteil ist jedoch auch dann zu erzielen, wenn eine Datenreduktion anderer Kategorie vorgenommen wird, beispielsweise bei Verwendung eines 64- Bit-Controllers, für den 32-Bit-Variablen verwendet werden. Bei dem Durchnummerieren werden die ersten Eingänge beispielsweise als Knoten dereferenziert (bzw. der Speicherbereich des„res“-Feldes eines Knotens), alles darüber oder danach sind dann beispielsweise die Sensoren, dann Aktionen, alles darüber wird als Variablen behandelt. Dies kann sich aus der in Fig. 9b dargestellten Reihenfolge ergeben, in der nacheinander die Knoten, Variablen (VARS), Sensoren und Aktionen. Die dargestellte Reihenfolge ist dabei beliebig oder willkürlich. Es ist jedoch erforderlich, dass sie einmal festgelegt wird und anschließend identisch bleibt bzw. eingehalten wird. Der dadurch erhaltene Informationsgewinn kann somit innerhalb des Konfigurationssignals 14 eingespart werden, da die Struktur beidseitig bekannt ist.
Eine derartige Konfiguration ist beispielsweise in der Fig. 9c dargestellt, die einen beispielhaften Code für eine derartige Strukturierung angibt. So kann beispielsweise definiert werden, dass alle Knotentypen unterhalb des zuvor festgelegten Wertes T_SEN Knoten sind. Werte T_SEN Knoten sind. Werte ä T_SEN und < T_AKT sind Sensoren. Von diesem Wert ausgehend sind alle Werte von a T_AKT und < T_THR Aktionen. Alles Darüber hinaus gehende, das bedeutet a T_THR, sind Variablen. T_MAX gibt dabei die maximal mögliche Zahl im System an.
In anderen Worten kann die„typ“-Variable im Knoten-struct (der Definition der Struktur) festlegen, was genau der Knoten zu tun hat, sobald er aufgerufen wird. Hierüber kann auch die Art des Knotens festgelegt werden, etwa als Arithmetik-Knoten, in dem die ID 661 bis 6615 verwendet wird, die im Zusammenhang mit der Fig. 7 erläutert ist. Die Art der Knoten kann sich in verschiedene Gruppen aufteilen lassen. Zum einen können Arithmetik-Knoten implementiert sein, die für arithmetische Rechenoperationen wie z. B.„+“ oder „*“ eingerichtet ist. Hierbei werden die Werte der beiden Input-Speicherbereiche, der Eingänge, verwendet und das Ergebnis der Operation im„res“-Feld des Knoten-structs gespeichert. Alternativ oder zusätzlich kann es Vergleichs-Knoten geben, die für Vergleiche wie z. B.„<“,„==“ und/oder logische Operationen wie z. B.„UND“ eingerichtet sind. Auch hier können die Werte der beiden Input-Speicherbereiche verwendet und das Ergebnis der Operation im„res“-Feld gespeichert werden. Dies lässt jedoch auch Ausnahmen zu, beispielsweise eine Negation oder einen Vergleich auf„true“ bzw.„false“ (wahr/falsch), da diese nur eine Input-Variable verwenden.
Alternativ oder zusätzlich können einer oder mehrere Speicherknoten definiert werden, die den Wert an der Adresse eines der Eingänge verwenden und diesen beispielsweise an die Adresse des anderen Eingangs oder in ein extra hierfür vorgesehenes„res“-Feld schreiben, wie es beispielsweise im Zusammenhang mit der Fig. 6c beschrieben ist. Speicherknoten können beispielsweise benutzt werden, um Sensorwerte (die sich über die Zeit ändern können) zu speichern. Alternativ oder zusätzlich können Aktions-Knoten vorgesehen sein, die dazu verwendet werden können, vorher implementierte Funktionen im Programmcode aufzurufen. Die beiden Input-Variablen können dabei als Übergabepa- rameter für die aufgerufene Funktion dienen, wobei dies optional ist. Aktions-Knoten können relevant sein, um komplexere Programmstrukturen zu ermöglichen. So kann beispielsweise das Senden eines Werts über einen Aktions-Knoten repräsentiert werden. Die verfügbaren Aktionen sind dabei zum Teil Hardware-abhängig, da eine Vorrichtung zum Senden einer WLAN-Nachricht ein WLAN-Modul erfordert. Die Aktions-Knoten können demzufolge für die verwendete Hardware speziell implementiert oder eingerichtet sein. Sämtliche vom Benutzer gewünschten im Programmcode auf ruf baren Funktionen können mit einem jeweils zugeordneten Aktions-Knoten verknüpft werden und durchnummeriert werden, etwa unter Verwendung einer entsprechenden Kennung, die mit der Funktions-ID vergleichbar ist. Eine Aktion mit einer gewissen Nummer entspricht dann immer derselben Funktion im eigentlichen Programmcode und diese wird aufgerufen, sobald im Graphen ein Aktions-Knoten mit der entsprechenden Kennung, die über das„typ“-Feld repräsentiert werden kann, aufge rufen oder getriggert wird.
Die maximale Anzahl an Knotentypen kann durch den Zahlenbereich der Variable„typ" in der Knotenstruktur begrenzt sein, siehe beispielsweise Fig. 9a. Alle Werte, die nicht für Arithmetik-, Logik- oder Speicherknoten verwendet werden, können mit einer Aktion assoziiert werden. Um zu jedem Zeitpunkt eine T uring-Vollständigkeit zu gewährleisten, können beispielsweise mindestens Knoten für Addition (+), Subtraktion (-), Vergleiche (==) und ein Speicherknoten implementiert sein.
Fig. 10a zeigt einen beispielhaften Code, bei dem in Zeile 2 eine maximale Anzahl von Knoten des Handlungsablaufs definiert wird, was dazu führt, dass die Liste an Knoten eine innerhalb dieser Konfiguration stets gleiche Länge aufweist. In Zeile 5 wird eine Liste von Aktionen für den Knoten definiert. In Zeile 8 wird eine Liste von Knoten in einem ersten Layer (First-Layer) definiert, worauf später eingegangen wird. In Zeile 1 1 werden unterschiedliche Variablen, etwa Schwellwerte oder Zwischenspeicher, definiert. In Zeile 14 werden Sensorwerte definiert.
Wie bereits erwähnt, ist die Anzahl der maximal möglichen Knoten und Aktionen sowie Sensoren und Variablen (wobei Sensoren effektiv als„read-only“ (Nur-Lesen-) Variablen interpretiert werden können), a priori vorgegeben. Deshalb kann vor Beginn der Main- Funktion der Speicherbereich für die entsprechenden Strukturen allokiert, das bedeutet assoziiert werden. Die gerade erwähnten First-Layer-Knoten oder Startknoten können ein wichtiges Element für die Auswertung der auf der Vorrichtung implementierten Handlungsabläufe sein. Eine Liste an Pointern auf die Knoten-Struktur kann dazu verwendet werden, um die Startknoten festzulegen, wie es in Zeile 8 des Codes in Fig. 10a beschrieben ist. Der Startknoten kann beispielsweise ein Knoten 46, des jeweiligen Regelbaums 44 sein, wie es im Zusammenhang mit Fig. 4 beschrieben ist.
Fig. 10b zeigt einen beispielhaften Code, der anzeigt, dass eine Knotennummer i bis zu einer maximalen Anzahl N_ACTIVE_FL von Knoten oder Aktionen der Graph vollständig durchlaufen wird und der entsprechende Knoten ausgeführt wird (doKnot).
Der Generator einer erfindungsgemäßen Vorrichtung kann ausgebildet sein, um den Handlungsablauf so zu erstellen, dass dieser zumindest einen Startknoten, an dem der Handlungsablauf durch den Prozessor begonnen wird, umfasst. Für den Fall, dass der Handlungsablauf mehrere Regelbäume umfasst, kann für jeden Regelbaum ein solcher Startknoten vorgesehen sein. Der Prozessor ist ausgebildet, um den zumindest einen Startknoten periodisch auszuwerten, um ein Auswertungsergebnis zu erhalten. Das bedeutet, jeder Regelbaum wird an dem entsprechend zu geordneten Startknoten periodisch begonnen. Der Prozessor kann dabei ausgebildet sein, um die Vielzahl ausführbarer Ablaufteile des Handlungsablaufs von dem Startpunkt, d. h. dem Startknoten des Handlungsablaufs, bis zu einem Ende des Handlungsablaufs auszuführen, wie es beispielsweise in Fig. 4 dargestellt ist.
Auch Fig. 10c, die einen beispielhaften Code zum Ausführen durch den Prozessor darstellt, zeigt dies. Ein empfangener Wert k wird ausgewertet, wobei der Wert k beispielsweise einen Pointer auf den Knoten, welcher gerade ausgeführt werden soll, repräsentiert. Mit dem
Figure imgf000028_0001
Operator können die Werte aus dem zugehörigen Knoten gelesen werden. Der Ausdruck„k->typ“ kann bspw. den Typen des Knoten zurückgeben, d. h., in den Zeilen 3, 7 und 12 erfolgt bspw. eine Auswertung des Typs des Knotens. Der Ausdruck„k- >inp_1“ in Zeile 14 steht beispielhaft dafür, die Index Nummer des ersten Eingangs zu enthalten. Der Wert des Eingangs kann durch die Funktion ,,getlnput(...)“ in den Zeilen 14 und 15 bereitgestellt werden, welche die Index-Nummern der Eingänge in die zugehörigen Werte überführt. Analog kann die Funktion„getPointer(...)‘‘ in Zeile 10 funktionieren; diese nimmt die Index-Nummer des Ausgangs („k->next_t“ oder„k->next_f“) und liefert den zugehörigen Pointer auf den nächsten Knoten. Wird durch die„typ“ Variable in„k“ festgestellt, dass es sich um eine Aktion handelt, so wird die zugehörige Aktion nicht über den Wert„k“ abgerufen, sondern über den Wert„k- >typ“, da jede Aktion eindeutig über die Typnummern festgelegt ist. Eine entsprechende Ausgestaltung kann bspw. dadurch erhalten werden, dass in Übereinstimmung mit den Ausführungen im Zusammenhang mit Fig. 7 und Fig. 10d Knoten dergestalt definiert werden, dass Werte von k mit 64 und größer durchzuführende Aktionen definieren. Die in der Zeile 7 durchgeführte Überprüfung unterscheidet also, ob es sich um eine Aktion handelt, wenn der Wert k zumindest 64 beträgt, wobei beliebige andere Ausgestaltungen möglich sind. Der Rückgabewert der Funktion (welche mit der Aktion verknüpft ist), wird hier beispielhaft nicht betrachtet. Bei dem Pointer, welcher in der angegebenen Zeile 10 zurückgegeben wird, handelt es sich um den Pointer auf den nächsten Knoten, welcher durch den oben beschriebenen Mechanismus bereitgestellt wird.
Handelt es sich im angegebenen Beispiel um keinen Aktionsknoten, kann eine entsprechende Verarbeitung erfolgen, wie es in den Zeilen 12 ff. beschrieben ist. In Zeile 17 ist dargestellt, dass ein als Speicherknoten vorgesehener Knoten als Sonderfall behandelt werden kann, bei dem der Wert 1 in das„res“-Feld geschrieben wird, siehe Zeile 19, oder in den Speicherbereich des anderen Eingangswerts, siehe Zeilen 21 und 22.
In anderen Worten können die Startknoten in der Main-Funktion des Programmcodes der Reihe nach ausgewertet werden. Diese Routine kann dabei immer identisch sein, unabhängig von den Graphen, die dann die eigentliche Funktionalität des Geräts bereitstellen. Dadurch kann gewährleistet werden, dass der Programmcode im EEPROM, d. h. dem Datenspeicher 16, unverändert bleiben kann, selbst wenn das Gerät umprogrammiert wird. Die Funktion, welche die Knoten auswertet, ist ebenfalls immer identisch und fest im Programmcode vergossen, das bedeutet im Datenspeicher 16 hinterlegt. Sie kann beispielsweise initial von der Main-Funktion für die Startknoten aufgerufen werden und sich dann an den Output-Pointern der einzelnen Knoten entlanghangeln, bis das Ende des Graphen (Nullpointer bzw. Knoten 48) erreicht wird. Dabei kann der Prozessor ausgebildet sein, um einen auszuführenden Knoten danach auszuwerten, um welchen Typen es sich handelt und um dann die entsprechende mit dem Knoten verknüpfte Operation auszuführen, wie es anhand von Fig. 10d beschrieben ist.
Fig. 10d zeigt eine beispielhafte Darstellung von Code, der Instruktionen wiedergibt, die den Prozessor 31 der Vorrichtung 10 oder die Steuereinrichtung 38 der Vorrichtung 30 anweisen, das Ergebnis der Auswertung des Knotentyps (k->typ) aus Fig. 10c weiterzu- führen. Dort wird bspw. festgestellt, dass es sich um keinen Aktionsknoten handelt, Zeile 12 in Fig. 10c, und mittels„switch (k-> typ) in die konkreten Auswertung gewechselt. Durch die Auswertung (case), welche Funktions-ID 661 bis 66x angegeben ist, wird daraus inhärent angegeben, welche der im Zusammenhang mit Fig. 7 dargestellten Funktionen implementiert wird. Der Ausdruck„k->res“ gibt dabei an, dass ein Ergebnis res aufgrund der nachfolgend definierten Funktion erhalten wird.
Bei dem Ausführen des Handlungsablaufs kann die Steuereinrichtung 38 oder der Prozessor 31 den Knoten bzw. die Funktion dahin gehend auswerten, um welchen Typen es sich handelt und dann die entsprechende mit dem Knoten verknüpfte Operation ausführen.
In anderen Worten können Ergebnisse des Knotens bzw. der Funktion im„res“-Feld der Struktur hinterlegt werden. Wird ein Knoten als Eingang von einem anderen Knoten gesetzt, so liest der dahinter liegende Knoten den Speicherbereich des„res“-Feldes von dem Eingangsknoten aus. Dadurch können Ergebnisse durch simple Verknüpfung von Knoten im Graphen weitergereicht werden.
Nachdem die Auswertung eines einzelnen Knotens abgeschlossen ist, kann der nachfolgende Knoten ausgewertet werden. Dabei ist bei einigen Knoten der Nachfolger anhängig vom Ergebnis des „res“-Feldes des Vorgängerknotens, insbesondere bei Vergleichen sowie logischen Operationen, was in Fig. 10e illustriert ist, die einen beispielhaften Code anzeigt, bei dem für den Fall des Knotentyps als arithmetischer Knoten (IS_ARI) der Pointer für den nächsten Knoten abgerufen wird, siehe Zeile 4. Für den Fall eines Vergleichsknotens (IS_VGL) wird der Pointer abhängig von dem erhaltenen Ergebnis true/false erhalten, siehe Zeilen 9 bis 12. Das bedeutet, wird der nächste auszuführende Knoten bestimmt.
Ausführungsbeispiele der vorliegenden Erfindung basieren auf der Erkenntnis, dass der Graph zur Laufzeit der Vorrichtung neu konfiguriert werden kann, um beliebige Funktionen oder Programme zu repräsentieren, das bedeutet, eine Flexibilität der Vorrichtung zu erhalten. Da die Strukturen für die Knoten, Aktionen und Variablen für eine Hardware fest sein können und zur Laufzeit im flüchtigen Speicher liegen, kann es ausreichend sein, diese der Reihe nach richtig zu verknüpfen und zu konfigurieren, um ein neues Programm zu repräsentieren. Derartige Informationen können in dem Konfigurationssignal angegeben werden. Als Initialisierung können beispielsweise alle Knoten auf Typ 0, d. h. nicht initialisiert, gesetzt werden. Dies kann beispielsweise über ein hierfür geeignetes Event, das bedeutet eine entsprechende Anweisung, etwa von einer zentralen Steuereinrichtung oder einem Server ausgesendet, angesteuert oder getriggert werden. Jeder Knoten eines Regelbaums kann über eine Integer-Zahl adressierbar sein. Jeder Knoten kann darüber hinaus über fünf Integer-Zahlen eindeutig definiert werden. Zwei Werte für Input und Output sowie einer für den Typ. Es können also pro verwendetem Knoten sechs Integer- Werte verwendet werden, nämlich die erwähnten fünf Integer-Zahlen für die Konfiguration des Knotens sowie ein sechster Wert für die Knotennummer. Das Konfigurationssignal kann die sechs Integer-Werte aufweisen. Es ist möglich, jedoch nicht erforderlich, pro Knoten eine Nachricht zu senden. Es ist möglich, sechs hintereinanderliegende Werte in der Nachricht für einen Knoten zu verwenden und eine beliebige Anzahl von Knoten innerhalb eines Konfigurationssignals zu definieren.
In dem Konfigurationssignal oder einem weiteren Konfigurationssignal kann definiert werden, welcher Knoten oder welche Knoten als Startknoten fungieren. Diese Information kann grundsätzlich auch Teil der Konfigurationsnachricht der Knoten sein, beispielsweise an das Ende gesetzt werden, ist aber bevorzugt eindeutig von den anderen Integer- Werten abgetrennt. Als Beispiel kann dienen, dass für die Definition des Graphen mit 256 Knoten lediglich 256*16 Bit (bei Verwendung von 16-Bit-lntegern für die Durchnummerierung der Knoten und Variablen) = 512 Byte an Informationen übertragen werden und zusätzlich optional ein paar weitere Byte je nach Menge der verwendeten Startknoten. Nach erfolgreicher Konfiguration durch den Generator kann der Graph sofort verwendet werden.
Fig. 1 1 zeigt ein schematisches Blockschaltbild einer Vorrichtung 110 gemäß einem Ausführungsbeispiel, die Eingänge (Schnittstelle 28i),„Ausgänge“ (Schnittstelle 285) und eine innere Logik, die den Handlungsablauf 24 umfasst. Als Eingänge können z. B. Sensoren, Schalter/Taster oder andere Bedienelemente dienen. Die innere Logik kann das abzulaufende Programm, das der Benutzer vorher durch das Interface festgelegt hat, implementieren. Dieses kann beispielsweise im Regelbetrieb in einer Dauerschleife ausgeführt werden. Ausgänge können beispielsweise Aktuatoren diverser Art, Schalter, Motoren, eine Kommunikation nach außen, etwa Sendewert XY an Server N, umfassen, kann alternativ oder zusätzlich aber auch das Setzen/Ändern von Timern und Interrupts auf der Hardware des Geräts und/oder das Ändern von Speicherbereichen im flüchtigen Speicher der Hardware umfassen. Durch die innere Logik kann ein Algorithmus oder ein Programm bzw. eine Sequenz maschinenlesbare Instruktionen repräsentiert werden, welche Eingän- ge und Ausgänge aber auch Variablen, Timer und interne Elemente des Micro-Prozessors verwendet. Durch die erfindungsgemäße Struktur kann ein beliebiges Programm repräsentiert und aufgebaut werden.
Fig. 12 zeigt ein schematisches Blockschaltbild einer Vorrichtung 120 gemäß einem Ausführungsbeispiel, das ähnlich gebildet sein kann wie die Vorrichtung 10 oder die Vorrichtung 30 oder die Vorrichtung 110, wobei an den Ausgängen 28s die Peripherie 32 in Form eines Schalters drahtgebunden oder drahtlos angeschlossen ist, der in unterschiedliche Zustände, entweder„anVaus“ oder dergleichen, steuerbar ist. Über die Eingänge 28i können Steuersignal 681 und/oder 682 von externen Einrichtungen 72i und/oder 722 erhalten werden, etwa Server oder dergleichen. Die Steuersignale 681 und/oder 682 können eine Anweisung zum Anschalten oder Ausschalten des Schalters der Peripherie 32 aufweisen. Der Handlungsablauf, der in der Vorrichtung 120 implementiert ist, kann dabei so ausgeführt sein, dass die Peripherie gemäß den Steuersignalen 681 und 682 angesteuert wird.
In anderen Worten zeigt Fig. 12 ein Beispiel, wie die Logik im Gerät Eingänge und Ausgänge miteinander verknüpft und wozu Ausführungsbeispiele verwendet werden können. Die Vorrichtung 120 ist beispielsweise als reiner Aktuator ausgebildet. Die innere Logik kann so ausgelegt sein, dass im Falle, dass die externe Einrichtung 72i instruiert, den Schalter anzuschalten, oder, wenn die externe Einrichtung 722 instruiert, den Schalter 32 anzuschalten, die Vorrichtung 120 die Peripherie 32 dann entsprechend ansteuert. Ansonsten wird der Schalter am Ausgang 285 auf„aus“ geschaltet.
Fig. 13 zeigt ein schematisches Blockschaltbild einer Vorrichtung 130 gemäß einem Ausführungsbeispiel, bei dem die Eingänge 28i mit Sensoren 74t und 742 in beliebiger Anzahl ä 1 verbunden sind, um Sensorsignale 76i und 762 mit entsprechenden Sensorwerten zu empfangen. Die Vorrichtung 130 kann ausgebildet sein, um die Sensorsignale 76t und 762 auszuwerten und um mittels eines Ausgangssignals 78 die Peripherie anzusteuern, die beispielsweise einen Server umfasst, um die ausgewerteten Daten dort zu speichern.
In anderen Worten zeigt Fig. 13 eine Konfiguration der Vorrichtung 130 als reinen Sensor mit einer Kommunikation. Die innere Logik kann beispielsweise so ausgestaltet sein, dass regelmäßig, etwa alle 60 Minuten ein neuer Wert von dem Sensor 74i gespeichert wird. In einem gleichen oder verschiedenen Zeitintervall, etwa alle 120 Minuten, wird ein neuer Wert von dem Sensor 742 gespeichert. Die innere Logik kann so ausgestaltet sein, dass, wenn beispielsweise eine bestimmte Anzahl Messwerte, etwa 100, vorliegen, ein Minimum und ein Maximum der Werte aus Sensor 74i und/oder ein Mittelwert der Werte aus Sensor 742 berechnet wird. Ein entsprechendes Ergebnis wird an den Server gesendet. Alternativ oder zusätzlich können die alten Werte gelöscht werden und eine neue Messreihe begonnen werden.
Fig. 14 zeigt ein schematisches Blockschaltbild einer Vorrichtung 140, die mit der Peripherie 32 verbunden ist und die als Sensor/Aktor-Logik bzw. als Sender und Empfänger, etwa für eine Smart-Home-Einrichtung (intelligentes Zuhause), konfiguriert ist. Hierfür kann der Sensor 74 beispielsweise eingerichtet sein, um eine Temperatur zu erfassen, ein Server 82 kann eine Steuerung, etwa eines zusätzlichen Schalters oder Ventils bzw. Heizungsventils 84, bewirken, wobei die Vorrichtung 140 ausgebildet ist, um diverse Schalter 861 und/oder 862 zu steuern, das Heizungsventil 84 zu öffnen oder zu schließen und dabei Informationen von Schaltern 861, Sensoren 74 und/oder Servern 82 zu empfangen. Beispielsweise kann der Sensor 74 als Temperatursensor eingerichtet sein, um eine Temperatur zu messen, wobei jede andere Konfiguration ebenfalls implementierbar ist.
In anderen Worten kann die innere Logik z. B. so ausgestaltet sein, dass, wenn der Wert des Schalters 861 verändert wird oder die Temperatur veränderlich ist, sich beispielsweise um mehr als 10 Grad geändert hat, dann wird ein neuer Zustand an den Server 82 gesendet und die entsprechenden Werte gespeichert. Wenn beispielsweise der Server 82 die Steuerung 68 auf „an“ setzt, so kann beispielsweise die Temperatur geprüft werden und mit einem Soll-Wert verglichen werden, wenn die Temperatur unter dem Soll-Wert ist, dann kann das Heizungsventil 84 geöffnet werden, ansonsten geschlossen. Wenn der Server die Steuerung auf „an“ setzt, so kann beispielsweise ein Zustand des Eingangs- Schalters 861 an den Ausgangs-Schalter 862 weitergegeben werden, sonst kann der Ausgang auf„aus“ geschaltet werden.
Die Fig. 12, 13 und 14 beschreiben unterschiedliche Konfigurationen von Vorrichtungen. Es wird darauf hingewiesen, dass diese Konfigurationen von ein und derselben Vorrichtung implementierbar sind, beispielsweise durch Neukonfiguration oder Umkonfiguration oder Re-Konfiguration mittels eines Konfigurationssignals. Ist die Vorrichtung derart implementiert, dass alle Konfigurationen von der Hardware abbildbar sind, kann somit jedes der Beispiele lediglich durch das Konfigurationssignal in die jeweils andere Konfiguration umkonfiguriert werden. Wenn der Graph, d. h. der Handlungsablauf, geändert werden soll, kann für jeden verwendeten Knoten eine Nachricht mit dem nachfolgend beschriebenen Aufbau gesendet werden und/oder es wird eine kombinatorische Nachricht mit Informationen bezüglich mehrerer oder aller Knoten gesendet, entweder aller Knoten insgesamt oder aller zu ändernden Knoten. Die Länge der Nachricht kann abhängig vom verwendeten Kommunikationsprotokoll ausgestaltet sein. Unter Verwendung von jeweils sechs Zahlenwerten kann ein Knoten neu definiert werden. Es können entweder nur einzelne Knoten geändert/neu definiert werden oder über eine spezielle Lösch-Nachricht dem Gerät mitgeteilt werden, dass es seinen aktuellen Graphen komplett zurücksetzen soll. Die sechs Zahlenwerte, die einen Knoten definieren, können beispielsweise wie folgt definiert angeordnet werden, wobei eine Reihenfolge beliebig ausgestaltet sein kann, solange sie dem Gerät vorbekannt ist, um eine korrekte Decodierung zu ermöglichen:
• IndexJMr.; Index-Nummer des zu ändernden Knotens;
• Typ_Nr.; Neuer Typ des zu ändernden Knotens;
• indxjnpl ; Index-Nummer des Speicherbereichs 1 des ersten Eingangs;
• indx_inp2; Index-Nummer des Speicherbereichs 2 des zweiten Eingangs;
• indx_out1 ; Index-Nummer des ersten Ausgangs, gegebenenfalls True-Ausgangs; und
• indx_out2; Index-Nummer des zweiten Ausgangs, beispielsweise des Falls- Ausgangs.
Da alle Knoten und Variablen eindeutig durch ihre Index-Nummer adressiert werden können, können vier Zahlen ausreichend sein, um die Struktur des Graphen, d. h. die Verknüpfung der Knoten untereinander und mit Variablen, zu ändern, indem die Index- Nummern der Speicherbereiche der Eingänge und Ausgänge verändert werden. Eine weitere Index-Nummer kann angeben, welcher Knoten neu definiert wird und mit einem zusätzlichen, sechsten Integer-Wert kann die Art des Knotens geändert werden.
Bekannt sind verschiedene Möglichkeiten, wie Geräte mit neuen Aufgaben/Programmen von außen bespielt werden können.
Die naivste Methode ist, das komplette Programm über die Kommunikationsschnittstelle zu senden. Dieses Verfahren bietet die größte Flexibilität, da sich hier selbst Hardware- Treiber austauschen lassen. Der größte Nachteil besteht darin, dass zum einen Programmcode sehr groß ist und zum anderen dafür der Mikroprozessor aufwendig neu pro- grammiert bzw. geflashed werden muss. Der Flash-Vorgang im laufenden Betrieb ist enorm aufwendig und sehr energieintensiv (was das Verfahren gerade auf Hardware mit begrenzten Ressourcen/Energy-Harvesting unbrauchbar macht) und stellt des Weiteren ein Risiko dar, falls er nicht vollständig abgeschlossen werden kann (in diesem Fall ist das Gerät dann ggf.„gebrickt“ und von außen nicht mehr ansprechbar, es sei denn, man verbindet den Prozessor wieder über einen Debugger für die Prozessorfamilie mit einem PC).
Die Variante der Szenarien/Parametrierung versucht den Ansatz, eine Auswahl an möglichen Programmen, die der Benutzer verwenden will,„vorzuprogrammieren" - d. h., es existieren mehrere kleine Unterprogramme auf dem Gerät, welche alle zur Auslieferung kompiliert auf der Hardware existieren. Soll das Gerät seine Funktionalität ändern, kann ihm mitgeteilt werden, dass es jetzt ein anderes Szenario/Programm auswählen soll.
Durch dieses Verfahren ist man allerdings am Ende sehr unflexibel - es können nur die Szenarien gewählt werden, die der Hersteller bereitgestellt hat. Eine Verwendung der Hardware für andere als die vorgesehenen Szenarien oder eine Änderung einer kleinen Regel in einem Szenario ist nicht vorgesehen. Ein weiterer kleiner Nachteil ist, dass der Speicherbedarf im Gerät durch das wesentlich größere Gesamt-Programm etwas erhöht ist.
Ein Interpreter ist ein Programm, welches in der Lage ist, Code in der sog.„Interpretersprache“ in ein Hochsprachliches Äquivalent (z. B. C++) umzuwandeln. Die Umwandlung erfolgt dabei Zeile für Zeile; d. h., es muss nicht das gesamte zu interpretierende Programm permanent vorliegen und zusätzlich ist keine Aufbauphase wie bei einem Compiler notwendig. Interpreter sind tendenziell sehr aufwendige Programme, die aber durch ihre 1 -ZU-1 -Umwandlung in Hochsprachlichen Programmcode maximale Flexibilität bereitstellen. Der Nachteil ist hier analog zu dem Verfahren des Neuflashens, dass der übertragene Programmcode (trotz Interpretersprache) sehr groß ist. Des Weiteren wird bei dieser Variante sehr viel Speicher benötigt, da permanent der zu interpretierende Code im Speicher gehalten werden muss sowie auch die Elemente des auszuführenden Programmes. Interpreter werden allgemein auf„fester Hardware“ (Desktop PCs etc.) eingesetzt.
Die Vorteile der erfindungsgemäßen FPGRA-Lösung liegen dabei darin, dass zur Änderung der gesamten Funktionalität nur ein relativ kleiner Code gesendet werden muss, wodurch sich eine große Flexibilität ergibt. Grundsätzlich ermöglichen erfindungsgemäße FPGRA-Ausführungsbeispiele eine hohe Flexibilität, wenig Übertragung und benötigen keinen energieaufwendigen Flash-Vorgang. Diese Vorteile können möglicherweise einhergehen mit einer etwas schlechteren Ausführungseffizienz des Programmes, da simpel gesagt immer der Umweg über den Graphen und den Knoten-Datentyp gegangen wird, was allerdings für den Einsatzbereich weniger wichtig ist, da z. B. das Senden oder Empfangen einer Nachricht über Funk weit mehr Energie verbraucht als das Ausführen von Code auf dem Haupt-Prozessor - vom Flash- Vorgang und darüber hinaus auch weitere Vorteile erhalten werden. Dadurch ist das beschrieben Konzept hervorragend dazu geeignet, auf Hardware mit begrenzten Ressourcen in Form von Energie sowie Geräten mit Energy-Harvesting eingesetzt zu werden.
Für den Beweis der Turing-Vollständigkeit wird gezeigt, dass mit der Syntax, welcher von den Knoten im Graphen aufgespannt wird, GOTO-Prog ramme ausführbar sind/die GOTO- Language vollständig abgebildet wird („GOTO-Berechenbarkeit“). Dazu wird gezeigt, dass die komplette Syntax der GOTO-Language durch die Knoten repräsentiert werden kann.
Jede Funktion, die GOTO-berechenbar ist, ist Turing-vollständig (und umgekehrt).
• Die Speicheradressen/Index-Nummern der Knoten sind äquivalent zu den Sprungmarken im GOTO-Programm
• Die Zuweisung einer Variable durch eine andere vermehrt um eine Konstante ist durch den Arithmetikknoten gegeben
• Die Zuweisung einer Variable durch eine andere (ohne Veränderung des Wertes) ist durch den Speicherknoten gegeben
• Die Erhöhung einer Variablen um eine Konstante ist durch einen Arithmetikknoten gegeben
• Die Sprunganweisung GOTO steckt implizit in den Pointern jedes Knotens
• Die bedingte Sprunganweisung wird vollständig durch die Vergleichsknoten repräsentiert
• Die STOP-Anweisung wird durch das Setzen des„next-pointers“ auf die„Null-ID“ repräsentiert
Es kann also jedes GOTO-Programm durch Knoten repräsentiert werden, was heißt, dass jedes Turing-vollständige Programm durch die Knoten-Struktur repräsentiert werden kann. Einige Ausführungsbeispiele sind nachfolgend beschrieben. So bezieht sich ein Ausführungsbeispiel auf ein loT-basiertes Heizungsthermostat, bei dem die Peripherie einen Temperatursensor und ein Stellglied oder Aktuator um Stellen eines Heizungsventils aufweist. Ein Generator oder ein Teil einer Steuereinrichtung ist ausgebildet, um basierend auf einem von dem loT-basierten Heizungsthermostat empfangenen Konfigurationssignal einen Handlungsablauf zu erstellen, dessen graphische Repräsentation einen ersten Graphen aufweist, der eine widerholte, ggf. zyklische Abfrage des Temperatursensors bewirkt. Die ausgelesenen Sensorsignale können lokal gespeichert und/oder an einen Server übertragen werden. Der Handlungsablauf bewirkt im selben Graphen oder als Teil eines weiteren Graphen ein Steuern des Aktuators in Abhängigkeit der festgestellten Temperatur, um etwa ein Ventil zu schließen sofern eine Solltemperatur erreicht oder überschritten ist und/oder um das Ventil zu öffnen, sollte die Temperatur unterschritten sein. Gemäß Ausführungsbeispielen lässt sich eine derartige Vorrichtung auch für Kühlgeräte, etwa Klimaanlagen einsetzen, wobei dann das Ventil geöffnet wird, wenn eine Solltemperatur überschritten ist und geschlossen wird, wenn die Solltemperatur erreicht oder unterschritten ist.
Fig. 15 zeigt ein schematisches Blockschaltbild eines Systems 150 gemäß einem Ausführungsbeispiel, das beispielhaft die Vorrichtung 10 umfasst, alternativ oder zusätzlich aber auch andere hierin beschriebene Vorrichtungen umfassen kann, beispielsweise die Vorrichtung 30, 110, 120, 130 oder 140.
Das System 150 umfasst ferner eine Vorrichtung 155, die eine Ausgangsschnittstelle aufweist, die ausgebildet ist, um das Konfigurationssignal 14 an die Vorrichtung 10 zu senden. Die Vorrichtung 155 umfasst einen Signalgenerator 92, der ausgebildet ist, um das Konfigurationssignal, zumindest in einer Basisband-Version hiervon, bereitzustellen. Hierbei wird das Konfigurationssignal 14 bevorzugt so durch den Signalgenerator 92 bereitgestellt, dass es eine Abfolge von ausführbaren Ablaufteilen einer Vielzahl von ausführbaren Ablaufteilen beschreibt, also eine Teilmenge der in der Vorrichtung 10 hinterlegten aus führbaren Ablaufteilen selektiert sowie deren Verknüpfung untereinander angibt. Die angegebene Abfolge von ausführbaren Ablaufteilen beschreibt einen Handlungsablauf, etwa den Handlungsablauf 24, eindeutig. Die Vorrichtung 155 kann ausgebildet sein, um eine Benutzereingabe 94 zu erhalten, die den zu erstellenden Handlungsablauf beschreibt. Hierfür kann beispielsweise eine graphische Repräsentation 96 des Handlungsablaufs 24 vorgesehen sein, die der Benutzer an einer hierfür vorgesehenen Vorrichtung 98 erstellen oder konfigurieren kann. Die Vorrichtung 98 kann dabei Teil der Vorrichtung 155 sein, kann aber auch Zugriff auf ein Web- Interface 102 der Vorrichtung 155 nutzen, so dass die Benutzereingabe 94 über eine Netzwerkverbindung von der über die Netzwerkverbindung verbundenen Vorrichtung 98 empfangen werden kann. Die graphische Repräsentation 96 ist dabei lediglich eine von mehreren möglichen Ausgestaltungen, die alternativ oder zusätzlich auch eine Programmierung in Textform beinhalten kann.
In anderen Worten kann ein Arbeitsablauf Folgendes umfassen: a) Zusammenstellen der abzulaufenden Logik/des Graphen oder des Handlungsablaufs an einem Computer über beispielsweise ein Web-Interface oder ein Programm:
b) Komprimierung und Codierung der Logik/des Graphen;
c) Senden der codierten Logik über eine Kommunikationsschnittstelle an das Gerät, das bedeutet Senden des Konfigurationssignals;
d) Decodieren der Nachricht und Aufbau der inneren Logik im Gerät, wodurch dieses nun einsatzfähig ist und in Dauerschleife das decodierte Programm ausführt.
Fig. 16 zeigt ein schematisches Blockschaltbild eines Systems 160 gemäß einem Ausführungsbeispiel. Das System 160 kann die Vorrichtungen 98 (Block B) und 155 (Block C) umfassen, die ausgebildet sind, um einen Datenfluss zum Austausch von Logik und/oder Parametern oder Soll-Werten auszutauschen, wie es durch den Buchstaben a angedeutet ist. Die Vorrichtung 155, das heißt der Codierer, kann mit einer oder mehreren Vorrichtungen 10i und/oder IO2 über ein Kommunikationsnetzwerk (Block D), etwa dem Internet, in Verbindung stehen, ebenso wie die Vorrichtung 98. Die Peripherie 32 (Block E) kann mit den Vorrichtungen 10i und/oder IO2 ebenfalls über das Kommunikationsnetzwerk 104 in Verbindung stehen. An der Vorrichtung 98 zur Programmierung des Graphen oder der Logik kann auch Metainformation für die Peripherie erstellt werden, etwa eine Benamung oder virtuelle Adressen, wie es durch den Buchstaben e dargestellt ist. Zwischen den Vorrichtungen 10i und I O2 und der Vorrichtung 98 können weitere Informationen, etwa hardwarespezifische Informationen wie IDs (Identifikationen), Spezifikationen und/oder hard warenahe Belegungen ausgetauscht werden, wie es durch den Buchstaben b dargestellt ist. Darüber hinaus können die Vorrichtungen 10i und I O2 mit der Peripherie 32 unter Verwendung des Kommunikationsnetzwerks 104 Ausgabewerte, Sensorwerte oder Ist- Parameter (Buchstabe c) und/oder Soll-Parameter (Buchstabe b) austauschen. Ein Austausch von Logikinformationen oder Parametrierungen kann zwischen den Vorrichtungen 98 und 155 sowie unter Verwendung des Kommunikationsnetzwerks 104 mit den Vorrichtungen 10i und IO2 ausgetauscht werden, wie es durch den Buchstaben a dargestellt ist. Dies beinhaltet beispielsweise das Konfigurationssignal.
Die Vorrichtungen 10i und I O2 können untereinander (Buchstabe f) und mit dem Kommunikationsnetzwerk 104 unter Verwendung eines ressourcenbeschränkten Mediums 106 kommunizieren, beispielsweise schmalbandige Kanäle eines Mobilfunknetzwerks (schmalbandig = narrowband Nb), etwa für Nb-LTE zum Implementieren von Nb-loT- Vorrichtungen. Die Peripherie 32 kann jedwede Art von Datenempfängern/Senken, Aktua toren, Steuer-Devices zur Parametrierung anpassen, darunter auch mobile Geräte wie etwa Smartphones.
In anderen Worten: kann ein Zahlencode, der bspw. eine Sequenz der Parameter widergibt, (im Datenflussgraphen (a) - in den Zahlen sind die Parameter codiert, welche später den Programmablauf steuern) in eine ausführbare Programmlogik umgewandelt werden, die dann in Dauerschleife auf dem Gerät (im Datenflussgraphen (A)) ausgeführt wird. Man kann sich dies in etwa wie bei einem Compiler vorstellen, welcher Programmcode (z. B. C++) in Maschinensprache übersetzt, welche dann auf einer Hardware ausgeführt werden kann.
Der Unterschied zwischen dem FRGRA und einem Compiler ist, dass hierbei kein ausführbarer Maschinencode erzeugt wird. Das FPGRA ist auch kein Interpreter, da der Code nicht direkt in ein Hochsprachliches Äquivalent umgewandelt und ausgeführt wird. Es ist analog zum Compiler keine„Aufbauphase“ nötig.
Es wird im bestehenden Programmcode durch geschickte Pointer-Arithmetik und Klassenstrukturen, welche in der Lage sind, den Programmablauf zu steuern, eine Logik aufgebaut, die im flüchtigen Speicher gehalten wird.
Der eigentliche Programmcode, welcher auf dem Gerät permanent ausgeführt wird, bleibt dabei unangetastet und unverändert (vereinfacht gesagt läuft die ganze Zeit das gleiche Programm, nur mit anderen Parametern).
Durch dieses Vorgehen kann auf den energieaufwendigen Flash-Vorgang zum Ändern von Strukturen im nicht-flüchtigen Speicher (EEPROM) verzichtet werden und es besteht trotzdem die Möglichkeit, das Gerät Turing-vollständig umzuprogrammieren. Der Benutzer setzt hier den Programmablauf fest, dem das Gerät später folgen soll. Dies kann über das„Zusammenklicken“ eines Graphen geschehen, der die Regeln und Handlungsabläufe beinhaltet; aber auch z. B. über eine Art von Skriptsprache, mit der sich die Ablaufregeln definieren lassen („Wenn X, dann Y, sonst Z -> Danach A“).
Das Interface legt neben in der inneren Logik auch die möglichen Aktionen des Gerätes bzw. die Ausgänge fest. Eine Aktion kann beispielsweise eine Hardware-Funktion sein („Sende XY“,„Setze Time N auf X“), aber auch einfach ein Funktionsaufruf in der Software. Diese Vorauswahl ist nötig, da zum einen technisch die Menge der Aktionsknoten (welche die verfügbaren Aktionen im Gerät zur Verfügung stellen im Gerät begrenzt ist - da in der Realität der verfügbare Speicher immer begrenzt ist - und zum anderen die Ausgänge und ausführbaren Aktionen hardwarespezifisch sind (beispielsweise darf ein Gerät, welches über keinen Aktor verfügt, nicht mit einem Regelwerk versehen werden, welches am Ende einen Aktor bedienen will).
Selbiges gilt für die möglichen Eingänge/Sensoren und Kommunikationsschnittstellen (beispielsweise darf ein Graph, der im Eingang einen T emperatur-Sensor auswertet, auch nur auf Geräte, die einen solchen Sensor besitzen, gebracht werden oder WiFi- Kommunikation nur auf WiFi-fähige Geräte.
Ausführungsbeispiele basieren darauf, den für den konkreten Anwendungsfall der Vorrichtung relevanten Teil auszuführender Instruktionen (Programmcode) als Regelbaum darzustellen, das bedeutet, die implementierten Funktionen sind als Regelbaum darstellbar. Ein derartiger Graph kann durch eine spezielle Struktur im Programmcode repräsentiert werden und kann jederzeit durch eine Konfigurationsnachricht, die wesentlich weniger Information zur Übertragung umfasst als ein normaler Programmcode, neu zusammengebaut werden, um ein anderes Programm zu repräsentieren. Wie es beschrieben ist, kann diese Art der Repräsentation Turing-vollständig sein, wodurch effektiv jedes beliebige Programm dargestellt werden kann, solange es in dem Speicher speicherbar ist. Knoten des Graphen können als so etwas wie die kleinstmöglichen Unterprogramme verstanden werden, die auf der Hardware möglich sind. Hierzu zählen logische und/oder arithmetische Funktionen („UND“,„ODER“,„+“,„*“, ...), aber auch komplexere Programmabläufe/- funktionen wie z. B. Instruktionen gemäß„Sende den Wert an Adresse x zurück an den Server“ oder„Lege dich für x Minuten schlafen“. Beispielhafte Konfigurationen, die die Vielfältigkeit demonstrieren, jedoch nicht einschränkend wirken sollen, sind hierin be- schrieben. Es ist anzumerken, dass eine einzelne Vorrichtung zwischen unterschiedlichen Konfigurationen, die beschrieben sind, mit gegebenenfalls lediglich einer Konfigurationsnachricht wechseln kann, d. h. umprogrammiert werden kann, ohne dass dabei der ausgeführte Programmcode in einem Festspeicher (EEPROM) geändert werden muss.
Fig. 17 zeigt ein schematisches Ablaufdiagramm eines Verfahrens 1700 gemäß einem Ausführungsbeispiel, das beispielsweise von einer hierin beschriebenen fernprogrammierbaren Vorrichtung, etwa der Vorrichtung 10, 30, 110, 120, 130 oder 140, ausgeführt werden kann. Ein Schritt 1710 umfasst ein Speichern einer Vielzahl ausführbarer Ablaufteile in einem Datenspeicher, wobei jeder Ablaufteil zumindest eine Handlungsvorschrift beschreibt. Ein Schritt 1720 umfasst ein Empfangen eines Konfigurationssignals mit einer Eingangsschnittstelle. Ein Schritt 1730 umfasst ein Erstellen eines Handlungsablaufs, der eine Abfolge von in dem Konfigurationssignal angegebenen Ablaufteilen der Vielzahl von gespeicherten Ablaufteilen umfasst. Ein Schritt 1740 umfasst ein Ansprechen einer Peripherie gemäß dem Handlungsablauf unter Verwendung einer Schnittstelle, die ausgebildet ist, um mit der Peripherie zu kommunizieren.
Fig. 18 zeigt ein schematisches Fiussdiagramm eines Verfahrens 1800 zum Bereitstellen eines Konfigurationssignals, das beispielsweise unter Verwendung der Vorrichtung 155 ausführbar ist. Ein Schritt 1810 umfasst ein Bereitstellen eines Konfigurationssignals unter Verwendung eines Signalgenerators, so dass das Konfigurationssignal eine Abfolge von ausführbaren Ablaufteilen aus einer Vielzahl von ausführbaren Ablaufteilen beschreibt, wobei die Abfolge von Ablaufteilen einen Handlungsablauf mit einer Mehrzahl von Handlungsvorschriften eindeutig beschreibt. Ein Schritt 1820 umfasst ein Senden des Konfigurationssignals mit einer Ausgangsschnittstelle.
Fig. 19 zeigt ein schematisches Blockschaltbild einer Vorrichtung 190 gemäß einem Ausführungsbeispiel, bei der die Eingängen 28i zur Verbindung mit einem loT Modem 108 eingerichtet sind, etwa zur Kommunikation über das resourcenbeschränkte Medium 106. Das loT Modem 108 kann alternativ auch eine interne Vorrichtung sein. Ferner können die Eingänge eingerichtet sein, um mit einem oder mehreren Sensoren 74 verbunden zu werden, etwa ein MEMS-Sensor. Dieser kann bspw. als Beschleunigungssensor eingerichtet sein. Der Ausgang 28s kann zur Kommunikation mit einem Server der Peripherie 32 eingerichtet sein. Das Gerät kann ausgebildet sein, um ansprechend auf ein empfangenes Konfigurationssignal den Handlungsablauf so zu erstellen, dass bei entsprechendem Signal des Sensors 74, was eine Bewegung oder eine ausbleibende Bewegung oder eine entsprechende Beschleunigung sein kann, eine Nachricht an den Server gesendet wird, die eine Position der Vorrichtung 190 angibt, etwa unter Angabe einer durch das Modem 108 verwendeten Funkzelle, in welcher sich die Vorrichtung gegenwärtig befindet.
In anderen Worten kann die Vorrichtung 190 als Bewegungstracker fungieren, etwa für Transportgut eines Logistik-Unternehmens. Als Eingänge dienen hier ein Beschleunigungs-Sensor („MEMS“) und die aktuell Empfangene Funkzelle des NB-loT Modems (dieses ist bspw. kein extra Gerät, sondern ggf. im Gerät vorhanden). Der Benutzer könnte hier beispielsweise das Gerät so konfigurieren, dass es nachdem initial eine Bewegung detektiert wurde über den MEMS, das Gerät in einen„Transport-Zustand“ fällt (was über eine Interne Variable gelöst ist). Im„T ransport-Zustand“ prüft das Gerät dann in einem Regelmäßigen Intervall, ob es sich noch in Bewegung befindet. Sobald n-Mal keine Bewegung festgestellt wurde, wird der„T ransport-Zustand“ beendet und das Gerät sendet die aktuell Verbundene Funkzelle an einen Server. So kann ein Unternehmer bspw. Feststellen, welche Fracht wann und wohin Transportiert wurde. Die Schwellwerte, ab wann das Gerät in Bewegung ist und in welchem Intervall das Gerät wieder auf Bewegung prüft sind selbstverständlich frei wählbar und mittels des Konfigurationssignals festlegbar bzw. mittels erneuter Konfigurationssignale veränderbar. Ebenso sind komplexere Verschachtelungen mit weiteren Zuständen möglich.
Fig. 20 zeigt ein schematisches Blockschaltbild einer Vorrichtung 200 gemäß einem Ausführungsbeispiel, bei der die Eingängen 28i zur Verbindung mit einer mobilen Vorrichtung 1 12, etwa ein Smartphone/Mobiltelefon, ein Tabletcomputer oder dergleichen eingerichtet sind. Die mobile Vorrichtung 112 kann eine Positioniervorrichtung 114 aufweisen über die eine Position feststellbar ist, etwa mittel Global Positioning System (GPS), Galileo oder Glonass. Alternativ kann eine entsprechende Positioniervorrichtung auch als eigenständige Vorrichtung vorgesehen sein und über die Eingänge 28i mit der Vorrichtung 200 verbunden sein. Die Vorrichtung 200 kann ausgebildet sein, um ansprechend auf ein Konfigurationssignal den Handlungsablauf so zu erstellen, dass über die Ausgänge 28s ein oder mehrere Vorrichtungen oder Komponenten angesprochen werden. So kann ein Der- ver 32i eine Nachricht mit einer Position der Vorrichtung 200 empfangen, etwa in vorgegebenen Intervallen und/oder wenn die mittels der Positioniervorrichtung 114 empfangene Position von einer vorgegebenen und in der Vorrichtung 200 hinterlegten oder von extern empfangenen Position oder Bereich abweicht. Alternativ oder zusätzlich kann die mobile Vorrichtung 112 entsprechend informiert werden, etwa eine Anwendung (Application; App), die dort ausgeführt wird. Alternativ oder zusätzlich die Vorrichtung 200 ausgebildet sein, um eine Anzeigeeinrichtung 322 anzusteuern, um einen Status anzeigen.
In anderen Worten kann die Vorrichtung 200 als Diebstahl-Sicherung fungieren, bspw. für bspw. Fahrräder oder Fahrzeuge. Die Sicherung wird bspw. über eine App im Handy 1 12 aktiviert (der Zustand in der App wird an das Gerät gesendet und ist intern in einer Variable gespeichert, welche als Eingang des Handlungsablaufs gesetzt werden kann), dies wird zusätzlich über eine angeschlossene LED visualisiert. Im aktivierten Modus merkt sich das Gerät seine aktuelle Position über ein GPS-Modul 114. Diese wird in einem regelmäßigem, vom Anwender vorgegebenen Intervall aktualisiert. Bei einer Änderung meldet das Gerät sofort seine aktuelle Position in einem regelmäßigen Intervall zurück an das Smart- phone 112 des Benutzers und/oder einen Server 32i.
Fig. 21 zeigt ein schematisches Blockschaltbild einer Vorrichtung 210 gemäß einem Ausführungsbeispiel, die konfiguriert ist, um über die Eingängen 28i mit unterschiedlichen Einrichtungen oder Vorrichtungen verbunden zu werden, um Eingangssignale zu erhalten. Hierzu gehören bspw. eine Drahtlosschnittstelle 1 16, etwa Bluetooth ® oder eine andere Drahtlostechnologie, ein Zeitgeber oder Uhr 118, eine Signalgenerator einer Benutzereingabe, etwa ein Schalter oder Knopf 122 und/oder andere Sensoren wie ein Pulsmesser 124. Die Daten können verarbeitet werden und entsprechende Ergebnisse an eine Anzeigeeinrichtung 126, etwa ein LCD (LCD = Liquid Chrystal Display), ein LED-Display, eine einzelne LED oder dergleichen zum Darstellen einer Information. Die Vorrichtung 210 kann ausgebildet sein, um bspw. basierend auf der Benutzereingabe zwischen zwei oder mehreren Betriebsmodi umzuschalten, in denen an der Anzeigeeinrichtung 126 unterschiedliche Informationen dargestellt werden, etwa über die Schnittstelle 116 empfangene Informationen, eine Zeit des Zeitgebers 118 und/oder Informationen des Sensors 124 und/oder hieraus abgeleiteter Informationen. Diese Informationen können über die Ausgänge 28s sowohl übermittelt werden, etwa unter Verwendung der Schnittstelle 1 16, als auch alternativ oder zusätzlich dargestellt werden.
In anderen Worten kann die Vorrichtung 210 eine Art intelligente Puls-Uhr bereitstellen. Über einen Knopf 122 kann umgeschaltet werden, was die LCD-Anzeige 126 darstellen soll. Über Bluetooth 1 16 kann das Gerät Informationen von anderen Devices (bspw. dem zugehörigen Brustgurt bei differentieller Pulsmessung oder dem Tachometer eines Fahrrads oder ein Smartphone) erhalten bzw. an andere Devices senden. Die über Bluetooth 116 erhaltenen Informationen können z.B. dafür genutzt werden, um einen Alarm auf dem Display 126 anzuzeigen, wenn ein vom Benutzer eingestellter Wert überschritten wird.
Die hierin beschriebenen Vorrichtung können unter Verwendung von Konfigurationssignalen programmiert oder umprogrammiert werden. Hierbei können entsprechende Teil- Handlungsabläufe in den Vorrichtung vorhinterlegt sein und mittels des Konfigurationssignals neu verknüpft oder konfiguriert werden. In Vorrichtung unterschiedlicher Ausgestaltung können die Ablaufteile entsprechend der zur Vorrichtung gehörenden oder vorgesehenen oder möglichen Hardware unterschiedlich sein, die Ausgestaltung des Generators kann jedoch gleich oder gleichwirkend sein.
Hierin beschriebene Ablaufteile können als vordefinierte und/oder parametrierbare und/oder anpassbare Codebausteine verstanden werden, die zu einem Gesamtcode, dem Handlungsablauf, in durch das Konfigurationssignal bestimmter Auswahl und/oder Eigenschaft und/oder Reihenfolge zusammengefügt werden können.
Obwohl manche Aspekte im Zusammenhang mit einer Vorrichtung beschrieben wurden, versteht es sich, dass diese Aspekte auch eine Beschreibung des entsprechenden Verfahrens darstellen, sodass ein Block oder ein Bauelement einer Vorrichtung auch als ein entsprechender Verfahrensschritt oder als ein Merkmal eines Verfahrensschrittes zu verstehen ist. Analog dazu stellen Aspekte, die im Zusammenhang mit einem oder als ein Verfahrensschritt beschrieben wurden, auch eine Beschreibung eines entsprechenden Blocks oder Details oder Merkmals einer entsprechenden Vorrichtung dar.
Je nach bestimmten Implementierungsanforderungen können Ausführungsbeispiele der Erfindung in Hardware oder in Software implementiert sein. Die Implementierung kann unter Verwendung eines digitalen Speichermediums, beispielsweise einer Floppy-Disk, einer DVD, einer Blu-ray Disc, einer CD, eines ROM, eines PROM, eines EPROM, eines EEPROM oder eines FLASH-Speichers, einer Festplatte oder eines anderen magnetischen oder optischen Speichers durchgeführt werden, auf dem elektronisch lesbare Steuersignale gespeichert sind, die mit einem programmierbaren Computersystem derart Zusammenwirken können oder Zusammenwirken, dass das jeweilige Verfahren durchgeführt wird. Deshalb kann das digitale Speichermedium computerlesbar sein. Manche Ausführungsbeispiele gemäß der Erfindung umfassen also einen Datenträger, der elektronisch lesbare Steuersignale aufweist, die in der Lage sind, mit einem programmierbaren Com- putersystem derart zusammenzuwirken, dass eines der hierin beschriebenen Verfahren durchgeführt wird.
Allgemein können Ausführungsbeispiele der vorliegenden Erfindung als Computerpro grammprodukt mit einem Programmcode implementiert sein, wobei der Programmcode dahin gehend wirksam ist, eines der Verfahren durchzuführen, wenn das Computerprogrammprodukt auf einem Computer abläuft. Der Programmcode kann beispielsweise auch auf einem maschinenlesbaren Träger gespeichert sein.
Andere Ausführungsbeispiele umfassen das Computerprogramm zum Durchführen eines der hierin beschriebenen Verfahren, wobei das C o m pute rprog ra m m auf einem maschinenlesbaren Träger gespeichert ist.
Mit anderen Worten ist ein Ausführungsbeispiel des erfindungsgemäßen Verfahrens somit ein Computerprogramm, das einen Programmcode zum Durchführen eines der hierin beschriebenen Verfahren aufweist, wenn das Computerprogramm auf einem Computer abläuft. Ein weiteres Ausführungsbeispiel der erfindungsgemäßen Verfahren ist somit ein Datenträger (oder ein digitales Speichermedium oder ein computerlesbares Medium), auf dem das Computerprogramm zum Durchführen eines der hierin beschriebenen Verfahren aufgezeichnet ist.
Ein weiteres Ausführungsbeispiel des erfindungsgemäßen Verfahrens ist somit ein Datenstrom oder eine Sequenz von Signalen, der bzw. die das Computerprogramm zum Durchführen eines der hierin beschriebenen Verfahren darstellt bzw. darstellen. Der Datenstrom oder die Sequenz von Signalen kann bzw. können beispielsweise dahin gehend konfiguriert sein, über eine Datenkommunikationsverbindung, beispielsweise über das Internet, transferiert zu werden.
Ein weiteres Ausführungsbeispiel umfasst eine Verarbeitungseinrichtung, beispielsweise einen Computer oder ein programmierbares Logikbauelement, die dahin gehend konfiguriert oder angepasst ist, eines der hierin beschriebenen Verfahren durchzuführen.
Ein weiteres Ausführungsbeispiel umfasst einen Computer, auf dem das Computerprogramm zum Durchführen eines der hierin beschriebenen Verfahren installiert ist. Bei manchen Ausführungsbeispielen kann ein programmierbares Logikbauelement (beispielsweise ein feldprogrammierbares Gatte rarray, ein FPGA) dazu verwendet werden, manche oder alle Funktionalitäten der hierin beschriebenen Verfahren durchzuführen. Bei manchen Ausführungsbeispielen kann ein feldprogrammierbares Gatterarray mit einem Mikroprozessor Zusammenwirken, um eines der hierin beschriebenen Verfahren durchzuführen. Allgemein werden die Verfahren bei einigen Ausführungsbeispielen seitens einer beliebigen Hardwarevorrichtung durchgeführt. Diese kann eine universell einsetzbare Hardware wie ein Computerprozessor (CPU) sein oder für das Verfahren spezifische Hardware, wie beispielsweise ein ASIC.
Die oben beschriebenen Ausführungsbeispiele stellen lediglich eine Veranschaulichung der Prinzipien der vorliegenden Erfindung dar. Es versteht sich, dass Modifikationen und Variationen der hierin beschriebenen Anordnungen und Einzelheiten anderen Fachleuten einleuchten werden. Deshalb ist beabsichtigt, dass die Erfindung lediglich durch den Schutzumfang der nachstehenden Patentansprüche und nicht durch die spezifischen Einzelheiten, die anhand der Beschreibung und der Erläuterung der Ausführungsbeispiele hierin präsentiert wurden, beschränkt sei.

Claims

Patentansprüche
1. Vorrichtung mit: einer Eingangsschnittstelle (12), die ausgebildet ist, um ein Konfigurationssignal (14) zu empfangen; einem Datenspeicher (16; 36), in dem eine Vielzahl ausführbarer Ablaufteile (18) gespeichert ist, wobei jeder Ablaufteil (18) zumindest eine Handlungsvorschrift beschreibt; einem Generator (22), der ausgebildet ist, um einen Handlungsablauf (24) zu erstellen, der eine Abfolge von in dem Konfigurationssignal (14) angegebenen Ablaufteilen (18) der Vielzahl von gespeicherten Ablaufteilen umfasst; eine Schnittstelle (28), die ausgebildet ist, um mit einer Peripherie (32) zu kommunizieren; und einem Prozessor (31), der konfiguriert ist, um die Peripherie (32) gemäß dem Handlungsablauf (24) anzusprechen.
2. Vorrichtung gemäß Anspruch 1 , wobei der Datenspeicher (36) einen ersten Speicherabschnitt (16) und einen zweiten Speicherabschnitt (34) umfasst.
3. Vorrichtung gemäß Anspruch 2, wobei der erste Speicherabschnitt (16) ausgebildet ist, um die Vielzahl ausführbarer Ablaufteile (18) zu speichern und der Generator (22) ausgebildet ist, um in dem zweiten Speicherabschnitt (34) den Handlungsablauf (24) zu speichern.
4. Vorrichtung gemäß einem der Ansprüche 2 oder 3, wobei der erste Speicherabschnitt (16) einen nicht-flüchtigen Speicherabschnitt umfasst und der zweite Speicherabschnitt (34) einen flüchtigen Speicherabschnitt umfasst.
5. Vorrichtung gemäß einem der Ansprüche 1 bis 4, wobei das Konfigurationssignal (14) eine Information (26) aufweist, die eine Abfolge von ausführbaren Ablaufteilen (18) der Vielzahl ausführbarer Ablaufteile beschreibt und so den Handlungsablauf (24) eindeutig festlegt.
6. Vorrichtung gemäß Anspruch 5, wobei die Information (26) eine Sequenz von In- teger-Zahlen aufweist.
7. Vorrichtung gemäß einem der Ansprüche 1 bis 6, wobei der Generator (22) ausgebildet ist, um den Handlungsablauf (24) so zu erstellen, dass dieser durch zumindest einen Regelbaum (44i, 442) ausführbarer Ablaufteile (18) der Vielzahl ausführbarer Ablaufteile repräsentiert wird, wobei der Regelbaum (44i, 442) eine Mehrzahl von Knoten (46, 48, 52) und eine Mehrzahl von Verknüpfungen (54) zwischen Knoten (46, 48, 52) umfasst, und ein ausführbarer Ablaufteil (18) der Vielzahl ausführbarer Ablaufteile durch einen Knoten (46, 48, 52) in dem Regelbaum (44i ; 442) repräsentiert wird; wobei zumindest eine Verknüpfung (54) der Mehrzahl von Verknüpfungen von einem ersten Knoten (52i) auf einen nächsten, zweiten Knoten (522) des Regelbaumes zeigt.
8. Vorrichtung gemäß einem der Ansprüche 1 bis 7, wobei der Generator (22) ausgebildet ist, um den Handlungsablauf (24) so zu erstellen, dass dieser zumindest einen Startknoten (46), an welchem der Handlungsablauf durch den Prozessor (31) begonnen wird, umfasst; wobei der Prozessor (31) ausgebildet ist, um den zumindest einen Startknoten (46) periodisch auszuwerten, um ein Auswertungsergebnis zu erhalten.
9. Vorrichtung gemäß Anspruch 8, wobei der Prozessor (31) konfiguriert ist, um die Vielzahl ausführbarer Ablaufteile (18) des Handlungsablaufs (24) vom dem Startknoten (46) des Handlungsablaufs (24) bis zu einem Ende (48) des Handlungsablaufs (24) auszuführen.
10. Vorrichtung gemäß Anspruch 8 oder 9, wobei das Konfigurationssignal (14) eine Information aufweist, die den zumindest einen Startknoten (46) des Handlungsablaufs (24) definiert.
11. Vorrichtung gemäß einem der Ansprüche 1 bis 10, wobei der Handlungsablauf (24) zumindest eine Teilmenge der in dem Datenspeicher (16) gespeicherten Vielzahl ausführbarer Ablaufteile (18) umfasst; und wobei der Prozessor (31) ausgebildet ist, um zum Ansprechen der Peripherie (32) die Teilmenge von ausführbaren Ablaufteilen (18) zu durchlaufen und in einem ersten Ablaufteil (18i) zumindest eine Eingangsgröße zu verarbeiten, um eine Ausgangsgröße zu erhalten, und um die Ausgangsgröße als Eingangsgröße eines zweiten Ablaufteils (182) zu verwenden.
12. Vorrichtung gemäß einem der Ansprüche 1 bis 1 1 , wobei ein erster ausführbarer Ablaufteil des Handlungsablaufs zwei Eingänge (56) und zwei Ausgänge (58) aufweist; und wobei mindestens ein Ausgang (58) des ersten ausführbaren Ablaufteils (181) mit einem nächsten, zweiten ausführbaren Ablaufteil (182) des Handlungsablaufs (24) durch eine Verknüpfung (54) verknüpft ist.
13. Vorrichtung gemäß einem der Ansprüche 1 bis 12, wobei jedem ausführbarem Ablaufteil (18) der Vielzahl ausführbarer Ablaufteile eine Funktion, die eine Verarbeitung mindestens einer Eingangsgröße des ausführbaren Ablaufteils definiert, zugeordnet ist; und wobei die Funktion eine Vergleichsoperation, eine Arithmetikoperation, eine Speicheroperation oder einen Aktionsoperation umfasst.
14. Vorrichtung gemäß einem der Ansprüche 1 bis 13, wobei eine Art eines ausführba ren Ablaufteils der Vielzahl ausführbarer Ablaufteile durch fünf Parameter eindeutig definiert ist.
15. Vorrichtung gemäß Anspruch 14, wobei ein erster Parameter der fünf Parameter die Funktion des ausführbaren Ablaufteils der Vielzahl ausführbarer Ablaufteile (18) definiert; wobei ein zweiter Parameter der fünf Parameter einen ersten Speicherbereich, der mit einem ersten Eingang des ausführbaren Ablaufteils assoziiert ist, definiert; wobei ein dritter Parameter der fünf Parameter einen zweiten Speicherbereich, der mit einem zweiten Eingang des ausführbaren Ablaufteils assoziiert ist, definiert; wobei ein vierter Parameter der fünf Parameter einen dritten Speicherbereich, der mit einem ersten Ausgang des ausführbaren Ablaufteils assoziiert ist, definiert; und wobei ein fünfter Parameter der fünf Parameter einen vierten Speicherbereich, der mit einem zweiten Ausgang des ausführbaren Ablaufteils assoziiert ist, definiert.
16. Vorrichtung gemäß einem der Ansprüche 14 oder 15, wobei der Generator (22) ausgebildet ist, um das Konfigurationssignal (14) auf Integer-Zahlen zu überprüfen, die jeden der fünf Parameter wiedergeben.
17. Vorrichtung gemäß Anspruch 16, wobei der Generator (22) ausgebildet ist, um die Integer-Zahlen, die die fünf Parameter wiedergeben, jeweils mit einem Speicherbereich des Datenspeichers eindeutig zu assoziieren.
18. Vorrichtung gemäß einem der Ansprüche 1 bis 17, wobei jedem ausführbaren Ablaufteil (18) der Vielzahl ausführbarer Ablaufteile oder des Handlungsablaufs (24) eine vordefinierte Knotennummer (62) zugeordnet ist, über die der ausführbare Ablaufteil (18) eindeutig adressierbar ist; wobei der Prozessor (31 ) ausgebildet ist, jeden ausführbaren Ablaufteil (18) der Vielzahl ausführbarer Ablaufteile über die vordefinierte Knotennummer (31 ) zu adressieren.
19. Vorrichtung gemäß einem der Ansprüche 1 bis 18, wobei die Vorrichtung ausgebildet ist, um das Konfigurationssignal (14) an der Eingangsschnittstelle (12) über ein Kommunikationsnetzwerk (104) zu empfangen.
20. Vorrichtung gemäß Anspruch 19, wobei das Kommunikationsnetzwerk (104) ein drahtloses Netzwerk umfasst.
21. Vorrichtung gemäß Anspruch 20, wobei das drahtlose Netzwerk (104) ein Funknetzwerk umfasst.
22. Vorrichtung gemäß einem der Ansprüche 1 bis 21 , wobei die Peripherie (32) zumindest einen Sensor (74) und/oder einen Server (82) und/oder einen Schalter (86) und/oder einen Aktuator und/oder einen Motor umfasst.
23. Vorrichtung gemäß einem der Ansprüche 1 bis 22, wobei der Handlungsablauf (24) ein erster Handlungsablauf ist, der von dem Prozessor basierend auf einem ersten Konfigurationssignal (14) bereitgestellt ist; wobei die Vorrichtung ausgebildet ist, um zur Änderung des ersten Handlungsablaufes in einen zweiten Handlungsablauf ein zweites Konfigurationssignal (14) zu empfangen; wobei der Generator (22) ausgebildet ist, um basierend auf dem zweiten Konfigurationssignal (14) eine Neudefinition zumindest eines ausführbaren Ablaufteils des ersten Handlungsablaufes auszuführen; wobei die Neudefinition des Handlungsablaufes Turing-vollständig ist; wobei der Generator (22) ausgebildet ist, um das zweite Konfigurationssignal (14) auf sechs Parameter auszuwerten, die den zumindest einen ausführbaren Ablaufteil (18) für die Neudefinition bestimmen.
24. Vorrichtung gemäß Anspruch 23, wobei ein erster Parameter der sechs Parameter eine Knotennummer (62) des ausführbaren Ablaufteils der Vielzahl ausführbarer Ablaufteile ist; wobei ein zweiter Parameter der sechs Parameter eine Funktion des ausführbaren Ablaufteils neu definiert; wobei ein dritter Parameter der sechs Parameter einen ersten Speicherbereich, der mit einem ersten Eingang des ausführbaren Ablaufteils assoziiert ist, neu definiert; wobei ein vierter Parameter der sechs Parameter einen zweiten Speicherbereich, der mit einem zweiten Eingang des ausführbaren Ablaufteils assoziiert ist, neu definiert; wobei ein fünfter Parameter der sechs Parameter einen dritten Speicherbereich, der mit einem ersten Ausgang des ausführbaren Ablaufteils assoziiert ist, neu definiert; und wobei ein sechster Parameter der sechs Parameter einen vierten Speicherbereich, der mit einem zweiten Ausgang des ausführbaren Ablaufteils assoziiert ist, neu definiert.
25. Vorrichtung gemäß einem der Ansprüche 23 oder 24, wobei jeder der sechs Parameter in dem Konfigurationssignal als eine Integer-Zahl enthalten ist.
26. Vorrichtung gemäß einem der Ansprüche 1 bis 25, die eine loT -Vorrichtung ist.
27. Vorrichtung (155) mit: einer Ausgangsschnittstelle (88), die ausgebildet ist, um ein Konfigurationssignal (14) zu senden; einem Signalgenerator (92), der ausgebildet ist, um das Konfigurationssignal (14) bereitzustellen, so dass das Konfigurationssignal (14) eine Abfolge von ausführbaren Ablaufteilen (18) einer Vielzahl von ausführbaren Ablaufteilen beschreibt; wobei die Abfolge von ausführbaren Ablaufteilen (18) einen Handlungsablauf (24) mit einer Mehrzahl von Handlungsvorschriften eindeutig beschreibt.
28. Vorrichtung gemäß Anspruch 27, die ausgebildet ist, um eine Benutzereingabe (94) zu erhalten, die den Handlungsablauf (24) beschreibt.
29. Vorrichtung gemäß Anspruch 27 oder 28, die ein Web-Interface (102) bereitstellt, um die Benutzereingabe (94) von einer über eine Netzwerkverbindung verbundenen Vorrichtung (98) zu empfangen.
30. System (150) mit: einer Vorrichtung gemäß einem der Ansprüche 1 bis 26; und einer Vorrichtung gemäß einem der Ansprüche 27 bis 29.
31. Verfahren (1700) mit folgenden Schritten:
Speichern (1710) einer Vielzahl ausführbarer Ablaufteile in einem Datenspeicher, wobei jeder Ablaufteil zumindest eine Handlungsvorschrift beschreibt;
Empfangen (1720) eines Konfigurationssignals mit einer Eingangsschnittstelle;
Erstellen (1730) eines Handlungsablaufs, der eine Abfolge von in dem Konfigurationssignal angegebenen Ablaufteilen der Vielzahl von gespeicherten Ablaufteilen umfasst; und
Ansprechen (1740) einer Peripherie gemäß dem Handlungsablauf unter Verwendung einer Schnittstelle, die ausgebildet ist, um mit der Peripherie zu kommunizieren.
32. Verfahren (1800) mit folgenden Schritten:
Bereitstellen (1810) eines Konfigurationssignals unter Verwendung eines Signalgenerators, so dass das Konfigurationssignal eine Abfolge von ausführbaren Ablaufteilen aus einer Vielzahl von ausführbaren Ablaufteilen beschreibt, wobei die Abfolge von Ablaufteilen einen Handlungsablauf mit einer Mehrzahl von Handlungsvorschriften eindeutig beschreibt; und
Senden (1820) des Konfigurationssignals mit einer Ausgangsschnittstelle.
33. Computerprogramm mit einem Programmcode zur Durchführung des Verfahrens nach Anspruch 31 oder 32, wenn das Programm auf einem Computer läuft.
PCT/EP2020/057130 2019-03-18 2020-03-16 Vorrichtung und verfahren zur fernprogrammierung Ceased WO2020187843A1 (de)

Applications Claiming Priority (2)

Application Number Priority Date Filing Date Title
DE102019203639.2A DE102019203639A1 (de) 2019-03-18 2019-03-18 Vorrichtung und Verfahren zur Fernprogrammierung
DE102019203639.2 2019-03-18

Publications (1)

Publication Number Publication Date
WO2020187843A1 true WO2020187843A1 (de) 2020-09-24

Family

ID=69845433

Family Applications (1)

Application Number Title Priority Date Filing Date
PCT/EP2020/057130 Ceased WO2020187843A1 (de) 2019-03-18 2020-03-16 Vorrichtung und verfahren zur fernprogrammierung

Country Status (2)

Country Link
DE (1) DE102019203639A1 (de)
WO (1) WO2020187843A1 (de)

Cited By (1)

* Cited by examiner, † Cited by third party
Publication number Priority date Publication date Assignee Title
WO2024093926A1 (zh) * 2022-11-04 2024-05-10 北京镁伽机器人科技有限公司 用于自动化系统的控制方法、装置、电子设备及存储介质

Families Citing this family (1)

* Cited by examiner, † Cited by third party
Publication number Priority date Publication date Assignee Title
DE102024107985A1 (de) * 2024-03-20 2025-09-25 Winterhalter Product & Technology GmbH Flexible Eingangsschnittstelle zum Betrieb einer Spülmaschine

Citations (3)

* Cited by examiner, † Cited by third party
Publication number Priority date Publication date Assignee Title
EP1315055A2 (de) * 2001-11-27 2003-05-28 Rockwell Automation Technologies, Inc. System und Verfahren zum Erzeugen von Aufträgen zur Funktionsblock-Ausführung
EP2357541A1 (de) * 2010-02-12 2011-08-17 Rockwell Automation Technologies, Inc. Makrofunktionsblock zum Verkapseln einer eingebetteten Logik auf Vorrichtungsebene
EP2790076A1 (de) * 2013-04-10 2014-10-15 Siemens Aktiengesellschaft Verfahren zum Bedienen einer Produktions- oder Werkzeugmaschine, Computerprogramm zur Implementierung des Verfahrens und Bedieneinrichtung mit einem solchen Computerprogramm

Family Cites Families (1)

* Cited by examiner, † Cited by third party
Publication number Priority date Publication date Assignee Title
US10255043B2 (en) * 2016-07-08 2019-04-09 Board Of Trustees Of Western Michigan University Field programmable block system delivering context-aware services in resource-challenged environments

Patent Citations (3)

* Cited by examiner, † Cited by third party
Publication number Priority date Publication date Assignee Title
EP1315055A2 (de) * 2001-11-27 2003-05-28 Rockwell Automation Technologies, Inc. System und Verfahren zum Erzeugen von Aufträgen zur Funktionsblock-Ausführung
EP2357541A1 (de) * 2010-02-12 2011-08-17 Rockwell Automation Technologies, Inc. Makrofunktionsblock zum Verkapseln einer eingebetteten Logik auf Vorrichtungsebene
EP2790076A1 (de) * 2013-04-10 2014-10-15 Siemens Aktiengesellschaft Verfahren zum Bedienen einer Produktions- oder Werkzeugmaschine, Computerprogramm zur Implementierung des Verfahrens und Bedieneinrichtung mit einem solchen Computerprogramm

Cited By (1)

* Cited by examiner, † Cited by third party
Publication number Priority date Publication date Assignee Title
WO2024093926A1 (zh) * 2022-11-04 2024-05-10 北京镁伽机器人科技有限公司 用于自动化系统的控制方法、装置、电子设备及存储介质

Also Published As

Publication number Publication date
DE102019203639A1 (de) 2020-09-24

Similar Documents

Publication Publication Date Title
DE112005001031B4 (de) Grafisches Bildschirmkonfigurationsgerüst für vereinheitlichte Prozesssteuerungssystemoberfläche
DE10305643B4 (de) Vielzwecksteuerung und Verfahren zur Konfiguration für ein Prozesssteuerungssystem
EP1182529B1 (de) Industrielle Steuerung auf der Basis Technologischer Objekte
DE102018124414A1 (de) Systeme und verfahren zur einfachen entwicklung der grafischen anzeigekonfiguration in einer prozesskontrollanlage
DE10012249A1 (de) Modifikationsfunktionsblöcke in einem Prozeßsteuerungssystem
EP3807728B1 (de) Prozesssteuerungseinheit und verfahren zum interprozessualen austausch von prozessvariablen
EP1904903B1 (de) Verfahren zum bedienen und beobachten eines steuergeräts, hiermit korrespondierendes bedien-/beobachtungsgerät, steuergerät sowie maschine mit einem solchen steuergerät und verwendungen des verfahrens sowie datenspeichermedien
EP3538960B1 (de) Ablaufsteuerung von programmmodulen
DE102007039425A1 (de) Steuerknoten und Steuerung
WO2008068333A1 (de) Steuerungssystem sowie verfahren zur konfiguration eines steuerungssystems
DE102006025747A1 (de) Automatisiertes System zur Steuerung von Textilmaschinen
DE102019203639A1 (de) Vorrichtung und Verfahren zur Fernprogrammierung
WO2013107466A1 (de) Verfahren zur konfiguration einer fluidsteuereinheit, computerprogrammprodukt und fluidisches system
EP2407842B1 (de) Verfahren zur Inbetriebnahme von Maschinen oder Maschinen einer Maschinenserie und Projektierungssystem
EP1947568A1 (de) Verfahren zur Beobachtung eines Steuergeräts
EP2804165A1 (de) System mit einem Haushaltsgerät und einer Kommunikationseinrichtung sowie Verfahren zum Betrieb eines solchen Systems
EP1137972B1 (de) Automatisierungssystem zur lösung einer prozesstechnischen aufgabenstellung und verfahren hierzu
EP2324399A1 (de) Automatisierungssystem mit frameworkbasierter steuerung
WO2019057873A1 (de) Industrielle steuerung
EP1495381B1 (de) Messeinrichtung f r die prozesstechnik und betriebsverfahren f r eine messeinrichtung
DE10055168A1 (de) Industrielle Steuerung auf der Basis verteilbarer Technologischer Objekte
DE102013019354A1 (de) Verfahren zum Anbieten von Waren, Dienstleistungen und/oder sonstigen Werten für den Bereich der Gebäudeautomation an Nutzer im Internet
WO2014173739A1 (de) Steuerungssystem für eine automatisierungsanlage und zugehöriges entwicklungssystem
WO2023117938A1 (de) Technik zur parametrierung und/oder konfiguration für eine auf einer speicher-programmierbaren steuerung basierenden vorrichtung
WO2016038203A1 (de) Kommunikation zwischen netzwerkknoten mittels skripten

Legal Events

Date Code Title Description
121 Ep: the epo has been informed by wipo that ep was designated in this application

Ref document number: 20711920

Country of ref document: EP

Kind code of ref document: A1

DPE1 Request for preliminary examination filed after expiration of 19th month from priority date (pct application filed from 20040101)
NENP Non-entry into the national phase

Ref country code: DE

122 Ep: pct application non-entry in european phase

Ref document number: 20711920

Country of ref document: EP

Kind code of ref document: A1