When it’s time to mass produce your PCBs, you’ll no doubt want to start working with SMCs — surface mount components — as a replacement for the through-hole components you’ve been using. The most effective way to solder SMCs to your PCB is through the use of a reflow oven.

Before any of that happens, though, you gotta get the solder paste on those tiny pads! Bob from SparkFun Electronics shows you how in this short tutorial video.

Over the last few weeks I’ve been messing around quite a bit with the Processing programming language. I was drawn to it initially because it is a close cousin to the Arduino language and programming environment (which is based on Processing), so naturally I wanted to find a way to combine the two in a project.

Background

What I had in mind, of course, was an outlandishly-complicated, full-screen Processing user interface, with dials and button and knobs and sliders and big maps and graphs of data readouts and a little videoport showing the view from the Kinect-based eyes of some hardy Arduino-powered robot as it trundled bravely into the caldera of a smoking volcano.

But alas, I thought it would be better to start small — with one little graphical slider control, one Arduino, and one LED. The slider would command a brightness level for the LED, serial communication would do the talking, and pulse-width modulation (PWM) would do the legwork. In my quest for the ultimate ready-made user interface, however, I did stumble across the awesome-looking and fully-featured controlP5 GUI library for Processing.

Arduino Setup

As you can see in the video, I used an Adafruit Boarduino and a breadboard for this little experiment, and both are great!, but neither are necessary. You need to have your Arduino plugged into your PC’s USB port (or serial, if you’re old school), and you need to have an LED and an appropriate resistor plugged into Pin 9 (or any PWM pin) and GND on the board (pictured below). That’s it!

Software Setup

You’re going to be running both the Arduino and Processing development environments side-by-side, so be careful not to confuse one for the other. Open the SliderSerial_Arduino sketch (download it below) in the Arduino environment, and open SliderSerial_Processing in Processing.

If you don’t already have the controlP5 GUI library for Processing, download that as well and install it in your Processing Libraries folder (should be in the same directory where all your sketches are saved — see below for help installing libraries).

Upload the Arduino sketch to your Arduino board, then run the Processing sketch. A small window should open, revealing the slider control, which should control the brightness of the LED.

Serial Communication

If the Processing sketch doesn’t work the first time, you may need to make a small adjustment to properly locate the port to which your Arduino is connected. In the Processing sketch, look for this code block and follow the instructions in the comments:

  // =======================================================
  //            SERIAL COMMUNICATION SETUP:
  // =======================================================
  
  // CHANGE THE FOLLOWING VARIABLE to match the port
  // to which your Arduino is connected.
  
  // SEE THE LIST of available ports in the black debugging
  // section at the bottom of the Processing window. (It will
  // appear after the first time you run the sketch.
  
  // THE LIST LOOKS LIKE THIS on Windows:
  //   [0] "COM1"
  //   [1] "COM3"
  //   [2]  etc...
  // or like this on a Mac:
  //   [0] "/dev/tty.usbserial-somenumbers"
  //   [1] "/dev/tty.usbserial-othernumbers"
  //   [3]  etc... 
  
  // TYPE THE NUMBER (inside the brackets) of the desired
  // port after the equals sign.
  
  int serialPortNumber = 0;
    
  // =======================================================

Quick Reference Checklist

1. Download and install the Arduino software.
2. Download and install Processing.
3. Download the controlP5 GUI Library for Processing.
4. Install the controlP5 library. (Here’s how.)
5. Download and unzip the SliderSerial_Arduino sketch.
6. Download and unzip the SliderSerial_Processing sketch.
7. Configure your Arduino and LED as pictured above.
8. Open SliderSerial_Arduino in your Arduino software environment.
9. Open SliderSerial_Processing in your Processing environment.
10. Upload SliderSerial_Arduino to your Arduino.
11. Run SliderSerial_Processing and make sure the LED will dim with the slider.
12. If it works, congratulations! If not, try changing the serialPortNumber variable as described above.

I hope this little project helps people get Arduino and Processing working together. This code could be the jumping off point for bigger things and I think Processing is a natural choice for interfacing Arduinos with PCs. Enjoy!

I dug up some old Principia Aerospace footage for my first foray into iMovie (yeah, I just got my first Mac since OS 8), and put together this little 3-minute video chronicling a launch and CATO event from January, 2007.

Lots more information and some extended video footage related to this project can be found in the following articles:

• Rocket-Mounted Digital Video Camera

• Rocket Stability and Performance

• CATO: Catastrophic Engine Failure

Hope you enjoy it!

For the past few days, I’ve been jumping-out-of-my-shoes excited from reading the cover story of the February 2010 issue of Wired magazine entitled “The New Industrial Revolution,” by long-tail theorist Chris Anderson, and the related issue of Make magazine, the theme of which is “Desktop Manufacturing.”

The Wired article is simply a must-read for anyone interested in making things — in turning ideas into physical reality.

The basic premise is this: The tools of digital design and fabrication — which traditionally were high-priced, closed-source, corporate-entity terrain — are now becoming cheap enough to find their way into the hands of small startups, hackerspaces, and even individuals.

Digital Fabrication and the MakerBot

What is digital fabrication? 100kGarages says it best:

Digital fabrication allows a precise design to be created using computer software and then passed to another computer attached to a fabrication or CNC tool, which are capable of producing the 3D design with high precision and detail. This fidelity to the design means that the parts or components are cut, drilled, or machined exactly as expected and exactly the same each time.

Both Make and Wired profile MakerBot Industries, and their associated physical and virtual communities, NYC Resistor and Thingiverse. MakerBot is a three-person startup in NYC which sells kits for their “Cupcake CNC” 3D printers — computer-controlled devices that can take a digital file of a 3D object and “print” the real thing right on your desktop — all for under $1000.

NYC Resistor is a Brooklyn hackerspace where the MakerBot founders met and tested ideas for their prototype device, and Thingiverse is their online repository of downloadable and printable objects — all created and uploaded by their community of MakerBot users.

You can learn more about MakerBot and Thingiverse from the video below:

Open-Source Hardware and the Long Tail

What this means is that more and more garage and basement hackers are going to be able to bring their ideas to marketplace. They’ll be able to create the “long tail” of products that the big corporations can’t, while retaining the flexibility to change direction swiftly and iterate more often.

What’s more, the shared nature of what Tom Igoe calls “open fabrication” will allow makers from all over the world to collaborate on open-source hardware projects, just like they do with software today.

Big changes are coming.

Cool Links

Some popular 3D CAD software:

• SolidWorks The (pricey) real deal.
• Rhino 3D Free trial.
• Alibre Design Free (Xpress version).
• Google SketchUp Free.

Some Personal CNC tools:

• Lumenlab “micRo” universal fabricator.
• ShopBot Shop-sized mill/router.
• Tormach Bench-top CNC mills.

NetHogs is a lightweight Linux terminal-based tool that monitors bandwidth usage, then groups it by process, so you can see which PIDs are using the most bandwidth, and if necessary, kill them with System Monitor.

To install NetHogs on Ubuntu (tested on 9.10 Karmic), you can either use Synaptic or simply apt-get, like so:

sudo apt-get install nethogs

To run NetHogs, simply feed it the internet connection you wish to examine, and sit back.

sudo nethogs eth0

For more information and the full list of options, visit the NetHogs man page.

man nethogs

sudo nano /etc/usplash.conf

The file should be altered to read:

# Usplash configuration file
# These parameters will only apply after running update-initramfs.

xres=1280
yres=1024

The final step is to update initramfs, the initial RAM disk used by the kernel when Linux first boots up:

sudo update-initramfs -u

If you skip the last step, you will probably only see your new usplash resolution during shutdown and not when your computer boots up.

That’s it!

No, no, they couldn’t possibly email this information to you — you had to check the page manually. And if your products were backordered, as mine were, you’d be checking often.

Well, that’s just stupid, I thought, and since I had a computer sitting right in front of me, I thought it might be a good idea to automate the process.

So I cobbled together a little Python script on my Ubuntu box, which uses the pycURL interface to grab the URL in question, parse it, search it for my order number, and then fire me off an email (using sendmail) if and when it finds anything.

I automated the script to run hourly using cron, like so:

crontab -e

and then included the following line in my crontab file:

# m h  dom mon dow   command
7 * * * * /path/to/searchagent.py

Seven minutes after the hour (for luck), every hour, every day.

On the hunch that this script might be useful to somebody else, I decided to post it here. Fair warning to all: this is a huge hack, and I’m sure it needs work. Also, there’s probably a better method that I’ve completely overlooked. Comments, corrections, and suggestions are welcome, as always.

Here’s the script:

#!/usr/bin/env python

#############################
# Module:   searchagent.py
# Author:   Brian D. Wendt
# Date:     2008/08/15
# Version:  Draft 0.3
'''
Searches for a specified string in a supplied webpage,
then sends an email when found.

Requires Linux 'sendmail' and 'pycurl' module.
On Ubuntu, try 'sudo apt-get install sendmail python-pycurl'
'''
################################

import sys, os
import pycurl

#####################################################
### Edit these variables! ###########################
#####################################################

# webpage to search
url = 'http://reddit.com/'

# string to find in the webpage
query_string = "LOLcats"

# email message particulars
to_name    = "Harry S. Noob"
to_email   = "hsnoob@example.com"
from_name  = "Python Search Agent"
from_email = "searchagent@example.com"
subject    = "We've Found Something!"
body       = "Your search query %s was found in a scan of %s." % (query_string, url)

#####################################################
### The mail-sending function (requires sendmail) ###
#####################################################

def sendmail(to_name, to_email, from_name, from_email, subject, body):
    # full path to sendmail
    mailerdaemon = "/usr/sbin/sendmail"
    # logfile when email sent (so you only send once!)
    email_log = "searchagent.log"
    # format the message
    mail = "To: \"%s\" <%s>\nFrom: \"%s\" <%s>\nSubject: %s\n\n%s" % (to_name, to_email, from_name, from_email, subject, body)
    # check to see if the email logfile exists
    try:
        logfile = open(email_log, 'r')
        email_sent = logfile.readline()
    except:
        email_sent = ""
    # if no mail's been sent, send one
    if email_sent == "":
        # open a pipe to sendmail and write message to the pipe
        print "Sending email..."
        p = os.popen("%s -t" % mailerdaemon, 'w')
        p.write(mail)
        exitcode = p.close()
        if exitcode:
            print "Oops! There was an error: %s" % exitcode
        else:
            print "Mail sent!"
            # log the sending, so you don't send again
            log = open(email_log, 'w')
            log.write("MAIL SENT")
    else:
        print "Email already sent!  Exiting..."

#####################################################
### Read the webpage using pyCURL ###################
#####################################################

# some CURL options (pose as a Mozilla browser)
USER_AGENT = 'Mozilla/4.0 (compatible; MSIE 6.0)'
headers = ['Cache-control: max-age=0', 'Pragma: no-cache', 'Connection: Keep-Alive']

# create temporary textfile for results
tempfile = "TEMP-HTML.txt"
outputfile = open(tempfile, "w")

# keep track of the result count and results list
results_count = 0
results_list = []

# set up CURL object
c = pycurl.Curl()
c.setopt(pycurl.URL, url)
c.setopt(pycurl.HEADER, 1)
c.setopt(pycurl.USERAGENT, USER_AGENT)
c.setopt(pycurl.FOLLOWLOCATION, 1)
c.setopt(pycurl.CONNECTTIMEOUT, 40)
c.setopt(pycurl.TIMEOUT, 300)
c.setopt(pycurl.FILE, outputfile);
c.perform()
outputfile.close()

# now search the file line by line
file = open(tempfile, "r")
for line in file.readlines():
    search = line.find(query_string)
    if search != -1:
        # store results in a list, if desired
        # results_list.append(line.strip())
        results_count += 1

# if there's any result, send an email
if results_count > 0:
    print "Found a match.  ",
    sendmail(to_name, to_email, from_name, from_email, subject, body)
else:
    print "No matches found."

# delete temporary textfile
os.remove(tempfile)

What you need is SSH, the Secure Shell. SSH is a powerful tool which allows secure remote login over insecure networks. It provides an encrypted terminal session with strong authentication of both the server and client using public-key cryptography. This tutorial will cover the basics of SSH’s most useful features:

• Logging into a remote computer over a secure connection.
• Transferring files and directories between computers over a secure connection.
• Enabling public-key authentication.
• Passwordless authentication for use with scripts and cron jobs.

The following assumptions are made about the reader:

• You know what a terminal/command line/shell is and how to start a session.
• You have at least a basic familiarity with Linux/Mac command-line syntax.
• You’re on a private LAN with access to at least two Linux/Mac computers (or, you have a user account on a remote server that accepts SSH connections).

As always, comments, corrections, and suggestions for improvement are appreciated.

Installing OpenSSH

The Ubuntu (and MacOS X) flavor of SSH is called OpenSSH, a free, open-source implementation of the ssh protocol. It consists of two basic components, an openssh-client and an openssh-server. SSH clients communicate with SSH servers over encrypted network connections.

The openssh-client software should already be installed by default on Ubuntu. If you want to be able to accept SSH connections as well as request them, you’ll need the server software as well. The easiest way to ensure you have both is simply to run:

sudo apt-get install openssh-client openssh-server

Using SSH to Log into a Remote Computer

Once OpenSSH is installed, you can login to a remote SSH server by using the ssh command:

ssh remoteuser@remotebox

where remoteuser is the username of the remote account you’re trying to access, and remotebox is the remote server’s hostname or IP address.

For example, if you know that your Kubuntu desktop box (now running openssh-server) has a user account named joebanks and that the IP address of that computer on your private LAN is 192.168.0.12, you could login remotely to that account from your Linux/Mac laptop by typing:

ssh joebanks@192.168.0.12

Or, if you’ve got a web hosting account that allows shell access (e.g., DreamHost) with a domain name like cooldomain.com, your syntax might look like:

ssh joebanks@cooldomain.com

Now, the first time an SSH client encounters a new remote server, it will report that it’s never seen the machine before, by printing the following message:

The authenticity of host 'remotebox (192.168.0.12)' can't be established.
RSA key fingerprint is 53:b4:ad:c8:51:17:99:4b:c9:08:ac:c1:b6:05:71:9b.
Are you sure you want to continue connecting (yes/no)?

This is just an extra security measure to ensure that you’re actually connecting to the machine you think you are. If you type yes (the most common response), you’ll see the following:

Warning: Permanently added 'remotebox' (RSA) to the list of known hosts.

Subsequent login attempts to this machine will omit the warning message. You’ll then be asked for the remoteuser‘s password:

remoteuser@remotebox's password:

And after correctly entering it, like magic, you’ll be logged into the remote machine, and instead of your local machine’s command prompt, you’ll see the following:

remoteuser@remotebox:~$

And, voila! You can execute commands on the remote machine just as you would on your local box. To close the connection to the remote server, type exit, or use Ctrl-D.

Copying Files

To transfer files and directories from your local machine to the remote server and vice-versa, you’ll use SSH’s “secure copy” command, or scp. To copy a single file from your local machine to the server, use the following syntax:

scp file.txt remoteuser@remotebox:/directory

where file.txt is the name of a file in the current directory of your local machine, remoteuser@remotebox is the username and hostname or IP address of the server (just like in the above ssh examples, and /directory is the directory path on the server where you want your file copied.

For example, if you want to copy the local file.txt to the /home/joebanks/docs directory on the server you logged into above, you’ll run the following command from a local terminal session:

scp file.txt joebanks@192.168.0.12:/home/joebanks/docs

You can be as verbose as you want with the local and remote filenames and directories, even changing the filename in the process, like so:

scp ~/docs/oldfile.txt joebanks@192.168.0.12:/home/joebanks/docs/newfile.txt

To copy a file from the server to your local machine, use the following syntax:

scp remoteuser@remotebox:file.txt /local/directory

where remoteuser@remotebox is the username and hostname or IP address of the server, file.txt is a file in the /home/remoteuser directory, and /local/directory is the local directory path into which the file will be copied.

Again, you can be as verbose as necessary, for example:

scp joebanks@192.168.0.12:~/docs/newfile.txt /home/joe/downloads

Copying Directories

To copy an entire directory (and all of its contents) from the local machine to the remote server, use the recursive -r switch, like so:

scp -r /local/directory remoteuser@remotebox:/remote/directory

where /local/directory is the path to the local directory you want copied, and /remote/directory is the remote directory into which you want the directory to be copied.

To copy an entire directory (and all of its contents) from the remote server to the local machine, use the following:

scp -r remoteuser@remotebox:/remote/directory /local/directory

where /remote/directory is the path to the remote directory you want copied, and /local/directory is the local directory into which you want the directory to be copied.

Stop Typing the Stupid IP Address All Day, Will You?

By now you’re no doubt getting sick of typing joebanks@192.168.0.12 or whatever. It sure would be nice to type something shorter. Let’s fix that.

OpenSSH uses a client configuration file, located at ~/.ssh/config, to simplify some of the tedious typing associated with logging into remote machines. To edit (or create) that file, we’ll use the nano text editor, but you can use vi, emacs, kate or whatever:

nano ~/.ssh/config

The simplest configuration file might look something like this:

Host volcano
  HostName 192.168.0.12

This associates the Host volcano with the HostName (or IP address) 192.168.0.12, so now to login you’ll only need to type:

ssh joebanks@volcano

That’s cool, but let’s get a little more lazy, shall we? How about this:

Host BigWoo
  HostName 192.168.0.12
  User joebanks

Now all we need to type is:

ssh BigWoo

Far out! You can add as much configuration data as you need to this Host, and as many different Hosts as you like. And this shorthand will also work with all the scp examples:

scp file.txt BigWoo:

To learn more visit the OpenSSH docs, or run man ssh_config.

Public-Key Authentication

To increase the security of your SSH session, or to set up passwordless authentication, you can enable SSH’s built-in public-key cryptography. Then, instead of entering the remoteuser‘s password on each login attempt, SSH will initiate a challenge-and-response protocol which attempts to match an encrypted public key (stored on the server) with a protected private key (stored on the local machine). This completely eliminates the need to send sensitive information (like a password) over the network, encrypted or not.

To generate a public/private key pair on your local machine, open a terminal and type:

ssh-keygen -t dsa

You’ll see the following message:

Generating public/private dsa key pair.
Enter file in which to save the key (~/.ssh/id_dsa):

Hit Enter. This selects the default location. Next you’ll see:

Enter passphrase (empty for no passphrase):

Enter a secure passphrase, ideally something unique and unguessable. Unlike a password, a passphrase is usually a phrase or complete sentence, with spaces and punctuation if you like. The longer and more obscure the phrase, the stronger it is.

After typing a passphrase and hitting Enter, you’ll see:

Enter same passphrase again:

Enter the same passphrase again. And finally:

Your identification has been saved in ~/.ssh/id_dsa.
Your public key has been saved in ~/.ssh/id_dsa.pub.
The key fingerprint is:
42:ac:8a:81:31:81:e5:7b:d2:01:42:2d:64:32:0f:dd localuser@localbox

Now copy your public key, which is stored in the local file ~/.ssh/id_dsa.pub to the remote machine, by running the following command from a local terminal session:

ssh-copy-id -i ~/.ssh/id_dsa.pub remoteuser@remotebox

You’ll be prompted for the remoteuser‘s password one last time, and then you’ll see the message:

Now try logging into the machine, with "ssh 'remoteuser@remotebox'", and check in:

  .ssh/authorized_keys

to make sure we haven't added extra keys that you weren't expecting.

Once the ~/.ssh/authorized_keys file on the remote machine contains your public key, you’ll be prompted for your passphrase at each login attempt, rather than the remoteuser‘s system password, like so:

Enter passphrase for key '~/.ssh/id_dsa':

Finally, it’s a good idea to change the permissions of the ~/.ssh directory and the ~/.ssh/id_dsa file on your local machine, to disable any outside access to your private key.

chmod 700 ~/.ssh
chmod 600 ~/.ssh/id_dsa

Passwordless Authentication for Automated Tasks

You can use ssh and scp in shell scripts and cron jobs to automate repetitive tasks, such as remote backups of critical files. To do so, however, you’ll need to implement some sort of passwordless authentication scheme, so that scripts can run without human intervention.

Two methods are presented below, the first is the easiest to implement (and possibly the most prevalent), while the second is the most secure.

Method 1: Sans Passphrase

If you want your scripts to have access to the ssh command without requiring a password or passphrase, simply go through the steps outlined above for enabling public-key authentication, but instead of entering a passphrase when prompted, simply press Enter.

The ssh-keygen program will generate a public/private key pair for you that will allow password- and passphrase-less access to any remote server which has your public key stored in its authorized_keys file.

Is this secure? Well, no. And yes. It’s probably more secure than typing in the remoteuser‘s password and sending it over the network. Sure it’s encrypted, but it could still be intercepted.

Public-key authentication sends no password or passphrase data over the network. The “challenge” sent by the server is encrypted with your public key, and can only be decrypted with your private key, which only you have.

However, as mentioned above, if someone gains access to your local computer, they’ll also have access to every remote server with your public key.

So, you’ll need to decide the level of security required. In my opinion, if you’re only communicating with machines on a private LAN, under your control, behind a router’s firewall, then this method is adequate. Others may disagree.

Method 2: Using ssh-agent and keychain

The “proper” and secure way to achieve passwordless authentication is by using the ssh-agent and keychain daemons to store your passphrase between terminal sessions, so you don’t need to type it every time.

Setup of this method is beyond the scope of this article, but the following tutorials will walk you through the entire process, as well as the theory behind it:

• OpenSSH key management, Part 1
• OpenSSH key management, Part 2

Go Forth and SSHify!

I hope this tutorial serves as a gentle introduction to the Secure Shell. For further reading and advanced topics, check out the references listed below, and browse the OpenSSH Documentation. Thanks for reading.

References

1. SSH Tutorial for Linux
2. SSH: Ubuntu Community Documentation
3. Secure Communications with OpenSSH
4. Getting Started with SSH
5. Indiana University Knowledge Base: SCP
6. Example Syntax for Secure Copy
7. Bash Reference Manual

LightScribe is an innovative technology that uses a special disc drive, special media, and label-making software to burn labels directly onto CDs and DVDs. The labels are laser-etched, not printed, so there’s no ink, no smudging, and no peeling.

LightScribe lets you create one-of-a-kind designs with your own photos, text, and artwork. The days of hand-labeling or printing stickers for your CDs and DVDs are over.

This short tutorial will describe how to install and run LightScribe software on Ubuntu. These instructions are tailored specifically for Ku/Xu/Ubuntu 64-bit users, since the LightScribe software is designed for the 32-bit architecture. Where necessary, alterations for 32-bit users are included.

What You Need

Before downloading anything, make sure you have the necessary hardware and materials at hand, or you may have to make an emergency trip to your local big-box electronics store.

LightScribe hardware

LightScribe-enabled disc drives do double duty. The same laser that burns your data will also laser-etch your customized CD/DVD labels. LightScribe-enabled CD/DVD burners are ubiquitous these days. You may already have one.

Just look for the LightScribe logo on the drive bay door:

LightScribe media

LightScribe CDs and DVDs have a special coating that interacts with the laser in your LightScribe-enabled disc drive. You must use LightScribe CDs and DVDs in order to burn a label onto your discs.

LightScribe software

LightScribe software may have come packaged with your CD/DVD burner, and different flavors are available from a variety of vendors online. Unfortunately, they’re all for Windows. For Linux, we’ll be using basically two programs: (1) the LightScribe System Software, which handles the low-level system tasks like communicating with your disc drive, and; (2) the Lacie LightScribe Labeler for Linux, or 4L for short.

Installing the Software

1. Download the LightScribe System Software using the following command, or get the most current version from the LightScribe Downloads page. Open a terminal and paste the following code:

wget http://download.lightscribe.com/ls/lightscribe-1.12.37.1-linux-2.6-intel.deb

2. Download the Lacie LightScribe Labeler for Linux (4L).

from here:

wget http://principialabs.com/files/4l_1.0-r6_i386.deb

or here:

wget http://uploads.mitechie.com/lightscribe/4l_1.0-r6_i386.deb

3. Install the LightScribe System Software. Important: You must install this first, before installing 4L! Open a terminal and paste the following code, but be sure the package name matches the one you downloaded from the LightScribe website (e.g. lightscribe-1.12.37.1-linux-2.6-intel.deb). [Note: For 32-bit users, simply remove the --force-architecture switch from the command.]

sudo dpkg --force-architecture -i lightscribe-1.12.37.1-linux-2.6-intel.deb

4. Install 4L, the Lacie LightScribe Labeler for Linux. Important: You must install the LightScribe System Software first, or this won’t work! [Note: For 32-bit users, simply remove the --force-architecture switch from the command.]

sudo dpkg --force-architecture -i 4l_1.0-r6_i386.deb

Running the Lacie LightScribe Labeler

The graphical user interface to 4L is called 4L-gui and can be run from the command line. It must be run as the root user, like so:

sudo 4L-gui

This will launch the 4L GUI pictured above. The interface is fairly intuitive, but the basic procedure is:

1. Insert LightScribe media into your disc drive, label side down!
2. Select an image to burn onto the CD or DVD by using the “Import Image” button.
3. Adjust the image size and alignment as necessary using the scale slider.
4. Preview the finished product by pressing the “Print” button and then selecting “Preview.”
5. Press “Print” to burn the label to the disc. A full-size image should take about 20 minutes.
6. Remove the CD/DVD media and FLIP!
7. Use K3b (or your favorite burner program) to burn data on your new hella-cool custom disc!

Burn – Flip – Burn!

One final technical note: Unfortunately, the installation process above does not create a new item in your programs menu. If you’d like to create an item in your program menu for the LightScribe labeler, check out this thread on the Ubuntu Forums.