Language - MATLAB

MATLAB has a supported API for all Phidgets devices, and code samples for some devices. For a complete list of the status for our supported languages, please click here.

MATLAB does not allow any form of event driven programming. Most of our other supported languages do, we recommend choosing a language that does.

If this is your first time working with a Phidget, we suggest starting with the Getting Started page for your specific device. That page will walk you through installing drivers and libraries for your operating system, and will then bring you back here to use MATLAB specifically.

Development Environments and Compilers

There could be difference between MATLAB and Octave (open source MATLAB). TO BE FILLED IN

Drivers, Libraries and Resources

Before you can run your program, you need to set up the proper environment and get the necessary files off the Phidgets website. The MATLAB functions essentially call functions in the C library. Hence, you will need the C/C++ libraries below, and you will probably find the C/C++ API documentation below useful.

Visit the drivers section at www.phidgets.com and get the latest:

• Phidget Framework

You will need the Phidget Framework to use and to program with Phidgets. We also recommend that you download the following reference materials:

• C/C++ API Manual
• API Reference
• MATLAB Sample Code
• You can find a high level discussion about programming with Phidgets in general on the General API page.
• The Device Functionality page explains the general operational information for your device.

You may want to have these pages open while working through these instructions.

Getting Started

The Phidget examples were written using MATLAB m-files and this tutorial assumes its use. Your project will need to be able to find the phidget21Matlab.h from the MATLAB examples.

Setting up the Libraries

Before you can use the Phidget, you must include a reference to the library in the code in the main body of code. Copy phidget21Matlab.h to your project directory and then in MATLAB:

  function phidgettest(n)
     loadlibrary phidget21 phidget21Matlab.h;
      % More code goes here
  end

Developing Code

Running Examples

One good way to start developing your application is to run and modify existing examples. You can find the MATLAB example code here:

• MATLAB Examples
• C/C++ API, the basis for MATLAB calls

To run the example code, you'll need to find the source code for your specific device within the example package. If your device does not have an example written for it, try the HelloWorld.m example. Then, run the code within MATLAB as you would any .m file. This will allow you to:

• Make sure your libraries are properly linked, as above
• Go from source code to a test application as quickly as possible

Writing Your Own Code

Programming with Phidgets will make extensive use of the calllib() function to the C/C++ library, so the C/C++ API reference will be helpful:

• C/C++ API Reference

You can use a Phidget in code by essentially by:

1. Opening it,
2. Setting it up (waiting for it to be plugged in, turning on antennas, etc.),
3. Doing things with it (like reading data), and
4. Closing it.

These steps are generally outlined for all devices and languages on the General Phidget Programming page. The General Phidget Programming page also introduces using the Phidget in a linear manner using logic code. Event-driven examples are given on the General Phidget Programming page, these do not apply to MATLAB.

Specific calls in MATLAB will differ in syntax from those on the General Phidget Programming page, but the concepts stay the same. If we were using a Phidget Interface Kit as our device, the general calls would look like this:

1. To initialize and open:

  ikptr = libpointer('int32Ptr',0);
  calllib('phidget21', 'CPhidgetInterfaceKit_create', ikptr);
  ikhandle = get(ikptr, 'Value');

The ikptr is converted to ikhandle as a handle of the PhidgetInterfacekit, and is used for all the C function calls where CPhidgetHandle phid is used. The object name for any type of Phidget is listed in the API manual. Every type of Phidget also inherits functionality from the Phidget base class.

Note that open() opens the software object, but not hardware. So, it is not a guarantee you can use the Phidget immediately.

The different types of open can be used with parameters to try and get the first device it can find, open based on its serial number, or even open across the network. The API manual lists all of the available modes that open provides.

2. To wait for an attachment (plugging in) of the Phidget:

To use the Phidget, it must be plugged in (attached). We can handle this by calling waitForAttachment. WaitForAttachment will block indefinitely until a connection is made to the Phidget, or an optional timeout is exceeded:

  calllib('phidget21', 'CPhidget_open', ikhandle, -1);
  if calllib('phidget21', 'CPhidget_waitForAttachment', ikhandle, 2500) == 0
     % Insert your code here
  end

3. Do Things with the Phidget:

The most common thing you might want to do is read data from sensors. MATLAB does not support event handling, so all data must be read and sent directly. Simply use the C API functions such as CPhidgetInterfaceKit_getSensorValue() or CPhidgetInterfaceKit_setOutState() for Interface Kits:

  while n<10
    dataptr = libpointer('int32Ptr',0);
    calllib('phidget21', 'CPhidgetInterfaceKit_getSensorValue', ikhandle, 0, dataptr)
    disp(get(dataptr, 'Value'));
    n=n+1;
  end

Here a pointer is created to mark a value from the InterfaceKit inside a polling loop, and then its value is displayed to screen.

4. Close and Delete:

  calllib('phidget21', 'CPhidget_close', ikhandle);
  calllib('phidget21', 'CPhidget_delete', ikhandle);

At the end of your program, don’t forget to call close to free any locks on the Phidget that the open() call put in place!

The complete set of functions you have available for all Phidgets can be found in the C/C++ API. Note, however, MATLAB does not make use of the event functions in the C/C++ API

If you are looking for more information about a particular function, we provide that as well. You can find more description on any function either in:

1. Our API Overview which describes the set of calls common to all Phidgets, or
2. The Device API page for calls available only on your specific Phidget.

Working with multiple Phidgets

Multiple Phidgets of the same type can easily be run inside the same program. In our case, it requires another pointer and handle initialized for a PhidgetInterfaceKit. The new instance can then be set up, opened and used in the same fashion as the previous one. If the application needs to distinguish between the devices, open can be called with the serial number of a specific Phidget.

Building your Project

Describe the different ways a project could be built using this language.

Common Problems and Solutions/Workarounds

Here you can put various frequent problems and our recommended solutions.