Using Events - Revision history

Mparadis at 17:09, 16 May 2025

2025-05-16T17:09:34Z

Mparadis: /* Using Multiple Event Handlers */

2022-04-19T20:54:40Z

Using Multiple Event Handlers

← Older revision		Revision as of 20:54, 19 April 2022
Line 140:		Line 140:
	JavaScript=		JavaScript=
	<syntaxhighlight lang=javascript>		<syntaxhighlight lang=javascript>


	~~...~~
	// Declare your objects		// Declare your objects
	const oneChannel = new phidget22.DigitalInput()		const oneChannel = new phidget22.DigitalInput()
Line 148:		Line 145:
	...		...
	// Define the handlers that will be called when the event occurs		// Define the handlers that will be called when the event occurs
	oneChannel.StateChange = function ~~stateChange~~(state) {		oneChannel.StateChange = function(state) {
	console.log('State: ' + state)		console.log('State: ' + state)
	}		}
	anotherChannel.StateChange = function ~~aDifferentStateChange~~(state) {		anotherChannel.StateChange = function(state) {
	console.log('A Different StateChange Handler')		console.log('A Different StateChange Handler')
	if(state) {		if(state) {

Mparadis at 20:47, 19 April 2022

2022-04-19T20:47:27Z

← Older revision		Revision as of 20:47, 19 April 2022
Line 140:		Line 140:
	JavaScript=		JavaScript=
	<syntaxhighlight lang=javascript>		<syntaxhighlight lang=javascript>
	// Declare the event ~~handlers~~
	function stateChange(state) {
			...
			// Declare your objects
			const oneChannel = new phidget22.DigitalInput()
			const anotherChannel = new phidget22.DigitalInput()
			...
			// Define the handlers that will be called when the event occurs
			oneChannel.StateChange = function stateChange(state) {
	console.log('State: ' + state)		console.log('State: ' + state)
	}		}
			anotherChannel.StateChange = function aDifferentStateChange(state) {
	function aDifferentStateChange(state) {
	console.log('A Different StateChange Handler')		console.log('A Different StateChange Handler')
	if(state) {		if(state) {
Line 154:		Line 160:
	}		}
	}		}
	~~...~~
	~~// Declare your objects~~
	~~var oneChannel = new phidget22.DigitalInput()~~
	~~var anotherChannel = new phidget22.DigitalInput()~~
	~~...~~
	~~// Assign the handlers that will be called when the event occurs~~
	~~oneChannel.StateChange += stateChange;~~
	~~anotherChannel.StateChange += aDifferentStateChange;~~
	</syntaxhighlight>		</syntaxhighlight>
	</tabber>		</tabber>
Line 237:		Line 235:
	}		}
	...		...
	~~var~~ ch = new phidget22.DigitalInput();		const ch = new phidget22.DigitalInput();
	...		...
	//Here we create a property of ch called "myVariable", with the information to store		//Here we create a property of ch called "myVariable", with the information to store
Line 245:		Line 243:
	ch.onStateChange = stateChange;		ch.onStateChange = stateChange;

	ch.open();		await ch.open();

	//The rest of your code here...		//The rest of your code here...

Mparadis at 16:24, 4 July 2019

2019-07-04T16:24:01Z

← Older revision		Revision as of 16:24, 4 July 2019
Line 57:		Line 57:
	public static DigitalInputStateChangeListener onStateChange = new DigitalInputStateChangeListener() {		public static DigitalInputStateChangeListener onStateChange = new DigitalInputStateChangeListener() {
	@Override		@Override
	public void ~~onStateChangeHandler~~(StateChangeEvent e) {		public void onStateChange(StateChangeEvent e) {
	System.out.println("State: " + e.getState());		System.out.println("State: " + e.getState());
	}		}
Line 64:		Line 64:
	public static DigitalInputStateChangeListener aDifferentStateChange = new DigitalInputStateChangeListener() {		public static DigitalInputStateChangeListener aDifferentStateChange = new DigitalInputStateChangeListener() {
	@Override		@Override
	public void ~~onStateChangeHandler~~(StateChangeEvent e) {		public void onStateChange(StateChangeEvent e) {
	System.out.println("A Different StateChange Handler");		System.out.println("A Different StateChange Handler");
	if(e.getState()) {		if(e.getState()) {

Mparadis at 16:24, 9 April 2019

2019-04-09T16:24:36Z

@@ Line 92: / Line 92: @@
+}
-void stateChange(object sender, Phidget22.Events.StateChangeEventArgs e) {
+void aDifferentStateChange(object sender, Phidget22.Events.StateChangeEventArgs e) {
      Console.WriteLine("A Different StateChange Handler");
      if(e.State) {
@@ Line 136: / Line 136: @@
 PhidgetDigitalInput_setOnStateChangeHandler(oneChannel, onStateChangeHandler, NULL);
 PhidgetDigitalInput_setOnStateChangeHandler(anotherChannel, onStateChangeHandler, NULL);
 </syntaxhighlight>
 </tabber>

Jdecoux at 16:47, 15 March 2019

2019-03-15T16:47:22Z

@@ Line 23: / Line 23: @@
 ===Error Events===
 Make sure not to ignore using the Phidget error event handler, as many Phidgets will send critical information to the program using error events, such as when a sensor takes a measurement outside of its valid range, or activates some safety feature.
 ==Linking Data to Events==

Jdecoux: /* Linking Data to Events */

2019-03-06T17:28:37Z

Linking Data to Events

← Older revision		Revision as of 17:28, 6 March 2019
Line 86:		Line 86:
	\|-\|		\|-\|
	JavaScript=		JavaScript=
	JavaScript is dynamically interpreted, and objects follow a less rigid structure than in other languages. To link a variable with a given Phidget object to have it available from the event, you can add it to the Phidget object that will be triggering the event. Then, you may access the information using the {{code\|~~self~~}} parameter of the event.		JavaScript is dynamically interpreted, and objects follow a less rigid structure than in other languages. To link a variable with a given Phidget object to have it available from the event, you can add it to the Phidget object that will be triggering the event. Then, you may access the information using the {{code\|this}} parameter of the event.

	For example, if we wanted to group a number with a Phidget channel to be used in an event:		For example, if we wanted to group a number with a Phidget channel to be used in an event:

Burley at 17:12, 6 March 2019

2019-03-06T17:12:04Z

← Older revision		Revision as of 17:12, 6 March 2019
Line 111:		Line 111:

	==When should I poll?==		==When should I poll?==
	If all you need is a simple program that reads a small amount of data from a device, it is possible to ~~write a program that opens~~ a channel, ~~waits~~ for attachment, ~~reads~~ the data, and ~~closes~~ the channel. In that case, the code to implement and set event handlers might not be worth the effort. When polling, '''error checking becomes very important''', as accessing some channel properties while the channel is detached, or before any data comes back from the Phidget, will result in an error or exception that could kill the program. There will always be a race between checking the {{Code\|Attached}} property and accessing a data or state property.		If all you need is a simple program that reads a small amount of data from a device, it is possible to open a channel, wait for attachment, read the data, and close the channel. In that case, the code to implement and set event handlers might not be worth the effort. When polling, '''error checking becomes very important''', as accessing some channel properties while the channel is detached, or before any data comes back from the Phidget, will result in an error or exception that could kill the program. There will always be a race between checking the {{Code\|Attached}} property and accessing a data or state property.

	When in doubt, use event handlers.		When in doubt, use event handlers.

	{{Flow_Navigation_Buttons\|{{Flow Page Number\|{{PAGENAME}} }} }}		{{Flow_Navigation_Buttons\|{{Flow Page Number\|{{PAGENAME}} }} }}

Burley at 17:11, 6 March 2019

2019-03-06T17:11:30Z

← Older revision		Revision as of 17:11, 6 March 2019
Line 111:		Line 111:

	==When should I poll?==		==When should I poll?==
	If all you need is a simple program that reads a small amount of data from a device, it is possible to write a program that ~~simply~~ opens a channel, waits for attachment, reads the data, and closes the channel. In that case, the code to implement and set event handlers might not be worth the effort. When polling, '''error checking becomes very important''', as accessing some channel properties while the channel is detached, or before any data comes back from the Phidget, will result in an error or exception that could kill the program. There will always be a race between checking the {{Code\|Attached}} property and accessing a data or state property.		If all you need is a simple program that reads a small amount of data from a device, it is possible to write a program that opens a channel, waits for attachment, reads the data, and closes the channel. In that case, the code to implement and set event handlers might not be worth the effort. When polling, '''error checking becomes very important''', as accessing some channel properties while the channel is detached, or before any data comes back from the Phidget, will result in an error or exception that could kill the program. There will always be a race between checking the {{Code\|Attached}} property and accessing a data or state property.

	When in doubt, use event handlers.		When in doubt, use event handlers.

	{{Flow_Navigation_Buttons\|{{Flow Page Number\|{{PAGENAME}} }} }}		{{Flow_Navigation_Buttons\|{{Flow Page Number\|{{PAGENAME}} }} }}

Jdecoux: Created page with "Category:Programming{{Recommended_Flow_Links|{{Flow Page Number|{{PAGENAME}} }} }} NOTOC If you are new to Phidgets, or event-driven programming, chances are your fir..."

2019-02-28T20:06:07Z

Created page with "Category:Programming{{Recommended_Flow_Links|{{Flow Page Number|{{PAGENAME}} }} }} __NOTOC__ If you are new to Phidgets, or event-driven programming, chances are your fir..."

New page

[[Category:Programming]]{{Recommended_Flow_Links|{{Flow Page Number|{{PAGENAME}} }} }}
__NOTOC__

If you are new to Phidgets, or event-driven programming, chances are your first instinct will be to poll for everything. Polling is the action of repeatedly checking a variable or property to see if it has changed, and is generally done in-line from the main body of your application. While this can be effective in smaller applications, this quickly becomes inefficient. You also risk missing a change your program is waiting for, if it polls for data too slowly.

==Events==
[[Image:Event_Explanation_Flowchart.png|200px|right|link={{Server}}/docs/images/2/21/Event_Explanation_Flowchart.png|thumb|'''Click to Enlarge''']]
The Phidget library allows for the use of '''event-driven programming'''. This allows your program to react to certain stimuli as they happen, rather than having to constantly check for changes. By setting up event handlers, you are setting up functions that run every time the event associated with them occurs. Once they have been assigned, these functions run '''''independently from the main body of code'''''. For example, a '''State Change''' event handler for a {{code|DigitalInput}} channel will run every time the input state changes. Similarly, '''Attach''' and '''Detach''' events will occur when a device channel attaches to and detaches from your program (e.g. is plugged in and unplugged).

Using events can be very useful for tasks such as recording every data point from a Phidget sensor, reacting to a button being pressed, or initializing a channel as soon as it is attached. This frees up the main body of your program from having to constantly check the status of the Phidget, which can significantly clean up many applications.
<br clear="all">

==Special Considerations==
When using events, you must be mindful of keeping the code handling the event running as quickly as possible. If the event handler takes longer than the interval between events, this will cause the events to pile up and fall out of sync with the time they occur, and eventually start being lost.

When using events, you will need to be careful about what you share between the event and your main code. This is because '''events can happen at any time''', so any variables shared with them could change unexpectedly.

==Recommendations==
We recommend all but the simplest program should set handlers that will be called when a channel '''attaches''', '''detaches''', sends an '''error''', or receives new sensor data.

Initializing a channel should be done from the '''attach''' event handler, so it will always be configured as intended, even if something causes it to be unplugged and plugged back in.

===Error Events===
Make sure not to ignore using the Phidget error event handler, as many Phidgets will send critical information to the program using error events, such as when a sensor takes a measurement outside of its valid range, or activates some safety feature.

==Linking Data to Events==
When you're using events in your program, it may become useful to link certain information to the event for a given Phidget channel. Some programming languages provide a convenient way of doing exactly that, though the specifics depend on the programming language you are using:

<tabber>
Python=
Python is dynamically interpreted, and objects follow a less rigid structure than in other languages. To link a variable with a given Phidget object to have it available from the event, you can add it to the Phidget object that will be triggering the event. Then, you can access the information using the {{code|self}} parameter of the event.

For example, if we wanted to group a number with a Phidget channel to be used in an event:
<syntaxhighlight lang=python>
def onStateChangeHandler(self, state):
#We can now access and even change "myVariable" from the event
print(self.myVariable)
self.myVariable += 1

ch = DigitalInput()

#Addressing info here

#Here we create an attribute of ch called "myVariable", and assign it the information to store
#We'll use an integer here for simplicity, but this could be anything, even a second Phidget Handle
ch.myVariable = 0
ch.setOnStateChangeHandler(onStateChangeHandler)

ch.openWaitForAttachment(5000)

# The rest of your code here....
</syntaxhighlight>
|-|
C=
In C, all event handler declarations have a context pointer that can be pointed at any object you choose. This can be a set of relevant data, or even a Phidget handle.

For example, if we wanted to link a number with a specific event for a Phidget channel:

<syntaxhighlight lang=C>
static void CCONV onStateChangeHandler(PhidgetDigitalInputHandle pdih, void *ctx, int state) {

//We can now access the information at the pointer from the event
int* myIntPtr = (int*)ctx;
printf("Int: %d\n", *myIntPtr);
(*myIntPtr) ++;
}

int main() {
PhidgetDigitalInputHandle ch = NULL;
int myIntMain = 0;

PhidgetDigitalInput_create(&ch);

//Addressing info here

//Here we pass "myStringMain" as the context pointer so we can access it from the event
//This can be a pointer to any variable or structure, or even a second Phidget handle
PhidgetDigitalInput_setOnStateChangeHandler(ch, onStateChangeHandler, &myIntMain);

Phidget_openWaitForAttachment((PhidgetHandle)ch, 5000);

//The rest of your code here...

}
</syntaxhighlight>
|-|
JavaScript=
JavaScript is dynamically interpreted, and objects follow a less rigid structure than in other languages. To link a variable with a given Phidget object to have it available from the event, you can add it to the Phidget object that will be triggering the event. Then, you may access the information using the {{code|self}} parameter of the event.

For example, if we wanted to group a number with a Phidget channel to be used in an event:
<syntaxhighlight lang=javaScript>
function stateChange(state) {
//We can now access and even change "myVariable" from the event
console.log(this.myVariable);
this.myVariable += 1;
}
...
var ch = new phidget22.DigitalInput();
...
//Here we create a property of ch called "myVariable", with the information to store
//We'll use an integer here for simplicity, but this could be anything,
//even a second Phidget Handle
ch.myVariable = 0
ch.onStateChange = stateChange;

ch.open();

//The rest of your code here...
</syntaxhighlight>
</tabber>

==When should I poll?==
If all you need is a simple program that reads a small amount of data from a device, it is possible to write a program that simply opens a channel, waits for attachment, reads the data, and closes the channel. In that case, the code to implement and set event handlers might not be worth the effort. When polling, '''error checking becomes very important''', as accessing some channel properties while the channel is detached, or before any data comes back from the Phidget, will result in an error or exception that could kill the program. There will always be a race between checking the {{Code|Attached}} property and accessing a data or state property.

When in doubt, use event handlers.

{{Flow_Navigation_Buttons|{{Flow Page Number|{{PAGENAME}} }} }}