OS - Linux: Difference between revisions

From Phidgets Support
 
(285 intermediate revisions by 10 users not shown)
Line 1: Line 1:
__TOC__
<metadesc>Communicate over USB with sensors, controllers and relays with Phidgets! Program in Linux using a wide variety of programming languages.</metadesc>
[[Category:OS]]
{|
|style="vertical-align:middle; width: 60%;"|
==Getting Started with Linux==
Welcome to using Phidgets with Linux!


Phidgets can run on Linux directly using USB, or remotely over a network using the [[Phidget Webservice]]. 
If you are ready to go, the first step in creating Linux applications with Phidgets is installing our libraries.
 
|{{TOC limit|3}}
You need kernel '''version 2.6''' or later.
|}
 
===Install===
==Getting Started (Libraries and Drivers)==
The first step to using Phidgets with Linux is installing the Phidget22 libraries.
 
{{LinuxSupport}}
Linux does not have a graphical user interface to check your Phidget, but it does have a complete API for [[#Programming Languages|many languages]].
If you're running one of the supported distros, we recommend using the '''Package Install'''. For other systems, you can use the '''Source Install'''.  
 
For any language, you will need the basic Phidget Libraries for Linux:
 
*[http://www.phidgets.com/downloads/libraries/libphidget_2.1.8.20110615.tar.gz Phidget Libraries]
 
===Installing===
 
To install the libraries, follow these steps:
 
#Download '''libusb-0.1''' and its development libraries
#*Try <code>apt-cache search libusb</code> in a terminal to find current packages
#*Or install [http://www.libusb.org/ from source], which includes the libusb development libraries
#Unpack and install the '''Phidget Libraries''' for Linux (download above)
#*From the main libraries directory, run:
#*:<code>./configure</code>
#*:<code>make</code>
#*:<code>sudo make install</code>
#*This will compile phidget21.h and place the library into your gcc path
 
'''Note:''' Although the libraries are written in C, the libraries for Python, Java, and most other Phidget-supported languages depend on them.
 
===Checking===
 
To confirm the libraries were installed and work correctly, you can check both the hardware and software sides of the interface.  It is worth checking the software side first, because if it works then you know the hardware side is also okay.
 
====Software====
 
To confirm that the libraries were installed correctly and can be used in code, you can use the Phidget C Examples:
 
*[http://www.phidgets.com/downloads/examples/phidget21-c-examples_2.1.8.20111028.tar.gz Phidget C Examples]
 
The easiest way to confirm correct installation will be to compile and run the '''<code>HelloWorld</code>''' C example.  This does not involve writing any C code, but it does involve compiling the example and running it, which is a quick process as we show below.  If you feel more comfortable running the '''<code>HelloWorld</code>''' example for your specific language, you can skip below and pick your language, but keep in mind that any problems could be with the C library installation and not necessarily with your language.
 
To compile and run the basic C example for checking your installation:
 
1. Unpack the '''Phidget C Examples''' (download above)<br>
2. Open a terminal (often Ctrl-Alt-T) and go to the directory where the examples are unpacked<br>
3. Compile the <code>HelloWorld.c</code> example:<br>
<div style="background-color: #f3f3f3; border-color: #1c9edb; border-width:1px; border-style: dashed;">
<font size="3">
<source lang=bash>
 
    gcc HelloWorld.c -o HelloWorld -lphidget21
 
</source>
</font>
</div>
4. Run the <code>HelloWorld</code> example:<br>
<div style="background-color: #f3f3f3; border-color: #1c9edb; border-width:1px; border-style: dashed;">
<font size="3">
<source lang=bash>
 
    sudo ./HelloWorld
 
</source>
</font>
</div>
:(The sudo is needed for USB access for now)
 
The <code>-lphidget21</code> will look in the standard library location for your Linux distribution (usually <code>/usr/lib/</code>) for the Phidget 21 library file. 
 
Generally, libraries to be linked on Linux through <code>gcc</code> have a naming convention.  For example, <code>-lphidget21</code> looks for the binary files '''<code>libphidget21.a</code>''' and '''<code>libphidget21.so</code>''' in the library location (usually '''<code>/usr/lib</code>''').  These files are automatically put in the library location during the <code>make install</code> step of [[#Installing | installing the libraries above]].
 
The HelloWorld program will simply print out basic information for any device you plug in, and print a message upon unplugging the device.  For example, starting the program, plugging in an Interface Kit Phidget, unplugging the Interface Kit, and pressing Enter displays:
 
<div style="background-color: #f3f3f3; border-color: #1c9edb; border-width:1px; border-style: dashed;">
<font size="3">
<source lang=bash>
 
  $ sudo ./HelloWorld
 
  Opening...
  Press Enter to end
 
  Hello to Device Phidget InterfaceKit 8/8/8, Serial Number: 37299
  Goodbye Device Phidget InterfaceKit 8/8/8, Serial Number: 37299
 
  Closing...
 
</source>
</font>
</div>
 
====Hardware====
 
If the out-of-the-box examples do not work, make sure the Phidget is seen by your USB interface.  To check this, you can use the kernel log reader '''<code>dmesg</code>'''.  Pipe the output of '''<code>dmesg</code>''' into the utility '''<code>tail</code>''' to simply read the last ten lines of the log:
 
<div style="background-color: #f3f3f3; border-color: #1c9edb; border-width:1px; border-style: dashed;">
<font size="3">
<source lang=bash>
 
    $> dmesg | tail
    ....(9 lines)....
    [24344.013638] usb 2-1.2: new low speed USB device number 5 using ehci_hcd
 
</source>
</font>
</div>
 
The number between the [ ] is the system time in seconds since the last boot up, so you can tell whether the event was recent or not.  (This will also tell you the interrupt type of Phidget that is registered by the USB interface, see the [[#Limitations | limitations section below]] for more information on what this means.)
 
The Phidget should both connect and disconnect properly, so unplugging it should result in an additional line at the tail:
 
<div style="background-color: #f3f3f3; border-color: #1c9edb; border-width:1px; border-style: dashed;">
<font size="3">
<source lang=bash>
 
    $> dmesg | tail
    ....(8 lines)....
    [24344.013638] usb 2-1.2: new low speed USB device number 5 using ehci_hcd
    [25094.809328] usb 2-1.2: USB disconnect, device number 5
 
</source>
</font>
</div>
 
If you don't see similar lines to these at the tail of your kernel log, take a look at the [[#Troubleshooting|troubleshooting]] section below, as well as the '''Communications''' section of our [[General Troubleshooting#Communications Troubleshooting|general troubleshooting page]].
 
====Troubleshooting====
 
If the examples '''do not''' work but USB '''does''' work (i.e. your computer can consistently see the device in the [[#Hardware|hardware]]), take a moment to check the basics:
* No other programs, drivers, or processes are using that USB port in software
* You are running the example program as root (or your udev rules have been set properly)
* You are using libusb 0.1 (not 1.0 or later)
* You have compiled versions of libphidget21.a and libphidget21.so in your system library location (usually <code>/usr/lib</code>)
* The Phidget libraries are the latest version (visit the [[#Getting Started (Libraries and Drivers)| getting started section above]] to download them)
* Your Linux kernel version is 2.6 or later (type '''<code>uname -r</code>''' in a terminal to get your kernel version)
* Check the [[#Limitations|limitations]] section below, some specific combinations can cause problems
 
If your problem doesn't seem to be fixed by the steps above, make sure that the Phidget is seen '''consistently''' by USB (if it is erratic, try our [[General Troubleshooting|general troubleshooting guide]]). If you are still having problems after the troubleshooting guide, please [[Contact Information|ask us]]!
 
==Programming Languages==
 
Now that you have the basic libraries installed, you can pick your language and begin programming! 
 
If you are not using the [[#Webservice | webservice]] (discussed below) to control a Phidget over a network, your next step will be to delve into the use of your specific language.  Each page has its own set of specific libraries, code examples, and setup instructions. 
 
On Linux, we recommend the following languages:
 
*[[Language - C/C++|C/C++]]
*[[Language - Java | Java]]
*[[Language - Python | Python]]
*[[Language - C Sharp | C#]] (Using [[Language - C Sharp#Mono|Mono]])
*[[Language - Flash AS3 | Flash AS3]]
 
You can also use these languages, but they do not support [[General Phidget Programming#Event Driven Code | event driven code]], and must use [[General Phidget Programming#Logic Code | logic code]] only:
 
*[[Language - MATLAB|MATLAB]]
 
==Webservice==
 
The Phidget Webservice allows you to remotely control a Phidget over a network.<br>
Before using these webservice drivers, it may help to learn about how the [[Phidget Webservice]] works.
 
*[http://www.phidgets.com/downloads/libraries/phidgetwebservice_2.1.8.20111028.tar.gz Linux Phidgets Webservice] libraries
*The Webservice on Linux uses <code>avahi</code>
 
===Installing the Webservice===
 
To install the webservice, you must first have the [[#Installing|Phidget libraries installed]].  Then, follow these steps:
 
#Download '''avahi''' and its development libraries (mdnsresponder/bonjour is also an option, see [[#Webservice with mDNSResponder|below]])
#*Try <code>apt-cache search avahi</code> in a terminal to find current packages
#*Often, this is installed in a default system, you may already have it
#Unpack and install the '''Phidget Webservice''' source code tarball for Linux (download above)
#*From the unpacked Webservice source code directory, run:
#*:<code>./configure</code>
#*:<code>make</code>
#*:<code>sudo make install</code>
#*This will compile the executable '''<code>phidgetwebservice21</code>''' and place it into '''<code>/usr/bin/phidgetwebservice21</code>'''
 
====Webservice with BSD====
 
For '''BSD''', the webservice has been found to work (BSD 8+) but requires a special configuration at the '''<code>./configure</code>''' step:
 
<div style="background-color: #f3f3f3; border-color: #1c9edb; border-width:1px; border-style: dashed;">
<font size="3">
<source lang=bash>
./configure LIBS=/usr/lib/libphidget21.so CFLAGS=-pthread
</source>
</font>
</div>
 
Then '''<code>make</code>''' and '''<code>sudo make install</code>''' are the same.
<br>
The '''<code>LIBS</code>''' argument may not be necessary, but sometimes BSD has trouble finding the library install location.  The '''<code>CFLAGS</code>''' argument is needed because BSD needs explicit linking for using threads.
 
====Webservice with mDNSResponder====
 
To use '''mdnsresponder''' instead of avahi, change the configure script to be:
 
<div style="background-color: #f3f3f3; border-color: #1c9edb; border-width:1px; border-style: dashed;">
<font size="3">
<source lang=bash>
  ./configure --enable-zeroconf=bonjour
</source>
</font>
</div>
 
(To see all options, use '''<code>./configure --help</code>''' like you would any configure script)
 
===Setting Up the Webservice===
 
To set up and use the webservice, it helps to have [[#Setting udev Rules|set your udev rules]]. Otherwise, you must run the webservice as root.
 
You can get command line help with '''<code>phidgetwebservice21</code>''' by using the '''<code>-h</code>''' option:


[[Image:Linux_phidget21webservice_help.png]]
<div class="bigTabs">
<tabber>
Package Install=
====Install Script====
To run the install script and install phidget22, enter the following command in the terminal:


You will see this help regardless of whether the webservice was correctly hooked in to avahi.  In fact, you will see it even if you explicitly disabled mDNS in the '''<code>./configure</code>''' step at compile:
{{LinuxInstallScript}}


<div style="background-color: #f3f3f3; border-color: #1c9edb; border-width:1px; border-style: dashed;">
====Manual Install====
<font size="3">
To install our package repository manually, enter the following command in the terminal, replacing ''distro'' with your distro codename:
<source lang=bash>
  ./configure --disable-zeroconf
</source>
</font>
</div>


(To see all options, use '''<code>./configure --help</code>''' like you would any configure script)
{{LinuxGetKey}}


Using a server name to connect would not be an option without avahi or some other mDNS service; otherwise you would have to use an IP address.  In that case, the command line is the fastest way to learn the default server name and IP address of your computer:
We support Debian releases from 6 to current, and Ubuntu LTS releases from 14.04 to current. If you are using another flavour of Linux (such as Mint), which is based on Ubuntu or Debian, use the corresponding Ubuntu or Debian codename.
*For the default server name, use '''<code>hostname</code>''' on the command line.
*For your IP address, use '''<code>ifconfig -a</code>''' on the command line.
**A line in the return text, under your main internet connection (usually '''<code>eth0</code>''') will say something like '''<code>inet addr:192.168.3.178</code>''', which is your IP.


===Using the Webservice===
Update your package lists:
{{LinuxAptUpdate}}


To use a Phidget over the webservice, you'll want to:
Finally, install the Phidget package by entering the command below:
# Start the webservice on both the computer that directly connects to the Phidget and the computer that will remotely control it
{{LinuxAptInstall}}
# Run your program on the remote computer that will control the Phidget via code.


The easiest way to test this on Linux is simply to set up the webservice and run the Phidget program on the same computer.  Later, you can replace one of the two ends with a different computer and/or operating system.
====Additional Packages====
You may also want to apt-get install the following optional packages:
* '''libphidget22-dev''': The C development libraries for Phidget22
* '''libphidget22extra''': Extra runtime library required for the Network Server and Admin tools
* '''phidget22networkserver''': The [[Phidget Network Server]], which enables use of Phidgets over your network
* '''libphidget22java''': The Java libraries for Phidget22
* [[Phidget22admin Guide|'''phidget22admin''']]: An administrator utility for listing Phidgets and upgrading firmware
* '''phidget22wwwjs''': The JavaScript libraries for Phidget22. This package also installs the HTML examples which can be accessed through the web interface


To easily create code to run remotely, in our examples we include commented out lines with openRemote() function calls of different types.  In the C example for your device, find the line that says:


'''<code>CPhidget_open((CPhidgetHandle) device, -1)</code>'''
The libraries are now installed on your machine. Next, set up the UDev rules below.


and change it to be:
|-|
Source Install=
====Source Install====
To install our libraries, first install libusb-1.0 development libraries. The exact command and package name will vary depending on distribution. For Debian based distributions, including Ubuntu and Mint, the command would be:
<syntaxhighlight lang=bash>
apt-get install libusb-1.0-0-dev
</syntaxhighlight>


<div style="background-color: #f3f3f3; border-color: #1c9edb; border-width:1px; border-style: dashed;">
<font size="3">
<source lang=c>
  int serial_number = 37299
  CPhidget_openRemoteIP ((CPhidgetHandle) device, serial_number, "127.0.0.1", 5001, NULL)
</source>
</font>
</div>


Except that you should replace '''37299''' with the serial number of your Phidget, which you can obtain from either the Phidget board itself, or from when you ran the [[#Checking|HelloWorld example code above]]. The IP address "127.0.0.1" simply loops back to the same computer, and 5001 is the default port as found from using '''<code>phidget21webservice -h</code>''' [[#Setting Up the Webservice|as shown above]].
Next, download and unpack the following files:
*[https://cdn.phidgets.com/downloads/phidget22/libraries/linux/libphidget22.tar.gz libphidget22] (Mandatory)
*[https://cdn.phidgets.com/downloads/phidget22/libraries/linux/libphidget22extra.tar.gz libphidget22extra] (Optional - needed by NetworkServer and Admin)
*[https://cdn.phidgets.com/downloads/phidget22/libraries/linux/libphidget22java.tar.gz libphidget22java] (Optional - Java Libraries)
*[https://cdn.phidgets.com/downloads/phidget22/servers/linux/phidget22networkserver.tar.gz phidget22networkserver] (Optional - [[Phidget Network Server]])
*[https://cdn.phidgets.com/downloads/phidget22/tools/linux/phidget22admin.tar.gz phidget22admin] (Optional - Phidget Admin Tool)
Open the README file that is included at the top of each directory. This file will give you important information about how to properly install the files.


Let's say your computer that is directly connected to the Phidget has a default name of '''<code>phidget-test</code>'''.  Then, to connect
{| style="border:1px solid black; background-color:#ffffcc; text-align:left;" cellpadding="10" cellspacing="0"
!Directly Controlling Computer
! width="20px" | &nbsp;
! Remotely Controlling Computer
|-
| 1. Start the Phidget Webservice
| width="20px" | &nbsp;
|
|-
|
| width="20px" | &nbsp;
| 2. Start your Phidget code <br /> (using openRemote() in code starts the webservice on this system)
|-
| 3. Plug in the Phidget
| width="20px" | &nbsp;
|
|-
|
| width="20px" | &nbsp;
| 4. Code waits for attachment or event
|-
|
| width="20px" | &nbsp;
| 5. Use the Phidget!
|}


1. If you are directly connecting the Phidget to a Linux computer, start the webservice on that computer in a terminal (usually opened via Ctrl-Alt-T) via:
Libraries are installed in /usr/local/lib by default. If you run into trouble finding the libraries during linking or at runtime, this probably means that /usr/local/lib is not on the library path for your distribution.


<div style="background-color: #f3f3f3; border-color: #1c9edb; border-width:1px; border-style: dashed;">
You can handle this in a number of ways:
<font size="3">
<source lang=bash>
  phidgetwebservice21 &
</source>
</font>
</div>


This will broadcast any Phidget events, and receive any Phidget requests, both over the network.
Specify a different install folder during compile
<syntaxhighlight lang=bash>./configure --prefix=/usr && make && sudo make install</syntaxhighlight>
OR Add /usr/local/lib to the system-wide library path
<syntaxhighlight lang=bash>echo /usr/local/lib >> /etc/ld.so.conf && sudo ldconfig</syntaxhighlight>
OR Add /usr/local/lib in your local shell every time
<syntaxhighlight lang=bash>export LD_LIBRARY_PATH=$LD_LIBRARY_PATH:/usr/local/lib</syntaxhighlight>


2. If the computer you are using to control a Phidget over a network is also Linux, run the
The libraries are now installed on your machine. Next, you should set the UDev Rules.
 
</tabber>
===Debugging the Webservice===
 
In addition to enabling [[General Phidget Programming#Logging|logging]] in your Phidget code, you can get additional debugging information from the Webservice itself.  This additional debugging is enabled via a re-compile of the webservice.  From the source code directory, do:
 
<div style="background-color: #f3f3f3; border-color: #1c9edb; border-width:1px; border-style: dashed;">
<font size="3">
<source lang=bash>
  make clean
 
  ./configure --enable-debug
 
  make
 
  sudo make install
</source>
</font>
</div>
</div>


==Advanced Uses==
=== Setting UDev Rules ===
By default, Linux will not grant permission to regular users to access physical hardware as a security feature.  This means that in order to run Phidgets code from user space you must grant yourself root privileges via sudo.  For example:


===Setting udev Rules===
sudo ./HelloWorld


If you don't want to be using '''<code>sudo</code>''' to run Phidget programs (including the webservice) forever, you will want to create a '''<code>udev</code>''' rule to allow yourself access to the Phidget when you are not root.
You can grant access manually or, more commonly, set up a rules file to do it automatically keying off of the vendor code for Phidget USB devices.  To do this, create a text file called "99-libphidget22.rules" with the following contents:


Udev has an easy way to set the owner and permissions of the USB interface of the Phidget. But you need to give udev something to match in order to apply the new settings.  Here, we will tell udev to match the vendor code for Phidgets, Inc.  You can get the vendor code in hex by using '''<code>lsusb</code>''':
# All current and future Phidgets - Vendor = 0x06c2, Product = 0x0030 - 0x00af
SUBSYSTEMS=="usb", ACTION=="add", ATTRS{idVendor}=="06c2", ATTRS{idProduct}=="00[3-a][0-f]", MODE="666"


<div style="background-color: #f3f3f3; border-color: #1c9edb; border-width:1px; border-style: dashed;">
Where mode 666 means every user has permission to read and write to the specified file/device.  You need to then move this file to "/etc/udev/rules.d". Now you can run Phidget related code as a regular user without the OS denying permission.
<font size="3">
<source lang=bash>
  $> lsusb
  ....Information about other devices...
  Bus 002 Device 013: ID 06c2:0045 Phidgets Inc. (formerly GLAB) PhidgetInterface Kit 8-8-8
</source>
</font>
</div>


The two numbers separated by a colon are the codes for '''vendor:product'''.  Since we want to set up the rule so that all Phidgets, no matter what product, can be used without root privileges, we use the vendor code, which is '''06c2'''.
===Verify===
The best way to verify that your libraries are working properly is to compile and run an example program.


The rules for udev are kept in files in '''<code>/etc/udev/rules.d/</code>''' and are traditionally grouped into order of running (10 runs before 20, 30, etc) and device type (cd, network, etc).  There should be one or more files in there already - if this is your first time editing udev rules take a look at them to see the syntax to use:
* Commas separate each pair with == or =
* One rule on each line, no line breaks
* Quotes around the value to be matched or changed
* Comments can be added on lines starting with #


Strictly speaking, the files run in lexical order (i.e. the order they're listed when you use '''<code>ls</code>''').  A device can match many rules, and all will apply (if possible).  If conflicting rules are found, the first rule found is followed.
First, download and unpack this C example:
*[https://cdn.phidgets.com/downloads/phidget22/examples/c/Manager/Phidget22_HelloWorld_C_Ex.zip HelloWorld C example]


To make sure the Phidget udev rules are found first, we can create a file '''<code>10-persistent-usb.rules</code>''' (all udev rule files need to end with '''<code>.rules</code>''') and add one line to it:
'''Note:''' If using the Debian intallation methods, you will need to install the '''libphidget22-dev''' package to use the C libraries for Phidget22


<div style="background-color: #f3f3f3; border-color: #1c9edb; border-width:1px; border-style: dashed;">
Next, open the terminal at the example location. Compile the example by entering the following command:
<font size="3">
<syntaxhighlight lang=bash>
<source lang=bash>
gcc HelloWorld.c -o HelloWorld -lphidget22
  SUBSYSTEM=="usb", ATTRS{idVendor}=="06c2", MODE="0666", OWNER="user"
</syntaxhighlight>
</source>
</font>
</div>


Make sure to replace '''<code>user</code>''' with your user name.  You probably recognize the '''06c2''' from the vendor discussion above.  We have added the match on '''<code>SUBSYSTEM</code>''' to search first within usb (within a possibly big database).  The '''<code>MODE</code>''' sets read and write privileges for everyone to the device, and '''<code>OWNER</code>''' sets the owner to be you.


Save the '''<code>10-persistent-usb.rules</code>''' in '''<code>/etc/udev/rules.d/</code>''' and then change its permissions so it can be read by all:
Run the HelloWorld example:
<syntaxhighlight lang=bash>
./HelloWorld
</syntaxhighlight>


<div style="background-color: #f3f3f3; border-color: #1c9edb; border-width:1px; border-style: dashed;">
<font size="3">
<source lang=bash>
  sudo chmod a+r /etc/udev/rules.d/10-persistent-usb.rules
</source>
</font>
</div>


The udev rule is now set, and it just has to get read in.  The reading of the rules is goverened by a daemon, '''<code>udevd</code>''', which you can manage via the program '''<code>udevadm</code>'''.  The '''<code>udevadm</code>''' man page is quite extensive for all sorts of uses of '''<code>udevadm</code>''' while you are testing this or other udev rules. To re-read and implement the rules without having to reset the daemon or reset the computer, you can use:
Your terminal should look something like this:
[[File:linux_helloworld.PNG|link=|center]]


<div style="background-color: #f3f3f3; border-color: #1c9edb; border-width:1px; border-style: dashed;">
<font size="3">
<source lang=bash>
  sudo udevadm control --reload-rules
</source>
</font>
</div>
Finally, if you performed all of these steps with the Phidget plugged in to your computer, you will need to unplug and plug the Phidget back in before trying to use usb access without root privileges.
===Starting the Webservice at Boot===
===Cross-Compiling with a Custom Toolchain===
This would allow you to have the Phidget libraries compiled to include in code for an embedded device.  When developing for an embedded device, you will often write code for it on your 'normal' computer, and then build the code to binary with a different target than the processor in your computer.  Many microcontrollers do not have the ability to run a full operating system, and hence cannot compile code natively. 
The collection of tools used to create binary code for a separate system is called a ''toolchain''.  Compiling the Phidget libraries specifically for an embedded system, and placing them into the path for writing code on top of the libraries is like adding another link in this chain.
<div style="background-color: #f3f3f3; border-color: #1c9edb; border-width:1px; border-style: dashed;">
<font size="3">
<source lang=bash>
  sudo apt-get install gcc-arm-linux-gnueabi
</source>
</font>
</div>
You can use the typical ./configure setup for custom build targets:
'''<code>./configure --prefix=toolchain_location --build=this_system --host=target_system</code>'''


For the Phidget libraries, the '''<code>./configure</code>''' tool works this way as well. For example, let's say you're building the libraries to develop code for the [[SBC|Phidget Single Board Computer (SBC)]] as a target.  Your system is a 32 bit system (i686-pc-linux-gnu) and the target system for the [[SBC]] is <code>arm-linux-gnueabi</code>.  Download the Phidget libraries [[#Getting Started (Libraries and Drivers)|above]] and unpack them into a folder '''<code>phidget_libraries</code>'''. If <code>/usr/arm-linux-gnueabi</code> is the location of your ARM toolchain (downloaded above in '''<code>gcc-arm-linux-gnueabi</code>'''), type:
The HelloWorld program will simply communicate when a Phidget has been attached or detached, as can be seen in the image above.


<div style="background-color: #f3f3f3; border-color: #1c9edb; border-width:1px; border-style: dashed;">
<font size="3">
<source lang=bash>


  user@server:~/phidget_libraries$ ./configure --prefix=/usr/arm-linux-gnueabi --build=i686-pc-linux-gnu --host=arm-linux-gnueabi
Your Phidget is now able to communicate with your development machine. The next step is selecting a programming language so you can start to write some code!
 
</source>
</font>
</div>


==Common Problems and Solutions==
==Programming==
Ready to write some code? Select one of the programming languages below:


None yet, yay!
{{Programming_Languages_Table}}


==Limitations==
==Older Versions==
If you need older versions of the Phidget22 Linux libraries, [{{SERVER}}/downloads/phidget22/libraries/linux/libphidget22/ click here].


* Linux will only schedule one low-speed interrupt transfer per millisecond.  The practical consequence of this is if your system has many low speed Phidgets attached, they will each be throttled down.  Low speed Phidgets require an interrupt transfer as often as every 8 milliseconds.  A Linux system could only have up to 8 of these Phidgets attached.
If you need Phidget21 Linux Libraries, [{{SERVER}}/downloads/phidget21/libraries/linux/libphidget/ click here].

Latest revision as of 15:45, 9 September 2024

Getting Started with Linux

Welcome to using Phidgets with Linux!

If you are ready to go, the first step in creating Linux applications with Phidgets is installing our libraries.

Install

The first step to using Phidgets with Linux is installing the Phidget22 libraries.

Supported Distros / Archs
Debian 6 (Squeeze) i386 armel
Debian 7 (Wheezy)
Debian 8 (Jessie) armhf
Debian 9 (Stretch)
Debian 10 (Buster) amd64 arm64
Debian 11 (Bullseye)
Debian 12 (Bookworm)
Ubuntu Xenial 16.04 LTS i386 armhf
Ubuntu Bionic 18.04 LTS amd64 arm64
Ubuntu Focal 20.04 LTS
Ubuntu Jammy 22.04 LTS
Ubuntu Noble 24.04 LTS

If you're running one of the supported distros, we recommend using the Package Install. For other systems, you can use the Source Install.

Install Script

To run the install script and install phidget22, enter the following command in the terminal: 

curl -fsSL https://www.phidgets.com/downloads/setup_linux | bash -
apt-get install -y libphidget22


curl -fsSL https://www.phidgets.com/downloads/setup_linux | sudo -E bash -
sudo apt-get install -y libphidget22

Manual Install

To install our package repository manually, enter the following command in the terminal, replacing distro with your distro codename: 

wget -qO /usr/share/keyrings/phidgets.gpg \
  https://www.phidgets.com/gpgkey/pubring.gpg
echo deb [signed-by=/usr/share/keyrings/phidgets.gpg] \
  http://www.phidgets.com/debian distro main \
  > /etc/apt/sources.list.d/phidgets.list


sudo wget -qO /usr/share/keyrings/phidgets.gpg \
  https://www.phidgets.com/gpgkey/pubring.gpg
echo deb [signed-by=/usr/share/keyrings/phidgets.gpg] \
  http://www.phidgets.com/debian distro main | sudo tee \
  /etc/apt/sources.list.d/phidgets.list > /dev/null

We support Debian releases from 6 to current, and Ubuntu LTS releases from 14.04 to current. If you are using another flavour of Linux (such as Mint), which is based on Ubuntu or Debian, use the corresponding Ubuntu or Debian codename.

Update your package lists: 

apt-get update


sudo apt-get update

Finally, install the Phidget package by entering the command below: 

apt-get install libphidget22


sudo apt-get install libphidget22

Additional Packages

You may also want to apt-get install the following optional packages:

  • libphidget22-dev: The C development libraries for Phidget22
  • libphidget22extra: Extra runtime library required for the Network Server and Admin tools
  • phidget22networkserver: The Phidget Network Server, which enables use of Phidgets over your network
  • libphidget22java: The Java libraries for Phidget22
  • phidget22admin: An administrator utility for listing Phidgets and upgrading firmware
  • phidget22wwwjs: The JavaScript libraries for Phidget22. This package also installs the HTML examples which can be accessed through the web interface


The libraries are now installed on your machine. Next, set up the UDev rules below.

Source Install

To install our libraries, first install libusb-1.0 development libraries. The exact command and package name will vary depending on distribution. For Debian based distributions, including Ubuntu and Mint, the command would be: 

apt-get install libusb-1.0-0-dev


Next, download and unpack the following files:

Open the README file that is included at the top of each directory. This file will give you important information about how to properly install the files.


Libraries are installed in /usr/local/lib by default. If you run into trouble finding the libraries during linking or at runtime, this probably means that /usr/local/lib is not on the library path for your distribution.

You can handle this in a number of ways:

Specify a different install folder during compile 

./configure --prefix=/usr && make && sudo make install

OR Add /usr/local/lib to the system-wide library path 

echo /usr/local/lib >> /etc/ld.so.conf && sudo ldconfig

OR Add /usr/local/lib in your local shell every time 

export LD_LIBRARY_PATH=$LD_LIBRARY_PATH:/usr/local/lib

The libraries are now installed on your machine. Next, you should set the UDev Rules.

Setting UDev Rules

By default, Linux will not grant permission to regular users to access physical hardware as a security feature. This means that in order to run Phidgets code from user space you must grant yourself root privileges via sudo. For example:

sudo ./HelloWorld

You can grant access manually or, more commonly, set up a rules file to do it automatically keying off of the vendor code for Phidget USB devices. To do this, create a text file called "99-libphidget22.rules" with the following contents:

  1. All current and future Phidgets - Vendor = 0x06c2, Product = 0x0030 - 0x00af

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

Where mode 666 means every user has permission to read and write to the specified file/device. You need to then move this file to "/etc/udev/rules.d". Now you can run Phidget related code as a regular user without the OS denying permission.

Verify

The best way to verify that your libraries are working properly is to compile and run an example program.


First, download and unpack this C example:

Note: If using the Debian intallation methods, you will need to install the libphidget22-dev package to use the C libraries for Phidget22

Next, open the terminal at the example location. Compile the example by entering the following command: 

 gcc HelloWorld.c -o HelloWorld -lphidget22


Run the HelloWorld example: 

./HelloWorld


Your terminal should look something like this:

Linux helloworld.PNG


The HelloWorld program will simply communicate when a Phidget has been attached or detached, as can be seen in the image above.


Your Phidget is now able to communicate with your development machine. The next step is selecting a programming language so you can start to write some code!

Programming

Ready to write some code? Select one of the programming languages below:

Core Languages Mobile Languages Other Languages
C Sharp C# Objective C Objective C LabVIEW LabVIEW
C/C++ C/C++ Swift Swift Max/MSP Max/MSP
Python Python Android Android Java
Java Java
Visual Basic .NET Visual Basic .NET
JavaScript JavaScript

Older Versions

If you need older versions of the Phidget22 Linux libraries, click here.

If you need Phidget21 Linux Libraries, click here.

Retrieved from "https://www.phidgets.com/docs/index.php?title=OS_-_Linux&oldid=34500"