Best Phidgets Practices - Revision history

Burley at 16:42, 4 January 2019

2019-01-04T16:42:01Z

← Older revision		Revision as of 16:42, 4 January 2019
Line 22:		Line 22:
	== Be Specific With Addressing ==		== Be Specific With Addressing ==

	When you open a Phidget channel, the library ~~try~~ to attach a channel matching all the addressing properties that have been set. If none of the matching properties are set, the Phidget library will match the first channel of the same class. In simple cases this will be fine. If your program deals with multiple Phidgets, it is always wise to be specific.		When you open a Phidget channel, the library tries to attach a channel matching all the addressing properties that have been set. If none of the matching properties are set, the Phidget library will match the first channel of the same class. In simple cases this will be fine. If your program deals with multiple Phidgets, it is always wise to be specific.

	For example, if a Phidget temperature sensor is the only device connected to a computer, opening a {{Code\|TemperatureSensor}} channel without setting any addressing properties will attach to that temperature sensor; however, if a DC motor controller is connected to the computer, the on-board temperature sensor on the motor controller might attach to the channel instead. This could be prevented by setting a {{code\|DeviceSerialNumber}} or {{code\|HubPort}}.		For example, if a Phidget temperature sensor is the only device connected to a computer, opening a {{Code\|TemperatureSensor}} channel without setting any addressing properties will attach to that temperature sensor; however, if a DC motor controller is connected to the computer, the on-board temperature sensor on the motor controller might attach to the channel instead. This could be prevented by setting a {{code\|DeviceSerialNumber}} or {{code\|HubPort}}.

Jdecoux at 22:33, 25 October 2018

2018-10-25T22:33:24Z

← Older revision		Revision as of 22:33, 25 October 2018
Line 7:		Line 7:
	== Use Event Handlers ==		== Use Event Handlers ==
	The Phidget library supports both polling channel properties to determine state and to get current data values, and the library supports firing events when states change and data is received. Reading channel properties directly is useful to determine the state or current data value at a point in time, but is difficult to implement correctly. Event handlers are more predicable and easier to implement correctly. Unless a program has a specific and obvious reason to access properties directly, event handlers should be used.		The Phidget library supports both polling channel properties to determine state and to get current data values, and the library supports firing events when states change and data is received. Reading channel properties directly is useful to determine the state or current data value at a point in time, but is difficult to implement correctly. Event handlers are more predicable and easier to implement correctly. Unless a program has a specific and obvious reason to access properties directly, event handlers should be used.

			== Set Properties in the Attach Handler ==

			An attach event will occur each time a channel is matched. This makes the attach handler the perfect place to initialize properties such as {{Code\|DataInterval}}, {{Code\|ChangeTrigger}}, gain values, and ranges. If properties are initialize elsewhere, in a situation where the channel detaches temporarily, those properties will revert to defaults during the next attach. Setting properties within the attach handler ensures they are always the expected values.

	== Keep Event Handlers Short ==		== Keep Event Handlers Short ==
Line 23:		Line 27:

	Since there's no way to predict what other Phidgets may be plugged into a computer (or become available over the network), you should be as specific as possible before opening a channel.		Since there's no way to predict what other Phidgets may be plugged into a computer (or become available over the network), you should be as specific as possible before opening a channel.

			== Don't Forget to Close() ==

			Calling {{Code\|Close()}} on a channel releases the channel so that it can be matched again, and to ensure your Phidget has stopped. For example, certain motor controllers will maintain speed or continue trying to track the last position they were sent to, if they are not stopped or closed before the program ends. In [[Language_-_LabVIEW\|LabVIEW]], the runtime environment executes a program internally, so if {{Code\|Close()}} is not called, the LabVIEW environment will continue to tie up the channel despite the program having been stopped.

	== When In Doubt, Open Remotely ==		== When In Doubt, Open Remotely ==
Line 28:		Line 36:

	See the <code>IsRemote</code> and <code>IsLocal</code> Phidget properties in the {{Phidget22API}}.		See the <code>IsRemote</code> and <code>IsLocal</code> Phidget properties in the {{Phidget22API}}.

	~~== Set Properties in the Attach Handler ==~~

	An attach event will occur each time a channel is matched. This makes the attach handler the perfect place to initialize properties such as {{Code\|DataInterval}}, {{Code\|ChangeTrigger}}, gain values, and ranges. If properties are initialize elsewhere, in a situation where the channel detaches temporarily, those properties will revert to defaults during the next attach. Setting properties within the attach handler ensures they are always the expected values.

	~~== Don't Forget to Close() ==~~

	Calling {{Code\|Close()}} on a channel releases the channel so that it can be matched again, and to ensure your Phidget has stopped. For example, certain motor controllers will maintain speed or continue trying to track the last position they were sent to, if they are not stopped or closed before the program ends. In [[Language_-_LabVIEW\|LabVIEW]], the runtime environment executes a program internally, so if {{Code\|Close()}} is not called, the LabVIEW environment will continue to tie up the channel despite the program having been stopped.

	== Further Reading ==		== Further Reading ==

Jdecoux: /* Be Specific With Addressing */

2018-10-24T22:35:41Z

Be Specific With Addressing

← Older revision		Revision as of 22:35, 24 October 2018
Line 20:		Line 20:
	When you open a Phidget channel, the library try to attach a channel matching all the addressing properties that have been set. If none of the matching properties are set, the Phidget library will match the first channel of the same class. In simple cases this will be fine. If your program deals with multiple Phidgets, it is always wise to be specific.		When you open a Phidget channel, the library try to attach a channel matching all the addressing properties that have been set. If none of the matching properties are set, the Phidget library will match the first channel of the same class. In simple cases this will be fine. If your program deals with multiple Phidgets, it is always wise to be specific.

	For example, if a Phidget temperature sensor is the only device connected to a computer, opening a {{Code\|TemperatureSensor}} channel without setting any addressing properties will attach to that temperature sensor; however, if a DC motor controller is connected to the computer, the on-board temperature sensor on the motor controller might attach to the channel instead. This could be prevented by setting a {{code\|DeviceSerialNumber}} or {{HubPort}}.		For example, if a Phidget temperature sensor is the only device connected to a computer, opening a {{Code\|TemperatureSensor}} channel without setting any addressing properties will attach to that temperature sensor; however, if a DC motor controller is connected to the computer, the on-board temperature sensor on the motor controller might attach to the channel instead. This could be prevented by setting a {{code\|DeviceSerialNumber}} or {{code\|HubPort}}.

	Since there's no way to predict what other Phidgets may be plugged into a computer (or become available over the network), you should be as specific as possible before opening a channel.		Since there's no way to predict what other Phidgets may be plugged into a computer (or become available over the network), you should be as specific as possible before opening a channel.

Jdecoux at 22:18, 24 October 2018

2018-10-24T22:18:52Z

← Older revision		Revision as of 22:18, 24 October 2018
Line 35:		Line 35:
	== Don't Forget to Close() ==		== Don't Forget to Close() ==

	Calling {{Code\|Close()}} on a channel releases the channel so that it can be matched again~~. In most cases~~, ~~it's not technically necessary~~ to ~~call {{Code\|Close()}} because when a program exits~~, ~~the channel~~ will ~~be released; however, it is good practice~~ to ~~close~~ the ~~channel when you~~ are ~~finished as some environments will~~ not ~~release~~ the ~~channel automatically~~. ~~For example in~~ [[Language_-_LabVIEW\|LabVIEW]], the runtime environment executes a program internally, so if {{Code\|Close()}} is not called, the LabVIEW environment will continue to tie up the channel despite the program having been stopped.		Calling {{Code\|Close()}} on a channel releases the channel so that it can be matched again, and to ensure your Phidget has stopped. For example, certain motor controllers will maintain speed or continue trying to track the last position they were sent to, if they are not stopped or closed before the program ends. In [[Language_-_LabVIEW\|LabVIEW]], the runtime environment executes a program internally, so if {{Code\|Close()}} is not called, the LabVIEW environment will continue to tie up the channel despite the program having been stopped.

	== Further Reading ==		== Further Reading ==

Jdecoux at 22:10, 24 October 2018

2018-10-24T22:10:08Z

← Older revision		Revision as of 22:10, 24 October 2018
Line 16:		Line 16:
	A common mistake is to update a GUI, or wait for user input from within an event handler. Most GUI APIs have support for dispatching updates to the GUI thread, and those should be used. Waiting for user input will block the event handler, and should never be done. Instead, a flag should be set and a loop in another thread should wait for the input.		A common mistake is to update a GUI, or wait for user input from within an event handler. Most GUI APIs have support for dispatching updates to the GUI thread, and those should be used. Waiting for user input will block the event handler, and should never be done. Instead, a flag should be set and a loop in another thread should wait for the input.

	== Be Specific With ~~Open()~~ ==		== Be Specific With Addressing ==

	When you ~~use {{Code\|Open()}} to access~~ a Phidget ~~device~~ channel, the library ~~will first~~ try to ~~match~~ a channel of the ~~class~~ that ~~you're using~~. ~~After~~ the ~~class, there are a number of other~~ matching properties ~~can be~~ set ~~to further filter which device~~ channel is ~~matched~~. ~~For example:~~		When you open a Phidget channel, the library try to attach a channel matching all the addressing properties that have been set. If none of the matching properties are set, the Phidget library will match the first channel of the same class. In simple cases this will be fine. If your program deals with multiple Phidgets, it is always wise to be specific.

	* The '''serial number''' of a device or VINT Hub		For example, if a Phidget temperature sensor is the only device connected to a computer, opening a {{Code\|TemperatureSensor}} channel without setting any addressing properties will attach to that temperature sensor; however, if a DC motor controller is connected to the computer, the on-board temperature sensor on the motor controller might attach to the channel instead. This could be prevented by setting a {{code\|DeviceSerialNumber}} or {{HubPort}}.
	* The '''hub port''' a VINT device is plugged into
	* The '''channel''' number of a device channel, when a device has multiple channels of the same class
	* If a channel '''is remote''' or '''is local'''
	* The '''server name''', if a device channel is being accessed over the [[Phidget Network Server]]

	~~If none of the matching properties are set, the Phidget library will match the first channel of the same class. In simple cases this will be fine.~~ For example, if a Phidget temperature sensor is the only device connected to a computer, opening a {{Code\|TemperatureSensor}} channel without setting any ~~matching~~ properties will ~~match~~ that temperature sensor; however, if a DC motor controller is connected to the computer, the on-board temperature sensor on the motor ~~control may match~~. ~~Setting the~~ {{~~Code~~\|DeviceSerialNumber}} ~~will force the channel to match the desired device channel~~.

	Since there's no way to predict what other Phidgets may be plugged into a computer (or become available over the network), you should be as specific as possible before opening a channel.		Since there's no way to predict what other Phidgets may be plugged into a computer (or become available over the network), you should be as specific as possible before opening a channel.

Chad: /* Use Event Handlers */

2017-07-12T19:21:21Z

Use Event Handlers

← Older revision		Revision as of 19:21, 12 July 2017
Line 1:		Line 1:
	[[Category:Programming]]		[[Category:Programming]]
	The purpose of this page is to provide a list of "Best Practices" to follow when writing code that uses Phidgets. These "Best Practices" are designed to eliminate common mistakes made when using the {{Phidget22API}}, and to help maintain an stable structure while build more complicated systems.		The purpose of this page is to provide a list of "Best Practices" to follow when writing code that uses Phidgets. These "Best Practices" are designed to eliminate common mistakes made when using the {{Phidget22API}}, and to help maintain an stable structure while build more complicated systems.

			== Check Results ==
			Almost every method in the {{Phidget22API}} returns a result code, or throws an exception if the language supports exceptions. The result code must be checked, and any exception caught, to ensure each operation is successful. Ignoring results will in the best case cause programs to crash, and in the worst, lead to invalid or unexpected behavior.

	== Use Event Handlers ==		== Use Event Handlers ==

Chad: /* Don't Forget to Close() */

2017-07-12T19:12:49Z

Don't Forget to Close()

← Older revision		Revision as of 19:12, 12 July 2017
Line 38:		Line 38:
	== Don't Forget to Close() ==		== Don't Forget to Close() ==

	Calling {{Code\|Close()}} on a channel releases the channel so that it can be matched again. In most cases, it's not technically necessary to call {{Code\|Close()}} because when ~~your~~ program exits, the channel will be released; however, it is good practice to close a channel when you are finished ~~with it~~ as some environments will not release the channel automatically. For example in [[Language_-_LabVIEW\|LabVIEW]], the runtime environment ~~merely interprets your~~ program, so if ~~you do not call~~ {{Code\|Close()}}, the LabVIEW environment will continue to tie up the channel despite having stopped ~~the program you're working on~~.		Calling {{Code\|Close()}} on a channel releases the channel so that it can be matched again. In most cases, it's not technically necessary to call {{Code\|Close()}} because when a program exits, the channel will be released; however, it is good practice to close the channel when you are finished as some environments will not release the channel automatically. For example in [[Language_-_LabVIEW\|LabVIEW]], the runtime environment executes a program internally, so if {{Code\|Close()}} is not called, the LabVIEW environment will continue to tie up the channel despite the program having been stopped.

	== Further Reading ==		== Further Reading ==

Chad: /* Set Properties in the Attach Handler */

2017-07-12T19:08:31Z

Set Properties in the Attach Handler

← Older revision		Revision as of 19:08, 12 July 2017
Line 34:		Line 34:
	== Set Properties in the Attach Handler ==		== Set Properties in the Attach Handler ==

	An ~~'''~~attach~~'''~~ event will occur each time a channel is matched. This makes the attach handler the perfect place to initialize properties such as {{Code\|DataInterval}}, {{Code\|ChangeTrigger}}, gain values, and ranges. If properties are initialize elsewhere, in a situation where the channel detaches those properties will revert to defaults. Setting properties within the ~~'''~~attach~~'''~~ handler ensures they are always the expected values.		An attach event will occur each time a channel is matched. This makes the attach handler the perfect place to initialize properties such as {{Code\|DataInterval}}, {{Code\|ChangeTrigger}}, gain values, and ranges. If properties are initialize elsewhere, in a situation where the channel detaches temporarily, those properties will revert to defaults during the next attach. Setting properties within the attach handler ensures they are always the expected values.

	== Don't Forget to Close() ==		== Don't Forget to Close() ==

Chad: /* When In Doubt, Open Remotely */

2017-07-12T19:05:56Z

When In Doubt, Open Remotely

← Older revision		Revision as of 19:05, 12 July 2017
Line 28:		Line 28:

	== When In Doubt, Open Remotely ==		== When In Doubt, Open Remotely ==
	When the [[Phidget Network Server\|Network Server]] is enabled, a channel can match both a local device channel and a remote channel. The end result would be the same ~~as the same actual device channel would be attached~~; however, most remote channels support being attached to multiple clients, while a local device channel can only be attached once. Unless the desire is to only allow the device channel to be attached once, or performance is critical, it is more flexible to match the network channel.		When the [[Phidget Network Server\|Network Server]] is enabled, a channel can match both a local device channel and a remote channel. The end result would be functionally the same; however, most remote channels support being attached to multiple clients, while a local device channel can only be attached once. Unless the desire is to only allow the device channel to be attached once, or performance is critical, it is more flexible to match the network channel as other clients will still be able to attach to the device channel.

	See the <code>IsRemote</code> and <code>IsLocal</code> Phidget properties in the {{Phidget22API}}.		See the <code>IsRemote</code> and <code>IsLocal</code> Phidget properties in the {{Phidget22API}}.

Chad: /* Be Specific With Open() */

2017-07-12T19:02:57Z

Be Specific With Open()

← Older revision		Revision as of 19:02, 12 July 2017
Line 15:		Line 15:
	== Be Specific With Open() ==		== Be Specific With Open() ==

	When you use {{Code\|Open()}} to access a Phidget device channel, the library will first try to match a channel of the class that you're using. ~~There~~ are a number of other matching properties can be set to further filter which device channel is matched. For example:		When you use {{Code\|Open()}} to access a Phidget device channel, the library will first try to match a channel of the class that you're using. After the class, there are a number of other matching properties can be set to further filter which device channel is matched. For example:

	* The '''serial number''' of a device or VINT Hub		* The '''serial number''' of a device or VINT Hub
	* The '''port''' a VINT device is plugged into		* The '''hub port''' a VINT device is plugged into
	* The '''channel''' number of a device channel, when a device has multiple channels of the same class		* The '''channel''' number of a device channel, when a device has multiple channels of the same class
	* If a channel '''is remote''' or '''is local'''		* If a channel '''is remote''' or '''is local'''