Template:PT3 Deck Sequence

From Phidgets Support

Select Language

Select your Programming Language:

C - Select Development Environment

Select your Development Environment:

Windows

MacOS

Linux

PhidgetSBC

Language - C

Windows with Visual Studio

Welcome to using Phidgets with C! By using C, you will have access to the complete Phidget22 API, including events.

Visual Studio is an IDE provided by Microsoft that can be used to develop code in a wide variety of programming languages, including C/C++.

Requirements

First, make sure you have the following installed:

Phidgets Drivers for Windows

● Microsoft Visual Studio

Using Phidgets in Your Programs

There are two ways you can use Phidgets in Visual Studio. You can either start from a sample project provided by our code sample generator, or you can start a new project from scratch.

Select your preferred method below for instructions:

«
»

Visual Studio Code Sample

Finding Code Samples

To find the code sample to use for your Phidget, navigate to the Code Samples page and select your device from the drop-down menu.

Once you select your device, the code sample generator will give you a working code sample, and a selection of options to customize it to your needs.

Using the Code Samples

If it's unclear what any of the options do, click on the nearby '?' for more info.

Once you've made your selections, click the Visual Studio Project button under Downloads.

Using the Code Samples

Extract the files and open the .sln file.

Then start the example by pressing the Start button:

What's Next?

Now that you've set up Phidgets in your C programming environment, you should read our guide on Phidget Programming Basics to learn the fundamentals of programming with Phidgets.

In particular, you should ensure that you familiarize yourself with how error handling is done in C, because it's not automatically implemented like in other programming languages. Once you've added error handling to your code, you can use the Error Code List to anticipate and handle various errors.

Continue down below for advanced information and troubleshooting for your device.

«
»

Visual Studio New Project

Setting up a New Project

When using Phidgets in a Visual Studio project, you need to properly link the Phidget C library.

1. First, create a new Win32 Console Application:

Setting up a New Project

2. Select an empty project and Finish:

Setting up a New Project

3. If you are using a 64-bit machine, select x64, otherwise, select x86:

Setting up a New Project

4. Next, right click on the source folder and click New Item:

Setting up a New Project

5. Give the source file a name and click Add:

Setting up a New Project

6. Right click your project and access its properties:

Setting up a New Project

7. Go to Configuration Properties -> C/C++ -> General and add this to the additional include directories:

C:\Program Files\Phidgets\Phidget22

Setting up a New Project

8. Go to Configuration Properties -> Linker -> Input and add the appropriate line to additional dependencies:

C:\Program Files\Phidgets\Phidget22\phidget22.lib (for 64-bit systems)

C:\Program Files\Phidgets\Phidget22\x86\phidget22.lib (for 32-bit systems)

Setting up a New Project

9. Lastly, include the Phidget library at the beginning of your program:

#include < phidget22.h >

Success! The project now has access to Phidgets.

What's Next?

Now that you've set up Phidgets in your C programming environment, you should read our guide on Phidget Programming Basics to learn the fundamentals of programming with Phidgets.

In particular, you should ensure that you familiarize yourself with how error handling is done in C, because it's not automatically implemented like in other programming languages. Once you've added error handling to your code, you can use the Error Code List to anticipate and handle various errors.

Continue down below for advanced information and troubleshooting for your device.

«
»

Language - C

Windows with Code::Blocks

Welcome to using Phidgets with C! By using C, you will have access to the complete Phidget22 API, including events.

Code::Blocks is a free, open source cross-platform IDE that can be used for C and C++.

Requirements

First, make sure you have the following installed:

Phidgets Drivers for Windows

Code::Blocks

Setting up a New Project

When you are building a project from scratch, or adding Phidget functionality to an existing project, you'll need to configure your development environment to properly link the Phidget C library.

To start, open Code::Blocks, and go to Settings -> Compiler as shown in the image below:

Setting up a New Project

From the Global compiler settings screen, go to Search directories -> Compiler and add:

C:\Program Files\Phidgets\Phidget22

Setting up a New Project

Next, select Search directories -> Linker and add the following directory:

C:\Program Files\Phidgets\Phidget22\x86

Setting up a New Project

Next, go to Linker settings and add the following line:

phidget22

Setting up a New Project

Next, create a new Console Application project, as follows:

Setting up a New Project

Name your project, and finish creating the project.

Setting up a New Project

Now your project is created, and you can open the generated main.c to begin coding.

To include the Phidget C library, add the following line to your code:

#include <phidget22.h>

Your project now has access to the Phidget libraries.

Finding Code Samples

To find the code sample to use for your Phidget, navigate to the Code Samples page and select your device from the drop-down menu.

Once you select your device, the code sample generator will give you a working code sample, and a selection of options to customize it to your needs.

Using the Code Samples

If it's unclear what any of the options do, click on the nearby '?' for more info.

Once you've made your selections, click the copy button and paste the code into your new project.

What's Next?

Now that you've set up Phidgets in your C programming environment, you should read our guide on Phidget Programming Basics to learn the fundamentals of programming with Phidgets.

In particular, you should ensure that you familiarize yourself with how error handling is done in C, because it's not automatically implemented like in other programming languages. Once you've added error handling to your code, you can use the Error Code List to anticipate and handle various errors.

Continue down below for advanced information and troubleshooting for your device.

«
»

Language - C

Windows with GCC

Welcome to using Phidgets with C! By using C, you will have access to the complete Phidget22 API, including events.

GCC is a compiler system for originally written for GNU, and is the standard compiler on unix-like operating systems. It is available on Windows by using tools like MinGW or Cygwin to allow compilation of C programs from the command line.

Requirements

First, make sure you have the following installed:

Phidgets Drivers for Windows

● One of the following:

- MinGW

- Cygwin

Finding Code Samples

To find the code sample to use for your Phidget, navigate to the Code Samples page and select your device from the drop-down menu.

Once you select your device, the code sample generator will give you a working code sample, and a selection of options to customize it to your needs.

Using the Code Samples

If it's unclear what any of the options do, click on the nearby '?' for more info.

Once you've made your selections, click the Download Example button under Downloads.

Compile and Run

Go to the folder where your code is and open the command prompt by typing 'cmd' in the address bar.

The specific command you will use depends on your compiler of choice:

Cygwin x86:

gcc example.c -o example -I"/cygdrive/c/Program Files/Phidgets/Phidget22"-L"/cygdrive/c/Program Files/Phidgets/Phidget22/x86" -lphidget22

Cygwin x64:

gcc example.c -o example -I"/cygdrive/c/Program Files/Phidgets/Phidget22" -L"/cygdrive/c/Program Files/Phidgets/Phidget22" -lphidget22

MinGW:

gcc example.c -o example -I"C:/Program Files/Phidgets/Phidget22" -L"C:/Program Files/Phidgets/Phidget22/x86" -lphidget22

Compile and Run

After running the commands above for either Cygwin or MinGW, an executable file called example.exe will be created. Enter the following command to run the program:

example.exe

What's Next?

Now that you've set up Phidgets in your C programming environment, you should read our guide on Phidget Programming Basics to learn the fundamentals of programming with Phidgets.

In particular, you should ensure that you familiarize yourself with how error handling is done in C, because it's not automatically implemented like in other programming languages. Once you've added error handling to your code, you can use the Error Code List to anticipate and handle various errors.

Continue down below for advanced information and troubleshooting for your device.

«
»

Language - C

MacOS with GCC

Welcome to using Phidgets with C! By using C, you will have access to the complete Phidget22 API, including events.

GCC is a compiler system for originally written for GNU, and is the standard compiler on unix-like operating systems. It is available on Windows by using tools like MinGW or Cygwin to allow compilation of C programs from the command line.

Requirements

First, make sure you have the following installed:

Phidgets Drivers for macOS

● gcc


You likely have gcc installed on your macOS machine already, but if not, you can easily get it by downloading Xcode.

Finding Code Samples

To find the code sample to use for your Phidget, navigate to the Code Samples page and select your device from the drop-down menu.

Once you select your device, the code sample generator will give you a working code sample, and a selection of options to customize it to your needs.

Using the Code Samples

If it's unclear what any of the options do, click on the nearby '?' for more info.

Once you've made your selections, click the Download Example button under Downloads.

Compile and Run

To compile the program, enter the following command in the terminal, substituting "example" for the name of your C file:

gcc example.c -o example -F /Library/Frameworks -framework Phidget22 -I /Library/Frameworks/Phidget22.framework/Headers

Finally, run the program by entering the following command in the terminal:

./example

Success! The project is now running with Phidgets.

What's Next?

Now that you've set up Phidgets in your C programming environment, you should read our guide on Phidget Programming Basics to learn the fundamentals of programming with Phidgets.

In particular, you should ensure that you familiarize yourself with how error handling is done in C, because it's not automatically implemented like in other programming languages. Once you've added error handling to your code, you can use the Error Code List to anticipate and handle various errors.

Continue down below for advanced information and troubleshooting for your device.

«
»

Language - C

Linux with GCC

Welcome to using Phidgets with C! By using C, you will have access to the complete Phidget22 API, including events.

GCC is a compiler system for originally written for GNU, and is the standard compiler on unix-like operating systems. It is available on Windows by using tools like MinGW or Cygwin to allow compilation of C programs from the command line.

Requirements

First, make sure you have the following installed:

Phidgets Drivers for Linux

● gcc


You likely have gcc installed on your Linux machine already, but if not, you can easily get it by entering the following command in the terminal:

apt-get install gcc

Setting UDev Rules

By default, Linux will not allow regular users to access physical hardware, as a security feature. This means that you must grant yourself root privileges via sudo to run Phidgets code.

sudo ./HelloWorld

To avoid having to use sudo every time, you can set up a rules file to allow it automatically using the vendor code for Phidget USB devices. Create a text file called 99-libphidget22.rules containing the following line:

SUBSYSTEMS=="usb", ACTION=="add", ATTRS{idVendor}=="06c2", ATTRS{idProduct}=="00[3-a][0-f]", MODE="666"

Mode 666 means every user has permission to read and write to the specified devices. Next, move this file to /etc/udev/rules.d. Now you can run code that uses Phidgets as a regular user without sudo.

Finding Code Samples

To find the code sample to use for your Phidget, navigate to the Code Samples page and select your device from the drop-down menu.

Once you select your device, the code sample generator will give you a working code sample, and a selection of options to customize it to your needs.

Using the Code Samples

If it's unclear what any of the options do, click on the nearby '?' for more info.

Once you've made your selections, click the Download Example button under Downloads.

Compile and Run

To compile the program, enter the following command in the terminal, substituting "example" for the name of your C file:

gcc example.c -o example -lphidget22

After compiling, you can run the program by entering the following command in the terminal:

./example

Success! The project is now running with Phidgets.

What's Next?

Now that you've set up Phidgets in your C programming environment, you should read our guide on Phidget Programming Basics to learn the fundamentals of programming with Phidgets.

In particular, you should ensure that you familiarize yourself with how error handling is done in C, because it's not automatically implemented like in other programming languages. Once you've added error handling to your code, you can use the Error Code List to anticipate and handle various errors.

Continue down below for advanced information and troubleshooting for your device.

«
»

Language - C

PhidgetSBC with GCC

Welcome to using Phidgets with C! By using C, you will have access to the complete Phidget22 API, including events.

GCC is a compiler system for originally written for GNU, and is the standard compiler on unix-like operating systems. It is available on Windows by using tools like MinGW or Cygwin to allow compilation of C programs from the command line.

Requirements

If you haven't already, check out the user guide in order to set up the following:

● Networking

● Administrator password


This guide will cover development using an external machine. For development using the SBC itself, go back and select GCC - Linux as your environment.

Introduction

To begin, this video will help you get started:

Developing With An External Computer

There are two main ways in which you can access your SBC from an external computer:

● SBC Web Interface

● Secure Shell (SSH)


Since the SBC User Guide covers the web interface in detail, this guide will cover SSH.

SSH

If you are unfamiliar with SSH, it is a simple yet powerful tool that allows you to log into a remote machine in order to execute commands. You can also transfer files using the associated SCP tool.

In order to use SSH, you need the following:

● The SBC's IP address (e.g. 192.168.3.195) or the link local address (e.g. phidgetsbc.local)

● The administrator password

● SSH enabled on the SBC

SSH

You can enable SSH on the SBC Web Interface as shown below:

SSH on Windows

To use SSH on Windows, we recommend PuTTY. Use the images below as a guide for configuring PuTTY (use the IP address or the link local address interchangeably):

SSH on Windows

After clicking open, simply login as root and provide the administrator password:

To transfer files between your SBC and Windows machine, we recommend either of these programs:

WinSCP

PuTTY PSCP

You will follow a similar process to access the SBC as described for SSH.

SSH on Linux and macOS

SSH is available on Linux and macOS by default. To run SSH, open the terminal and type:

ssh root@phidgetsbc.local

Or, something like this (you will need to know the IP address of your SBC):

ssh root@192.168.3.195

You will then be prompted for the password in order to gain access to the SBC:

SSH on Linux and macOS

To copy a file from the SBC to your development machine using SCP, open the terminal and type:

scp root@phidgetsbc.local:/path/to/source /path/to/destination

You can reverse this if you want to transfer a file from your development machine to your SBC:

scp /path/to/source root@phidgetsbc.local:/path/to/destination

Installing Packages For Development

Now that you are connected, you may want to start developing on the SBC.

Go to System->Packages, check Include full Debian Package Repository and click Install.

Finding Code Samples

To find the code sample to use for your Phidget, navigate to the Code Samples page and select your device from the drop-down menu.

Once you select your device, the code sample generator will give you a working code sample, and a selection of options to customize it to your needs.

Using the Code Samples

If it's unclear what any of the options do, click on the nearby '?' for more info.

Once you've made your selections, click the Download Example button under Downloads.

Setting up a New Project

When you are building a project from scratch, or adding Phidget functionality to an existing project, you'll need to configure your development environment to properly link the Phidget C library.

When developing on an external computer, you will write, compile, and test your programs on that machine. When you are ready, you will then upload your programs to the SBC to compile and run them.

Setting up a New Project

Once your code is written, follow these steps to get your program running on the SBC:

1. Using the SBC Web Interface, create a new project:

Setting up a New Project

2. Transfer all the project files from the development machine to the SBC, either using the SBC Web Interface or a tool like WinSCP.

The project directory will be:

/usr/userapps/ProjectName

Setting up a New Project

3. Use SSH to access the SBC terminal and go to the project folder:

cd /usr/userapps/ProjectName

Then compile the example by entering the following command in the terminal, replacing "example" with the name of your C file:

gcc example.c -o example -lphidget22

You can now run the program with the command:

./example

Success! The program is running on your SBC.

Running a Program Automatically

Click on the sections below for various automation options:

-----

Running a Program from the SBC Web Interface

To quickly test whether a program can be run automatically, you can try starting it from the SBC Web Interface.

1. To start the program, navigate to Projects->ProjectName->Startup Settings in the SBC Web Interface.

2. Select your program in the drop-down menu labeled Executable/Class Name.



3. Click the Start button on the SBC web interface.


4. You'll note that as it runs, there are two links below the Stop button which can be used to view the program output:

  • stdout: view the program output like you would in a terminal or command prompt
  • stderr: view the program error output

Run on Boot

Running on boot ensures that your program will never miss an event. As long as the SBC is running, your code will be running. This section assumes you have written and compiled your program on an external computer, and have uploaded it to the SBC Web Interface.


To have your program run on boot, navigate to Projects->ProjectName->Startup Settings in the SBC Web Interface. After selecting your project, copy the settings from the image below:



We will review some of the options that are shown in the image above:

  • Startup Order: lower numbers boot first. Booting later means more programs are available for use, booting earlier means other programs can use your program.
  • Run as a daemon: starts the program as a daemon. Unless you have explicitly written your program as a daemon, leave this checked, or else your SBC may hang on boot.
  • Executable/Class name: your main Java class or C file.
  • Arguments: any command line arguments the program needs.

After saving your changes, your program will run automatically whenever your SBC boots.


Run on a Schedule

Running your program on a schedule allows you to perform your task once a week, or once a minute without worrying about memory management issues or instability problems that may arise. It executes, and then gets cleaned up. To run your program on a schedule, we recommend using Cron. Cron can automatically schedule programs (known as jobs, or cron jobs). Cron simply reads a crontab file and runs whatever programs are listed, with whatever timing they are listed with. Cron runs continuously in the background, but the cron jobs only run as long as they naturally would, and then they exit.


Let's set up your first cron job. We will use nano to edit the crontab file, but feel free to use whatever editor you prefer.


First, set your editor to nano:

export EDITOR=nano

Next, edit your crontab file:

crontab -e

Finally, schedule your cron job:

#cron job that will run at 5AM every week:
0 5 * * 1 /root/code/myprogram argument1


After entering your task, simply save and exit the file.


What's Next?

Now that you've set up Phidgets in your C programming environment, you should read our guide on Phidget Programming Basics to learn the fundamentals of programming with Phidgets.

In particular, you should ensure that you familiarize yourself with how error handling is done in C, because it's not automatically implemented like in other programming languages. Once you've added error handling to your code, you can use the Error Code List to anticipate and handle various errors.

Continue down below for advanced information and troubleshooting for your device.

«
»

C# - Select Development Environment

Select your Development Environment:

Windows

MacOS

Linux

Language - C#

Windows with Visual Studio

Welcome to using Phidgets with C#! By using C#, you will have access to the complete Phidget22 API, including events.

Visual Studio is an IDE provided by Microsoft that can be used to develop code in a wide variety of programming languages, including C#.

Requirements

First, make sure you have the following installed:

Phidgets Drivers for Windows

● Microsoft Visual Studio


Nuget

The Phidget22.NET library is now available on nuget.org here. Nuget is the recommended way to install and use the .NET library in Visual Studio. The nuget package bundles the C library on Windows, so there are no other prerequisites that need to be installed. The nuget package adds targets for .NET Core and .NET Standard, so it should be usable from almost any .NET environment which also supports the C library.

Using Phidgets in Your Programs

There are two ways you can use Phidgets in Visual Studio. You can either start from a sample project provided by our code sample generator, or you can start a new project from scratch.

Select your preferred method below for instructions:

«
»

Visual Studio Code Sample

Finding Code Samples

To find the code sample to use for your Phidget, navigate to the Code Samples page and select your device from the drop-down menu.

Once you select your device, the code sample generator will give you a working code sample, and a selection of options to customize it to your needs.

The code samples we provide for C# are written to be used as Console Applications, but the concepts within can easily be re-purposed for use in a Windows Forms Application.

Using the Code Samples

If it's unclear what any of the options do, click on the nearby '?' for more info.

Once you've made your selections, click the Visual Studio Project button under Downloads.

Using the Code Samples

Extract the files and open the .sln file.

Then start the example by pressing the Start button:

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.

«
»

Visual Studio New Project

Setting up a New Project

When you're building a project from scratch or adding Phidget code to an existing project, you need to properly link the Phidget .NET library.

Create a new project (a Console Application will be created for this example):

Setting up a New Project

Next, right-click on References in the solution explorer and choose Add Reference.

Setting up a New Project

On the following screen, click Browse... and navigate to the location of Phidget22.NET.dll:

C:\Program Files\Phidgets\Phidget22\Phidget22.NET.dll

Setting up a New Project

Finally, to include the Phidget .NET library, add the following lines to main window class file:

using Phidget22;
using Phidget22.Events;

Success! The project now has access to Phidgets.

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.

«
»

Language - C#

Windows with Mono

Welcome to using Phidgets with C#! By using C#, you will have access to the complete Phidget22 API, including events.

Mono is an open-source programming environment that aims to make Microsoft .NET applications available across all operating systems.

Requirements

First, make sure you have the following installed:

Phidgets Drivers for Windows

Mono

Finding Code Samples

To find the code sample to use for your Phidget, navigate to the Code Samples page and select your device from the drop-down menu.

Once you select your device, the code sample generator will give you a working code sample, and a selection of options to customize it to your needs.

Using the Code Samples

If it's unclear what any of the options do, click on the nearby '?' for more info.

Once you've made your selections, click the Download Example button under Downloads.

Setting up a New Project

When you are building a project from scratch, or adding Phidget functionality to an existing project, you'll need to configure your development environment to properly link the Phidget .NET library.

The easiest way to allow Mono to access the Phidgets .NET library is to place a copy of the Phidget22.NET dll in the same folder as your program.

First, determine which version of the .NET Framework your version of Mono implements by checking the Mono Release Documentation.

Next, download the Phidget22 Development Libraries, which contain dlls for each .NET version.

Navigate in the zip file to /lib/dotnet/netXX where 'XX' is your .NET Framework version (for example, net46 for .NET 4.6), and grab the Phidget22.NET.dll from that folder.

Setting up a New Project

Next, move the Phidget22.NET.dll you extracted into the same folder as your program.

Your folder should look somehting like this:

Compile and Run

Once you are ready to run your program, open the Command Prompt and navigate to your project folder. Next, enter the following command:

mcs /r:Phidget22.NET.dll Program.cs

This will create an executable file called Program.exe. Type in the following command to run the example:

mono Program.exe

Success! The project is now using Phidgets.

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.

«
»

Language - C#

macOS with Mono

Welcome to using Phidgets with C#! By using C#, you will have access to the complete Phidget22 API, including events.

Mono is an open-source programming environment that aims to make Microsoft .NET applications available across all operating systems.

Requirements

First, make sure you have the following installed:

Phidgets Drivers for macOS

Mono

● You'll also need a copy of Phidget22.NET.dll

Finding Code Samples

To find the code sample to use for your Phidget, navigate to the Code Samples page and select your device from the drop-down menu.

Once you select your device, the code sample generator will give you a working code sample, and a selection of options to customize it to your needs.

Using the Code Samples

If it's unclear what any of the options do, click on the nearby '?' for more info.

Once you've made your selections, click the Download Example button under Downloads.

Setting up a New Project

Whether you are running our examples or adding Phidget functionality to an existing project, you'll need to configure your development environment to properly link the Phidget .NET library.

The easiest way to allow Mono to access the Phidgets .NET library is to place a copy of the Phidget22.NET dll in the same folder as your program.

First, determine which version of the .NET Framework your version of Mono implements by checking the Mono Release Documentation.

Next, download the Phidget22 Development Libraries, which contain dlls for each .NET version.

Navigate in the zip file to /lib/dotnet/netXX where 'XX' is your .NET Framework version (for example, net46 for .NET 4.6), and grab the Phidget22.NET.dll from that folder.

Setting up a New Project

Next, move the Phidget22.NET.dll you extracted into the same folder as your program.

Finally, you need to create a configuration file. Create a new file in the same directory and name it Phidget22.NET.dll.config. Copy the content below to the file.

<configuration>
<dllmap dll="phidget22.dll" target="/Library/Frameworks/Phidget22.framework/Versions/Current/Phidget22" />
</configuration>

Setting up a New Project

Your project directory should now look like this:

Compile and Run

Once you are ready to run your program, open the Terminal and navigate to your project folder. Next, enter the following command:

mcs Program.cs -r:Phidget22.NET.dll

This will create an executable file called Program.exe. Type in the following command to run your program:

mono Program.exe

Success! The project is now using Phidgets.

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.

«
»

Language - C#

Linux with Mono

Welcome to using Phidgets with C#! By using C#, you will have access to the complete Phidget22 API, including events.

Mono is an open-source programming environment that aims to make Microsoft .NET applications available across all operating systems.

Requirements

First, make sure you have the following installed:

Phidgets Drivers for Linux

● Mono

● A copy of Phidget22.NET.dll


You need our C development libraries in order to use Mono. You can install them with:

apt-get install libphidget22-dev

If you don't already have Mono installed, you can get it with:

apt-get install mono-complete

Setting UDev Rules

By default, Linux will not allow regular users to access physical hardware, as a security feature. This means that you must grant yourself root privileges via sudo to run Phidgets code.

sudo mono program.exe

To avoid having to use sudo every time, you can set up a rules file to allow it automatically using the vendor code for Phidget USB devices. Create a text file called 99-libphidget22.rules containing the following line:

SUBSYSTEMS=="usb", ACTION=="add", ATTRS{idVendor}=="06c2", ATTRS{idProduct}=="00[3-a][0-f]", MODE="666"

Mode 666 means every user has permission to read and write to the specified devices. Next, move this file to /etc/udev/rules.d. Now you can run code that uses Phidgets as a regular user without sudo.

Finding Code Samples

To find the code sample to use for your Phidget, navigate to the Code Samples page and select your device from the drop-down menu.

Once you select your device, the code sample generator will give you a working code sample, and a selection of options to customize it to your needs.

Using the Code Samples

If it's unclear what any of the options do, click on the nearby '?' for more info.

Once you've made your selections, click the Download Example button under Downloads.

Setting up a New Project

Whether you are running our examples or adding Phidget functionality to an existing project, you'll need to configure your development environment to properly link the Phidget .NET library.

The easiest way to allow Mono to access the Phidgets .NET library is to place a copy of the Phidget22.NET dll in the same folder as your program.

First, determine which version of the .NET Framework your version of Mono implements by checking the Mono Release Documentation.

Next, download the Phidget22 Development Libraries, which contain dlls for each .NET version.

Navigate in the zip file to /lib/dotnet/netXX where 'XX' is your .NET Framework version (for example, net46 for .NET 4.6), and grab the Phidget22.NET.dll from that folder.

Setting up a New Project

Move the Phidget22.NET.dll you extracted into the same folder as your program.

Your project directory should now look like this:

Compile and Run

Once you are ready to run your program, open the Terminal and navigate to your project folder. Next, enter the following command:

mcs Program.cs -r:Phidget22.NET.dll

An executable file will be created. Run the program using mono with the following command:

mono Program.exe

Success! The project is now using Phidgets.

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.

«
»

Language - C#

Windows with MonoDevelop / Xamarin Studio

Welcome to using Phidgets with C#! By using C#, you will have access to the complete Phidget22 API, including events.

MonoDevelop is an open-source programming environment that mimics the capabilities of Microsoft Visual Studio and is available across all operating systems.

Requirements

First, make sure you have the following installed:

Phidgets Drivers for Windows

● MonoDevelop or Xamarin Studio

Setting up a New Project

When you are building a project from scratch, or adding Phidget function calls to an existing project, you'll need to configure your development environment to properly link the Phidget .NET library.

First, create a new .NET project:

Setting up a New Project

Name the project and click Create.

Setting up a New Project

Next, add a reference to the Phidget .NET library:

Setting up a New Project

On the following screen, select Phidget22.NET.dll:

Success! The project now has access to Phidgets.

Finding Code Samples

To find the code sample to use for your Phidget, navigate to the Code Samples page and select your device from the drop-down menu.

Once you select your device, the code sample generator will give you a working code sample, and a selection of options to customize it to your needs.

Using the Code Samples

If it's unclear what any of the options do, click on the nearby '?' for more info.

Once you've made your selections, click the copy button and paste the code into your new project.

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.

«
»

Python - Select Development Environment

Select your Development Environment:

Windows

MacOS

Linux

PhidgetSBC

Language - Python

Windows with Pycharm

Welcome to using Phidgets with Python! By using Python, you will have access to the complete Phidget22 API, including events.

PyCharm is an integrated development environment for Python by JetBrains.

Installing the Phidget Python Module

First, install Python3 if you haven't already.

Next, select your preferred installation method below:

«
»

Language - Python

Installing the Phidget Python Module

You can install the Phidget22 libraries for your current PyCharm project with PIP by opening File > Settings

Installing the Phidget Python Module

Next, navigate to Project > Project Interpreter and click on the + symbol located on the right:

Installing the Phidget Python Module

Type Phidget22 into the search bar, select the package named Phidget22 and click Install Package:

Finding Code Samples

To find the code sample to use for your Phidget, navigate to the Code Samples page and select your device from the drop-down menu.

Once you select your device, the code sample generator will give you a working code sample, and a selection of options to customize it to your needs.

Using the Code Samples

Click the Download Example button to download the sample code:

Using the Code Samples

Add the example you just downloaded by dragging it into the project:

Using the Code Samples

Finally, run the project:

The project is now running with Phidgets!

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.

«
»

Language - Python

Installing the Phidget Python Module

Python 3.4+ includes PIP by default. To install the Phidget22 Python module with PIP, simply open the Command Prompt (press the Windows key and search for cmd), and enter the command:

python -m pip install Phidget22

Installing the Phidget Python Module

To use the global Phidget22 library in your PyCharm project, select Inherit global site-packages when creating a new project.

Finding Code Samples

To find the code sample to use for your Phidget, navigate to the Code Samples page and select your device from the drop-down menu.

Once you select your device, the code sample generator will give you a working code sample, and a selection of options to customize it to your needs.

Using the Code Samples

Click the Download Example button to download the sample code:

Using the Code Samples

Add the example you just downloaded by dragging it into the project:

Using the Code Samples

Finally, run the project:

The project is now running with Phidgets!

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.

«
»

Language - Python

Installing the Phidget Python Module

To install the Phidget22 Python module without PIP, you need to download it here:

Phidget22 Python Module

Unpack the Phidget22 Python module and open the Command Prompt (press the Windows key and search for cmd). Find the folder where you downloaded the Python module and enter this command:

python setup.py install

This will build the module and install the Python module files into your site-packages directory.

Finding Code Samples

To find the code sample to use for your Phidget, navigate to the Code Samples page and select your device from the drop-down menu.

Once you select your device, the code sample generator will give you a working code sample, and a selection of options to customize it to your needs.

Using the Code Samples

Click the Download Example button to download the sample code:

Using the Code Samples

Add the example you just downloaded by dragging it into the project:

Using the Code Samples

Finally, run the project:

The project is now running with Phidgets!

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.

«
»

Language - Python

Windows with Command Line

Welcome to using Phidgets with Python! By using Python, you will have access to the complete Phidget22 API, including events.

The command line is the default environment to make Python programs in Windows, since it's available immediately after installing Python.

Installing the Phidget Python Module

First, install Python3 if you haven't already.

Python 3.4+ includes PIP by default. To install the Phidget22 Python module with PIP, simply open the Command Prompt (press the Windows key and search for cmd), and enter the command:

python -m pip install Phidget22

Finding Code Samples

To find the code sample to use for your Phidget, navigate to the Code Samples page and select your device from the drop-down menu.

Once you select your device, the code sample generator will give you a working code sample, and a selection of options to customize it to your needs.

Using the Code Samples

Click the Download Example button to download the sample code:

Using the Code Samples

To run the example, open the command prompt at the location of the example and enter the following command:

python example.py

The script is now running with Phidgets!

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.

«
»

Language - Python

MacOS with Terminal

Welcome to using Phidgets with Python! By using Python, you will have access to the complete Phidget22 API, including events.

The terminal is the default environment to make Python programs in macOS, since it's available immediately after installing Python.

Requirements

First, install Python3 if you haven't already.

If you plan on using any USB Phidgets that use the HID stack, you'll need to install the Phidget drivers for MacOS. You can check which stack your USB Phidgets use by checking the 'USB Stack' in the product specifications. If all of your Phidgets use the PHIDUSB stack, you can skip installing the drivers.

Installing the Phidget Python Module

To install the Phidgets Python Module, you'll need PIP, which is included in Python 3.4+ by default. To install the Phidget22 Python module with PIP, simply open the Terminal and enter the command:

python pip install Phidget22

Finding Code Samples

To find the code sample to use for your Phidget, navigate to the Code Samples page and select your device from the drop-down menu.

Once you select your device, the code sample generator will give you a working code sample, and a selection of options to customize it to your needs.

Using the Code Samples

Click the Download Example button to download a Java file with the sample code:

Using the Code Samples

To run the example, open the command prompt at the location of the example and enter the following command:

python example.py

Success! Your program is now running with Phidgets!

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.

«
»

Language - Python

Linux with Terminal

Welcome to using Phidgets with Python! By using Python, you will have access to the complete Phidget22 API, including events.

The terminal is the default environment to make Python programs in Linux, since it's available immediately after installing Python.

Installing the Phidget Python Module

First, install Python3 if you haven't already.

Python 3.4+ includes PIP by default. To install the Phidget22 Python module with PIP, simply open the Terminal and enter the command:

pip3 install Phidget22

Setting UDev Rules

By default, Linux will not allow regular users to access physical hardware, as a security feature. This means that you must grant yourself root privileges via sudo to run Phidgets code.

sudo python3 Python_Example.py

To avoid having to use sudo every time, you can set up a rules file to allow it automatically using the vendor code for Phidget USB devices. Create a text file called 99-libphidget22.rules containing the following line:

SUBSYSTEMS=="usb", ACTION=="add", ATTRS{idVendor}=="06c2", ATTRS{idProduct}=="00[3-a][0-f]", MODE="666"

Mode 666 means every user has permission to read and write to the specified devices. Next, move this file to /etc/udev/rules.d. Now you can run code that uses Phidgets as a regular user without sudo.

Finding Code Samples

To find the code sample to use for your Phidget, navigate to the Code Samples page and select your device from the drop-down menu.

Once you select your device, the code sample generator will give you a working code sample, and a selection of options to customize it to your needs.

Using the Code Samples

Click the Download Example button to download a Java file with the sample code:

Using the Code Samples

To run the example, open the command prompt at the location of the example and enter the following command:

python3 Python_Example.py

Success! Your program is now running with Phidgets!

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.

«
»

Language - Python

PhidgetSBC with Python

Welcome to using Phidgets with Python! By using Python, you will have access to the complete Phidget22 API, including events.

Requirements

If you haven't already, check out the user guide in order to set up the following:

● Connection to local Network

● Administrator password


This guide will cover development using an external machine. For development using the SBC itself, go back and select Terminal - Linux as your environment.

Installing Python

The quickest way to install Python is through the SBC web interface. Open the Phidget Control Panel on your external machine and click on the Network Phidgets tab.

Double click on your SBC in the device list.

Installing Python

Once you're logged in to the web interface, click on System and Packages.

It may take a minute or two to load this page.

Installing Python

Finally, click on the Install button next to Python Support.

It will take a few minutes to install. Once it's complete you can click on the Back button.

Developing With An External Computer

There are two main ways in which you can access your SBC from an external computer:

● SBC Web Interface

● Secure Shell (SSH)


Since the SBC OS Guide covers the web interface in detail, this guide will cover SSH.

SSH

If you are unfamiliar with SSH, it is a simple yet powerful tool that allows you to log into a remote machine in order to execute commands. You can also transfer files using the associated SCP tool.

In order to use SSH, you need the following:

● The SBC's IP address (e.g. 192.168.3.195) or the link local address (e.g. phidgetsbc.local)

● The administrator password

● SSH enabled on the SBC

SSH

You can enable SSH on the SBC Web Interface as shown below:

SSH on Windows

To use SSH on Windows, we recommend PuTTY. Use the images below as a guide for configuring PuTTY (use the IP address or the link local address interchangeably):

SSH on Windows

After clicking open, simply login as root and provide the administrator password:

To transfer files between your SBC and Windows machine, we recommend either of these programs:

WinSCP

PuTTY PSCP

You will follow a similar process to access the SBC as described for SSH.

SSH on Linux and macOS

SSH is available on Linux and macOS by default. To run SSH, open the terminal and type:

ssh root@phidgetsbc.local

Or, something like this (you will need to know the IP address of your SBC):

ssh root@192.168.3.195

You will then be prompted for the password in order to gain access to the SBC:

SSH on Linux and macOS

To copy a file from the SBC to your development machine using SCP, open the terminal and type:

scp root@phidgetsbc.local:/path/to/source /path/to/destination

You can reverse this if you want to transfer a file from your development machine to your SBC:

scp /path/to/source root@phidgetsbc.local:/path/to/destination

Finding Code Samples

To find the code sample to use for your Phidget, navigate to the Code Samples page and select your device from the drop-down menu.

Once you select your device, the code sample generator will give you a working code sample, and a selection of options to customize it to your needs.

Using the Code Samples

If it's unclear what any of the options do, click on the nearby '?' for more info.

Once you've made your selections, click the Download Example button under Downloads.

Setting up a New Project

When developing on an external computer, you should write and test your programs on that machine. When you are ready, upload your program to the SBC.

Setting up a New Project

Once your code is written, follow these steps to get your program running on the SBC:

1. Using the SBC Web Interface, create a new project:

Setting up a New Project

2. Transfer all the project files from the development machine to the SBC, either using the SBC Web Interface or a tool like WinSCP.

The project directory will be:

/usr/userapps/ProjectName

Setting up a New Project

3. Use SSH to access the SBC terminal and go to the project folder:

cd /usr/userapps/ProjectName

You can now run the program with the command:

python ExampleName.py

Success! The program is running on your SBC.

Running a Program Automatically

To run a Python script as a standalone application or to run it in the web interface, you will need to add a line to the top of the script with the path to your Python executable. If you have followed the steps in this guide, it will be:

#!/usr/bin/python

Click on the sections below for various automation options:

-----

Running a Program from the SBC Web Interface

To quickly test whether a program can be run automatically, you can try starting it from the SBC Web Interface.

1. To start the program, navigate to Projects->ProjectName->Startup Settings in the SBC Web Interface.

2. Select your program in the drop-down menu labeled Executable/Class Name.



3. Click the Start button on the SBC web interface.


4. You'll note that as it runs, there are two links below the Stop button which can be used to view the program output:

  • stdout: view the program output like you would in a terminal or command prompt
  • stderr: view the program error output

Run on Boot

Running on boot ensures that your program will never miss an event. As long as the SBC is running, your code will be running. This section assumes you have written and compiled your program on an external computer, and have uploaded it to the SBC Web Interface.


To have your program run on boot, navigate to Projects->ProjectName->Startup Settings in the SBC Web Interface. After selecting your project, copy the settings from the image below:



We will review some of the options that are shown in the image above:

  • Startup Order: lower numbers boot first. Booting later means more programs are available for use, booting earlier means other programs can use your program.
  • Run as a daemon: starts the program as a daemon. Unless you have explicitly written your program as a daemon, leave this checked, or else your SBC may hang on boot.
  • Executable/Class name: your main Java class or C file.
  • Arguments: any command line arguments the program needs.

After saving your changes, your program will run automatically whenever your SBC boots.


Run on a Schedule

Running your program on a schedule allows you to perform your task once a week, or once a minute without worrying about memory management issues or instability problems that may arise. It executes, and then gets cleaned up. To run your program on a schedule, we recommend using Cron. Cron can automatically schedule programs (known as jobs, or cron jobs). Cron simply reads a crontab file and runs whatever programs are listed, with whatever timing they are listed with. Cron runs continuously in the background, but the cron jobs only run as long as they naturally would, and then they exit.


Let's set up your first cron job. We will use nano to edit the crontab file, but feel free to use whatever editor you prefer.


First, set your editor to nano:

export EDITOR=nano

Next, edit your crontab file:

crontab -e

Finally, schedule your cron job:

#cron job that will run at 5AM every week:
0 5 * * 1 /root/code/myprogram argument1


After entering your task, simply save and exit the file.


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.

«
»

Language - Python

Windows with LiClipse

Welcome to using Phidgets with Python! By using Python, you will have access to the complete Phidget22 API, including events.

LiClipse is a closed-source development environment based on Eclipse, with support for Python.

Installing the Phidget Python Module

First, install Python3 if you haven't already.

Python 3.4+ includes PIP by default. To install the Phidget22 Python module with PIP, simply open the Command Prompt (press the Windows key and search for cmd), and enter the command:

python -m pip install Phidget22

Setting Up a New Project

When you are building a project from scratch, or adding Phidget functionality to an existing project, you'll need to configure your development environment to properly link the Phidget Python library.

To start, create a new Python project:

Setting Up a New Project

Next, add a new file to the project:

Finding Code Samples

To find the code sample to use for your Phidget, navigate to the Code Samples page and select your device from the drop-down menu.

Once you select your device, the code sample generator will give you a working code sample, and a selection of options to customize it to your needs.

Using the Code Samples

If it's unclear what any of the options do, click on the nearby '?' for more info.

Once you've made your selections, click the copy button and paste the code into your new project.

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.

«
»

Language - Python

Windows with Visual Studio

Welcome to using Phidgets with Python! By using Python, you will have access to the complete Phidget22 API, including events.

Visual Studio is an IDE provided by Microsoft that can be used to develop code in a wide variety of programming languages, including Python.

Installing the Phidget Python Module

First, install Python3 if you haven't already.

You can install the Phidget22 libraries and python module for your current Visual Studio project with PIP by opening View > Other Windows > Python Environments

Installing the Phidget Python Module

Next, select Packages (PyPI) from the drop-down menu:

Installing the Phidget Python Module

Type Phidget22 into the search bar, then click Install Phidget22:

Success! Your project now has access to Phidget22.

Setting Up a New Project

When you are building a project from scratch, or adding Phidget functionality to an existing project, you'll need to configure your development environment to properly link the Phidget Python library.

To start, create a new Python project:

Setting Up a New Project

Then open the Python file that was generated with the project.

Finding Code Samples

To find the code sample to use for your Phidget, navigate to the Code Samples page and select your device from the drop-down menu.

Once you select your device, the code sample generator will give you a working code sample, and a selection of options to customize it to your needs.

Using the Code Samples

If it's unclear what any of the options do, click on the nearby '?' for more info.

Once you've made your selections, click the copy button and paste the code into your new project.

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.

«
»

Language - Python

Installing the Phidget Python Module

You can install the Phidget22 libraries for your current Visual Studio project with PIP by opening View > Other Windows > Python Environments

Installing the Phidget Python Module

Next, select Packages (PyPI) from the drop-down menu:

Installing the Phidget Python Module

Type Phidget22 into the search bar, then click Install Phidget22:

Success! Your project now has access to Phidget22.

Setting Up a New Project

When you are building a project from scratch, or adding Phidget functionality to an existing project, you'll need to configure your development environment to properly link the Phidget Python library.

To start, create a new Python project:

Setting Up a New Project

Then open the Python file that was generated with the project.

Finding Code Samples

To find the code sample to use for your Phidget, navigate to the Code Samples page and select your device from the drop-down menu.

Once you select your device, the code sample generator will give you a working code sample, and a selection of options to customize it to your needs.

Using the Code Samples

If it's unclear what any of the options do, click on the nearby '?' for more info.

Once you've made your selections, click the copy button and paste the code into your new project.

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.

«
»

Language - Python

Installing the Phidget Python Module

To install the Phidget22 Python module without PIP, you need to download it here:

Phidget22 Python Module

Unpack the Phidget22 Python module and open the Command Prompt (press the Windows key and search for cmd). Find the folder where you downloaded the Python module and enter this command:

python setup.py install

This will build the module and install the Python module files into your site-packages directory.

Setting Up a New Project

When you are building a project from scratch, or adding Phidget functionality to an existing project, you'll need to configure your development environment to properly link the Phidget Python library.

To start, create a new Python project:

Setting Up a New Project

Then open the Python file that was generated with the project.

Finding Code Samples

To find the code sample to use for your Phidget, navigate to the Code Samples page and select your device from the drop-down menu.

Once you select your device, the code sample generator will give you a working code sample, and a selection of options to customize it to your needs.

Using the Code Samples

If it's unclear what any of the options do, click on the nearby '?' for more info.

Once you've made your selections, click the copy button and paste the code into your new project.

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.

«
»

Language - Python

Windows with IDLE

Welcome to using Phidgets with Python! By using Python, you will have access to the complete Phidget22 API, including events.

IDLE is a cross-platform development environment for Python targeted at newcomers to the language.

WARNING: We do not recommend using Idle with Phidgets. It has known problems dealing with multiple threads, which is a required feature if your program uses events.

Installing the Phidget Python Module

First, install Python3 if you haven't already.

Python 3.4+ includes PIP by default. To install the Phidget22 Python module with PIP, simply open the Command Prompt (press the Windows key and search for cmd), and enter the command:

python -m pip install Phidget22

Finding Code Samples

To find the code sample to use for your Phidget, navigate to the Code Samples page and select your device from the drop-down menu.

Once you select your device, the code sample generator will give you a working code sample, and a selection of options to customize it to your needs.

Using the Code Samples

If it's unclear what any of the options do, click on the nearby '?' for more info.

Once you've made your selections, click the copy button.

Using the Code Samples

Paste the sample code into a new Python script file in IDLE:

Using the Code Samples

To run the example, simply click on Run and select Run Module:

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.

«
»

Java - Select Development Environment

Select your Development Environment:

Windows

MacOS

Linux

PhidgetSBC

Android

Language - Java

Windows with Javac

Welcome to using Phidgets with Java! By using Java, you will have access to the complete Phidget22 API, including events.

Javac is a command line-based compiler for java programs that compiles java code into bytecode class files.

Requirements

First, make sure you have the following installed:

Phidgets Drivers for Windows

● The Java Development Kit from Oracle

Finding Code Samples

To find the code sample to use for your Phidget, navigate to the Code Samples page and select your device from the drop-down menu.

Once you select your device, the code sample generator will give you a working code sample, and a selection of options to customize it to your needs.

Using the Code Samples

If it's unclear what any of the options do, click on the nearby '?' for more info.

Once you've made your selections, click the Download Example button to download a sample Java file.

Setting up a New Project

Whether you are running our examples or adding Phidget functionality to an existing project, you'll need to configure your development environment to properly link the Phidget Java library.

The easiest way to allow Java to access the Phidgets Java library is to place a copy of phidget22.jar in the same folder as your program. We recommend you copy phidget22.jar from the following location:

C:\Program Files\Phidgets\Phidget22\phidget22.jar

Your folder should look something like this:

Compile and Run

Once you are ready to run your program, open the command prompt at the folder location. Next, enter the following command in the command prompt:

javac -classpath .;phidget22.jar example.java

Finally, enter the following command to run the program:

java -classpath .;phidget22.jar example

The project is now using Phidgets!

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.

«
»

Language - Java

MacOS with Javac

Welcome to using Phidgets with Java! By using Java, you will have access to the complete Phidget22 API, including events.

Javac is a command line-based compiler for java programs that compiles java code into bytecode class files.

Requirements

First, make sure you have the following installed:

Phidgets Drivers for macOS

● The Java Development Kit from Oracle

● A copy of phidget22.jar

Finding Code Samples

To find the code sample to use for your Phidget, navigate to the Code Samples page and select your device from the drop-down menu.

Once you select your device, the code sample generator will give you a working code sample, and a selection of options to customize it to your needs.

Using the Code Samples

If it's unclear what any of the options do, click on the nearby '?' for more info.

Once you've made your selections, click the Download Example button to download a sample Java file.

Setting up a New Project

Whether you are running our examples or adding Phidget functionality to an existing project, you'll need to configure your development environment to properly link the Phidget Java library.

The easiest way to allow Java to access the Phidgets Java library is to place a copy of phidget22.jar in the same folder as your program:

Compile and Run

Once you are ready to run your program, open the terminal at the folder location. Next, enter the following command in the terminal:

javac -classpath .:phidget22.jar example.java

Finally, enter the following command to run the program:

java -classpath .:phidget22.jar example

The project is now using Phidgets!

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.

«
»

Language - Java

Linux with Javac

Welcome to using Phidgets with Java! By using Java, you will have access to the complete Phidget22 API, including events.

Javac is a command line-based compiler for java programs that compiles java code into bytecode class files.

Requirements

First, make sure you have the following installed:

Phidgets Drivers for Linux

● The Java Development Kit from Oracle

● A copy of phidget22.jar

Setting UDev Rules

By default, Linux will not allow regular users to access physical hardware, as a security feature. This means that you must grant yourself root privileges via sudo to run Phidgets code.

sudo java -classpath .:phidget22.jar example

To avoid having to use sudo every time, you can set up a rules file to allow it automatically using the vendor code for Phidget USB devices. Create a text file called 99-libphidget22.rules containing the following line:

SUBSYSTEMS=="usb", ACTION=="add", ATTRS{idVendor}=="06c2", ATTRS{idProduct}=="00[3-a][0-f]", MODE="666"

Mode 666 means every user has permission to read and write to the specified devices. Next, move this file to /etc/udev/rules.d. Now you can run code that uses Phidgets as a regular user without sudo.

Installing Java

In order to use Java, you will need to download and install the JDK. You can do this by entering the following command in the terminal (where VERSION is replaced with your preferred version number):

apt-get install openjdk-VERSION-jdk

Before continuing, ensure your JDK version matches your JRE version:

javac -version
java -version

Finding Code Samples

To find the code sample to use for your Phidget, navigate to the Code Samples page and select your device from the drop-down menu.

Once you select your device, the code sample generator will give you a working code sample, and a selection of options to customize it to your needs.

Using the Code Samples

If it's unclear what any of the options do, click on the nearby '?' for more info.

Once you've made your selections, click the Download Example button to download a sample Java file.

Setting up a New Project

Whether you are running our examples or adding Phidget functionality to an existing project, you'll need to configure your development environment to properly link the Phidget Java library.

The easiest way to allow Java to access the Phidgets Java library is to place a copy of phidget22.jar in the same folder as your program:

Compile and Run

Once you are ready to run your program, open the terminal at the folder location. Next, enter the following command in the terminal:

javac -classpath .:phidget22.jar example.java

Finally, enter the following command to run the program:

java -classpath .:phidget22.jar example

The project is now using Phidgets!

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.

«
»

Language - Java

PhidgetSBC with Javac

Welcome to using Phidgets with Java! By using Java, you will have access to the complete Phidget22 API, including events.

Javac is a command line-based compiler for java programs that compiles java code into bytecode class files.

Requirements

If you haven't already, check out the user guide in order to set up the following:

● Networking

● Administrator password


This guide will cover development using an external machine. For development using the SBC itself, go back and select Javac - Linux as your environment.

Introduction

To begin, this video will help you get started:

Developing With An External Computer

There are two main ways in which you can access your SBC from an external computer:

● SBC Web Interface

● Secure Shell (SSH)


Since the SBC User Guide covers the web interface in detail, this guide will cover SSH.

SSH

If you are unfamiliar with SSH, it is a simple yet powerful tool that allows you to log into a remote machine in order to execute commands. You can also transfer files using the associated SCP tool.

In order to use SSH, you need the following:

● The SBC's IP address (e.g. 192.168.3.195) or the link local address (e.g. phidgetsbc.local)

● The administrator password

● SSH enabled on the SBC

SSH

You can enable SSH on the SBC Web Interface as shown below:

SSH on Windows

To use SSH on Windows, we recommend PuTTY. Use the images below as a guide for configuring PuTTY (use the IP address or the link local address interchangeably):

SSH on Windows

After clicking open, simply login as root and provide the administrator password:

To transfer files between your SBC and Windows machine, we recommend either of these programs:

WinSCP

PuTTY PSCP

You will follow a similar process to access the SBC as described for SSH.

SSH on Linux and macOS

SSH is available on Linux and macOS by default. To run SSH, open the terminal and type:

ssh root@phidgetsbc.local

Or, something like this (you will need to know the IP address of your SBC):

ssh root@192.168.3.195

You will then be prompted for the password in order to gain access to the SBC:

SSH on Linux and macOS

To copy a file from the SBC to your development machine using SCP, open the terminal and type:

scp root@phidgetsbc.local:/path/to/source /path/to/destination

You can reverse this if you want to transfer a file from your development machine to your SBC:

scp /path/to/source root@phidgetsbc.local:/path/to/destination

Installing Packages For Development

The simplest way to set up Java on the SBC is via the install buttons on located on the SBC Web Interface (System->Packages). Check Include full Debian Package Repository before installing.

You will need to run commands on the SBC to install support for Python. You can either use SSH to issue the commands, or you can connect directly to the SBC via a monitor and keyboard.

Installing Packages For Development

When developing for Java, ensure your development machine and your SBC have the same version of Java. Check your Java version by entering this command:

java -version

If you need to update the version of Java on your SBC, use the following commands:

apt-get install default-jre-headless
su
update-alternatives --config java

You're now ready to begin programming! Continue through this guide for code examples and directions on where to go next.

Finding Code Samples

To find the code sample to use for your Phidget, navigate to the Code Samples page and select your device from the drop-down menu.

Once you select your device, the code sample generator will give you a working code sample, and a selection of options to customize it to your needs.

Using the Code Samples

If it's unclear what any of the options do, click on the nearby '?' for more info.

Once you've made your selections, click the Download Example button to download a sample Java file.

Setting up a New Project

When you are building a project from scratch, or adding Phidget functionality to an existing project, you'll need to configure your development environment to properly link the Phidget Java library.

When developing on an external computer, you will write, compile, and test your programs on that machine. When you are ready, you will then upload your programs to the SBC to run them.

Setting up a New Project

Once your code is written, follow these steps to get your program running on the SBC:

1. Place phidget22.jar on your development machine in a directory that you will use to compile your Java files.

2. Compile your ProgramName.java file. If you are using a Windows machine, type the following into the command prompt:

javac -classpath .;phidget22.jar ProgramName.java

3. If you are using a Linux or macOS machine, type the following into the terminal:

javac -classpath .:phidget22.jar ProgramName.java

You should now have a number of .class files in your project directory

Setting up a New Project

4. Using the SBC Web Interface, create a new project:

Setting up a New Project

5. Transfer all the .class files from the development machine to the SBC, either using the SBC Web Interface or a tool like WinSCP.

The project directory will be:

/usr/userapps/ProjectName

Setting up a New Project

6. Use SSH to access the SBC terminal and go to the project folder:

cd /usr/userapps/ProjectName

You can now run the program with the command:

java ExampleName

Success! The program is running on your SBC.

Running a Program Automatically

Click on the sections below for various automation options:

-----

Running a Program from the SBC Web Interface

To quickly test whether a program can be run automatically, you can try starting it from the SBC Web Interface.

1. To start the program, navigate to Projects->ProjectName->Startup Settings in the SBC Web Interface.

2. Select your program in the drop-down menu labeled Executable/Class Name.



3. Click the Start button on the SBC web interface.


4. You'll note that as it runs, there are two links below the Stop button which can be used to view the program output:

  • stdout: view the program output like you would in a terminal or command prompt
  • stderr: view the program error output

Run on Boot

Running on boot ensures that your program will never miss an event. As long as the SBC is running, your code will be running. This section assumes you have written and compiled your program on an external computer, and have uploaded it to the SBC Web Interface.


To have your program run on boot, navigate to Projects->ProjectName->Startup Settings in the SBC Web Interface. After selecting your project, copy the settings from the image below:



We will review some of the options that are shown in the image above:

  • Startup Order: lower numbers boot first. Booting later means more programs are available for use, booting earlier means other programs can use your program.
  • Run as a daemon: starts the program as a daemon. Unless you have explicitly written your program as a daemon, leave this checked, or else your SBC may hang on boot.
  • Executable/Class name: your main Java class or C file.
  • Arguments: any command line arguments the program needs.

After saving your changes, your program will run automatically whenever your SBC boots.


Run on a Schedule

Running your program on a schedule allows you to perform your task once a week, or once a minute without worrying about memory management issues or instability problems that may arise. It executes, and then gets cleaned up. To run your program on a schedule, we recommend using Cron. Cron can automatically schedule programs (known as jobs, or cron jobs). Cron simply reads a crontab file and runs whatever programs are listed, with whatever timing they are listed with. Cron runs continuously in the background, but the cron jobs only run as long as they naturally would, and then they exit.


Let's set up your first cron job. We will use nano to edit the crontab file, but feel free to use whatever editor you prefer.


First, set your editor to nano:

export EDITOR=nano

Next, edit your crontab file:

crontab -e

Finally, schedule your cron job:

#cron job that will run at 5AM every week:
0 5 * * 1 /root/code/myprogram argument1


After entering your task, simply save and exit the file.


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.

«
»

Language - Java

Windows with NetBeans

Welcome to using Phidgets with Java! By using Java, you will have access to the complete Phidget22 API, including events.

NetBeans is an IDE used to write, compile, and run Java applications.

Requirements

First, make sure you have the following installed:

Phidgets Drivers for Windows

● The Java Development Kit from Oracle

Setting up a New Project

Whether you are running our examples or adding Phidget functionality to an existing project, you'll need to configure your development environment to properly link the Phidget Java library.

To start, open NetBeans and create a new project. Select Java Application then click Next:

Setting up a New Project

If necessary, download and activate the recommended features:

Setting up a New Project

Follow the steps to install the plugins:

Setting up a New Project

Give your project a name and finish creating the project:

Setting up a New Project

Next, add a reference to phidget22.jar by right-clicking on the libraries folder:

Setting up a New Project

You can find phidget22.jar at the following location:

C:\Program Files\Phidgets\Phidget22\phidget22.jar

Your project now has access to Phidgets!

Finding Code Samples

To find the code sample to use for your Phidget, navigate to the Code Samples page and select your device from the drop-down menu.

Once you select your device, the code sample generator will give you a working code sample, and a selection of options to customize it to your needs.

Using the Code Samples

If it's unclear what any of the options do, click on the nearby '?' for more info.

Once you've made your selections, click the copy button and paste the code into your new project.

Be sure to change the name of the top class to match the name of the file in your project.

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.

«
»

Language - Java

MacOS with NetBeans

Welcome to using Phidgets with Java! By using Java, you will have access to the complete Phidget22 API, including events.

NetBeans is an IDE used to write, compile, and run Java applications.

Requirements

First, make sure you have the following installed:

Phidgets Drivers for macOS

● The Java Development Kit from Oracle

● You will need a copy of phidget22.jar

Setting up a New Project

Whether you are running our examples or adding Phidget functionality to an existing project, you'll need to configure your development environment to properly link the Phidget Java library.

To start, open NetBeans and create a new project. Select Java Application then click Next:

Setting up a New Project

Give your project a name and finish creating the project:

Setting up a New Project

Next, add a reference to the phidget22.jar you downloaded above by right-clicking on the libraries folder:

The project now has access to Phidgets.

Finding Code Samples

To find the code sample to use for your Phidget, navigate to the Code Samples page and select your device from the drop-down menu.

Once you select your device, the code sample generator will give you a working code sample, and a selection of options to customize it to your needs.

Using the Code Samples

If it's unclear what any of the options do, click on the nearby '?' for more info.

Once you've made your selections, click the copy button and paste the code into your new project.

Be sure to change the name of the top class to match the name of the file in your project.

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.

«
»

Language - Java

Linux with NetBeans

Welcome to using Phidgets with Java! By using Java, you will have access to the complete Phidget22 API, including events.

NetBeans is an IDE used to write, compile, and run Java applications.

Requirements

First, make sure you have the following installed:

Phidgets Drivers for Linux

● The Java Development Kit from Oracle

● You will need a copy of phidget22.jar

Setting UDev Rules

By default, Linux will not allow regular users to access physical hardware, as a security feature. This means that you must grant yourself root privileges via sudo to run Phidgets code.

To avoid having to use sudo every time, you can set up a rules file to allow it automatically using the vendor code for Phidget USB devices. Create a text file called 99-libphidget22.rules containing the following line:

SUBSYSTEMS=="usb", ACTION=="add", ATTRS{idVendor}=="06c2", ATTRS{idProduct}=="00[3-a][0-f]", MODE="666"

Mode 666 means every user has permission to read and write to the specified devices. Next, move this file to /etc/udev/rules.d. Now you can run code that uses Phidgets as a regular user without sudo.

Setting up a New Project

Whether you are running our examples or adding Phidget functionality to an existing project, you'll need to configure your development environment to properly link the Phidget Java library.

To start, open NetBeans and create a new project. Select Java Application then click Next:

Setting up a New Project

Give your project a name and finish creating the project:

Setting up a New Project

Next, add a reference to phidget22.jar by right-clicking on the libraries folder:

Setting up a New Project

Locate phidget22.jar and click OK.

The project now has access to Phidgets.

Finding Code Samples

To find the code sample to use for your Phidget, navigate to the Code Samples page and select your device from the drop-down menu.

Once you select your device, the code sample generator will give you a working code sample, and a selection of options to customize it to your needs.

Using the Code Samples

If it's unclear what any of the options do, click on the nearby '?' for more info.

Once you've made your selections, click the copy button and paste the code into your new project.

Be sure to change the name of the top class to match the name of the file in your project.

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.

«
»

Language - Java

Windows with Eclipse

Welcome to using Phidgets with Java! By using Java, you will have access to the complete Phidget22 API, including events.

Eclipse is an IDE used to write, compile, and run Java applications.

Requirements

First, make sure you have the following installed:

Phidgets Drivers for Windows

● The Java Development Kit from Oracle

Setting up a New Project

To start, open Eclipse and create a new Java project. Give it a name and click Next:

Setting up a New Project

On the Libraries tab, click Add External JARs and add phidget22.jar to your project as an external jar:

Setting up a New Project

Create a new Class in your project:

Setting up a New Project

Name the class, and be sure to check the public static void main box.

Your project now has access to Phidgets!

Finding Code Samples

To find the code sample to use for your Phidget, navigate to the Code Samples page and select your device from the drop-down menu.

Once you select your device, the code sample generator will give you a working code sample, and a selection of options to customize it to your needs.

Using the Code Samples

If it's unclear what any of the options do, click on the nearby '?' for more info.

Once you've made your selections, click the copy button and paste the code into your new project.

Be sure to change the name of the top class to match the name of the file in your project.

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.

«
»

Language - Java

MacOS with Eclipse

Welcome to using Phidgets with Java! By using Java, you will have access to the complete Phidget22 API, including events.

Eclipse is an IDE used to write, compile, and run Java applications.

Requirements

First, make sure you have the following installed:

Phidgets Drivers for macOS

● The Java Development Kit from Oracle

● You will need a copy of phidget22.jar

Setting up a New Project

To start, open Eclipse and create a new Java project. Give it a name and click Next:

Setting up a New Project

On the Libraries tab, click Add External JARs and add phidget22.jar to your project as an external jar:

Setting up a New Project

Create a new Class in your project:

Setting up a New Project

Name the class, and be sure to check the public static void main box.

Your project now has access to Phidgets!

Finding Code Samples

To find the code sample to use for your Phidget, navigate to the Code Samples page and select your device from the drop-down menu.

Once you select your device, the code sample generator will give you a working code sample, and a selection of options to customize it to your needs.

Using the Code Samples

If it's unclear what any of the options do, click on the nearby '?' for more info.

Once you've made your selections, click the copy button and paste the code into your new project.

Be sure to change the name of the top class to match the name of the file in your project.

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.

«
»

Language - Java

Linux with Eclipse

Welcome to using Phidgets with Java! By using Java, you will have access to the complete Phidget22 API, including events.

Eclipse is an IDE used to write, compile, and run Java applications.

Requirements

First, make sure you have the following installed:

Phidgets Drivers for Linux

● The Java Development Kit from Oracle

● You will need a copy of phidget22.jar

Setting UDev Rules

By default, Linux will not allow regular users to access physical hardware, as a security feature. This means that you must grant yourself root privileges via sudo to run Phidgets code.

To avoid having to use sudo every time, you can set up a rules file to allow it automatically using the vendor code for Phidget USB devices. Create a text file called 99-libphidget22.rules containing the following line:

SUBSYSTEMS=="usb", ACTION=="add", ATTRS{idVendor}=="06c2", ATTRS{idProduct}=="00[3-a][0-f]", MODE="666"

Mode 666 means every user has permission to read and write to the specified devices. Next, move this file to /etc/udev/rules.d. Now you can run code that uses Phidgets as a regular user without sudo.

Setting up a New Project

To start, open Eclipse and create a new Java project. Give it a name and click Next:

Setting up a New Project

On the Libraries tab, click Add External JARs and add phidget22.jar to your project as an external jar:

Setting up a New Project

Create a new Class in your project:

Setting up a New Project

Name the class, and be sure to check the public static void main box.

Your project now has access to Phidgets!

Finding Code Samples

To find the code sample to use for your Phidget, navigate to the Code Samples page and select your device from the drop-down menu.

Once you select your device, the code sample generator will give you a working code sample, and a selection of options to customize it to your needs.

Using the Code Samples

If it's unclear what any of the options do, click on the nearby '?' for more info.

Once you've made your selections, click the copy button and paste the code into your new project.

Be sure to change the name of the top class to match the name of the file in your project.

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.

«
»

Language - Java

Android with Android Studio

Welcome to using Phidgets with Java! By using Java, you will have access to the complete Phidget22 API, including events.

Android Studio is a graphical IDE for Android java programs.

Creating A New Project

When you are building a project from scratch, or adding Phidget functionality to an existing project, you'll need to configure your development environment to properly link the Phidget Java libraries for Android Java.

To start, create a new project in Android Studio:

Creating A New Project

Once you have a new project, be sure to switch the side bar to Project view.

Creating A New Project

Next, download the Phidget22 Android Java libraries, extract the contents, and open the resulting folder.

Creating A New Project

Copy the .jar files into the app/libs/ folder of your project. If you are only going to use network Phidgets in your app, then you don't need to copy Phidget22usb.jar into your project.

Right click the jar files you just copied and select Add As Library.

Creating A New Project

Create a directory called jnilibs under app/src/main

Creating A New Project

Copy the remaining folders from the Phidget22 library (containing versions of libphidget22java.so) into the directory you just created.

Creating A New Project

To allow the use of the network and/or USB connections, the following lines must be added to your AndroidManifest.xml file:

<!-- Required for network access -->
<uses-permission android:name="android.permission.INTERNET" />

<!-- Required for USB access -->
<uses-feature android:name="android.hardware.usb.host" />

Finally, to import the Phidget22 library into your code, add the following line to the rest of your imports:

import com.phidget22.*;

The project now has access to Phidgets. Next, we'll walk through the steps for writing your own code.

Write Code

By following the instructions for your operating system and compiler above, you now have working examples and a project that is configured. This teaching section will help you understand how the examples were written so you can start writing your own code.

Your main reference for writing Android Java code will be:

● The Phidget22 API

● The Java example code

Write Code

Step One: Initialize and Open

You will need to declare your Phidget object in your code. For example, we can declare a digital input object like this:

DigitalInput device;

Next, we need to initialize the method(s) that the Android device can communicate with the Phidget. This is done either by enabling Network Server Discovery, and/or allowing direct USB connections as follows:

//Enable server discovery to list remote Phidgets
this.getSystemService(Context.NSD_SERVICE);
Net.enableServerDiscovery(ServerType.DEVICE_REMOTE);

//Allow direct USB connection of Phidgets
com.phidget22.usb.Manager.Initialize(this);

Write Code

To support remote (network) Phidgets on Android API versions earlier than API version 16, or to connect to Phidget Network Servers with passwords, you will need to add the specific server to your program:

//Add a specific network server to communicate with Phidgets remotely
Net.addServer("ServerName", "192.168.1.105", 5661, "password", 0);

After the connection methods are established, the Phidget object needs to be initialized and opened:

device = new DigitalInput();
device.open();

Write Code

Although we are not including it on this page, you should include error handling for all Phidget functions. Here is an example of the previous code with error handling:

try{
    device = new DigitalInput();
    device.open();
}catch (PhidgetException e) {
    e.printStackTrace();
}

For more information on error handling with Phidgets, see this page.

Write Code

Step Two: Wait for Attachment (plugging in) of the Phidget

Simply calling open does not guarantee you can use the Phidget immediately. To use a Phidget, it must be plugged in (attached). We can handle this by using event driven programming and tracking the attach events. Alternatively, we can modify our code so we wait for an attachment:

ch = new DigitalInput();
ch.open(5000); //wait for attach for 5 seconds, if not time out

Waiting for attachment will block indefinitely until a connection is made, or until the timeout value is exceeded.

Write Code

To use events, we have to modify our code:

ch = new DigitalInput();
device.addAttachListener(new AttachListener() {
    public void onAttach(final AttachEvent attachEvent) {
        AttachEventHandler handler = new AttachEventHandler(device);
        synchronized(handler)
        {
            runOnUiThread(handler);
            try {
                handler.wait();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }
});
ch.open();

Write Code

Next, we have to declare the function that will be called when an attach event is fired - in this case the function AttachEventHandler will be called.

class AttachEventHandler implements Runnable { 
    Phidget device;

    public AttachEventHandler(Phidget device) {
        this.device = device;
    }

    public void run() {
        TextView attachedTxt = (TextView) findViewById(R.id.attachedTxt);
        attachedTxt.setText("Attached");

        //notify that we're done
        synchronized(this)
        {
	    this.notify();
        }
    }
}

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 = new DigitalInput();
device.addStateChangeListener(new DigitalInputStateChangeListener() {
	public void onStateChange(DigitalInputStateChangeEvent stateChangeEvent) {
        DigitalInputStateChangeEventHandler handler = 
            new DigitalInputStateChangeEventHandler(device, stateChangeEvent);
	runOnUiThread(handler);
    }
});
ch.open();

This code will connect a function and an event. In this case, the DigitalInputStateChangeEventHandler function will be called when there has been a change to the devices input.

Write Code

Next, we need to create the DigitalInputStateChangeEventHandler function itself:

class DigitalInputStateChangeEventHandler implements Runnable {
    Phidget device;
    DigitalInputStateChangeEvent stateChangeEvent;

    public DigitalInputStateChangeEventHandler(Phidget device,
       DigitalInputStateChangeEvent stateChangeEvent)
    {
        this.device = device;
        this.stateChangeEvent = stateChangeEvent;
    }

    public void run() {
        CheckBox stateBox = (CheckBox) findViewById(R.id.stateBox);
        stateBox.setChecked(stateChangeEvent.getState());
    }
}

If events do not suit your needs, you can also poll the device directly for data using code like this:

boolean state = ch.getState();

Write Code

Step Four: Close and Delete

At the end of your program, be sure to close your device.

ch.close();

Once the device is closed, to completely clean up after using Phidgets, you must uninitialize the USB connection as follows:

//Disable USB connection to Phidgets
com.phidget22.usb.Manager.Uninitialize();

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.

Common Problems, Solutions and Workarounds

My Phidget Detached When I Rotated My Phone

You are likely using one of our examples, or handling the opening and closing of Phidgets in a similar way. In either case, chances are you are opening and closing Phidgets in your main activity. This is not recommended for practical applications, as the entire activity can be destroyed and re-created many times through its lifecycle due to configuration changes such as rotating the screen. This is a reality of the Android operating system, and must be addressed in whatever way best suits your application. A good option to keep your Phidgets connected would be to implement a Started Service or a Foreground Service, depending on your application, and open your Phidgets there.

«
»

JavaScript - Select Development Environment

Select your Development Environment:

Any OS

Language - JavaScript

JavaScript in Browser

Welcome to using Phidgets with JavaScript! By using JavaScript, you will have access to the complete Phidget22 API, including events.

Using JavaScript with a browser provides a good way to create a powerful web interface for your Phidgets programs.

Requirements

First, install the Phidgets JavaScript Library for Browsers.

If you're on MacOS and plan on using any USB Phidgets that use the HID stack, you'll need to install the Phidget drivers for MacOS. You can check which stack your USB Phidgets use by checking the 'USB Stack' in the product specifications. If all of your Phidgets use the PHIDUSB stack or you're on Windows or Linux, you can skip installing the drivers since they're packaged with the Javascript libraries.


Version History

1.x.x - Initial Release (unstable- highly recommend updating to 2.x.x or newer)

2.x.x - Fixed stability issues

3.x.x - Added WebUSB support for VINT devices

Each release has potential breaking changes, so you should always revisit your code when updating to a new major release.

Phidget Network Server

The Phidgets JavaScript library requires the Phidget Network Server. Go to the page below and select the tab with your OS to get the Network Server set up:

Phidget Network Server


The Phidget Server includes a built-in Webserver. This must be enabled when using the JavaScript library in browser, but can be left disabled when using the library from Node.js.

The Phidget Server Webserver can be used to serve files - such as the Phidget JavaScript library, or your own projects. By default, it serves the JavaScript control panel files. The main purpose of the Webserver is to support a Websockets connection for the Browser library - because regular sockets cannot be used in Browser. The Node.js library uses raw sockets to connect to the Phidget Server, and so does not require the Webserver or Websockets.

Phidget Network Server

If you're on Windows or Mac, you can enable the Webserver in the Phidget Control Panel:

If you're using Linux, you can enable it in the Network Server config file located at:

/etc/phidgets/phidget22networkserver.pc

JavaScript Control Panel

The JavaScript control panel is a Browser version of our Phidget control panel. This can be used to view and control all Phidgets attached to a Phidget server. The JavaScript control panel is installed by default on Windows, macOS and PhidgetSBC. You can also download the source here.

Make sure the Phidget Server - Webserver is enabled, and running, then navigate to http://localhost:8989. (If you changed the port setting on the Webserver, replace '8989' with your selected port)

JavaScript Control Panel

You will now see a program written with JavaScript/HTML that mimics the Phidget Control Panel. It will show all the Phidgets attached to your machine. By double-clicking on the Phidgets, and example will launch.

Use Our Examples

Now that you've confirmed the webserver is running properly by testing your Phidgets through the JavaScript Control Panel, you can try running some of our sample code:

JavaScript Browser Examples

Download the example(s) that correspond to your Phidget's channel classes. You can find them listed on the enclosure in most cases, or on the API tab of the product page.

Use Our Examples

Unpack the example and double click on the HTML file to open a simple graphical example.

If there are any issues, open the browser's developer console to see if there are any warnings or errors. If your Web Server is configured with a port or hostname other than the default (localhost, 8989), you'll have to update the code in the HTML file.

Write Your Own Code

To write your own JavaScript code, we recommend that you download one of the examples to use as a starting point. You can also start from scratch in a new HTML file- all you need is a copy of phidget22.min.js and sha256.min.js in the same folder. You can find these files packaged with our examples, or downloaded here.

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.

«
»

Language - JavaScript

JavaScript in Node.js

Welcome to using Phidgets with JavaScript! By using JavaScript, you will have access to the complete Phidget22 API, including events.

Node.js is an open-source, cross-platform JavaScript run-time environment that allows programs written in JavaScript to be run locally.

Requirements

If you're on MacOS and plan on using any USB Phidgets that use the HID stack, you'll need to install the Phidget drivers for MacOS. You can check which stack your USB Phidgets use by checking the 'USB Stack' in the product specifications. If all of your Phidgets use the PHIDUSB stack or you're on Windows or Linux, you can skip installing the drivers since they're packaged with the Javascript libraries.

Node.js


Version History

1.x.x - Initial Release (unstable- highly recommend updating to 2.x.x or newer)

2.x.x - Fixed stability issues

3.x.x - Added WebUSB support for VINT devices

Each release has potential breaking changes, so you should always revisit your code when updating to a new major release.

JavaScript using the Phidget Network Server

Go to the this page and select the tab with your OS to get the Network Server set up.

The Phidget Server includes a built-in Webserver. This must be enabled when using the JavaScript library in browser, but can be left disabled when using the library from Node.js.

The Phidget Server Webserver can be used to serve files - such as the Phidget JavaScript library, or your own projects. By default, it serves the JavaScript control panel files.

In order to connect remotely, you need to use the NetworkConnection object. When you download a code sample later in this guide, make sure the Remote box is checked.

JavaScript using WebUSB

For library version 3.x.x or newer, you can connect to Phidgets plugged in locally via USB without having the Network Server running. This feature is only supported on Phidgets that use the PHIDUSB stack. You can see which stack your USB Phidgets use by checking the specifications table.

In order to connect using USB, you need to use the USBConnection object. When you download a code sample later in this guide, make sure the Remote box is unchecked.

JavaScript Control Panel

The JavaScript control panel is a Browser version of our Phidget control panel. This can be used to view and control all Phidgets attached to a Phidget server. The JavaScript control panel is installed by default on Windows, macOS and PhidgetSBC. You can also download the source here.

Make sure the Phidget Server - Webserver is enabled, and running, then navigate to http://localhost:8989. (If you changed the port setting on the Webserver, replace '8989' with your selected port)

JavaScript Control Panel

You will now see a program written with JavaScript/HTML that mimics the Phidget Control Panel. It will show all the Phidgets attached to your machine. By double-clicking on the Phidgets, and example will launch.

Using the Code Samples

Now that you've confirmed the webserver is running properly by testing your Phidgets through the JavaScript Control Panel, you can try running some of our sample code. On the Code Samples page and select your device from the drop-down menu.

Using the Code Samples

If it's unclear what any of the options do, click on the nearby '?' for more info.

Once you've made your selections, click the Download Example button to download a sample script.

Using the Code Samples

Next, unpack the example and open the command prompt in the folder you extracted to and enter the following commands:

npm install phidget22
npm update

Then enter the following command to run the example (replacing example.js with your example name):

node example.js

Success! Your program is now running with Phidgets.

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.

«
»

VB - Select Development Environment

Select your Development Environment:

Windows

Language - VB

Windows with Visual Studio

Welcome to using Phidgets with Visual Basic! By using Visual Basic, you will have access to the complete Phidget22 API, including events.

Visual Studio is an IDE provided by Microsoft that can be used to develop code in a wide variety of programming languages, including Visual Basic.

Requirements

First, make sure you have the following installed:

Phidgets Drivers for Windows

● Microsoft Visual Studio


Nuget

The Phidget22.NET library is now available on nuget.org here. Nuget is the recommended way to install and use the .NET library in Visual Studio. The nuget package bundles the C library on Windows, so there are no other prerequisites that need to be installed. The nuget package adds targets for .NET Core and .NET Standard, so it should be usable from almost any .NET environment which also supports the C library.

Use Our Examples

One of the best ways to start programming with Phidgets is to use our example code as a guide.

VB Code Samples

Download the example(s) that correspond to your Phidget's channel classes. You can find them listed on the enclosure in most cases, or on the API tab of the product page.

Use Our Examples

Unpack and open the example project and click the Start button:

The application will open the Phidget, list basic information about the Phidget, and demonstrate the Phidget's functionality. Here is an example of a Digital Output channel on a RFID Phidget:

You should now have the example up and running for your device. This would be a good time to play around with the device and experiment with some of its functionality.

Editing the Examples

The Visual Basic .Net examples are derived from the Windows Phidget Control Panel, so you'll need to modify a few things to adapt them for your own purposes. To begin with, you can remove the following line:

commandLineData phidgetParameters = open.parseCmdLine(); //get command line parameters

Then, you can modify any line that mentions phidgetParameters by setting it to the desired value instead of using PhidgetParameters object...

Editing the Examples

For instance:

Try 'set all the values grabbed from command line.  these values have defaults that are set in ExampleUtils.vb, you can check there to see them
    device.Channel = phidgetParameters.Channel 'selects the channel on the device to open
    device.DeviceSerialNumber = phidgetParameters.SerialNumber 'selects the device or hub to open
    device.HubPort = phidgetParameters.HubPort 'selects th eport on the hub to open
    device.IsHubPortDevice = phidgetParameters.isHubPortDevice 'is the device a port on a vint hub?

    If phidgetParameters.isRemote Then 'are we trying to open a remote device?
        device.IsRemote = True
        Net.EnableServerDiscovery(ServerType.Device) 'turn on network scan
        If phidgetParameters.Password <> vbNullString And 
           phidgetParameters.ServerName <> vbNullString Then
           
            Net.SetServerPassword(phidgetParameters.ServerName, phidgetParameters.Password)
        End If
    Else
        device.IsLocal = True
    End If

    device.Open() 'open the device specified by the above parameters
Catch ex As PhidgetException
    errorBox.addMessage("Error opening the device: " + ex.Message)
End Try

Might become:

Try
    device.Channel = 0
    device.DeviceSerialNumber = 370097
    device.HubPort = 0
    device.IsHubPortDevice = True
    device.IsLocal = True

    device.Open()
Catch ex As PhidgetException
    errorBox.addMessage("Error opening the device: " + ex.Message)
End Try

You can then manipulate the rest of the code as your application requires.

Write Code

You now have working examples and a project that is configured. This 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 VB code will be:

● The Phidget22 API documentation

● The VB Example Code

Write Code

Step One: Create And Address

You will need to declare your Phidget object in your code. For example, we can declare a digital input object like this:

ch = New Phidget22.DigitalInput()

Next, we can address which Phidget we want to connect to by setting parameters such as DeviceSerialNumber.

ch.DeviceSerialNumber = 496911

You can find information about all available parameters here or in the API documentation.

Write Code

Step One: Create And Address

Although we will not discuss it in-depth on this page, you should include error handling for all Phidget functions. Here is an example of the previous code with error handling:

Try
  ch = New Phidget22.DigitalInput()
  ch.DeviceSerialNumber = 496911
Catch ex As PhidgetException
  errorBox.addMessage("Error initializing: " + ex.Message)
End Try

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(5000)

To use a Phidget, it must be plugged in (attached). We can handle this by calling Open(timeout), which will block indefinitely until a connection is made, or until the timeout value is exceeded. Simply calling Open does not guarantee you can use the Phidget immediately.

Write Code

Alternately, you could verify the device is attached by using event driven programming and tracking the attach events.

To use events to handle attachments, we have to modify our code slightly:

Private Sub device_Attach(ByVal sender As Object, ByVal e As Phidget22.Events.AttachEventArgs) Handles ch.Attach
  Console.WriteLine("Phidget Attached!");
End Sub

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:

Private Sub device_DigitalInputChange(ByVal sender As Object, ByVal e As Phidget22.Events.DigitalInputStateChangeEventArgs) Handles ch.StateChange
  stateText.Text = "State: " + e.State;
End Sub

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.

If events do not suit your needs, you can also poll the device directly for data using code like this:

state= device.State;
stateText.Text = "State: " + e.State;

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 exception. See more information on this on our page for Unknown Values.

Write Code

Step Three: Do Things With The Phidget

Enumerations: 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 Visual Basic will take the form of Phidget22.EnumerationType.Enumeration_Name.

For example, specifying a SensorType to use the 1142 for a voltage input would look like:

Phidget22.VoltageSensorType.PN_1142

and specifying a K-Type thermocouple for a temperature sensor would be:

Phidget22.ThermocoupleType.K

The Phidget error code for timing out could be specified as:

Phidget22.ErrorCode.Timeout

Write Code

Step Four: Close And Delete

At the end of your program, be sure to close and delete your device:

device.Close();

Setting up a New Project

When you are building a project from scratch, or adding Phidget functionality to an existing project, you'll need to configure your development environment to properly link the Phidget .NET library. To begin:

Create a new Windows Forms Application project:

Setting up a New Project

Next, right-click to add a reference to the Phidget .NET library:

Setting up a New Project

On the following screen, click Browse and navigate to the location of Phidget22.NET.dll:

Setting up a New Project

Finally, to include the Phidget .NET library, add the following lines to main window class file:

Imports Phidget22
Imports Phidget22.Events

Success! The project now has access to Phidgets.

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.

«
»

Language - VB

Windows with Mono

Welcome to using Phidgets with Visual Basic! By using Visual Basic, you will have access to the complete Phidget22 API, including events.

Mono is an open-source programming environment that aims to make Microsoft .NET applications available across all operating systems.

Requirements

First, make sure you have the following installed:

Phidgets Drivers for Windows

Mono


Nuget

The Phidget22.NET library is now available on nuget.org here. Nuget is the recommended way to install and use the .NET library in Visual Studio. The nuget package bundles the C library on Windows, so there are no other prerequisites that need to be installed. The nuget package adds targets for .NET Core and .NET Standard, so it should be usable from almost any .NET environment which also supports the C library.

Use Our Examples

First, download and unpack the HelloWorld example for VB. This example uses the Phidget Manager to list all Phidget channels that can be accessed by your computer:

HelloWorld example

Note: The HelloWorld example is compatible with Mono because it does not use Windows Forms. All other VB examples use Windows Forms.

Use Our Examples

Next, copy Phidget22.NET.dll from type the following location:

● C:\Program Files\Phidgets\Phidget22\Phidget22.NET.dll

Place both the HelloWorld example and the Phidget22.NET.dll file in the same location. Your folder should now look something like this:

Use Our Examples

Open the command prompt at the folder location and enter the following command:

vbnc /r:Phidget22.NET.dll Module1.vb

This will create an executable file called Module1.exe. Type in the following command to run the example:

mono Module1.exe

Use Our Examples

You should be able to see the channels of your Phidget listed when the program starts or whenever the Phidget is plugged in while the program is running.

Now that you've confirmed that your devices are properly connected, the next step is to download and edit sample code for your specific device.

Use Our Examples

To download the code samples, visit this page:

VB Code Samples

Download the example(s) that correspond to your Phidget's channel classes. You can find them listed on the enclosure in most cases, or on the API tab of the product page.

Editing the Examples

The Visual Basic examples are derived from the Windows Phidget Control Panel, so you'll need to modify a few things to adapt them for your own purposes. To begin with, you can remove the following line:

commandLineData phidgetParameters = open.parseCmdLine(); //get command line parameters

Then, you can modify any line that mentions phidgetParameters by setting it to the desired value instead of using PhidgetParameters object...

Editing the Examples

For instance:

Try 'set all the values grabbed from command line.  these values have defaults that are set in ExampleUtils.vb, you can check there to see them
    device.Channel = phidgetParameters.Channel 'selects the channel on the device to open
    device.DeviceSerialNumber = phidgetParameters.SerialNumber 'selects the device or hub to open
    device.HubPort = phidgetParameters.HubPort 'selects th eport on the hub to open
    device.IsHubPortDevice = phidgetParameters.isHubPortDevice 'is the device a port on a vint hub?

    If phidgetParameters.isRemote Then 'are we trying to open a remote device?
        device.IsRemote = True
        Net.EnableServerDiscovery(ServerType.Device) 'turn on network scan
        If phidgetParameters.Password <> vbNullString And 
           phidgetParameters.ServerName <> vbNullString Then
           
            Net.SetServerPassword(phidgetParameters.ServerName, phidgetParameters.Password)
        End If
    Else
        device.IsLocal = True
    End If

    device.Open() 'open the device specified by the above parameters
Catch ex As PhidgetException
    errorBox.addMessage("Error opening the device: " + ex.Message)
End Try

Might become:

Try
    device.Channel = 0
    device.DeviceSerialNumber = 370097
    device.HubPort = 0
    device.IsHubPortDevice = True
    device.IsLocal = True

    device.Open()
Catch ex As PhidgetException
    errorBox.addMessage("Error opening the device: " + ex.Message)
End Try

You can then manipulate the rest of the code as your application requires.

Write Code

You now have working examples and a project that is configured. This 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 VB code will be:

● The Phidget22 API documentation

● The VB Example Code

Write Code

Step One: Create And Address

You will need to declare your Phidget object in your code. For example, we can declare a digital input object like this:

ch = New Phidget22.DigitalInput()

Next, we can address which Phidget we want to connect to by setting parameters such as DeviceSerialNumber.

ch.DeviceSerialNumber = 496911

You can find information about all available parameters here or in the API documentation.

Write Code

Step One: Create And Address

Although we will not discuss it in-depth on this page, you should include error handling for all Phidget functions. Here is an example of the previous code with error handling:

Try
  ch = New Phidget22.DigitalInput()
  ch.DeviceSerialNumber = 496911
Catch ex As PhidgetException
  errorBox.addMessage("Error initializing: " + ex.Message)
End Try

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(5000)

To use a Phidget, it must be plugged in (attached). We can handle this by calling Open(timeout), which will block indefinitely until a connection is made, or until the timeout value is exceeded. Simply calling Open does not guarantee you can use the Phidget immediately.

Write Code

Alternately, you could verify the device is attached by using event driven programming and tracking the attach events.

To use events to handle attachments, we have to modify our code slightly:

Private Sub device_Attach(ByVal sender As Object, ByVal e As Phidget22.Events.AttachEventArgs) Handles ch.Attach
  Console.WriteLine("Phidget Attached!");
End Sub

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:

Private Sub device_DigitalInputChange(ByVal sender As Object, ByVal e As Phidget22.Events.DigitalInputStateChangeEventArgs) Handles ch.StateChange
  stateText.Text = "State: " + e.State;
End Sub

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.

If events do not suit your needs, you can also poll the device directly for data using code like this:

state= device.State;
stateText.Text = "State: " + e.State;

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 exception. See more information on this on our page for Unknown Values.

Write Code

Step Three: Do Things With The Phidget

Enumerations: 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 Visual Basic will take the form of Phidget22.EnumerationType.Enumeration_Name.

For example, specifying a SensorType to use the 1142 for a voltage input would look like:

Phidget22.VoltageSensorType.PN_1142

and specifying a K-Type thermocouple for a temperature sensor would be:

Phidget22.ThermocoupleType.K

The Phidget error code for timing out could be specified as:

Phidget22.ErrorCode.Timeout

Write Code

Step Four: Close And Delete

At the end of your program, be sure to close and delete your device:

device.Close();

Setting up a New Project

When you are building a project from scratch, or adding Phidget functionality to an existing project, you'll need to configure your development environment to properly link the Phidget .NET library. To begin:

To include the Phidget .NET library, simply add the following lines to your code:

Imports Phidget22
Imports Phidget22.Events

Setting up a New Project

Next, copy Phidget22.NET.dll from the following location:

● C:\Program Files\Phidgets\Phidget22\Phidget22.NET.dll

Place your program and the Phidget22.NET.dll file in the same location. Your folder should now look something like this:

Setting up a New Project

Open the command prompt at the folder location and enter the following command:

vbnc /r:Phidget22.NET.dll Module1.vb

This will create an executable file called Module1.exe. Type in the following command to run the example:

mono Module1.exe

Success! The project now has access to Phidgets.

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.

«
»

Swift - Select Development Environment

Select your Development Environment:

macOS

iOS

Language - Swift

Windows with Xcode

Welcome to using Phidgets with Swift! By using Swift, you will have access to the complete Phidget22 API, including events.

Xcode is an integrated development environment for macOS. It is commonly used as a tool for developing software for macOS and iOS applications.

Requirements

First, make sure you have the following installed:

Phidgets Drivers for macOS

Xcode from the Mac App Store


You will also need to install CocoaPods in order to access the Phidget libraries for Swift. You can do this by opening the terminal and entering the following command:

Using Phidgets in Your Programs

There are two ways you can use Phidgets in Xcode. You can either start from a sample project provided by our code sample generator, or you can start a new project from scratch.

Select your preferred method below for instructions:

«
»

Language - Swift

Use Our Examples

Now that you have Xcode and CocoaPods installed, download a Swift example that will work with your Phidget:

Swift Examples

After opening the example, you will notice that there is a file called Podfile

Use Our Examples

If you open the Podfile, you can see that there is a reference to the Phidget22Swift pod. Note that no version number is included, so the newest available version of the Phidget22Swift pod will be installed:

Use Our Examples

To install the Phidget libraries, open a terminal at the example location and enter the following command:

pod install

Use Our Examples

After the libraries are installed, open the generated .xcworkspace file:

Use Our Examples

Next, simply press run:

Use Our Examples

Here is an example output:

You should now have the example up and running for your device. This would be a good time to play around with the device and experiment with some of its functionality.

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.

«
»

Language - Swift

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 a macOS application:

Setting up a New Project

Name the project, select Swift as the language, and continue:

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.

«
»

Language - Swift

iOS with Xcode

Welcome to using Phidgets with Swift! By using Swift, you will have access to the complete Phidget22 API, including events.

Xcode is an integrated development environment for macOS. It is commonly used as a tool for developing software for macOS and iOS applications.

Requirements

First, make sure you have the following installed:

Phidgets Drivers for macOS on your development machine

Xcode from the Mac App Store


You will also need to install CocoaPods in order to access the Phidget libraries for Swift. You can do this by opening the terminal and entering the following command:

Using Phidgets in Your Programs

There are two ways you can use Phidgets in Xcode. You can either start from a sample project provided by our code sample generator, or you can start a new project from scratch.

Select your preferred method below for instructions:

«
»

Language - Swift

Use Our Examples

Now that you have Xcode and CocoaPods installed, download a Swift example that will work with your Phidget:

Swift Examples

After opening the example, you will notice that there is a file called Podfile

Use Our Examples

If you open the Podfile, you can see that there is a reference to the Phidget22Swift pod. Note that no version number is included, so the newest available version of the Phidget22Swift pod will be installed:

Use Our Examples

To install the Phidget libraries, open a terminal at the example location and enter the following command:

pod install

Use Our Examples

After the libraries are installed, open the generated .xcworkspace file:

Use Our Examples

Next, select the type of device you would like the application to run on, and press play:

Use Our Examples

Here is an example output:

You should now have the example up and running for your device. This would be a good time to play around with the device and experiment with some of its functionality.

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.

«
»

Language - Swift

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.

«
»

Objective C - Select Development Environment

Select your Development Environment:

macOS

iOS

Language - Objective C

macOS with Xcode

Welcome to using Phidgets with Objective C! By using Objective C, you will have access to the complete Phidget22 API, including events.

Xcode is an IDE provided by Apple that can be used to develop code in a wide variety of programming languages, including Objective C.

Requirements

First, make sure you have the following installed:

Phidgets Drivers for macOS

Xcode from the Mac App Store

Use Our Examples

Next, download some of our sample code:

Objective-C Examples

Download the example(s) that correspond to your Phidget's channel classes. You can find them listed on the enclosure in most cases, or on the API tab of the product page.

Use Our Examples

Start the example by pressing the Run button:

Use Our Examples

The application will attach to the Phidget and show you some basic information. Here is an example of a Digital Output channel on a RFID Phidget:

You should now have the example up and running for your device. Play around with the device and experiment with some of the functionality. The next step is configuring your project and writing your own code!

Configure Your Project

When you are building a project from scratch, or adding Phidgets to an existing project, you'll need to configure your development environment to properly link the Phidget iOS library. To begin, create a new Xcode project:

Configure Your Project

Next, select a macOS Cocoa application:

Configure Your Project

Name that project:

Configure Your Project

Navigate to your target's Build Settings and find the Framework Search Path setting:

Configure Your Project

Add a reference to /Library/Frameworks where the Phidget22 framework is installed:

Configure Your Project

Next, navigate to the Linked Frameworks and Libraries setting under General and add a reference to the Phidget22 framework which is installed to /Library/Frameworks:

Configure Your Project

Finally, navigate to your header file and add a reference to phidget22.h

#import <Phidget22/phidget22.h>

Success! Your project now has access to Phidgets. Now that you have working examples and a project that is configured, we'll cover how the examples were written so you can start writing your own code.

Remember: your main reference for writing Objective C code will be:

● The Phidget22 API Manual (select 'C' as the language)

● Objective C example code

Write Code

Step One: Initialize and Open

You will need to declare your Phidget object in your code. For example, we can declare a digital input object like this:

PhidgetDigitalInput ch;

Next, the Phidget object needs to be initialized and opened.

PhidgetDigitalInput_create(&ch);
Phidget_open((PhidgetHandle)ch);

Write Code

Step One: Initialize and Open

We won't go into detail on it in this guide, but this is the previous code with error handling:

PhidgetReturnCode res;
const char* errorString;

res = PhidgetDigitalInput_create(&ch);
if(res != EPHIDGET_OK){
  Phidget_getErrorDescription ( returnValue, &errorString );
  NSLog(@"Handle error here");
}

res = Phidget_open((PhidgetHandle)ch);
if(res != EPHIDGET_OK){
  Phidget_getErrorDescription ( returnValue, &errorString );
   NSLog(@"Handle error here");
}

Write Code

Step Two: Wait for Attachment of the Phidget

Simply calling open does not guarantee you can use the Phidget immediately. To use a Phidget, it must be plugged in (attached). We can handle this by using event driven programming and tracking the attach events. Alternatively, we can modify our code so we wait for an attachment:

PhidgetDigitalInput_create(&ch);
Phidget_openWaitForAttachment(ch, 5000);

Waiting for attachment will block indefinitely until a connection is made, or until the timeout value is exceeded.

To use events to handle attachments, we have to modify our code slightly:

PhidgetDigitalInput_create(&ch);
Phidget_setOnAttachHandler((PhidgetHandle)ch,gotAttach,(__bridge void*)self);
Phidget_open((PhidgetHandle)ch);

Write Code

Step Two: Wait for Attachment of the Phidget

Next, we have to declare the function that will be called when an attach event is fired - in this case the function gotAttach will be called:

static void gotAttach(PhidgetHandle phid, void *context){
    [(__bridge id)context performSelectorOnMainThread:@selector(deviceAttached)
                                           withObject:nil
                                        waitUntilDone:NO];
}

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:

PhidgetDigitalInput_create(&ch);
Phidget_setOnAttachHandler((PhidgetHandle)ch,gotAttach,(__bridge void*)self);
PhidgetDigitalInput_setOnStateChangeHandler(ch, gotStateChange, (__bridge void*)self);
Phidget_open((PhidgetHandle)ch);

This code will connect a function and an event. In this case, the gotStateChange function will be called when there has been a change to the devices input. Next, we need to create the gotStateChange function.

void gotStateChange(PhidgetDigitalInputHandle phid, void *context, int state){
        [(__bridge id)context performSelectorOnMainThread:@selector(onStateChangeHandler:)
                                               withObject:[NSNumber numberWithInt:state]
                                            waitUntilDone:NO];
}

Above, the onStateChangeHandler method is invoked on the main thread. Event data is stored as an NSNumber.

Write Code

Step Three: Do Things with the Phidget

The method onStateChangeHandler is defined as follows:

- (void)onStateChangeHandler:(NSNumber *)state{
    if(state.intValue)
        stateTextField.stringValue = @"True";
    else
        stateTextField.stringValue = @"False";
}

If events do not suit your needs, you can also poll the device directly for data using code like this:

int state;

PhidgetDigitalInput_getState(ch, &state);
stateTextField.stringValue = [NSString stringWithFormat:@"%@", state ? @"True" : @"False"];

Write Code

Step Four: Close and Delete

At the end of your program, be sure to close and delete your device:

Phidget_close((PhidgetHandle)ch);
PhidgetDigitalInput_delete(&ch);

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.

«
»

Language - Objective C

iOS with Xcode

Welcome to using Phidgets with Objective C! By using Objective C, you will have access to the complete Phidget22 API, including events.

Xcode is an IDE provided by Apple that can be used to develop code in a wide variety of programming languages, including Objective C.

Requirements

First, make sure you have the following installed:

Phidgets Drivers for macOS on your development machine

Xcode from the Mac App Store

Use Our Examples

Next, download and unpack the Phidget libraries for iOS development

Phidget iOS Libraries

You will later need to reference these files from your Xcode project in order to use Phidgets.

Next, download the Objective-C example:

Objective-C Example

Use Our Examples

Unpack the Objective-C example and navigate to Phidget.xcodeproj. Open the file in Xcode:

Use Our Examples

With Phidgets as your target, navigate to Build Settings and find the Header Search Paths setting:

Use Our Examples

The header file phidget22.h was included in the Phidget iOS libraries download. Add a reference to the folder that contains phidget22.h under the Header Search Paths setting:

Use Our Examples

Next, find the Other Linker Flags setting:

Use Our Examples

Add a reference to the Phidget libraries that were included in the Phidget iOS libraries download:

Use Our Examples

Now that the library files are linked, simply select the type of device you would like the application to run on and press play:

Write Code

The application will detect any servers that are currently online and have Phidgets connected. Here is an example output:

First, confirm that the Phidgets Example is working. Then, run the example for your specific device by selecting your server and then continue to navigate through the hierarchy until you reach your device. After tapping your device, the example will show automatically. Currently, we have example programs for the following classes:

  • DigitalInput
  • DigitalOutput
  • VoltageInput
  • VoltageRatioInput

Write Code

Here is an example of what the VoltageInput example looks like:

You should now have the example up and running for your device. Play around with the device and experiment with some of the functionality. When you are ready, the next step is configuring your project and writing your own code!

Configure Your Project

When you are building a project from scratch, or adding Phidgets to an existing project, you'll need to configure your development environment to properly link the Phidget iOS library. To begin, create a new Xcode project:

Configure Your Project

Select an iOS application. For this tutorial's purposes, we will use a Single View Application:

Configure Your Project

Name the project, select Objective-C as the language, and choose which devices will be supported:

Configure Your Project

Now that your project is created, you need to add references to the Phidget iOS libraries in the same way you added them to run our example code earlier in this guide.

After you have linked the Phidget iOS libraries, simply add a reference to phidget22.h in your header file:

#import <Phidget22/phidget22.h>

Success! The project now has access to Phidgets and we are ready to begin coding.

Remember: your main reference for writing Objective C code will be:

● The Phidget22 API Manual (select 'C' as the language)

● Objective C example code

Write Code

Step One: Initialize and Open

You will need to declare your Phidget object in your code. For example, we can declare a digital input object like this:

PhidgetDigitalInput ch;

Next, the Phidget object needs to be initialized and opened.

PhidgetDigitalInput_create(&ch);
Phidget_open((PhidgetHandle)ch);

Write Code

Step One: Initialize and Open

We won't go into detail on it in this guide, but this is the previous code with error handling:

PhidgetReturnCode res;
const char* errorString;

res = PhidgetDigitalInput_create(&ch);
if(res != EPHIDGET_OK){
  Phidget_getErrorDescription ( returnValue, &errorString );
  NSLog(@"Handle error here");
}

res = Phidget_open((PhidgetHandle)ch);
if(res != EPHIDGET_OK){
  Phidget_getErrorDescription ( returnValue, &errorString );
   NSLog(@"Handle error here");
}

Write Code

Step Two: Wait for Attachment of the Phidget

Simply calling open does not guarantee you can use the Phidget immediately. To use a Phidget, it must be plugged in (attached). We can handle this by using event driven programming and tracking the attach events. Alternatively, we can modify our code so we wait for an attachment:

PhidgetDigitalInput_create(&ch);
Phidget_openWaitForAttachment(ch, 5000);

Waiting for attachment will block indefinitely until a connection is made, or until the timeout value is exceeded.

To use events to handle attachments, we have to modify our code slightly:

PhidgetDigitalInput_create(&ch);
Phidget_setOnAttachHandler((PhidgetHandle)ch,gotAttach,(__bridge void*)self);
Phidget_open((PhidgetHandle)ch);

Write Code

Step Two: Wait for Attachment of the Phidget

Next, we have to declare the function that will be called when an attach event is fired - in this case the function gotAttach will be called:

static void gotAttach(PhidgetHandle phid, void *context){
    [(__bridge id)context performSelectorOnMainThread:@selector(deviceAttached)
                                           withObject:nil
                                        waitUntilDone:NO];
}

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:

PhidgetDigitalInput_create(&ch);
Phidget_setOnAttachHandler((PhidgetHandle)ch,gotAttach,(__bridge void*)self);
PhidgetDigitalInput_setOnStateChangeHandler(ch, gotStateChange, (__bridge void*)self);
Phidget_open((PhidgetHandle)ch);

This code will connect a function and an event. In this case, the gotStateChange function will be called when there has been a change to the devices input. Next, we need to create the gotStateChange function.

void gotStateChange(PhidgetDigitalInputHandle phid, void *context, int state){
        [(__bridge id)context performSelectorOnMainThread:@selector(onStateChangeHandler:)
                                               withObject:[NSNumber numberWithInt:state]
                                            waitUntilDone:NO];
}

Above, the onStateChangeHandler method is invoked on the main thread. Event data is stored as an NSNumber.

Write Code

Step Three: Do Things with the Phidget

The method onStateChangeHandler is defined as follows:

- (void)onStateChangeHandler:(NSNumber *)state{
    if(state.intValue)
        stateTextField.stringValue = @"True";
    else
        stateTextField.stringValue = @"False";
}

If events do not suit your needs, you can also poll the device directly for data using code like this:

int state;

PhidgetDigitalInput_getState(ch, &state);
stateTextField.stringValue = [NSString stringWithFormat:@"%@", state ? @"True" : @"False"];

Write Code

Step Four: Close and Delete

At the end of your program, be sure to close and delete your device:

Phidget_close((PhidgetHandle)ch);
PhidgetDigitalInput_delete(&ch);

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.

«
»

Max - Select Development Environment

Select your Development Environment:

Windows

macOS

Language - Max

Windows with Max

Welcome to using Phidgets with Max! By using Max, you will have access to the complete Phidget22 API, including events.

Phidget22 supports Max versions 6 and up.

Requirements

First, make sure you have the following installed:

Phidgets Drivers for Windows

Max

Use Our Examples

Next, download and unpack the Phidgets Max library:

Phidget Max library

Use Our Examples

After unpacking the download, navigate to the externals folder. Copy the following folder to your clipboard:

  • For 32-bit Max, copy the x86 folder
  • For 64-bit Max, copy the x64 folder

Use Our Examples

The folder you copied needs to be placed in a specific location for Max to reference it. Open Max and navigate to Options -> File Preferences.

Use Our Examples

The folder that you copied earlier needs to be placed in any of the locations listed in File Preferences. Navigate to one of the locations and paste the folder:

Use Our Examples

The Phidget Max library is now being referenced. Next, navigate to the examples folder located within the Phidget22MaxMSP folder you previously unpacked:

Use Our Examples

From here, select an example that will work with your Phidget and open it in Max. You can run the example by simply pressing the start button:

The example is now running. Play around with the device and experiment with some of the functionality. When you are ready, the next step is configuring your project and writing your own code!

Write Code

You should now have working examples and a project that is configured. This 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 Max code will be:

● The Phidget22 API Manual

● The Max examples

Write Code

First, let's explain how to operate the examples. We will take a look at the PhidgetVoltageInput example:

For this particular example, the Max object is called PhidgetVoltageInput. Objects/message boxes are connected to the inputs and outputs of this object. Input objects will either cause a property of the device to change or request for a property to be retrieved. Output objects return the retrieved information.

All supported functions for Max can be found in the Phidget22 API.

Write Code

Try it for yourself! Click on the getDeviceSerialNumber message box to request the Phidget to retrieve the serial number of the device. You should see the a message in the Max window denoting the serial number of your device. All devices support the getDeviceSerialNumber message, making it an easy way to determine if the Phidget libraries are correctly set up, and whether the Max application is connected to your device.

If your example contains a get[DataType] message box (e.g. getVoltage), click on it to cause the associated data to be output with a relevant prefix. [DataType] can be data member the object has. A list of available messages and their associated outputs is outlined in the Phidget22 API for your device.

Write Code

If your example contains the start message box, you can continuously poll for events. Just press the start message box to start sampling. When an event occurs on a Phidget (i.e. when a sensor detects a change in the measured data), associated data will be output with related prefixes. Press the stop message box to stop sampling.

For the PhidgetDigitalOutput example, there are setDutyCycle and setState message boxes. Changing the numbers will cause the digital output to change. Your example may contain device specific message boxes to click on. Click them to see what they do!

Write Code

Your best resource to program in Max will be our examples. If you aren't familiar with concepts in Phidget programming, you may find our Phidget Programming Basics page helpful. It provides a very generic overview of what traditional languages follow when using Phidgets. For Max users, conceptual details about particular actions (e.g. opening a Phidget) are explained there.

Keep in mind when reading these general resources that the Max libraries may not implement the full Phidgets API - some function calls and Phidget classes may not be supported.

In general, Phidget objects can be placed inside the patcher, and functions can be called on them using appropriately connected messages. We'll go over a basic setup next.

Write Code

Step One: Initialize and Open

Initializing and opening the device is be done by placing a new object. Other objects handle different Phidgets - a Spatial, a Light Sensor, a Motor Controller, etc. Only the name of the object changes. You can find the name for the object in the device's .maxhelp file (e.g. VoltageInput.maxhelp). If you are unsure what the software object for your device is, go to the API tab on its product page on our website.

In the case of a Voltage Input, we name it PhidgetVoltageInput:

Important: a local connection will reserve the device until closed. This prevents any other instances from retrieving data from the Phidget, including other programs. Every Phidget object in Max will automatically try to connect to and reserve a Phidget for itself. As long as a Max Phidget object is running, it will continuously try to connect to a Phidget, even trying to reconnect if it gets disconnected.

Write Code

Specifying a Phidget

When the instance is created as with the Voltage Input above, normally it will make a connection to the first device of its type it can find. The Phidget object can also be declared with a number of specifiers to open a specific Phidget instead.

Specifiers can be added to the object in the format: PhidgetExternal {Specifiers}. These will be written in the form: specifier=value

The full list of specifiers that can be used to identify a Phidget in Max are as follows:

  • serialnumber - The serial number of the device
  • channel - The channel of the device to open
  • hubport - The hub port the device is plugged into (where applicable)
  • ishubport - Specifies whether this channel should be opened on a hub port directly, or on a VINT device attached to a hub port.
  • remote - Forces connection to a remote device over a network, ignoring devices on the local machine
  • local - Forces connection to a device plugged into the local machine, ignoring network devices

Write Code

Specifying a Phidget

For instance, to open a VoltageInput with serial number 349428, you would use:

Some other examples:

Open a Digital Input:

PhidgetDigitalInput

Open channel 1 of a Digital Input Phidget connected to port 2 of a hub with serial number 35569

PhidgetDigitalInput serialnumber=35569 channel=1 hubport=2

Open open hub port 2 as a DigitalInput for a hub with serial number 35569

PhidgetDigitalInput serialnumber=35569 hubport=2 ishubport=1

Write Code

Using a Phidget Over a Network

To use the Network Server, first the Phidget needs to be plugged in to a computer that has the Network Server turned on within your local network. (For information on how to do this, see the Phidget Network Server page in the section on how to use the Network Server for your operating system).

Next, in your patch you need a PhidgetNet object. To automatically find local networks, send it a message saying enableServerDiscovery.

Then, to connect a Phidget over the network, change the object text to specify it is to connect to a Phidget on a remote server, as per the following example.

Write Code

Step Two: Wait for Attachment (plugging in) of the Phidget

Although this is a required step in many of our other languages (and therefore you may be expecting this if coming from another Phidget language), in Max you do not have to add a specific waitForAttachment block.

Keep in mind, however, that if your Phidget is not responding within your Max program, it may simply not be plugged in! Send a getAttached message to a Phidget object at any time to see if it's attached.

Write Code

Step Three: Do Things with the Phidget

Phidget data is accessed either by one-time polling or at a fixed rate via on-board timers for some devices.

Getting or setting values directly via polling on the Phidget is done through messages linked to the inlet. The object’s inlet can be wired to send commands to the device, and the outlet used to retrieve the results. You can set values on the Phidget by using the set messages, and some properties can be read with get messages:

To sample at a fixed rate, use the start and stop messages to start and stop the data flow, respectively.

Write Code

Step Three: Do Things with the Phidget

Outlet data is always given a prefix to allow for routing. For instance, the digital input state state change event data is given the prefix stateChange, and the voltage input voltage change event similarly use voltageChange. The specific prefixes for each set of outlet data is listed on the API page for that class.

The rightmost outlet on the Phidget object outputs error event data. This will send information on error events such as saturation events. To see which error events may apply to your device, check its API page.

Write Code

Step Four: Close and Delete

Although this is a required step in many of our other languages (and therefore you may be expecting this if coming from another Phidget language), in Max you do not have to add a specific close and delete block.

Special Case: Multiple Phidgets

Multiple Phidgets of the same type can easily be used inside a single program, it only requires another Phidget object placed. If two of the same type of Phidget object are placed, the serial number and channel arguments should always be specified (as well as hub port, if applicable) to ensure that the correct Phidget gets associated with the correct object.

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.

«
»

Language - Max

MacOS with Max

Welcome to using Phidgets with Max! By using Max, you will have access to the complete Phidget22 API, including events.

Phidget22 supports Max versions 6 and up.

Requirements

First, make sure you have the following installed:

Phidgets Drivers for macOS

Max

Use Our Examples

Next, download and unpack the Phidgets Max library:

Phidget Max library

Use Our Examples

After unpacking the download, navigate to the externals folder and copy it to your clipboard:

Use Our Examples

The folder you copied needs to be placed in a specific location for Max to reference it. Open Max and navigate to Options -> File Preferences.

You will see something similar to this:

Use Our Examples

The folder that you copied earlier needs to be placed in any of the locations listed in File Preferences. Navigate to one of the locations and paste the folder:

Use Our Examples

The Phidget Max library is now being referenced. Next, navigate to the examples folder located within the Phidget22MaxMSP folder you previously unpacked:

Use Our Examples

From here, select an example that will work with your Phidget and open it in Max. You can run the example by simply pressing the start button:

The example is now running. Play around with the device and experiment with some of the functionality. When you are ready, the next step is configuring your project and writing your own code!

Write Code

You should now have working examples and a project that is configured. This 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 Max code will be:

● The Phidget22 API Manual

● The Max examples

Write Code

First, let's explain how to operate the examples. We will take a look at the PhidgetVoltageInput example:

For this particular example, the Max object is called PhidgetVoltageInput. Objects/message boxes are connected to the inputs and outputs of this object. Input objects will either cause a property of the device to change or request for a property to be retrieved. Output objects return the retrieved information.

All supported functions for Max can be found in the Phidget22 API.

Write Code

Try it for yourself! Click on the getDeviceSerialNumber message box to request the Phidget to retrieve the serial number of the device. You should see the a message in the Max window denoting the serial number of your device. All devices support the getDeviceSerialNumber message, making it an easy way to determine if the Phidget libraries are correctly set up, and whether the Max application is connected to your device.

If your example contains a get[DataType] message box (e.g. getVoltage), click on it to cause the associated data to be output with a relevant prefix. [DataType] can be data member the object has. A list of available messages and their associated outputs is outlined in the Phidget22 API for your device.

Write Code

If your example contains the start message box, you can continuously poll for events. Just press the start message box to start sampling. When an event occurs on a Phidget (i.e. when a sensor detects a change in the measured data), associated data will be output with related prefixes. Press the stop message box to stop sampling.

For the PhidgetDigitalOutput example, there are setDutyCycle and setState message boxes. Changing the numbers will cause the digital output to change. Your example may contain device specific message boxes to click on. Click them to see what they do!

Write Code

Your best resource to program in Max will be our examples. If you aren't familiar with concepts in Phidget programming, you may find our Phidget Programming Basics page helpful. It provides a very generic overview of what traditional languages follow when using Phidgets. For Max users, conceptual details about particular actions (e.g. opening a Phidget) are explained there.

Keep in mind when reading these general resources that the Max libraries may not implement the full Phidgets API - some function calls and Phidget classes may not be supported.

In general, Phidget objects can be placed inside the patcher, and functions can be called on them using appropriately connected messages. We'll go over a basic setup next.

Write Code

Step One: Initialize and Open

Initializing and opening the device is be done by placing a new object. Other objects handle different Phidgets - a Spatial, a Light Sensor, a Motor Controller, etc. Only the name of the object changes. You can find the name for the object in the device's .maxhelp file (e.g. VoltageInput.maxhelp). If you are unsure what the software object for your device is, go to the API tab on its product page on our website.

In the case of a Voltage Input, we name it PhidgetVoltageInput:

Important: a local connection will reserve the device until closed. This prevents any other instances from retrieving data from the Phidget, including other programs. Every Phidget object in Max will automatically try to connect to and reserve a Phidget for itself. As long as a Max Phidget object is running, it will continuously try to connect to a Phidget, even trying to reconnect if it gets disconnected.

Write Code

Specifying a Phidget

When the instance is created as with the Voltage Input above, normally it will make a connection to the first device of its type it can find. The Phidget object can also be declared with a number of specifiers to open a specific Phidget instead.

Specifiers can be added to the object in the format: PhidgetExternal {Specifiers}. These will be written in the form: specifier=value

The full list of specifiers that can be used to identify a Phidget in Max are as follows:

  • serialnumber - The serial number of the device
  • channel - The channel of the device to open
  • hubport - The hub port the device is plugged into (where applicable)
  • ishubport - Specifies whether this channel should be opened on a hub port directly, or on a VINT device attached to a hub port.
  • remote - Forces connection to a remote device over a network, ignoring devices on the local machine
  • local - Forces connection to a device plugged into the local machine, ignoring network devices

Write Code

Specifying a Phidget

For instance, to open a VoltageInput with serial number 349428, you would use:

Some other examples:

Open a Digital Input:

PhidgetDigitalInput

Open channel 1 of a Digital Input Phidget connected to port 2 of a hub with serial number 35569

PhidgetDigitalInput serialnumber=35569 channel=1 hubport=2

Open open hub port 2 as a DigitalInput for a hub with serial number 35569

PhidgetDigitalInput serialnumber=35569 hubport=2 ishubport=1

Write Code

Using a Phidget Over a Network

To use the Network Server, first the Phidget needs to be plugged in to a computer that has the Network Server turned on within your local network. (For information on how to do this, see the Phidget Network Server page in the section on how to use the Network Server for your operating system).

Next, in your patch you need a PhidgetNet object. To automatically find local networks, send it a message saying enableServerDiscovery.

Then, to connect a Phidget over the network, change the object text to specify it is to connect to a Phidget on a remote server, as per the following example.

Write Code

Step Two: Wait for Attachment (plugging in) of the Phidget

Although this is a required step in many of our other languages (and therefore you may be expecting this if coming from another Phidget language), in Max you do not have to add a specific waitForAttachment block.

Keep in mind, however, that if your Phidget is not responding within your Max program, it may simply not be plugged in! Send a getAttached message to a Phidget object at any time to see if it's attached.

Write Code

Step Three: Do Things with the Phidget

Phidget data is accessed either by one-time polling or at a fixed rate via on-board timers for some devices.

Getting or setting values directly via polling on the Phidget is done through messages linked to the inlet. The object’s inlet can be wired to send commands to the device, and the outlet used to retrieve the results. You can set values on the Phidget by using the set messages, and some properties can be read with get messages:

To sample at a fixed rate, use the start and stop messages to start and stop the data flow, respectively.

Write Code

Step Three: Do Things with the Phidget

Outlet data is always given a prefix to allow for routing. For instance, the digital input state state change event data is given the prefix stateChange, and the voltage input voltage change event similarly use voltageChange. The specific prefixes for each set of outlet data is listed on the API page for that class.

The rightmost outlet on the Phidget object outputs error event data. This will send information on error events such as saturation events. To see which error events may apply to your device, check its API page.

Write Code

Step Four: Close and Delete

Although this is a required step in many of our other languages (and therefore you may be expecting this if coming from another Phidget language), in Max you do not have to add a specific close and delete block.

Special Case: Multiple Phidgets

Multiple Phidgets of the same type can easily be used inside a single program, it only requires another Phidget object placed. If two of the same type of Phidget object are placed, the serial number and channel arguments should always be specified (as well as hub port, if applicable) to ensure that the correct Phidget gets associated with the correct object.

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.

«
»

Language - LabVIEW

Windows with LabVIEW

Welcome to using Phidgets with LabVIEW! By using LabVIEW, you will have access to the complete Phidget22 API, including events. We also provide example code in LabVIEW for all Phidget devices.

LabVIEW is a development environment for a graphical programming language created by National Instruments.

Requirements

First, make sure you have the following:

Phidgets Drivers for Windows

Phidget LabVIEW Library downloaded


Note: The LabVIEW Library also contains example VI trees, which we'll cover later in this guide.

Using Our Examples

One of the best ways to start programming with Phidgets is to use our example code as a guide.

Unpack the Phidget LabVIEW Library and rename the unpacked folder to Phidgets.

Using Our Examples

Navigate to the following directory:

● For 32-bit LabVIEW, C:/Program Files (x86)/National Instruments/LabVIEW 20xx/instr.lib

● For 64-bit LabVIEW, C:/Program Files/National Instruments/LabVIEW 20xx/instr.lib

Place the renamed folder at this location:

Using Our Examples

Next, open LabVIEW and create a new VI:

Using Our Examples

In the new block diagram window, open the functions palette (View -> Functions Palette).

Next, go to the Phidgets palette (Instrument I/O -> Instrument Drivers -> Phidgets):

Using Our Examples

Next, select a palette that will work for your Phidget and drag VI Tree.vi onto your block diagram:

Using Our Examples

Right-click on VI Tree.vi and select Open Front Panel:

Using Our Examples

From the front panel, navigate to the block diagram (Window -> Block Diagram):

Using Our Examples

The VI Tree Block Diagram lists all VIs available for its Phidget Class, and which subpalette to find them under. The examples are located near the bottom of the block diagram. Right-click the example you would like to use and select Open Front Panel:

Using Our Examples

When you are ready, press Run and the application will demonstrate the Phidget's functionality.

Here is an example of an Accelerometer channel on a Spatial Phidget:

You should now have the example up and running for your device. Play around with the device and experiment with some of the functionality. When you are ready, the next step is configuring your environment and writing your own code!

Configure Your Environment

First, we recommend enabling the Show constant labels setting in LabVIEW. This setting will reduce complexity when developing, and is especially recommended for beginners.

To enable the setting, first navigate to Tools -> Options on your block diagram:

Configure Your Environment

Select the Environment category and enable Show created constant labels at the bottom:

Configure Your Environment

To begin working with Phidgets, you will need both a StartPhidget VI and a ClosePhidget VI:

Configure Your Environment

Select a class that will work with your Phidget from the drop-down menu for each VI:

Configure Your Environment

You can now add device information or any initialization parameters to the StartPhidget VI. Using your mouse, hover over each of the connection nodes to see information about it:

Configure Your Environment

If you would like to add device information or initialization parameters, right-click the connection node and navigate to one of the following:

Create -> Constant

Create -> Control

Configure Your Environment

Creating a constant will allow you to modify device information from the block diagram:

Configure Your Environment

Creating a control will allow you to modify device information from the front panel:

The environment now has access to Phidgets. Next, we'll walk through writing your own code.

Write Code

Along with this guide, your main resources for writing LabVIEW code will be:

● The examples

● The Phidget22 API

● The VI help files

Examples of more complex general topics such as using multiple Phidgets and connecting to a Phidget over the Network Server can be found under the VI Tree for the Phidget Common palette.

Example Flow

Most LabVIEW examples follow the same basic flow: starting a Phidget, reading some data, and closing the Phidget.

Step One: Initialize, Open And Wait For Attachment Of The Phidget

The entire process of opening and initializing a Phidget can be done by using the version of StartPhidget.vi that corresponds to your device. In most cases, StartPhidget.vi will also attempt to wait for the first data to become available from the device for 5 seconds after initialization.

If you'd prefer to initialize the device manually, you can use OpenPhidget.vi for your device and call the individual functions to set up the device.

Step Two: Do Things With The Phidget

You can read data and interact with your Phidget both by polling it for its current state (or to set a state), or by catching events that trigger when the data changes.

To poll devices, simply place the corresponding blocks:

To use events, there are three main blocks for each type, to create, execute, and close the event handler. When creating the event, all devices using an event of the same type must be grouped into an array to ensure the events get processed correctly.

Step Two: Do Things With The Phidget

Once created, the events will be processed by [Name]EventExe.vi. When an event occurs, the pertinent information will be output, as well as information to reference which device caused it.

After a program has run its course, the event handler must be closed.

Step Three: Close And Delete

Closing a Phidget is done by using the appropriate version of ClosePhidget.vi

That's all the basic building blocks you need to create a LabVIEW program using Phidgets.

Help and Documentation

For more information on the use of any VI and its parameters, right-click the VI and select Help

Help and Documentation

This will take you to an HTML page outlining the function of the VI. This includes a list of all its parameters, which devices support them, their range of acceptable values, and their default values, where applicable:

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.

Scroll down for device-specific troubleshooting, or go to the next slide for LabVIEW troubleshooting.

LabVIEW Troubleshooting

Expand All
I cannot attach to an object any more after running my program once

What this means is you probably aborted the VI which stopped the program before the Phidget could be closed. Aborting execution will not release the Phidget device properly and will consequently make it unusable until the Phidgets library (or LabVIEW) has been restarted.

To resolve this, you may open a new VI, place PhidgetResetLibrary.vi, and run it. This will completely reset the current Phidget library, making it possible again to connect to all Phidgets.

Note that this action will close all Phidgets that are currently open in LabVIEW, and should not be used while other Phidgets-related LabVIEW VIs are running.

Phidget Reset All Palette.png

Phidget Reset All.png

In order to prevent this from happening you should use a software stop button when possible instead of halting operation. That way the Close subVI gets called and the Phidget will be released.

I cannot find my error code on this website

All Phidgets-based error codes in LabVIEW are offset by 7000 to avoid conflicting with LabVIEW's own error codes. To get the equivalent Phidget return code from the LabVIEW error code, simply subtract 7000. For instance, error code 7003 in LabVIEW translates to Phidget Return Code 3.

To find the meaning of all Phidget Return Codes, you can go to the Phidget22 API page, and open the PhidgetReturnCode section under Enumerations.

Events Can Occasionally Cause Issues, Especially When There Are Multiple Of The Same Type Of Event

In other words, if you open 2 of the same device and have a sensor change event for each one your system can behave unpredictably. This problem is a quirk in the way that LabVIEW handles passing events to and from C. There are a few solutions to this issue, either:

  • Stop using events and simply poll the device. Events work similarly to polling in LabVIEW anyway and should not cause substantial performance changes to your application.
  • Implement a simple fix to the events which are causing the problem. The pointer is identical in the case where two events of the same type are passed from a single function. This causes the events in C to output to the same event in LabVIEW. To get around this you need to copy the offending subVI, then change the name of the cluster object in it from "Event" to something else (your choice), change the name of the .vi to something else and then use those two different subVIs in your program. You would need to repeat this for each subsequent event of the same type you wish to have.
  • Make an array of all the devices you intend to use with the event, and feed the array into a single EventCreate vi, and use a single EventExe handler for all the events. When using this method, it might be tempting to add multiple event handlers, but keep in mind that events only occur once, in whichever handler sees them first. When running multiple Phidgets through the single event handler, you can determine which one caused the event by comparing the phid terminal from the EventExe VI to the Phidget IDs (Device In/Device Out) of your Phidgets.

We recommend using either of the the first two solutions where possible. The first is a bit cleaner, but the second will work just as well. We only recommend using the third method in cases where it is not practical to manually create individual event handlers.

«
»