Setting up a New Project
Whether you are building a project from scratch, or adding Phidget functionality to an existing project, you will need to configure your development environment
to properly link the Phidget libraries. To begin, create a new Xcode project:
Setting up a New Project
Next, select an iOS application. For this tutorial, we will use a Single View Application:
Setting up a New Project
Name the project, select Swift as the language, and choose which devices will be supported:
Setting up a New Project
Now that your project is created, you need to add the Phidget libraries (using CocoaPods). Open a terminal at the example location and enter the following
command:
pod init
Setting up a New Project
This will create a new Podfile. Open the Podfile in your favorite text editor and add a reference to the Phidget22Swift pod:
Setting up a New Project
Save your edit to the Podfile, and then enter the following command in the terminal which was opened at the example location:
pod install
Setting up a New Project
After running the command, open the xcworkspace file and access the Phidget libraries by adding the following line to the top of your files:
import Phidget22Swift
Success! The project now has access to Phidgets and we are ready to begin coding.
Write Code
You should now have working examples and a project that is configured. This next teaching section will help you understand how the examples were written so you
can start writing your own code.
Remember: your main reference for writing Swift code will be:
● The Phidget22 API Manual
● Swift example code
Write Code
Step One: Create And Address
First, create a Phidget object. For example, we can create a digital input object like this:
let ch = DigitalInput()
Next, we can address which Phidget we want to connect to by setting parameters such as DeviceSerialNumber.
ch.setDeviceSerialNumber(496911);
This guide won't go in-depth on error handling, but here is an example of the previous
code with error handling:
do{
try ch.open
}catch let error as PhidgetError{
//handle error
}
Write Code
Step Two: Open And Wait For Attachment
After we have specified which Phidget to connect to, we can open the Phidget object like this:
ch.open(timeout: 5000)
To use a Phidget, it must be plugged in (attached). We can handle this by calling open(timeout), which will block until a connection is made, or until
the timeout expires. Simply calling open() does not guarantee you can use the Phidget immediately.
Instead, you can verify the device is attached by using an attach handler. To use events to handle attachments, we have to modify our code slightly:
PhidgetDigitalInputHandle ch;
PhidgetDigitalInput_create(&ch);
ch.attach.addHandler(attach_handler)
Phidget_open(ch)
Write Code
Step Two: Open And Wait For Attachment
Next, we have to declare the function that will be called when an attach event is fired - in this case the function onAttachHandler will be called:
func attach_handler(sender: Phidget){
let attachedDevice = sender as! DigitalInput
//configure device here
}
We recommend using this attach handler to set any initialization parameters for the channel such as DataInterval and ChangeTrigger from within the
AttachHandler, so the parameters are set as soon as the device becomes available.
Write Code
Step Three: Do Things With The Phidget
We recommend the use of event driven programming when working with Phidgets. In a similar way to handling an attach event as described above, we can also add an
event handler for a state change event:
ch.attach.addHandler(attach_handler)
ch.stateChange.addhandler(stateChange_handler)
ch.open()
This code will connect a function to an event. In this case, the onStateChangeHandler function will be called when there has been a change to the
channel's input.
Write Code
Step Three: Do Things With The Phidget
Next, we need to create the onStateChangeHandler function:
func stateChange_handler(sender: DigitalInput, state: Bool){
if(state){
//state is true
}
else{
//State is false
}
}
If you are using multiple Phidgets in your program, check out our page on
Using Multiple Phidgets for information on how to properly address them and use them in
events.
Write Code
Step Three: Do Things With The Phidget
If events do not suit your needs, you can also poll the device directly for data using code like this:
var state = ch.getState()
stateLabel.text = state ? "True" : "False"
Important Note: There will be a period of time between the attachment of a Phidget sensor and the availability of the first data from the device. Any
attempts to get this data before it is ready will result in an error code, and a specific nonsensical result. See more information on this on our page for
Unknown Values.
Write Code
Step Three: Do Things With The Phidget
Some Phidget devices have functions that deal with specific predefined values called enumerations. Enumerations commonly provide readable names to a set
of numbered options.
Enumerations with Phidgets in Swift will take the form of Phidget22Swift.EnumerationType.enumerationName.
For example, specifying a SensorType to use the 1142 for a voltage input would look like:
Phidget22Swift.VoltageSensorType.PN_1142
and specifying a K-Type thermocouple for a temperature sensor would be:
Phidget22Swift.ThermocoupleType.K
The Phidget error code for timing out could be specified as:
Phidget22Swift.ErrorCode.timeout
You can find the Enumeration Type under the Enumerations section of the Phidget22 API for your device,
and the Enumeration Name in the drop-down list within.
Write Code
Step Four: Close
At the end of your program, be sure to close your device:
ch.close()
What's Next?
Now that you've set up Phidgets in your programming environment, you should read our guide on Phidget Programming Basics to learn the fundamentals of programming with Phidgets.
Continue reading below for advanced information and troubleshooting for your device.
