I decided I wanted more LEDs so that I could have an easy notification of when there is a problem with my internet connection or tunnels. I did this on a WRT54GL using the white and orange LEDs behind the Linksys logo. You can easily script a blinking action that stops or changes color when your connection is down. However, the RSPro has only one user-programmable LED compared to the WRT’s 5 or so. However, there is a 7-pin GPIO header with a jumper block to select active low or high mode.

I already had an RGB LED, so once I figured out how to manually toggle the GPIO outputs, all I had to do was figure out how to wire it up. Use the RSPro page on either the OpenWRT wiki or the UBNT wiki for reference on the GPIO lines. I figured that the GPIO lines would act as a 3.3v source while the UART header could act as a ground. However, I learned that the LED in question used a common anode rather than a common cathode, which meant I would have to get creative. I instead used the 3.3v off the UART header and used some of the GPIO lines as the ground after setting them to “active low” mode. After that, it was simply a matter of tweaking resistances in order to get good color balance, since the different elements of the LED had different characteristics. This is difficult because you have to not only make each channel the same brightness when one of them is lit exclusively, but you also have to make the combination of the three look convincingly white.

Lastly, there was still the issue of fitting it in the box. I use the newer Netgate enclosure for the RSPro, which has quite a bit of room. However, there wasn’t a whole lot of room above the board, so the breadboard I used for the project would have to sit below the Routerstation. The breadboard was then covered in electrical tape to prevent contact with the board, and I had lines go to the LED, which stuck out of one of the SMA holes on the case.

Software

To be honest, I don’t remember all of what I had to install to get manual control over GPIO lines. This does not use the OpenWRT LED configuration. I think that ‘gpioctl’ had something to do with it, and maybe ‘kmod-leds-gpio’, although I doubt the latter since this bypasses the LED system. You can do something like this to set up the GPIO lines.

#!/bin/bash

#Path to GPIO folder
GPIOPATH="/sys/class/gpio"

#Expose GPIO lines
echo 0 > $GPIOPATH/export
echo 1 > $GPIOPATH/export
echo 3 > $GPIOPATH/export

#Set lines to output mode
echo out > $GPIOPATH/gpio0/direction
echo out > $GPIOPATH/gpio1/direction
echo out > $GPIOPATH/gpio3/direction

#Set them to 0 initially
echo 0 > $GPIOPATH/gpio0/value
echo 0 > $GPIOPATH/gpio1/value
echo 0 > $GPIOPATH/gpio3/value

A few things to note:

• Remember, GPIO 2 is the RF LED.
• Invert the values if you are using an active low line and 3.3v from elsewhere.

After this, you just have to ‘echo 0′ or ‘echo 1′ into the ‘value’ of the GPIO line to turn it on or off.

As shown in the videos, my script does two things: It flashes the LED blue-cyan under normal circumstances, with the speed dependent on system load average, and it flashes red if a connection problem is detected. Right now, the scripts are a hacked-together mess, so I’ll post them if I get them cleaned up.

Pictures and Videos

Videos coming soon, enjoy the pictures for now.

I ordered the RSPro kit V2 and the SR71-A kit from Netgate. The kits are not pre-assembled, so some work is required.

Basically, the procedure involved attaching a mounting bracket, removing the old serial port screws, then securing the back plate on with new ones. You then would install the card and pigtails.

After that, you just have to slide the assembly into case, screw the back panel on, and then install the front panel and light guide.

The default software on the router was OpenWRT, but not the latest version. I decided to update to the latest stable Backfire, 10.03. However, the SR-71A was not recognized. Updating to 10.03-rc3 solved this problem, and the radio was usable. The router’s CPU blows away typical home routers, with a stock clock of 680MHz (some other sources report 720MHz). In addition, there are four gigabit ports with the WAN port being on a separate interface and supporting PoE. The router requires 48V DC power, which can be supplied through either the dedicated DC-in jack or through the WAN port.

The back of the router is where all the interesting stuff is. People who want to add serial ports to their routers often have to go through a bit of work to install one, but this box has one built in. In addition, it has SDIO and USB support built in. SDIO can be used for anything from Wifi cards to GPS receivers. There are 10 antenna holes on the back, and 6 on the front. The antenna holes are SMA/RP-SMA-sized. There are three mini PCI slots, which can be used for WLAN cards or other peripherals such as storage controllers and crypto accelerators. There are even mini PCI Ethernet cards available, if four ports aren’t enough for you. My card of choice, the SR71-A, supports 2.4GHz and 5-5.8GHz, with a transmit power of 24dBm.

One particular problem I had was the regulatory limitations placed on certain channels. The SR71A supports both 2.4GHz and 5GHz (not simultaneously) but many of the 5GHz channels are limited to either 17dBm or 20dBm due to regulations, compared to the 27dBm limit on the 2.4GHz range. When I tried to use the 2.4GHz band instead, I was unable to use a 40MHz channel width due to too many other APs, so I couldn’t get more than 144mbit/s theoretical on 2.4GHz. Using the 5Ghz range solved this problem, but I had to use the highest channels (Channels 149-165) in order to use higher transmission power. My laptop (with Intel 6300 wifi card) could easily get over 60mb/s from upstairs, and it achieved over 100mbit/s while near the router. Despite the great performance, in hindsight, I would have probably gotten the SR71-15 instead, a 5GHz-only card, which has more transmit power. In addition, the tri-band antennas have decent gain (5dBi on 5GHz) but there are single-band antennas of much higher gain. Since the card only supports one band at a time, you would need separate antennas anyway if you wanted simultaneous dual-band because you would you need to use two cards. The RSPro has support for three cards, so you could easily do a simultaneous dual-band system by using a 2.4GHz card and a 5GHz card and you would still have a slot left over for whatever else you wanted to do with the board.

Gripes

I don’t have any major problems with the device, but I have some small concerns. First of all, many of Ubiquiti’s other products have sufficient LEDs on the front, usually the standard stuff, plus a signal bar. The RouterStation Pro only has a power LED, Ethernet LEDs, and one RF LED. One RF LED would not be sufficient if you would like to use more than one wifi card, and wish to have one LED for each card. For comparison, the WRT54GL has a programmable power led, DMZ LED, WLAN LED, and two different colored LEDs behind the Cisco logo.

Secondly, the SR-71A is not officially supported, and is not supported in the stock firmware, as of writing this. This is kind of disappointing to see Ubiquiti’s best card not being officially supported on their own device, especially when I was able to get it to work simply by updating the firmware.

Lastly, there appears to be some kind of bug with either ath9k or some other part of OpenWRT. After a while (sometimes hours, sometimes days), any wireless clients will lose connectivity to any routed networks. They can still connect to bridged hosts, but not any outside hosts. Running ‘wifi’ fixes this (temporarily).

Rating

Overall, it is a pretty nice board, and is a better value than most of its competitors.

Price: 9/10 (Cheaper than similar boards)
Performance: 8/10 (Could have had more flash)
Features: 9/10 (Good, other than a few minor issues)

You need to run ‘mvpybot.py 0′ because start.py is broken now. Substitute the zero with a different server number if you want to connect to a different server.

#!/usr/bin/python

def register():
 registerfunction('ping', ping)
 addhelp('ping', help_ping)

def ping():
 outstuff=''
 print "ping called"
 if (len(cmd)<2):
  return('PRIVMSG %s :Incorrect usage. Syntax: ping (4|6) <address>.' %(channel))
 else:
  if cmd[1]=='4' or cmd[1]=='6':
   if cmd[1]=='4':

    output=syscmd(['ping','-c','5','-i','0.2',cmd[2]])
    outsplit=output.split('\n')
    outparts=outsplit[-3:-1]
    for part in outparts:
     outstuff+='PRIVMSG %s :%s\n' %(channel,part) 

   if cmd[1]=='6':

    output=syscmd(['ping6','-c','5','-i','0.2',cmd[2]])
    outsplit=output.split('\n')
    outparts=outsplit[-3:-1]
    for part in outparts:
     outstuff+='PRIVMSG %s :%s\n' %(channel,part)
  return(outstuff)
  else:
   return('PRIVMSG %s :Error: protocol must be either 4 or 6' %channel)

def help_ping():
 return('PRIVMSG %s :Pings an internet address. Usage: ping (4|6) <address>.' %(channel))

A plugin’s register() function is called when the plugin is loaded. It can use registerfunction(), addlistener(), and addhelp(). You can use each function as many times as you want, in case you have multiple functions and/or listeners, or if you want to include help with your plugin.

Read more to find out how to use the new plugin features.

Function Usage

registerfunction() usage:

registerfunction('command', function)

where ‘command’ is the command that the user would use to access this function, and “function” is the actual python function that you have defined in your module. See the ping example above for a usage example.

addlistener() usage:

addlistener('type', function)

For addlistener(), ‘type’ is a string denoting the type of event to call the function on, such as “any” or “privmsg”. “function” works the same as with registerfunction().

addhelp() usage:

addhelp('command', function)

‘command’ is the command that the user will access help on (eg, if ‘command’ was ‘mycommand’, the user would use ‘help mycommand’ to read the help.) Function works the same as the others.

Other Notes

All plugins go in the “modules” folder now. There are no longer separate folders for different types of plugins.

I have not yet rewritten the on-the-fly module management commands (enabling, disabling, reloading, etc) so you will not be able to use these with the new system until I feel like rewriting them.

Lastly, I will be improving the plugin system, and I will try to make older plugins backwards-compatible, but the new system will make the plugin system more efficient. Instead of always having to scan for functions in plugins whenever a certain command is called, all function plugins will register in a list of plugins upon being loaded. This has the advantage of also allowing plugin authors to specify what functions are actual functions for the bot to use.

Now for the technical stuff. A listener is just a python file in the listeners folder, with functions defined in it. A function’s name should be botfunction_type, where type is the type of message to listen for (privmsg, join, part, etc) or it can be ‘any’ for all data received by the bot. Here is an example logger function:

#!/usr/bin/python

import time

enabled=1

logfile=open('log','a')
timestamp=time.strftime('[ Session starting at %y-%m-%d %H:%M:%S ]')
logfile.write(timestamp+'\n')
logfile.close()

def botfunction_any():
 logfile=open('log','a')
 timestamp=time.strftime('[%y-%m-%d %H:%M:%S] ')
 logfile.write(timestamp+line+'\n')
 logfile.close()

As you can see from the example, plugins can be quickly enabled or disabled by toggling the ‘enabled’ flag. Also, ‘line’ is passed to the plugin. Not that anything outside of function definitions will be run when the bot starts.

Listeners can use the ’socket’ variable to send data to the server, as shown in this example:

#!/usr/bin/python

enabled=0

def botfunction_privmsg():
 print "called"
 out="PRIVMSG %s :Botfunction_privmsg called" %(channel)
 print out
 socket.send(out+'\n')

Note that in the example, it uses botfunction_privmsg. To make listeners easier to write, the main program will automatically figure out these variables from privmsgs and pass them to the function:

info         #user info
msg          #the message
channel      #the channel the message was from (set to the sender for private messages)
sender       #the sender of the message
senderstuff  #info of the sender
isprivate    #whether or not the message was a private message as opposed to a channel message.

This only applies to privmsgs. All other events only get ’socket’ and ‘line’ passed and have to figure out everything from ‘line’

That’s all for now.

#!/usr/bin/python 

def test():
 return("PRIVMSG %s :test" %(channel))

This would make a function called test. The variables channel, sender, nick, cmd, and run are passed to the function. The functions syscmd() and getlevel() are also passed to the plugin.

The default plugins that are included with the bot are ping, for pinging addresses, testplugin, for testing the bot, yacas, for doing math with yacas (delete it if you don’t have yacas installed) and getlevel, for demonstrating the ability to use the getlevel function in a plugin.

I have also set up a page for the bot, see the links bar below the logo.

I am currently writing a small, fast, small-footprint IRC bot in Python. More details as I finish the bot. The functions created so far:

• Help (Displays Help)
• Echo (Echo back a message)
• Say (Send a message to a channel)
• Spam (Send a message to a channel a specified amount of times)
• Join (Join a channel)
• Part (Part a channel)
• Authorization (username+password)
• Deauthorization
• User lookup
• Raw (Use raw IRC commands)
• Uptime (Display uptime)
• Math (Do math functions with Yacas)

Planned functions:

• Encrypted passwords
• Data storage, either in a text file or a MySQL DB
• Channel mode control

This bot is not meant to be a complex bot, it is intended to be a fast, light bot that can be easily reprogrammed.

To be more fair this time, I’ll start with Apple and set a budget accordingly, since Apples cheapest laptop at the time of writing is $999. I’ll start with that one.

The $999 Macbook has a 13″ screen and a 2.26Ghz C2D. Not a bad CPU for a laptop. It has only 2GB of RAM, which can be upgraded to 4 for $100, but seems substandard these days. Unfortunately, already being at the budget, I couldn’t get any upgrades.

Looking at Dell’s lineup, everything starts at under $1000 in the studio line. They have an i7 version of the studio 17, which would almost certainly beat everything else, but it was over budget. I decided to start with the basic Studio 17. I took an upgrade to 4GB of RAM and an upgrade to a 4650 from an Intel GPU. Getting an 802.11n card put me $75 under budget, so I upgraded to CPU to end up at exactly $999.

Now for HP. I went to “high performance” and started with the dv7t. I upgraded to 4GB of DDR3, took the free upgrade to a 320GB hard drive, upgraded to a 4650 1GB, and got 802.11n+bluetooth, which put me at $989.

On to Lenovo. The Y550 was under $1000 and had discrete graphics, so I went with the top model. It was $688, so I had some room to improve it. Also, it was clear that it was better than the other systems in some areas. I upgrade the wireless to 802.11n, upgraded to 4GB DDR3, and had $220 left to spend. I got a 500GB HDD, bluetooth, and still had money to spend. I upgraded the CPU to a 2.53GHz C2D, but this put me slightly over, so I downgraded to a 320GB HDD.

For the last laptop, I decided to go with a Sony. The Vaio SR started at $819, which should leave plenty of room for improvement.

As you can see, the Macbook has poor RAM capacity, but makes up for it with a decent graphics card and CPU. The Lenovo, Dell, and HP seem to be the best overall, whereas the Sony seems to have lack in certain areas. No DDR3, slowest CPU, and smallest hard drive. Overall, all the laptops seems to be more even, and it’s nice to see Apple doesn’t seem to be doing the usual price-gouging routine, at least not as much.

Note: this is not intended to be a buying guide. This is just for showing which brands will give you the best computer for your money.