kivy and Python 2.7x On Windows (And Using Pip To Install Wheels)

I have been tinkering with GoLang for a while and haven’t been using  Python until today I came across a very interesting Python framework called kivy (“Kee-vee”?)  It’s a very nice frame work that runs OpenGL with accelerated hardware to give you a smooth graphical user interface.  It also allows multi-touch for inputs.  It claims to be able to deploy on any platform including Android.  That’s very cool!.

However, I ran into trouble quickly when I realize that I need Cython and other packages to use kivy.  My development environment is in Windows (I know I should use Linux, but we use Windows at work so I want to stay compatible with work).  Normally this is not a problem since I can go to my favorite Windows Binaries for Python Extension Packages webpage maintained by Mr. Christopher Gohlke.   He pretty much has everything you can think of for Windows binary packages.  It’s a lot cumbersome for me to go hunt down the Python sources for these packages and try to do the Python install myself.  It’s so much easier to go to a one stop shop like Mr. Gohlke’s page and just install the packages I want. The trouble is the page is now using Wheel files instead of the EXE files for the packages. This requires using PIP to do the installation and I have no idea at first how to do that.  Well, let me share with you what I found so that you can save time and frustration that require to use this amazing page of Python packages.

Install Python
I’ll make the instruction as a brand new Python install.  I chose Python 2.7.13 (32-bit) since it’s the latest 2.7.x as of the time of this writing.  I didn’t pick Python 3.x because we use Python 2.7.x at work and again I want to be compatible with work.  Someday I’ll try Python 3.x but so far many libraries are in Python 2.7.x and not everything has migrated over to Python 3.x yet even though it’s been almost like a decade since Python 3.x came out (2008 I think).  This instruction should technically work for any versions but you just need to make sure you match the packages with the version you are using.  For me, it’ll be 2.7.x and 32-bit for all the packages.

Now you need to make sure you have Python in you windows path variable or you can’t call python.exe from anywhere in the command line. Click Start Menu and type into the search box “Edit the system environment variables”.  Click on the option that showed up in search under Control Panel result.

Now click on the “Environment Variables …” button under the System Properties screen that showed up.

Click on the Path variable under System variables.  You might have to scroll down if you have a lot of stuff in your System variables like I do.  Then click “Edit …”

For Windows 10 (with Anniversary update), Microsoft kindly added a new easier to read screen for the path variable management.  If you have a different version of Windows, you’ll have to look through the long line of paths separated by semicolons (;).  To add path, just add a semicolon to the last path in the line and then type in the new path you want.  For Windows 10, just click on “New” button to add path variables.  Add the following paths (defaulted by Python 2.7.x install.  If you install python in a different folder, you’ll have to use your custom path):


Now that the difficult part is done, time to move on to PIP install.

Download and Install PIP
This page shows you how to install PIP but I’ll explain how I did it.  Basically, right click on and save it to some folder.  I put it in a C:\python_packages\ where I collect my packages to install.

Launch a command prompt (Click start button, type “CMD” into the search box and hit enter.).  Get to the directory where you keep the then type:


If you correctly setup your path variables as I explained in the previous section then this should execute a pip package download.  Once this is done, you are almost ready to be able to use the Python wheel packages.

Install Wheel Requirements to Use Mr. Gohlke’s packages
Scroll  down and look for Pip package then download pip-9.01-py2.py3-none-any.whl from Gohlke page into any folder.  I recommend using the same folder where you put the script.

[Update 4/21/2017]: You can get PIP wheel from Python Package Index as well.  It’s a bit faster to download than Gohlke page.  Download the

If your command prompt is still there and you are still in the same folder, you can type the following command:

pip install python.exe pip-9.0.1-py2.py3-none-any.whl/pip install pip-9.0.1-py2.py3-none-any.whl

It should say something about the requirement is installed. If it doesn’t come up with error then you are good to go.

Installing Cython
Since we have PIP installed and requirements met, we can try installing a package from Mr. Gohlke’s page.  Let’s try installing Cython since we’ll need that for Kyvi.  Look for Cython-0.25.2-cp27-cp27m-win32.whl or whatever the latest version would be for Python 2.7.x and 32-bit.  Click on the link and you’ll be prompted for a save file location.  Again, I’ll put the package into the same folder we have been working with.  Kudos to Mr. Gohlke, The page is pretty well organized and kept up-to-date.  You can see from the file name what Python version and Windows version you need.

Launch a command prompt again and navigate to our C:\python_packages folder. Type the following command to install the Cython package:

pip install pip install Cython-0.25.2-cp27-cp27m-win32.whl

You should see this message if everything went well:

If you get an error saying that pip is unrecognized then you need to make sure that you have the path C:\Python27\Scripts in your path variables.  Also make sure to close your command prompt and relaunch it any time you updated your path variables.  The command prompt doesn’t know about the new variables until you restart it.

The generic command for installing any packages is just:

pip install SomePackage.whl

That’s it for installing Windows Binary wheels!

Installing Kyvi
Let’s finish installing Kyvi now that we have Cython installed.

First make sure that we have the latest pip wheel and setup tools using the following command:

python -m pip install --upgrade pip wheel setuptools

Install all the dependencies required to run Kyvi:

python -m pip install docutils pygments pypiwin32 kivy.deps.sdl2 kivy.deps.glew

*Install gstreamer:

python -m pip install kivy.deps.gstreamer

You could use a command line, but I kept running into a memory error issue maybe due to it being a large file (121 MB) and my firewall and anti-virus program so I just went to the PyPI site to download the wheel.  I downloaded the appropriate version for my Python 2.7, 32-bit. ( kivy.deps.gstreamer-0.1.12-cp27-cp27m-win32.whl).  Once the file is downloaded to our usual location, run pip install:

pip install kivy.deps.gstreamer-0.1.12-cp27-cp27m-win32.whl

There shouldn’t be any error messages if everything went well.  Finally, install kivy itself:

python -m pip install kivy

Now let’s run an example python script using kivy to make sure that we have successfully installed kivy.  In command prompt, type in this command:
c:\Python27>python c:\python27\share\kivy-examples\demo\showcase\

If everything was installed correctly, you’ll see a brief script execution in the command prompt and you’ll be greeted with the hello world demo:

Now it’s time to have fun using kivy for your GUI.  I find it to be much prettier than Tk and much easier to use than Qt.  There are a lot of resources from  Here’s the link to building your first example app in kivy.

Controlling Arduino Nano with a Golang Webserver

Recently I have been obsessed with Go Programming Language (Golang) from Google.  It’s such a lovely tool for any programmers that want simplicity of Python but a raw power of a compiled C program.  Also, let’s add put it on steroid with a native concurrency support.  This is the power of Go.

Since you can easily just learn how to do the “Hello World” programming in Go yourself, I’m going to introduce something that would normally be difficult to do using other language and platform.  I’ll demonstrate how to build a simple web server to hand various request in the address to toggle the LED on, off, and blink on an Arduino Nano board hooked up to the web server computer.  I’ll be working with Windows version of Go.  Some minor change can be made to use the code in Linux.

The first thing to do is install Arduino IDE if you don’t already have one on your computer. I’m running version 1.8.1 which is the latest one as of this writing. You’ll also need an Arduino Nano if you want to follow this example exactly.  Otherwise, any Arduino board should work as long as it can be programmend with Firmata protocol and you know which pin is the LED pin.  If you want to support Arduino, you can buy the genuine version from many electronics vendor like Mouser here in the US for just under $30.  Arduino Nano could also be cheaply purchased on Ebay for under $5 with free shipping.  The reason why it’s so cheap on Ebay is because most of the components are probably fake.  If you don’t want to run into problems with FTDI bricking your cheap Arduino Nano, I’d suggest getting the version that uses CH340 as the serial to USB IC.

The Nano needs to be flashed with Firmata protocol.  This can be easily done via Arduino IDE.

Connecting to Arduino Nano using Arduino IDE

Launch Arduino IDE and then go to Tools -> Board.  Select Arduino Nano or whatever board you are using from the list.

Pick the correct processor for your Nano board.  In most cases, it’s ATMega328.  If you are not sure just look at the chip on the Nano.  For the one I have it says MEGA328P on it.

Now select the proper COM port where your Nano is connected.  In my case, it’s COM8.  After this is done, the next thing to do is load Firmata protocol into our Arduino Nano.

Uploading Firmata Protocol to Arduino Nano

We can load Firmata example into our Sketch window by going to File -> Examples -> Firmata -> StandardFirmata

Now you should see a pretty long sketch for StandardFirmata.  You can read through the codes if you are interested.  Several of people put their time and effort into making this available for free.  I love open-sourced community.  Anyway, check the lower right bottom of Arduino IDE to see whether you have the correct connection information to your Nano.  Click on the right arrow button on the top menu to program the firmware into your Arduino Nano.

If everything works, then you should see “Done uploading.” message.  Now your Nano is ready to be controlled by Go Webserver.  Close out Arduino IDE or you’ll prevent COM port on the Nano from being accessible.

I’m not going to cover Go installation in this post, but it might be a topic for a future post since I have already made some slides for work on how to install and use Go.  I’ll have to transfer the content here for public use.  I’ll assume that you already have Go ready to use on your system.  I use LiteIDE as my preferred Go Programming IDE.  It’s very stable and has all the features a paid program like WebStorm has. Package Installation

We require the use of library to interface with Arduino Nano.  To install go bot, in command prompt, type in this command

$ go get -d -u

It’ll look like your command prompt stopped responding, but give it a minute to finish the installation.  Once it’s done, you’ll see a new command prompt line.

Go Programming Web Server Example

Before we start playing with the Nano, let’s run the webserver example provided by Golang.  This code will create a web server on your local machine listening to port 8080.  Anything you type (web safe string) after / symbol will be shown in the greeting string.

package main

import (

func handler(w http.ResponseWriter, r *http.Request) {
    fmt.Fprintf(w, "Hi there, I love %s!", r.URL.Path[1:])

func main() {
    http.HandleFunc("/", handler)
    http.ListenAndServe(":8080", nil)
} LED Toggling Example

Now let’s do the example provided by to toggle our LED on using their example code.
First you just have to make sure to import the gobot libraries in your Go code.  For our example, we’ll only need to use the GPIO and FIRMATA libraries.

import (

Here’s the example LED toggling code from  There were a couple of examples, but I found that the firmata_blink_metal code gives you the most direct control of the hardware.

package main

import (


// Example of a simple led toggle without the initialization of
// the entire gobot framework.
// This might be useful if you want to use gobot as another
// golang library to interact with sensors and other devices.
func main() {
        f := firmata.NewAdaptor("/dev/ttyACM0")

        led := gpio.NewLedDriver(f, "13")

        for {
                time.Sleep(1000 * time.Millisecond)

This won’t work right off the bat if you are running a Windows Go on a Windows machine as I do.  The reference to COM port has to changed to “COM8” for my Nano to get it to work. The LED pin is 13 on the Nano so that doesn’t need to change.

        f := firmata.NewAdaptor("COM8")

You should be able to play around with this code to toggle your led on and off using other commands like led.On() and led.Off()

Merging the Codes Together

Now the hard part is trying to merge the 2 examples together.  This is not as straight forward as I initially thought since I didn’t want to re-open the COM port every time a new command is sent because there’ll be a delay and the Nano seems to reboot every time you reconnect to the COM port. To prevent that from happening, I need to be able to open the COM port at the beginning of the program and then just pass the reference to the COM port to the http handler.  I didn’t  know how I could even do that since I’m still new in using Go and there wasn’t any good examples on Gobot on how to do things outside the main function.   It took me a while to figure out how to solve this sending the firmata.Adaptor object to the http handler issue.  After doing some web searches, I came across this post that suggested using closure to pass the parameter to the http handler.  The answer was passing a string, but I figure that maybe you could pass the pointer reference to the firmata.Adaptor like this:

func handler(w http.ResponseWriter, r *http.Request, f *firmata.Adaptor)

Amazingly, it worked!  So after initiating the COM port and assign it the variable f, I can now pass it to the http handler using the closure technique.

	f := firmata.NewAdaptor("COM8")  //for Linux use ("/dev/ttyACM0")

	led := gpio.NewLedDriver(f, "13")

	http.HandleFunc("/", func(w http.ResponseWriter, r *http.Request) {
		handler(w, r, f)

Here’s the complete Go code.

package main
import (


func handler(w http.ResponseWriter, r *http.Request, f *firmata.Adaptor) {

     text := r.URL.Path[1:]
     text = strings.TrimSpace(strings.ToUpper(text))
     led := gpio.NewLedDriver(f, "13")
     command := "UNKNOWN"

     if text == "LED_ON" {
          command = "turning LED ON."
     } else if text == "LED_OFF" {
          command = "turning LED OFF."
     } else if text == "LED_TOGGLE" {
          command = "toggling LED."
          for i := 0; i < 10; i++ {
               time.Sleep(time.Millisecond * 250)
               time.Sleep(time.Millisecond * 250)
     } else if text == "EXIT" {
          command = "suggesting that you just close the browser window to exit."
     } else {
          command = "confused about what you want. Please send a new command."
     fmt.Fprintf(w, "Nano is %s", command)

func main() {
     f := firmata.NewAdaptor("COM8") //for Linux use ("/dev/ttyACM0")

     led := gpio.NewLedDriver(f, "13")

     http.HandleFunc("/", func(w http.ResponseWriter, r *http.Request) {
          handler(w, r, f)
     http.ListenAndServe(":8080", nil)

Now you can go to the web server and type

localhost:8080/LED_ON   to turn on the LED
localhost:8080/LED_OFF   to turn off the LED
localhost:8080/LED_Toggle   to make the LED blink 10 times

Any other command, the message will just complain about not understanding your command.

That’s it! I hope you enjoyed Go Programming and Arduino Hardware interfacing in this quick example.  There are many possibilities that you can expand this code to do more interesting stuff.  I’ll also play with ESP8266 so that we can do some cool wireless IoT with Go.

Installing YouTube-DL on Windows Subsystem for Linux (WSL)

Please read my previous post on how to enable Windows Subsystem for Linux (WSL) on Windows 10.  You must have the Windows 10 anniversary update installed since WSL is not available on the original Windows 10.

Youtube-dl is an awesome downloader for multimedia from the internet using a simple command line.  You can encode the video into a different format as well (namely FLV and MP4).

Since Windows System for Linux doesn’t automatically install Python which is required for Youtub-dl to work correctly, you need to first install Python.  You can install either Python 2.7x or Python 3.x.  I installed Python 2.7x since most libraries are more compatible with it.  To install Python 2.7x, open up your Ubuntu Bash window, and type in this command:

sudo apt-get install python

If you are adventurous and want to try Python 3, then use this command:

sudo apt-get install python3

In the past when I tried having both versions, there are conflicts when trying to run Python codes. So I just pick one version and stick with it. I recommend using 2.7x for stability and comparability. Eventually Python 3 will be the best version but maybe give it a couple more years.

There are many ways to install youtube-dl, here are the 2 common ways:

Using apt-get
Open up your Ubuntu Bash window, and type in this command:

sudo apt-get install youtube-dl

After the installation is done, run an update

sudo youtube-dl -U

Using Pip
First you have to install Pip

sudo apt-get install python-pip python-dev build-essential 
sudo pip install --upgrade pip 
sudo pip install --upgrade virtualenv 

Now you can install youtube-dl with pip using this command:

sudo pip install youtube_dl

Then upgrade with Pip

sudo pip install --upgrade youtube_dl

If you try to do a video download (Master of the House song from Le Miserable) from youtube, you’ll get a bunch of errors.

sudo youtube-dl -o LeMiserableMasterHouse.MP4 ""

From searching the web, I found that we need to do a bunch of permission settings to get the downloader to not error out due to things like Protocol error and such. Use this command first:

sudo curl -L -o /usr/local/bin/youtube-dl

Then set permissions:

sudo chmod a+rx /usr/local/bin/youtube-dl

Now you shouldn’t have problem downloading videos from youtube. The video is downloaded to the directory where you issues the youteb-dl command. You can supply the extension of the file to be .FLV or .MP4 when downloading.

For more details on the commands and options for youtube-dl, please visit this URL:

Enjoy downloading YouTube videos!

Launching Python Script when Raspberry Pi Boots (Console & Desktop Start)

We have been thinking about using Raspberry Pi 3 as our computer to control all the test equipment at work.  One idea is to use Python to control our equipment (like FTDI devices mentioned in the previous post).   So this got me thinking about how I could get a Raspberry Pi to launch the program when it first boots up.  After reading a bunch of posts on the wild wild internet, I came up with some ways to do this.

Console Mode Python Scripts Only

First, we need to make sure that we start up in the console mode rather than the X-window because the python script wouldn’t be executed from the console in the GUI mode. You could do this either by setting the Start X-server after boot to disable via

$ sudo raspi-config

Choose option 3 (Boot Options) to choose the boot environment.  To boot to console and login automatically use option B2 (Console Autologin Text console, automatiaclly logged in as ‘pi’ user)

Second, we need to be able to launch a python script right when the Pi boots up.  This is easy enough to do.  You just have to modify the profile file on Pi

sudo nano /etc/profile

Scroll to the bottom of the file and then add a script that you want to launch. In my case, I want to launch a python script called from my /home/pi directory.

sudo python /home/pi/

Now to test this, we can create the startup script and see whether it gets executed at boot time. Create our by using nano.

$ sudo nano /home/pi/

Here’s just a simple python code to go inside to display text:

print "**********************************************"
print "*  This is a start up test script inside     *"
print "* /home/pi/                  *"
print "* Other python script can run at start up    *"
print "* by editing /etc/profile                    *"
print "**********************************************"

Save the script and then initiate a reboot on the Raspberry Pi:


When Pi boots back up again you can see that our python script got executed and the text message got displayed right before the console.

Qt4 GUI Python Scripts

Now what if we want to run the scripts with GUI?  Obviously this is problematic if the GUI requires to have X-window running.  Qt4 script would need this so we need to start from the X-window mode.   We can re-enable this with raspi-config again or use the command:

$ sudo update-rc.d lightdm enable

This time choose the B4 option (Desktop Autologin Desktop GUI, automatically logged in as ‘pi’ user.  When being asked to reboot, say no for now so that we can add some startup scripts.

Remember to remove the python script being launched in /etc/profile since that’s still enabled.

To use PyQt4, we need to first install it in our Raspberry Pi. The -y parameter at the end of each command automatically answer yes to any prompt during install so we don’t have to type yes each time to continue the installation.

$sudo apt-get install python-qt4 -y
$sudo apt-get install pyqt4-dev-tools -y
$sudo apt-get install qtcreator

We should now have everything we need to make a python Qt4 program. Let’s create a generic Qt4 program that just shows a blank GUI window. I’ll call this and I’ll save it in /home/pi folder.

sudo nano /home/pi/

Here’s the code for render.pi:

# -*- coding: utf-8 -*-

import sys
from PyQt4 import QtGui

def main():

    app = QtGui.QApplication(sys.argv)

    w = QtGui.QWidget()
    w.resize(250, 150)
    w.move(300, 300)


if __name__ == '__main__':

You can try running this script on the desktop and you should see a blank window showing up. Now let’s see if we can just launch this program when our GUI desktop first starts up.

To launch the script at startup, modify the /etc/xdg/lxsession/LXDE-pi/autostart would work.

First edit autostart file:

$ sudo nano /etc/xdg/lxsession/LXDE-pi/autostart

Add the following line at the end to launch your PyQt4 script:

@sudo python /home/pi/

Save the file and exit.  We need to make sure the file permission is correct so that it can auto-launch.

$ sudo chmod +x

Now we can reboot and when the Desktop starts again, our program should be automatically launched.  If you want to make the program be something like a Kiosk mode that takes up the whole screen, substitute the line with w.showFullScreen().

Here’s the updated code to do the Kiosk mode:

# -*- coding: utf-8 -*-

import sys
from PyQt4 import QtGui

def main():

    app = QtGui.QApplication(sys.argv)

    w = QtGui.QWidget()
    w.resize(250, 150)
    w.move(300, 300)


if __name__ == '__main__':

This code doesn’t include a good way to exit the program so the full screen mode will be stuck. Click Alt+F4 to terminate the program (just like Windows!?!?).

*Note on the new image of Jessie that comes with PIXEL desktop, the Pixel Version of Desktop seems to use a different start up file. We need to edit /home/pi/.config/lxsession/LXDE-pi/autostart instead.

$sudo nano /home/pi/.config/lxsession/LXDE-pi/autostart

Add the the same line to the bottom of the file

@sudo python /home/pi/

Now when you reboot, it should launch our program.

Using Raspberry Pi (Model B+) to interface to FTDI devices

I have always used Windows computers to interface to an FTDI based USB devices I built. Now due to the low cost and great availability of Raspberry Pi modules, it makes sense to see whether I could use a Raspberry Pi to talk to my FTDI based USB devices.

I have several Raspberry Pi Model B+ available from previous projects working on cluster computing and from my general hoarding of Rasberry Pi modules.

Googling the internet is the first thing I try to learn more about how to create an interface from Raspberry Pi to an FTDI device.

I found 2 ways: 1) Use PySerial and 2) Use pyLibFTDI. I’ll talk about both methods since they are both useful.

*Note:  I’ll use ‘$’ in command line to show that it’s in the console terminal and if there’s no ‘$’ then it’s a python code.  Don’t type $ in the console or the command won’t run.

PySerial Method:
This method is pretty straight forward since Raspberry Pi should already come with PySerial installed.  If not, run the install with the command line:

$ sudo apt-get install python-serial

Once the installation is done, you can launch into python by typing

$ python

You can also write a python file and just run it using the command below where <myfile> is your file name.  There are many text editor in Raspberry Pi, but I normally use nano.  I’ll talk about this later when you have to create a rule file.

$ python <myfile>.py

In order to figure out all the serial devices attached to your Raspberry Pi, you can run the following codes in Python.  I’m using Python 2.7 by the way.

import glob
ports = glob.glob('/dev/tty[A-Za-z]*')
for port in ports:

You might see a listing like this:


Now you can interface to your device using the proper named port from the list.  My USB device is the ttyUSB0.  The ttyAMA0 is the GPIO serial port that you can actually use to to communicate to Raspbery Pi via serial via your computer.  You can google more about using ttyAMA0 if you are curious since I won’t cover that here.

import serial
ser = serial.Serial ("/dev/ttyUSB0")    #Open named port 
ser.baudrate = 9600                     #Set baud rate to 9600
ser.write('command\r')                  #send command string               #read data in read buffer
#You could also use ser.readline() to read but need to know # lines.

You can refer to PySerial API website to get all the commands and various things you can do with PySerial.

pyLibFTDI Method:
This is another way to interface to a USB device but you need them to be an FTDI device to work.  The nice thing about this method is the speed and reliability of the communication due to the use of FTDI’s own driver to talk to the device.  You can even bitbang the port using this method.  I’m not covering that topic, but you can find more details on pyLibFTDI website.

To use pyLibFTDI in Raspberry PI, you first need to install LibFTDI by running the following command:

$ sudo apt-get install libftdi-dev

After that is done, install pyLibFTDI.  You need PIP to install but I think that should already be available in Raspbian.  I’m using Raspbian Jessie (2016-05-27).

$ sudo pip install pylibftdi

The thing to worry about is the port access permission.  You can’t really access the port unless you are a root account or use Sudo to send the command.  This is problematic if you want to be able to just run the interface from any account.  To address this issue, defining a new rule by creating one like this:

 $ sudo nano /etc/udev/rules.d/99-libftdi.rules

Nano is my favorite editor on Raspberry Pi. Add these lines to the rule file then Ctrl+o (letter ‘O’ not zero) to write the file then Ctrl+x to exit.

SUBSYSTEMS=="usb", ATTRS{idVendor}=="0403", ATTRS{idProduct}=="6001", GROUP="dialout", MODE="0660"
SUBSYSTEMS=="usb", ATTRS{idVendor}=="0403", ATTRS{idProduct}=="6014", GROUP="dialout", MODE="0660"

You want to reload the rules so that this new rules take effect.

# Reload rules after edit.
$ udevadm control --reload-rules<\pre>

Now you are ready to try pyLibFTDI. Try listing the devices available by typing in console (not in python):

$ python -m pylibftdi.examples.list_devices

It should list the device(s) assuming you have FTDI device(s) connected to the Raspberry Pi. If you see an empty listing like


There’s a permission problem to access the port. Restarting Raspberry Pi seems to help to reload the rules when the reload rules command doesn’t work.

Now we can test pyLibFTDI in python. If you have listed your devices, you can use the device identity to talk to it.  For example, when I ran the list_devices example, I have


These are the 2 FTDI USB devices I have attached to my Raspberry Pi.  I’ll try to talk to the first one.

from pylibftdi import Device
device = Device('AK003XYN')
device.baudrate = 38400
device.write('?\r')             #send an identity query command.
                                #This device needs \r to end command.
device.readlines()              #Return data in buffer
device.close()                  #Close the device

These two methods to interface to your FTDI devices should get you started on having an ability to talk to your serial port devices without the need of a Windows based computer.  Enjoy and happy building and coding!