Systemetric

FRC

2012-02-24T18:32:00.001Z

We've just got back to Student Robotics, after a month and a half preparing a robot for FRC. The challenge this year was based on a game of basketball. This is what we were working on:

The robot Crated up

The robot was shipped off to NYC on Wednesday!

Sublime Text

2011-12-07T21:57:00.001Z

So our team was finding the IDE painful. The concept is great, and I can see it working for many people. We decided in the end that we would try to do everything off the cloud.

Problems

Compatibility: The IDE doesn't work in IE9 (through no fault of Student Robotics, I hasten to add). Our school uses IE9. As a result, we have to use Firefox, which technically we're not allowed to run on a school computer. It wasn't ideal, but it worked.
Speed: Building and deploying a zip is a 20 second operation. It wasn't helped by the insistence of 50 supposed errors, all of which executed correctly on the controller. But I digress. This wass bearable, but wasted a lot of time.
Restricted git access: Git is awesome. Git through the IDE is nothing special. We were having problems with concurrent editing of the same file, resulting in changes being overwritten without anyone knowing. Cue git merge. Once again, we'd like to stress how awesome it was for Student Robotics to give direct git access

An editor

So what are we writing out code in now? Sublime Text 2. It's a little known text editor, with some great features, including autocomplete (a programmers best friend), and a useful python plugin API. It's about on par with Notepad++, comes in a portable edition, and works on windows and linux. You can use it for free, but a license is suggested for extended use.

Setting up the editor

Install and run Sublime Text 2

Install the Sublime Package Manager

Push Ctrl+' to bring up the python console

Running the following in the console:

import urllib2,os;pf='Package Control.sublime-package';ipp=sublime.installed_packages_path();os.makedirs(ipp) if not os.path.exists(ipp) else None;open(os.path.join(ipp,pf),'wb').write(urllib2.urlopen('http://sublime.wbond.net/'+pf.replace(' ','%20')).read())

Restart Sublime Text 2 to complete the installation

Locate the Student Robotics plugin
1. Push Ctrl+Shift+P to bring up the Quick Panel
2. Select "Package Control: Add Repository"
3. Enter https://github.com/eric-wieser/sublime-student-robotics into the box at the bottom
Install plugins
1. Bring up the quick panel again, and select "Package Control: Install Package"
2. Install sublime-student-robotics and sublimelint

Bringing it together

So you've cloned your repository to your hard drive. Now open Sublime Text, and drag your project folder onto it - it'll open in the sidebar. You can open files by expanding the folder in the sidebar. When you're ready to deploy, open the quick panel (Ctrl+Shift+P), and select "Student Robotics: Deploy Zip". That's it. The zip will go on the usb drive very quickly.

A new window File opened Quick Panel Deployment menu

Caveats

Be aware that this approach has its drawbacks. First and foremost, we cannot (yet) guarantee that the code deployed by our plugin is the most recent version. You might be running an outdated version of the Student Robotics library.

You've also got to be careful with git. While it gives you more freedom, it also gives you more ways to give yourself a headache. Direct git access doesn't give you total immunity to concurrent editing. We managed to screw things up horribly at the tech day

Turning your robot into a remote control car

2011-12-04T19:54:00.001Z

Sure, writing code is fun. But sometimes, you just want to drive the thing around yourself. Well, it turns out that that's well within reach. All you need is a wireless USB keyboard. You'll need to grab the TwoWheeledRobot class from this post, and put it into a new file, "systemetric.py". Then, you can run this code:

import systemetric
import gtk

R = systemetric.TwoWheeledRobot()

# Monitor ALL THE KEYS!
keys = {}

def update():
    """Called whenever the state of the keyboard changes"""
     speed = steer = 0
 
    # Handle forwards / backwards
    if keys.get(gtk.keysyms.Up):
        speed += 100
    if keys.get(gtk.keysyms.Down]:
        speed -= 100
  
    # Handle steering
    if keys.get(gtk.keysyms.Left):
        steer -= 100
    if keys.get(gtk.keysyms.Right):
        steer += 100
  
    R.drive(speed, steer)

# Define an event handler for when a key is pressend
def key_press_event(self, event):
    keys[event.keyval] = True
    update()
 
# And one for when it is released
def key_release_event(self, event):
    keys[event.keyval] = False
    update()

# Create a window, bind the event handlers to it, and show it
w = gtk.Window(gtk.WINDOW_TOPLEVEL)
w.connect("key_press_event", key_press_event)
w.connect("key_release_event", key_release_event)
w.show()

#Show the GUI
gtk.main()

When you run it on the robot, a window will pop up, obscuring the logs screen. Armed with your wireless keyboard, you can now drive your robot using the arrow keys!

You may have seen us at the start of the tech day driving the robot around with this. It was a lot of fun.

Tweaking variables while code is running

2011-11-26T22:56:00.001Z

So our robot uses a PID controller to maintain its heading. But this needs tuning. Rather than change a single number in the code, then redownload over and over again, we decided to make a GUI

Here's some simple(ish) code that should allow you to drive your robot forward and backwards just by using the knobs on the front of the controller:

import pygtk
pygtk.require('2.0')
import gtk
import sr

class ManualControlWindow(gtk.Window):
    def __init__(self, name, onChanged):
        speedRange = gtk.Adjustment(
            value = 0
            lower = -100,
            upper = 100,
            step_incr = 10
        )
	
        gtk.Window.__init__(self, gtk.WINDOW_TOPLEVEL)
        self.set_border_width(10)
        self.set_title(name)

        scale = gtk.HScale(speedRange)
        scale.set_digits(0)
        scale.set_size_request(320, 50)
        scale.connect('value-changed', lambda _, adj: onChanged(adj.value), speedRange)
        scale.show()

        self.add(scale)
        self.show()

    def main(self):
        gtk.main()

R = sr.Robot()

def whenSliderMovedTo(x):
    R.motors[0].target = R.motors[1].target = x
		
gui = ManualControlWindow('Adjust robot speed', whenSliderMovedTo)
gui.main()

First intelligent movement!

2011-11-14T16:30:00.000Z

We've got it following a cube! Check out the video:

Features:

Compass-controlled robot orientation
Kill switch with libkoki marker 0, seen at end of video

The lathe

2011-11-13T09:23:00.001Z

So during this saturdays meeting, our mentor brought in a lathe

Lathing ensued.

The importance of classes, and finding tokens

2011-11-12T21:47:00.001Z

Classes are what makes code tidy, readable, and maintainable. We've been going through a cycle of writing some tests, testing the tests, fixing the tests, testing the fixed tests, then wrapping the code all up in a class. This usually prompts further testing, but it pays off in the end by making the rest of your code easier to write. Here's our most recent piece of code:

from sr import *
import time
import math
from systemetricRobot import SystemetricRobot

def main():
    R = SystemetricRobot()
    
    while True:
        # Make sure the robot is still to prevent motion blur
        R.stop()

        #Get only the tokens
        allMarkers = R.see()
        markers = [marker for marker in allMarkers if marker.info.marker_type == MARKER_TOKEN]
        
        # Are there any tokens?
        if markers:
            #Get the angle of the token
            angle = markers[0].centre.polar.rot_y
            
            print "Marker seen at: ", angle
            
            # Turn if we're more than 5 degrees off
            if math.fabs(angle) > 5:
                R.rotateBy(angle)
            
            # Drive forward almost the distance to the marker
            R.driveDistance(markers[0].dist * 0.9)
        else:
            print "No Marker..."
            
            # Spin 20 degrees clockwise
            R.rotateBy(20)

By defining methods such as rotateBy, driveDistance, and stop, we've hidden the complexities of the compass code away in the background. systemetric.Robot, along with CompassRobot, and TwoWheeledRobot, do all the "heavy" lifting.

All in all, lots of functionality, with minimal code.

The kill switch

2011-11-12T19:00:00.000Z

The robot is going to do things you don't want it to do - like spin around on the spot really fast, or make a very irritating motor whine. You can turn it off with the switch, but this is boring, and also requires the controller to be restarted.

What if, we thought, the robot stopped when it saw a special marker? We can just stop the motors, and leave the robot in a state where we can happily pull out the USB drive, change the code, and plug it back in. How? Simply by intercepting calls to Robot.see:

import sr
import sys

DIE_HORRIBLY = 0 # The kill marker

class KillableRobot(TwoWheeledRobot)
    def see(self, *args, **kw):
        markers = Robot.see(self, *args, **kw)
        for marker in markers:
            if marker.info.code == DIE_HORRIBLY:
                self.stop() #stop both the motors
                sys.exit(1)
                
        return markers

By using KillableRobot instead of TwoWheeledRobot, the robot will exit if it sees the kill marker whenever the camera is used. This makes the text-fix-redeploy cycle much faster, as there is no reboot step. If you're really lazy, you can (we did) stick the marker on a pole, so you can stop the robot without even bending down.

Use pretty colours!

2011-11-11T23:21:00.001Z

Why, hello there, new blog.

If you (the reader, being in some way related to Student Robotics) plan on writing blog entries involving some code, use syntax highlighting! Every time code is typeset in the same monotonous colour when different colours could be used, a kitten dies.

Note the difference in readability:

def quicksort(l):
    '''Do some funky recursive sorting'''
    if len(l) <= 1:
        return l
    less = []
    greater = []
    pivot = l.pop(randint(1, len(l)-1))
    for x in l:
        if x <= pivot:
            less += [x]
        else:
            greater += [x]
    return quicksort(less) + [pivot] + quicksort(greater)

def quicksort(l):
    '''Do some funky recursive sorting'''
    if len(l) <= 1:
        return l
    less = []
    greater = []
    pivot = l.pop(randint(1, len(l)-1))
    for x in l:
        if x <= pivot:
            less += [x]
        else:
            greater += [x]
    return quicksort(less) + [pivot] + quicksort(greater)

One of the best tools I've found for this mighty task is pygments. Use it. Use it for the kittens.

Adding a compass

2011-11-10T06:05:00.000Z

So we managed to get hold of a compass a couple of days ago. It gets us the heading of the to 0.1°. It's an I²C sensor, which the SR kit doesn't supply an interface for. Not a problem - we have an mbed!

The compass The mbed

Simply by connecting the compass to the mbed, and the mbed to the USB hub, we can use pyserial to send the compass heading!

Here's the class to use the compass from python

import serial

class Compass(object):
    def __init__(self, port = '/dev/ttyACM0'):
        try:
            self.port = serial.Serial(port)
            self.port.timeout = 0.25
            self.port.open()
        except Exception, c:
            raise Exception('Cannot connect to mbed')

    @property
    def heading(self):
        '''Get the compass heading from the mbed'''
        heading = None
        try:
            self.port.write('H')
            heading = self.port.readline()
            return int(heading) / 10.0 #convert the int we get from the mbed into a float.
        except:
            print 'Invalid reading (' + str(heading) +') from compass'
            return float('nan') #return NaN, because we don't know the heading
    
    def startCalibration(self):
        self.port.write('C')
        
    def stopCalibration(self):
        self.port.write('C')

And here's what we're running on the mbed:

#include "HMC6352.h"

HMC6352 compass(p9, p10);
Serial robo(USBTX, USBRX);

char in;
int main() {
    //robo.printf("1101\n");//8 byte handshake
    //Continuous mode, periodic set/reset, 20Hz measurement rate.
    compass.setOpMode(HMC6352_CONTINUOUS, 1, 20);
    while(1) {
        in = robo.getc();
        if(in == 'H') {
            robo.printf("%d\n", compass.sample());
        }
        if(in == 'C') {
            compass.setCalibrationMode('E')
            robo.getc();
            compass.setCalibrationMode('C');    
        }
    }
}

Still to come - actually using the compass.

Driving Around

2011-11-06T22:31:00.000Z

Let's be honest, the SR API is not the easiest way to drive a robot around. You've got to remember which motor is 0 and which is 1, and there that .target, which frankly is all you could possibly mean anyway. We decided to write a class to make things easy. This is what we're using:

from sr import *
import math

class TwoWheeledRobot(Robot):
    def __init__(self):
        #Make sure the soton class is initiated, so we can connect to motors
        Robot.__init__(self)
        
        #Name the motors, for easy access
        self.leftMotor = self.motors[0]
        self.rightMotor = self.motors[1]
        
    @property
    def left(self):
        '''Property to control the speed of the left motor, without the hassle of `.target`'''
        return self.leftMotor.target
        
    @left.setter
    def left(self, value):
        if not math.isnan(value):
            self.leftMotor.target = value
        
    @property  
    def right(self):
        '''Property to control the speed of the right motor, without the hassle of `.target`'''
        return self.rightMotor.target
        
    @right.setter    
    def right(self, value):
        if not math.isnan(value):
            self.rightMotor.target = value
    
    def stop(self):
        '''Stop the robot, by setting the speed of both motors to 0'''
        self.right = 0
        self.left = 0
        
    def drive(self, speed=50, steer=0):
        '''Drive the robot forwards or backwards at a certain speed, with an optional steer'''
        self.right = speed - steer
        self.left = speed + steer
        
    def turn(self, speed):
        '''Rotate the robot at a certain speed. Positive is clockwise'''
        self.right = -speed
        self.left = speed

How do you use this, you ask? Simple! Connect your left and right motors to motor boards 0 and 1, copy the above code into twowheeledrobot.py, and then use it:

from twowheeledrobot import TwoWheeledRobot
import time

R = TwoWheeledRobot()

# 50% speed forward
R.drive(50) 
time.sleep(2)
R.stop()

# 25% speed turn clockwise
R.turn(25)
time.sleep(2)
R.stop()

# Drive backwards at 25% power, with a slight curve to the right
R.drive(speed=-25, steer=5) 
time.sleep(2)
R.stop()

# All the standard API calls still work
markers = R.see()

Note that your project will claim to contain errors in twowheeledrobot.py. These are not errors - ignore them. The code will work perfectly on the controller

Using our code? Great! Let us know in the comments how well it's working for you.

A grabber design!

2011-10-15T14:00:00.000+01:00

We made a grabber. Out of lego.

Open Closed Lifting

It's a pretty awesome grabber. In one movement with one motor, it closes the claw, lifts the arm, and drops the cube at the top