OS - Linux: Difference between revisions

From Phidgets Support
No edit summary
No edit summary
(37 intermediate revisions by 4 users not shown)
Line 1: Line 1:
<metadesc>Communicate over USB with sensors, controllers and relays with Phidgets! Program in Linux using a wide variety of programming languages.</metadesc>
[[Category:OS]]
[[Category:OS]]
__TOC__
{|
==Quick Downloads==
|style="vertical-align:middle; width: 60%;"|
Already know what you're doing? Here you go:
*[{{SERVER}}/downloads/phidget22/libraries/linux/libphidget22.tar.gz Phidget Libraries for Linux]
*[{{SERVER}}/downloads/phidget22/servers/linux/phidget22networkserver.tar.gz Phidget Network Server for Linux]
*[[Software License]]
 
==Getting Started with Linux==
==Getting Started with Linux==
Welcome to using Phidgets with Linux. If you haven't already, check out the [[:Category:UserGuide|user guide]] for your device. If you are ready to go, the first step in creating Linux applications with Phidgets is installing the Phidget libraries!
Welcome to using Phidgets with Linux!  
 
===Installing===
To install the libraries, follow these steps:
 


1. Install libusb-1.0 development libraries - {{Code|libusb-1.0-0-dev}}.
If you are ready to go, the first step in creating Linux applications with Phidgets is installing our libraries.
|{{TOC limit|2}}
|}
===Install===
If your Linux machine is running 32-bit Debian, jump ahead to [[#Debian install | Debian install]].


*Note that libusb-1.0 may be already on your system, but the development libraries probably aren't.
====Generic Install====
*Search for {{Code|libusb-1.0-0-dev}} or similar in your distribution package directory via {{Code|sudo apt-get install libusb-1.0-0-dev}}
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:
*Or, install [http://www.libusb.org/ from source].
 
2. Unpack and install the [{{SERVER}}/downloads/libraries/libphidget22.tar.gz Phidget Libraries]
 
From the main unpacked libraries directory, run:
<syntaxhighlight lang=bash>
<syntaxhighlight lang=bash>
./configure
apt-get install libusb-1.0-0-dev
make
sudo make install
</syntaxhighlight>
</syntaxhighlight>
This will compile phidget22.h and place the library into your gcc path.


''Although these libraries are written in C, the additional libraries for Python, Java, and most other Phidget-supported languages depend on them so they must be installed no matter what else you want to do.'' 


===Verify===
Next, download and unpack the following files:
The best way to verify that your libraries are installed and your Phidget is working is to compile and run the {{Code|HelloWorld}} C example, included in the [{{SERVER}}/downloads/examples/phidget21-c-examples.tar.gz C examples]. To compile and run the example, follow these steps:
*[{{SERVER}}/downloads/phidget22/libraries/linux/libphidget22.tar.gz libphidget22] (Mandatory)
*[{{SERVER}}/downloads/phidget22/libraries/linux/libphidget22extra.tar.gz libphidget22extra] (Optional - needed by NetworkServer and Admin)
*[{{SERVER}}/downloads/phidget22/libraries/linux/libphidget22java.tar.gz libphidget22java] (Optional - Java Libraries)
*[{{SERVER}}/downloads/phidget22/servers/linux/phidget22networkserver.tar.gz phidget22networkserver] (Optional - [[Phidget Network Server]])
*[{{SERVER}}/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.
 


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.


1. Unpack the C examples and open a terminal window at this location
You can handle this in a number of ways:


2. Compile the {{Code|HelloWorld.c}} example:
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>


<syntaxhighlight lang=bash>
The libraries are now installed on your machine. Next, let's verify that they are working properly. Jump ahead to [[#Verify | verifying]].
gcc HelloWorld.c -o HelloWorld -lphidget22
</syntaxhighlight>


3. Run the {{Code|HelloWorld}} example:
====Debian Install====
To install our libraries on Debian, first enter the following command in the terminal:
<syntaxhighlight lang=bash>
<syntaxhighlight lang=bash>
sudo ./HelloWorld
wget -qO- http://www.phidgets.com/gpgkey/pubring.gpg | apt-key add -
</syntaxhighlight>
</syntaxhighlight>


Note:
*Sudo is needed for USB access for now, see the [[#Setting udev Rules|Setting udev Rules]] section for how to change this
*By adding {{Code|-lphidget22}}, the compiler will look in the standard library location (usually {{Code|/usr/lib/}}) for the Phidget 22 library file. Generally, libraries to be linked on Linux through {{Code|gcc}} have a naming convention. For example, {{Code|-lphidget22}} looks for the binary files '''{{Code|libphidget22.a}}''' and '''{{Code|libphidget22.so}}''' in the library location.
Now that the program is running, it will simply print out basic information for any device you plug in, and print a message upon unplugging the device:


Next, enter the following command if you are running Debian ''stretch'':
<syntaxhighlight lang=bash>
<syntaxhighlight lang=bash>
$ sudo ./HelloWorld
echo 'deb http://www.phidgets.com/debian stretch main' > /etc/apt/sources.list.d/phidgets.list
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...
</syntaxhighlight>
</syntaxhighlight>
If you are running ''squeeze'' (Debian 6), ''wheezy'' (Debian 7) or ''jessie'' (Debian 8) simply replace ''stretch'' in the command above with your release. If you are running Ubuntu 16.04, replace ''stretch'' with ''xenial''.


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!
''If you do not see your device listed when running the HelloWorld program, visit the [[General Troubleshooting|general troubleshooting page]].''
===Programming===
Ready to write some code? Select one of the programming languages below:
''Great choices for beginners:''
*[[Language - C/C++|C/C++]]
*[[Language - Java | Java]]
*[[Language - Python | Python]]
''Also supported:''
*[[Language - C Sharp | C#]]
*[[Language - Visual Basic .NET | VB.Net]]
*[[Language - JavaScript | JavaScript]]
==Phidget Network Server==
The Phidget Network Server allows you to remotely control a Phidget over a network.<br>This section helps you install, check, and use the Network Server on Linux, but we also have an overview of the [[Phidget Network Server]] in general.
===Installing the Network Server===
To install the Network Server, 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 the [[#Network Server with mDNSResponder|network server with mDNSResponder]] section)
#*Try {{Code|apt-cache search avahi}} in a terminal to find current packages
#*Often, this is installed in a default system, you may already have it
#Unpack and install the [{{SERVER}}/downloads/libraries/phidgetnetworkserver.tar.gz Phidgets Network Server] source code tarball for Linux
#*From the unpacked Network Server source code directory, run:
#*:{{Code|./configure}}
#*:{{Code|make}}
#*:{{Code|sudo make install}}
#*This will compile the executable {{Code|phidget22networkserver}} and place it into {{Code|/usr/bin/phidget22networkserver}}
====Network Server with mDNSResponder====
To use '''mdnsresponder''' instead of avahi, change the configure script to be:


Update your package lists:
<syntaxhighlight lang=bash>
<syntaxhighlight lang=bash>
./configure --enable-zeroconf=bonjour
apt-get update
</syntaxhighlight>
</syntaxhighlight>


(To see all options, use {{Code|./configure --help}} like you would any configure script)
===Setting Up the Network Server===
To set up and use the Phidget Network Server, it helps to have [[#Setting udev Rules|set your udev rules]].  Otherwise, you must run it as root.
You can get command line help with {{Code|phidget22networkserver}} by using the {{Code|-h}} option:


Finally, install the Phidget package by entering the command below:
<syntaxhighlight lang=bash>
<syntaxhighlight lang=bash>
$ phidget22networkserver -h
apt-get install libphidget22
</syntaxhighlight>
</syntaxhighlight>


<syntaxhighlight lang=text>
You may also want to apt-get install the following optional packages:
usage: phidget22networkserver [-D][-E][-c <cfg>][-l <logfile>][-v][-w]
* '''libphidget22-dev''': The C development libraries for Phidget22
  -D          run as daemon
* '''libphidget22extra''': Extra runtime library required for the Network Server and Admin tools
  -E          log to stderr
* '''phidget22networkserver''': The [[Phidget Network Server]], which enables use of Phidgets over your network
  -c <cfg>    configuration file
* '''libphidget22java''': The Java libraries for Phidget22
  -l <logfile> log to 'logfile'
* '''phidget22admin''': An administrator utility which helps keep track of who is connected to your Phidgets over the network server
  -v          enable verbose logging (may be specified more than once)
* '''phidget22wwwjs''': The JavaScript libraries for Phidget22. This package also installs the HTML examples which can be accessed through the web interface
  -p          run phidget sever
  -w          run web server
</syntaxhighlight>


You will see this help regardless of whether the network server was correctly hooked in to avahi.  In fact, you will see it even if you explicitly disabled mDNS in the {{Code|./configure}} step at compile:


<syntaxhighlight lang=bash>
The libraries are now installed on your machine. Next, let's verify that they are working properly.
  ./configure --disable-zeroconf
</syntaxhighlight>


===Using the Network Server===
===Verify===
The best way to verify that your libraries are working properly is to compile and run an example program.


To use a Phidget over the network server, you'll want to:
* Obtain code you can use to open a Phidget remotely
* Start the network server on the computer that directly connects to the Phidget
* Run your program on the remote computer that will control the Phidget over the network


The easiest way to test these steps on Linux is simply to set up the network server and run the Phidget program on the same computer, using the loopback interface.  Later, you can replace one of the two ends with a different computer and/or operating system.
First, download and unpack this C example:
*[{{SERVER}}/downloads/phidget22/examples/c/Manager/Phidget22_HelloWorld_C_Ex.zip HelloWorld C example]


To quickly 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)}}
and change it to be:


Next, open the terminal at the example location. Compile the example by entering the following command:
<syntaxhighlight lang=bash>
<syntaxhighlight lang=bash>
  int serial_number = 37299
  gcc HelloWorld.c -o HelloWorld -lphidget22
CPhidget_openRemoteIP ((CPhidgetHandle) device, serial_number, "127.0.0.1", 5001, NULL)
</syntaxhighlight>
</syntaxhighlight>


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 [[#Checking|ran the HelloWorld example code]].  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|phidget21networkserver -h}} in [[#Setting Up the Network Server|the Setting Up the Network Server]] section.  The NULL is used to not specify a password.
Save the changed example under a different filename.  In the walkthrough here, we are using the {{Code|InterfaceKit.c}} example, and we rename it to be {{Code|InterfaceKitRemote.c}}
Compile your new C file. In our {{Code|InterfaceKitRemote.c}} case, this would be by:


Run the HelloWorld example:
<syntaxhighlight lang=bash>
<syntaxhighlight lang=bash>
gcc InterfaceKitRemote.c -o InterfaceKitRemote -lphidget21
./HelloWorld
</syntaxhighlight>
</syntaxhighlight>


1. Start two terminals to run this test, usually opened via Ctrl-Alt-T.  Your [[#Setting udev Rules|udev rules]] need to be set up or you should use sudo for every command.  First, start the network server in Terminal #1:


[[Image:Linux_ws_start.png|link=]]
Your terminal should look something like this:
[[File:linux_helloworld.PNG|link=|center]]


This will broadcast any Phidget events, and receive any Phidget requests, both over the network.


2. Start the InterfaceKitRemote program that you just compiled which will open the remote Phidget. In this case, it is {{Code|InterfaceKitRemote}}:
The HelloWorld program will simply communicate when a Phidget has been attached or detached, as can be seen in the image above.


[[Image:Linux_ws_step2.png|link=]]


3. Now, plug in the Phidget! The {{Code|phidget21networkserver}} program captures the attach and other events and sends them out over the network (in the background in Terminal #1) and the Phidget software objected opened with openRemote in Terminal #2 receives them:
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!


[[Image:Linux_ws_step3.png|link=]]
==Programming==
Ready to write some code? Select one of the programming languages below:


4. You can confirm that the network server was indeed behind this exchange by killing the network server process while still allowing the remote program to run:
{{Programming_Languages_Table}}


[[Image:Linux_ws_step4.png|link=]]
==Phidget Network Server==
The Phidget Network Server is an extremely useful tool that allows you to remotely control Phidgets over your network. If you haven't already, check out the [[Phidget Network Server]] page for a complete overview.


===Debugging the Network Server===
===Try it Out!===
In order to try the Phidget Network Server out, you will need a host computer, and a client computer with the Phidget libraries installed:
*'''Host computer:''' the computer that is physically connected to the Phidgets via USB and is running the Phidget Network Server.
*'''Client computer:''' a computer running a Phidgets application that accesses Phidgets connected to the host computer.
If you only have one computer, don't worry, your machine can act as both a host and a client.


In addition to enabling [[General Phidget Programming#Logging|logging]] in your Phidget code, you can get additional debugging information from the Network Server itself.  You can enable logging by editing {{Code|networkserver.cfg}}, which can be found in the build directory for the network server.


Next, open the terminal on the host computer and type in the following command to run the Network Server in the terminal:
<syntaxhighlight lang=bash>
<syntaxhighlight lang=bash>
phidget22networkserver
</syntaxhighlight>


# Server log level
Or, as a daemon:
# verbose | debug | info | warn | err
<syntaxhighlight lang=bash>
loglevel: debug
phidget22networkserver -D
 
# Server log file
logfile: "/home/<username>/Desktop/networkserver.log"
</syntaxhighlight>
</syntaxhighlight>


You can change the {{Code|loglevel}} to change what kind of messages show up in the logfile. Each successive level contains the messages of the lower levels as well.
* '''err''': The lowest logging level; Only messages from errors will be logged.
* '''warn''': Adds warning messages which result from unexpected but not necessarily erroneous behaviour.
* '''info''': Adds informational messages that track important events in the network server.
*'''debug''': For debugging the inner workings of the network server; not typically useful for end-users.
*'''verbose''': The highest logging level; Even not-very-important events will be tracked, so it may be difficult to find the messages that matter.
The {{Code|logfile}} path will lead you to the log file, or you can change the path to something else.
If you suspect multicast DNS (mDNS) may be the problem, you can:
* Try compiling the network server with mDNSResponder, as described in [[#Installing the Network Server|Installing the Network Server]], or
* Try compiling the network server completely without mDNS, as described in [[#Setting Up the Network Server|Setting Up the Network Server]]
==Advanced Information==
===Setting udev Rules===
If you don't want to be using {{Code|sudo}} to run Phidget programs (including the Network Server) forever, you will want to create a {{Code|udev}} rule to allow yourself access to the Phidget when you are not root.
Udev has an easy way to set the owner and permissions of the USB interface of the Phidget - it finds all devices that match a given set of rules, and applies new traits to them.  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. 
We recommend that you use the rules file included in the library download you have already installed.  Check the README file included in that download for information on how exactly to install it, or continue reading here. 
The rules for udev are kept in files in {{Code|/etc/udev/rules.d/}} 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. Simply find the file named {{Code|99-libphidget22.rules}} included with our library files, and move it into {{Code|/etc/udev/rules.d/}}.
Strictly speaking, the files run in lexical order (i.e. the order they're listed when you use {{Code|ls}}).  A device can match many rules, and all will apply (if possible).  If conflicting rules are found, the first rule found is followed.
===Starting the Network Server at Boot===
If you are tired of starting the network server on the command line all the time, you can have the network server start when your system starts, every time.
====User Space====
If you are running a standard Linux machine with an X-server (Unity, KDE) the easiest way to do this is to have the Phidget Network Server start when your x server starts.
In this case, the network server will be running in user space, so your [[#Setting udev Rules|udev rules need to be set up]] for the your user permissions to be able to access the USB ports using libusb.
Within the X-windowing system, there is usually some sort of {{Code|System &rarr; Settings/Preferences &rarr; Startup}} that you can choose to add programs that start when a user session starts.  On Ubuntu you can use Unity to find programs listing "startup" in their names to accomplish the same thing.  This will eventually lead you to a window like this one:
[[Image:linux_ws_boot.png|400px|link=]]
Simply add the {{Code|/usr/bin/phidget22networkserver}} program to the list.
====As A Service====
You would want to set the boot start of {{Code|phidgetnetworkserver21}} to be a service if you are running a server, or a headless machine.  It is handy any time you need the network server to be started as a booted, respawning service with a presence in different run levels and for all users.
A service is essentially a program that hangs out in the background, waiting to be used by some incoming task.  When the service is needed, the service forks a program to handle that need.  Most services that run on your Linux computer already have the ability to fork themselves. 
The network server, however, is just a binary on Linux - {{Code|phidgetnetworkserver21}} - and so we need a program that handles the forking for us.  For this, we use the {{Code|start-stop-daemon}} program to spawn a standalone process for us, or kill it, based on our service-like start, stop, and restart commands.
To do this, we need:
# A script that tells the boot process how to start and handle the networkserver (i.e. by using {{Code|start-stop-daemon}})
# A link from that script to the boot list
# An initialization file for the script
First, the script.  We will walk through Debian here, both because it is such a common distribution and because it is the distribution that our [{{SERVER}}products.php?product_id=1073 Single Board Computer] runs.  But {{Code|init}} is surprisingly diverse on Linux, including everything from a different boot order, to different initialization programs and structure, and even different runlevels. 
On Debian (including Ubuntu), the initialization script covers:
* Runlevels that the service should be present on
* Dependencies of the service
* Name of the service and other informative data
* The location of the PIDFILE, which stores the process ID (pid) for later dealing with a spawned instance
* Any configuration file locations
* What to do when the service is given instructions to '''start''', '''stop''', or '''reload'''.
The Debian script we use to start the network server on the [{{SERVER}}products.php?product_id=1073 Single Board Computer]:
<syntaxhighlight line start="1" lang=bash>
#!/bin/sh
### BEGIN INIT INFO
# Provides:          phidgetnetworkserver
# Required-Start:    $network $remote_fs
# Required-Stop:    $network $remote_fs
# Should-Start:      avahi
# Should-Stop:      avahi
# Default-Start:    2 3 4 5
# Default-Stop:      0 1 6
# Short-Description: Phidget Network Server
# Description:      Phidget Network Server for controlling Phidgets over the network.
### END INIT INFO
DESC="Phidget Network Server"
NAME=phidgetnetworkserver
BIN=phidgetnetworkserver21
DAEMON=/usr/bin/$BIN
PIDFILE=/var/run/$NAME.pid
CFG=/etc/default/$NAME
# Gracefully exit if the package has been removed.
test -x $DAEMON || exit 0
# load config
pws_port="5001"
pws_serverid=""
pws_password=""
[ -f $CFG ] && . $CFG


start() {
[[File:Linux_networkserver.PNG|link=|center]]
[ -z "$pws_port" ] || OPTIONS="-p $pws_port "
[ -z "$pws_password" ] || OPTIONS="$OPTIONS-P $pws_password "


if [ -z "$pws_serverid" ]; then
OPTIONS="$OPTIONS -n $( hostname )"
else
OPTIONS="$OPTIONS -n $pws_serverid"
fi
echo -n "Starting $DESC: "
start-stop-daemon -S -b -q -p $PIDFILE -m -x $DAEMON -- $OPTIONS && echo "OK" || echo "ALREADY RUNNING"
}


stop() {
The Network Server is now running on your machine with the default configuration. If you would like to change the Network Server configuration, you can do so by modifying the following file:
echo -n "Stopping $DESC: "
*/etc/phidgets/phidget22networkserver.pc
start-stop-daemon -K -q -p $PIDFILE -x $DAEMON && echo "OK" || echo "NOT RUNNING"
}


case "$1" in
  start)
start
;;
  stop)
stop
;;
  restart|force-reload)
stop
sleep 1
start
;;
  *)
echo "Usage: $0 {start|stop|restart}"
esac
exit 0
</syntaxhighlight>
Save the script into a file called {{Code|phidgetnetworkserver}}, and use {{Code|chmod 755}} to make it executable.
Also on Debian, startup service scripts should go in {{Code|/etc/init.d}}, and then put within the appropriate runlevel-numbered folder - by symbolic link.  There is a handy tool to do this for you, called {{Code|insserv}}:


You can also simply point towards your own configuration file with the following command:
<syntaxhighlight lang=bash>
<syntaxhighlight lang=bash>
sudo insserv -d phidgetnetworkserver
phidget22networkserver -c /path/to/configuration/file
</syntaxhighlight>
</syntaxhighlight>




The {{Code|insserv}} program is the program that makes use of the {{Code|### BEGIN INIT INFO...### END INIT INFO}} that appears at the top of the {{Code|phidgetnetworkserver}} script. Use {{Code|man insserv}} for more information.  The {{Code|insserv}} tool handles the mess of finding the right runlevel folders (i.e. the {{Code|rc.d}} numbered folders) and making the appropriate links. You can see what links would be updated by running {{Code|insserv}} with the {{Code|-n}} option, for a dry run.
Now that you have the Network Server running on your host computer, the next step will be accessing the Phidgets connected to your host computer from your client computer. Follow the steps below:


'''Note:''' When you run {{Code|insserv}}, all of the dependencies for the boot order are re-written.  This means that all of the initialization scripts in {{Code|/etc/init.d}} are re-examined.  So, you'll probably get a lot of output when you run the command.
Then, you can check that {{Code|phidgetnetworkserver}} is on the service list with:


Open the terminal on the client computer and type in the following command (if you are using a single machine, simply open a new terminal session and continue):
<syntaxhighlight lang=bash>
<syntaxhighlight lang=bash>
service --status-all
phidget22admin -s
</syntaxhighlight>
</syntaxhighlight>
[[File:Linux_networkserver_phidgetadmin.PNG|link=|center|850px]]




And you can start it right now without rebooting like this:
This will list all of the Phidget Servers on your network. Confirm that you can see the Network Server running on your host computer.
 
[[Image:linux_system_service_start.png|link=]]
 
The {{Code|service}} command has many options to start and stop services like the phidgetnetworkserver, try {{Code|man service}} for more information.


At this point, you can follow the client instructions on [[#Using the Network Server|using the network server]] to create a loopback test for the new network server that should now be running.
The final piece, for future configuration changes, is that the {{Code|/etc/init.d}} script looks for the file {{Code|/etc/default/phidgetnetwork server}} upon starting up.  The file is expected to contain the port, server ID, and password for the server side of the network server.  These are also set in the {{Code|phidgetnetworkserver}} script in {{Code|init.d}}, as you can see from reading the code above, but if you want to change them a lot, you can edit the configuration file rather than changing the {{Code|phidgetnetworkserver}} script and re-installing by {{Code|insserv}} every time.  The configuration file in {{Code|/etc/default/}} should contain the same syntax as that used in the script source above:


After you have confirmed your Network Server is running, type in the following command:
<syntaxhighlight lang=bash>
<syntaxhighlight lang=bash>
pws_port="5001"
phidget22admin -R -d
pws_serverid=""
pws_password=""
</syntaxhighlight>
</syntaxhighlight>


===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. 
This command will list all remote Phidgets on the network. Confirm that you can see the Phidgets attached to your host computer:
[[File:Linux_networkserver_phidadminlist.PNG|link=|center]]


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.


You can use the typical {{Code|./configure}} setup for custom build targets:
===Run Phidget Network Server on Boot===
If you would like the Network Server to run automatically when your computer boots, take a look at [{{SERVER}}/?view=articles&article=Daemon1 this project].


<syntaxhighlight lang=bash>
===What's next?===
./configure --prefix=toolchain_location --build=this_system --host=target_system
Now that you have seen the Network Server in action, you may be interested in implementing an application that takes advantage of all it's features. Luckily, every programming language we support comes with example code on how to do this! Jump to [[#Programming|programming languages]] above.
</syntaxhighlight>


For the Phidget libraries, the {{Code|./configure}} tool works this way as well. You'd use this in the [[#Installing|install the libraries section]] setup. For example, let's say you're building the libraries to develop code for the [{{SERVER}}products.php?product_id=1073 Single Board Computer] as a target.  Your system is a standard Linux system (i686-pc-linux-gnu) and the target system for the SBC is {{Code|arm-linux-gnueabi}}.  For this target, you'll need the base of the GNU embedded Debian chain:
For more information about the Network Server tab on the Phidget Control Panel, visit the Visit the [[Phidget Control Panel#macOS|Phidget Control Panel]] page.


<syntaxhighlight lang=bash>
==Advanced Information==
sudo apt-get install gcc-arm-linux-gnueabi
===Setting udev Rules===
</syntaxhighlight>
If you don't want to be using ''sudo'' to run Phidget programs (including the Network Server) forever, you will want to create a udev rule to allow yourself access to the Phidget when you are not root.


Udev has an easy way to set the owner and permissions of the USB interface of the Phidget - it finds all devices that match a given set of rules, and applies new traits to them.  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. 


Then, download the Phidget libraries [[#Quick Downloads|above]] and unpack them into a folder {{Code|phidget_libraries}}If {{Code|/usr/arm-linux-gnueabi}} is the location of your ARM toolchain (downloaded above in {{Code|gcc-arm-linux-gnueabi}}), type:
We recommend that you use the rules file included in the library download you have already installedCheck the README file included in that download for information on how exactly to install it, or continue reading here.  
 
<syntaxhighlight lang=bash>
  ~/phidget_libraries $> ./configure --prefix=/usr/arm-linux-gnueabi --build=i686-pc-linux-gnu --host=arm-linux-gnueabi
</syntaxhighlight>
 
 
===Linux on Non-Standard Systems===


We occasionally get requests to use Phidgets on Linux systems other than a standard laptop or desktop. One example is the Raspberry Pi system. Often these systems include USB ports, so the combination makes sense.
The rules for udev are kept in files in ''/etc/udev/rules.d'' 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. Simply find the file named ''99-libphidget22.rules'' included with our library files, and move it into ''/etc/udev/rules.d''.


Our libraries are installed by building from source, and their main dependency is the {{Code|libusb-1.0-0-dev}} library, so if you can get gcc on your machine (or set up a cross compiler for it) and you can also install the libusb-1.0 development headers, you can probably get Phidgets to workOf course, we don't offer much support for these systems, so - depending on your system - expect to spend some raw time getting it up and going.
Strictly speaking, the files run in lexical order (i.e. the order they're listed when you use the ''ls'' command).  A device can match many rules, and all will apply (if possible).  If conflicting rules are found, the first rule found is followed.


If you're new to the embedded computer thing, keep in mind that for these super basic systems, once you've gotten a power supply, and storage, and put the kernel you want on it, and then spent a couple of days of time getting things working, and  more time getting your drivers going, costs add up pretty quickly.  If you want a compact system that works right out of the box (and which can use all of our analog sensors in addition to our USB Phidgets), check out our [{{SERVER}}products.php?product_id=1073 Single Board Computer].  Our SBC3:
===Older Versions===
* Has many more USB ports than super-stripped devices, and also has digital and analog ports
If you need older versions of the Phidget22 Linux libraries, [{{SERVER}}/downloads/phidget22/libraries/linux/libphidget22/ click here].
* Includes a power supply and can run on batteries easily
* Has a nice amount of RAM, a decent embedded processor, and built-in onboard storage (we've run R, GRASS, and X11 on it)
* Includes installed Debian, working Phidget drivers, and [[Phidget Network Server|networked Phidget drivers]] from the moment it ships
* Has access to the full Debian repository including Python, Mono .NET, Ruby, and gcc
* Has a kernel development kit with patch file and instructions for adding new drivers (bluetooth, wireless, and so on)
* Comes with very in-depth documentation and technical support by phone and email
* Etc, etc.
The [[Phidget Network Server|networked support]] in particular allows it to work with your cell phone and more.


But if you really do want a raw hobbyist system to tinker with, go for it!  We're all nerds here - we've been there too and we certainly understand!
If you need Phidget21 Linux Libraries, [{{SERVER}}/downloads/phidget21/libraries/linux/libphidget/ click here].

Revision as of 18:47, 31 October 2018

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

If your Linux machine is running 32-bit Debian, jump ahead to Debian install.

Generic 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, let's verify that they are working properly. Jump ahead to verifying.

Debian Install

To install our libraries on Debian, first enter the following command in the terminal:

wget -qO- http://www.phidgets.com/gpgkey/pubring.gpg | apt-key add -


Next, enter the following command if you are running Debian stretch:

echo 'deb http://www.phidgets.com/debian stretch main' > /etc/apt/sources.list.d/phidgets.list

If you are running squeeze (Debian 6), wheezy (Debian 7) or jessie (Debian 8) simply replace stretch in the command above with your release. If you are running Ubuntu 16.04, replace stretch with xenial.


Update your package lists:

apt-get update


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

apt-get install libphidget22

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 which helps keep track of who is connected to your Phidgets over the network server
  • 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, let's verify that they are working properly.

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:


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

Phidget Network Server

The Phidget Network Server is an extremely useful tool that allows you to remotely control Phidgets over your network. If you haven't already, check out the Phidget Network Server page for a complete overview.

Try it Out!

In order to try the Phidget Network Server out, you will need a host computer, and a client computer with the Phidget libraries installed:

  • Host computer: the computer that is physically connected to the Phidgets via USB and is running the Phidget Network Server.
  • Client computer: a computer running a Phidgets application that accesses Phidgets connected to the host computer.

If you only have one computer, don't worry, your machine can act as both a host and a client.


Next, open the terminal on the host computer and type in the following command to run the Network Server in the terminal:

phidget22networkserver

Or, as a daemon:

phidget22networkserver -D


Linux networkserver.PNG


The Network Server is now running on your machine with the default configuration. If you would like to change the Network Server configuration, you can do so by modifying the following file:

  • /etc/phidgets/phidget22networkserver.pc


You can also simply point towards your own configuration file with the following command:

phidget22networkserver -c /path/to/configuration/file


Now that you have the Network Server running on your host computer, the next step will be accessing the Phidgets connected to your host computer from your client computer. Follow the steps below:


Open the terminal on the client computer and type in the following command (if you are using a single machine, simply open a new terminal session and continue):

phidget22admin -s
Linux networkserver phidgetadmin.PNG


This will list all of the Phidget Servers on your network. Confirm that you can see the Network Server running on your host computer.


After you have confirmed your Network Server is running, type in the following command:

phidget22admin -R -d


This command will list all remote Phidgets on the network. Confirm that you can see the Phidgets attached to your host computer:

Linux networkserver phidadminlist.PNG


Run Phidget Network Server on Boot

If you would like the Network Server to run automatically when your computer boots, take a look at this project.

What's next?

Now that you have seen the Network Server in action, you may be interested in implementing an application that takes advantage of all it's features. Luckily, every programming language we support comes with example code on how to do this! Jump to programming languages above.

For more information about the Network Server tab on the Phidget Control Panel, visit the Visit the Phidget Control Panel page.

Advanced Information

Setting udev Rules

If you don't want to be using sudo to run Phidget programs (including the Network Server) forever, you will want to create a udev rule to allow yourself access to the Phidget when you are not root.

Udev has an easy way to set the owner and permissions of the USB interface of the Phidget - it finds all devices that match a given set of rules, and applies new traits to them. 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.

We recommend that you use the rules file included in the library download you have already installed. Check the README file included in that download for information on how exactly to install it, or continue reading here.

The rules for udev are kept in files in /etc/udev/rules.d 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. Simply find the file named 99-libphidget22.rules included with our library files, and move it into /etc/udev/rules.d.

Strictly speaking, the files run in lexical order (i.e. the order they're listed when you use the ls command). A device can match many rules, and all will apply (if possible). If conflicting rules are found, the first rule found is followed.

Older Versions

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

If you need Phidget21 Linux Libraries, click here.