Yet the idea of having the installation "connect" the user with another place that she or he may or may not be familiar with -- but that is geographically close -- remains compelling. And working with live audio and video created plenty of space for the unexpected to sneak in. Last Miles Refactored, as I'll call this second version, is going to try to preserve as much of the initial vision for the project while making sure that the installation's technological supports are more reliable.

For now my ideas include:

• Interfacing with Flickr or similar service to pull down photos from Durham of public spaces (this latter may need to be flagged by users themselves)
• Better user interface with support for arbitrary display types -- I'm considering PyGTK or pygame. I'd really like to find something that lets me create nice looking transparent widgets out of the box. I used gtk last time but spent way too much time styling the interface.

For the conference I've revised the project description considerably, adding a bunch of visual aids and updating the description to reflect the current state of the project.

Update 2008-5-6. Here's a photo from the poster session on Saturday:

Their discussion of Ardunio's Serial.read() was especially helpful; it's prompted me to make some changes in my code.

For anyone interested in using the nunchuck with Arduino, there's a nice adapter piece that allows for a much nicer interface with the nunchuck:

Not knowing about the adapter, I cut the cable to get at the cords. It's not pretty (below). Hopefully I'll find a more elegant way to deal with this kind of wire..

p.s. Here's a vid showing the potential of the nunchuck..

The first two scripts are for testing, the full version is at bottom, but contains a lot more project-specific code.

simple ssl client

 
#!/usr/bin/env python
#
# Receive number from client where -10 < number < 10.
# Send that number to attached arduino.
# Also receive number from arduino, send that to client. Again, -10 < number < 10
# Log everything.
# SUPERSEDED BY arduino_ssl_relay.py
 
import socket
import logging
import re
from serial import *
 
logging.basicConfig(level=logging.DEBUG,
                    format='%(asctime)s %(levelname)s %(message)s',
                    filename='ssl_echo_client.log',
                    filemode='w')
NAME = "SSL Echo Client"
 
def main(ip='192.168.1.101'):
 
	logging.info(NAME + "started")
 
	ser = Serial(port="/dev/ttyUSB0", baudrate=9600)
	logging.info("Serial startd on " + ser.portstr)
 
	HOST = ip   # The remote host
	PORT = 50008              # The same port as used by the server
	s = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
	s.connect((HOST, PORT))
	logging.info("Connected to "+HOST+" at port "+ str(PORT))
 
	data = '0'
 
	s.send('Hello, world')
	#ssl_data = s.recv(1024)
	while True:
		try:
			line = ser.readline()   #read a '\n' terminated line
			logging.info("received from arduino: " + line)
			matches = re.search(r'log: arduino says computed pot_val: (\d{1,2})',line)
			if matches:
				val = matches.groups()[0]
				if int(val) > 0 and int(val) < 20:
					olddata = data
					data = val + "\n"
					if data != olddata: # only send if there's a change
						ssl_send = data
						s.send(data)
						logging.info("Sent data to server:" + data)
				else:
					logging.warning("Got an invalid value from arduino: " + val)
		finally:
			logging.warning("Closing sockets")
			s.close()
			ser.close()
			logging.warning("Shut down done")
 
if __name__ == "__main__":
	main()

simple ssl echo server

 
# Echo server program
# testing
# SUPERSEDED BY arduino_ssl_relay.py
import socket
import re
from serial import *
 
def main():
	HOST = ''                 # Symbolic name meaning the local host
	PORT = 50009              # Arbitrary non-privileged port
	s = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
	s.bind((HOST, PORT))
	s.listen(1)
	conn, addr = s.accept()
	print 'Connected by', addr
	while 1:
	    data = conn.recv(1024)
	    if not data: break
	    print 'Got data from client', data
	    conn.send(data) # have it echo back whatever it gets until we have two setups
	conn.close()
 
if __name__ == "__main__":
	main()

Combined (and a little more project specific

 
#!/usr/bin/env python
# Arduino Serial SSL Relay
# Relays output from one arduino to another arduino via SSL.
# @author: Allen Riddell <http:>
# @date:   2008-03-26
# For the Last Miles Project: http://dukevisualstudies/lastmiles/
# only supports IP4.
 
# TODO
#
# * more detailed log information (ip address)
# * simplify server and client connection variable (no s and conn, that's confusing)
# * standardized transmission format -- when one has multiple messages (i.e. pot, and others)
 
import socket
 
import re
import serial
from optparse import OptionParser
 
# logging
import logging
import sys
logging.basicConfig(level=logging.DEBUG,
                    format='%(asctime)s %(levelname)s %(message)s',
                    filename='/tmp/arduino_ssl_relay.log',
                    filemode='w') #DEBUG: change this to "a" when done
# console logging
console = logging.StreamHandler(sys.stdout)
console.setLevel(logging.INFO)
# formatter = logging.Formatter('%(message)s')
# console.setFormatter(formatter)
logger = logging.getLogger()
logger.addHandler(console)
 
# Constants
PORT = 50009 # arbitrary ssl port
DEV = "/dev/ttyUSB0" # port to which arduino is connected. /dev/ttyUSB0 on my linux box.
 
def main(ip='', server=True, dev=DEV, port=PORT):
 
    # open serial connection to arduino, fail if not available.
    try:
        ser = serial.Serial(port=dev, baudrate=9600)
    except serial.serialutil.SerialException, e : # fix this.
        logging.warning("couldn't establish serial connection" + str(e))
    logging.debug("Serial connection started on " + ser.portstr)
 
    # open ssl connection, fail if not available.
 
    HOST = ip                 # Symbolic name meaning the local host
    PORT = int(port)              # Arbitrary non-privileged port
 
    s = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
    mode_name = "server" if server else "client"
 
    # SERVER SSL Setup
    if server:
        try:
            s.bind((HOST, PORT))
            s.listen(1)
            logging.info("Starting " + mode_name + ", listening for connections.")
            conn, addr = s.accept()
            logging.info('Connected by' + str(addr))
        except Exception, e:
            logging.critical("Couldn't establish connection: "+ str(e))
            s.close()
            ser.close()
            sys.exit()
    # CLIENT SSL Setup
    else:
        try:
            s.connect((HOST, PORT))
            logging.info("Connected to "+HOST+" at port "+ str(PORT))
            s.settimeout(2)
        except socket.error, e:
            logging.critical("Couldn't establish connection: " + str(e))
            s.close()
            ser.close()
            sys.exit()
 
    # ssl settings for both
    logging.debug("Socket timeout is: "+ str(s.gettimeout()))   
 
    # main loop
    data = None
    sslsend = '10' + '\n' # default is to tell the servo not to move '10'
    ssldata = None
    line = None
    loop_count = 0
 
    while True:
        # handle serial connection
        try:
#           line = ser.readline()   #read a '\n' terminated line
            line = ser.read(256)
            if ser.inWaiting() &gt; 256:
                wait = ser.inWaiting()
                logging.warning("serial info ser.inWaiting(): " + str(wait))
                line = ser.read(ser.inWaiting())
        except (KeyboardInterrupt, SystemExit):
            break
        if line:
            logging.debug("received from arduino: " + line[:-1]) # get rid of final '\n'
        matches = re.findall(r'log: arduino says computed pot_val: (\d{1,2})',line)
        if matches:
            val = matches[-1] # use last match
            if int(val) &gt; 0 and int(val) &lt; 20:
                olddata = data
                data = val + "\n"
                sslsend = data
#                if data != olddata: # only send if there's a change
#                    sslsend = data
#                else:
#                    sslsend = None
 
        # first send ssl data "sslsend"
        if sslsend:
            try:
                logging.debug("attempting to send ssl data")
                if server:
                    conn.send(sslsend)
                else:
                    s.send(sslsend)
                logging.debug("sent ssl data:" + sslsend[:-1])
            except socket.timeout, e:
                logging.warning("failed to send ssl data:" + sslsend[:-1] + ", error: " + str(e))
                continue
            except socket.error, e:
                logging.warning("failed to send ssl data:" + sslsend[:-1] + ", error: " + str(e))
                break
        # receive ssl data "ssldata"
        oldssldata = ssldata
        try:
            logging.debug("attempting to receive ssl data")
            if server:
                ssldata = conn.recv(1024)
            else:
                ssldata = s.recv(1024)
            if ssldata:
                logging.debug("received ssl data:" + ssldata[:-1])
        except socket.timeout, e:
            logging.warning("failed to receive ssl data, error: " + str(e))
            continue
        except socket.error, e:
            logging.critical("failed to receive ssl data, error: " + str(e))
            break
        except (KeyboardInterrupt, SystemExit):
            break
        # send ssldata to arduino
        if ssldata:
            ssldata = ssldata[:-1] #strip \n -- maybe use string.rstrip(os.linesep)
            if ssldata != oldssldata and len(ssldata) &lt; 3:
                if int(ssldata) &gt; 0 and int(ssldata) &lt; 20:
                    ser.write(ssldata + "\n")
                    logging.info("sent arduino ssl data:" + ssldata)
        else:
            logging.warning("didn't receive data from remote connection")
        loop_count += 1
    # shut down, close connections
    logging.critical("shutting down, closing sockets")
    s.close()
    ser.close()
 
def parseOpts():
    parser = OptionParser()
    parser.add_option("-c", "--client", dest="mode",
                      default=SERVER,
                      help="run in client mode (provide an IP to connect to) (IP4 only)")
    return parser.parse_args()        
 
if __name__ == "__main__":
    usage = "usage: %prog [options] ip_address"
    parser = OptionParser(usage=usage)
    parser.add_option("-d", "--device", dest="dev", default=DEV,
                      help="Use an alternate serial device. Default is: "+DEV)
    parser.add_option("-p", "--port", dest="port", default=PORT,
                      help="Use an alternate port. Default is: "+str(PORT))
    (options, args) = parser.parse_args()
    if args:
        main(dev=options.dev,ip=args[0],port=options.port,server=False)
    else:
        main(dev=options.dev,port=options.port)
</http:>

UPDATE 2008-8-3: We ended up using "normal" (i.e. non-continuous) servos. So things work a bit differently now.

The servo is pictured above. I found a pdf with specifications and Basic Stamp code on Parallax's web site. From the instructions I figured out the important numbers. The servo wants intervals of 20ms and pulse widths of 1.5ms if it's going to do nothing. Widths greater than 1.5ms turn the servo counterclockwise, widths lower than 1.5ms turn the servo clockwise. When the servo is receiving 1.5ms width pulses, it's possible to adjust the set point with a tiny Phillips screw driver.

Here's my translation of BASIC Stamp 1 code into Arduino. The code should make the servo stay still, rotate left, rotate right (and repeat).

Basic Stamp 1 code

SYMBOL Temp = W0 'Work space for FOR NEXT
SYMBOL Servo_pin = 0 'I/O pin that is connected to servo
FOR temp = 0 TO 200 '
PULSOUT Servo_pin,150
PAUSE 20
NEXT
FOR temp = 0 TO 200
PULSOUT Servo_pin,180
PAUSE 20
NEXT
FOR temp = 0 TO 200
PULSOUT Servo_pin,120
PAUSE 20
NEXT
Stop


Arduino


int servoPin = 7;
void setup()
{
pinMode(servoPin,OUTPUT);
}
void loop()
{
int temp;
for (temp = 0; temp <= 200; temp++)
{
digitalWrite(servoPin,HIGH);
delayMicroseconds(1500); // 1.5ms
digitalWrite(servoPin,LOW);
delay(20); // 20ms
}
for (temp = 0; temp <= 200; temp++)
{
digitalWrite(servoPin,HIGH);
delayMicroseconds(1800); // 1.8ms
digitalWrite(servoPin,LOW);
delay(20); // 20ms
}
for (temp = 0; temp <= 200; temp++)
{
digitalWrite(servoPin,HIGH);
delayMicroseconds(1200); // 1.2ms
digitalWrite(servoPin,LOW);
delay(20); // 20ms
}
}


That's it!

Got through the "Hello World" equivalent for Arduino, i.e. make an LED flash. Next on my list was getting the servomotor to move. As luck would have it there's a presentation from ITP on the very subject: class 3 (communication, servos, and pwm).