The temperature sensor data is available via a 1-Wire module connected to the system via the USB bus. Writing Python (or any other language) code to directly communicate with the module over USB is a non-trivial task. But in this case, we didn't have to. The OWFS (http://owfs.sourceforge.net/) project provides access to 1-Wire devices via the filesystem, thereby greatly simplifying the code that has to be written to communicate with 1-Wire devices.

At system startup, the OWFS file system has to be mounted. Because there isn't an easy way to specify OWFS file systems in /etc/fstab, an init script is used to mount the file system.

 1 #! /bin/sh
 2 # $Id: owfs.init 18 2004-07-21 20:24:25Z peter $
 3 
 4 PATH=/opt/owfs/bin:/bin:/usr/bin:/sbin:/usr/sbin
 5 DAEMON=/opt/owfs/bin/owfs
 6 PIDFILE=/var/run/owfs.pid
 7 
 8 # Arguments to owfs
 9 #
10 MOUNT_POINT="/1-wire"
11 ARGS="-F -u $MOUNT_POINT"
12 
13 test -x $DAEMON || exit 0
14 
15 case "$1" in
16   start)
17     echo -n "Starting owfs"
18     start-stop-daemon --start --quiet --pidfile $PIDFILE \
        --exec $DAEMON --$ARGS
19     echo "."
20     ;;
21   stop)
22     echo -n "Stopping owfs"
23     umount $MOUNT_POINT
24     echo "."
25     ;;
26   restart)
27     sh $0 stop
28     sh $0 start
29     ;;
30   *)
31     echo "Usage: /etc/init.d/owfs {start|stop|restart}"
32     exit 1
33     ;;
34 esac
35 
36 exit 0

The owfs.init script is fairly simple and typical of a daemon startup script. When the start parameter (line 16) is specified, it starts the OWFS daemon telling it to mount the 1-Wire sensors under /1-wire.

A difference to other init scripts is when the stop parameter (line 21) is specified. Instead of stopping the daemon itself, the /1-wire file system is unmounted. This cleans up the kernel file system entries and such, as well as stopping the OWFS daemon process. The restart parameter (line 26) is just a simple way of issuing a stop followed by a start.

When the OWFS daemon mounts a file system, it queries the USB bus to find any 1-Wire sensors. For each of the sensors found, it queries the sensor to obtain it's unique address. With 1-Wire sensors, each sensor ever created has an address that Dallas Semiconductors insist is globally unique. A directory listing of /1-wire shows...

10.B7B64D000800/ 10.54BA4D000800/

... which are the addresses for the temperature sensors used on this project. Within each of those two directories, there are a number of files that provide access to all the details of the sensors. Of particular interest is the temperature file. Opening and reading from this gives the temperature as a string of a floating point number.

With 1-Wire sensors and OWFS, gaining access to the data is very easy. Just open the appropriate file and read the data. (At least that's the case for the temperature sensors. If time had permitted for this project, a humidity sensor would have been added. However, reading the humidity data isn't as simple as reading the temperature. And since this project had to be finished before the road trip started, the humidity sensor was dropped.)

The following script, one_wire_sensors.py, monitors the temperature.

  1 #! /usr/bin/env python
  2 
  3 # $Id: one_wire_sensors.py 23 2004-07-22 04:35:36Z peter $
  4 #
  5 # need to check for /1-wire mounted but Vendor=04fa is not
  6 # in the usb usb devices file. this can occur when the usb
  7 # dongle is no longer connected.
  8 #
  9 # check that /1-wire is mounted
 10 # if not, check that Vendor=04fa is in the usb devices file.
 11 # if it is, then kick /etc/init.d/owfs to start up again
 12 # if not, then ?
 13 
 14 
 15 import os
 16 import syslog
 17 import csv
 18 import time
 19 import util
 20 
 21 
 22 Debug           = True
 23 OWUSBVendor     = '04fa'
 24 USBDevices      = '/proc/bus/usb/devices'
 25 MountFile       = '/proc/mounts'
 26 OWUSBMount      = '/1-wire'
 27 MountCommand    = '/etc/init.d/owfs.init start'
 28 UnmountCommand  = '/etc/init.d/owfs.init stop'
 29 SensorLogName   = 'sensor.log'
 30 Sensors         = {
 31     'Temperature1' : os.path.join( OWUSBMount, '10.B7B64D000800' ),
 32     'Temperature2' : os.path.join( OWUSBMount, '10.54BA4D000800' ),
 33     #'Humidity1'   : os.path.join( OWUSBMount, '12.386623000000' ),
 34     #'Humidity2'   : os.path.join( OWUSBMount, '12.3B6F23000000' ),
 35    }
 36 Messages        = {
 37     'MountedNoPresence' :
 38     '1-wire mounted but no usb presence, unmounting 1-wire',
 39 
 40     'UnmountedPresence' :
 41     '1-wire not mounted but usb presence, mounting 1-wire',
 42 
 43     'UnmountedNoPresence' :
 44     '1-wire not mounted and no usb presence, nothing can be done',
 45 
 46     'MountedNoSensors' :
 47     '1-wire mounted and usb presense but no sensors, remounting 1-wire',
 48     }
 49 
 50 
 51 def log_message( message ):
 52     if Debug:
 53         print message
 54     syslog.syslog( syslog.LOG_DAEMON|syslog.LOG_WARNING, message )
 55 
 56 
 57 def check_mount( mount_point ):
 58     known_mounts = open( MountFile, 'r' ).readlines()
 59     for mount in known_mounts:
 60         if mount_point in mount:
 61             return True
 62     return False
 63 
 64 
 65 def check_usb_vendor( vendor ):
 66     usb_lines = open( USBDevices, 'r' ).readlines( )
 67     vendor = 'Vendor=' + vendor
 68     for line in usb_lines:
 69         if vendor in line:
 70             return True
 71     return False
 72 
 73 
 74 def check_sensors( ):
 75     for sensor in Sensors:
 76         if not os.path.isdir( Sensors[ sensor ] ):
 77             return False
 78     return True
 79 
 80 
 81 def read_temperature( ):
 82     path = os.path.join( Sensors[ 'Temperature1' ], 'temperature' )
 83     temperature1 = open( path, 'r' ).readlines( )
 84     path = os.path.join( Sensors[ 'Temperature1' ], 'temperature' )
 85     temperature2 = open( path, 'r' ).readlines( )
 86     return ( float( temperature1[ 0 ] ), float( temperature2[ 0 ] ) )
 87 
 88 
 89 def log_sensors( ):
 90     current_time = time.time( )
 91     path = util.log_path( '', SensorLogName )
 92     temperature1, temperature2 = read_temperature( )
 93     writer = csv.writer( file( path, 'a' ) )
 94     writer.writerow( ( current_time, temperature1, temperature2 ) )
 95 
 96 
 97 def one_wire( ):
 98     mounted      = check_mount( OWUSBMount )
 99     usb_presence = check_usb_vendor( OWUSBVendor )
100     sensors      = check_sensors( )
101 
102     if mounted:
103         if not usb_presence:
104             log_message( Messages[ 'MountedNoPresence' ] )
105             os.system( UnmountCommand )
106         elif not sensors:
107             log_message( Messages[ 'MountedNoSensors' ] )
108             os.system( UnmountCommand )
109             os.system( MountCommand )
110         elif Debug:
111             print 'all is right with the world'
112     elif usb_presence:
113         log_message( Messages[ 'UnmountedPresence' ] )
114         os.system( MountCommand )
115     else:
116         log_message( Messages[ 'UnmountedNoPresence' ] )
117 
118 
119 if __name__ == '__main__':
120     one_wire( )
121     if check_mount( OWUSBMount ):
122         log_sensors( )

A crontab entry was used to run one_wire_sensors.py every 5 minutes to collect the temperature data.

One of the more annoying issues discovered once this portion of the system was operational was that the sensor entries would disappear from the /1-wire directory. A bit of physical world debugging showed that the USB adapter used to connect the 1-Wire sensors to the system would jiggle in the socket. This resulted in a USB disconnect and reconnect happening in the kernel. Once the USB disconnect happened, the OWFS daemon would lose it's connection to the sensors and would drop the entries.

With the system being mounted on a motorcycle and subject to bounces from the road surface, this would be a problem. To get around this, the one_wire() function (line 97) is used to verify that the /1-wire directory is mounted and the sensors are accessible.

A GPS is an amazing device. Essentially, it receives faint time signals from a constellation of 24 satellites orbiting the earth at around 12,000 miles and compares those values to a known time value to compute how long it took the signals from different satellites to travel to the GPS. Based on how long the signals took, the GPS receiver is able to calculate the near-exact location of the receiver on the earth.

At system startup, the gps.init script (shown immediately below) starts a process running gps.py to collect the data.

 1 #! /bin/sh
 2 # $Id: gps.init 18 2004-07-21 20:24:25Z peter $
 3 
 4 PATH=/bin:/usr/bin:/sbin:/usr/sbin
 5 DAEMON=/root/ltodyssey/bin/gps.py
 6 PIDFILE=/var/run/gps.pid
 7 
 8 ARGS=""
 9 
10 test -x $DAEMON || exit 0
11 
12 case "$1" in
13   start)
14     echo -n "Starting GPS capture - gps.py"
15     start-stop-daemon --start --pidfile $PIDFILE --make-pidfile \
        --background --exec $DAEMON -- $ARGS
16     echo "."
17     ;;
18   stop)
19     echo -n "Stopping GPS capture - gps.py"
20     start-stop-daemon --stop --pidfile $PIDFILE
21     echo "."
22     ;;
23   restart)
24     sh $0 stop
25     sh $0 start
26     ;;
27   *)
28     echo "Usage: /etc/init.d/gps.init {start|stop|restart}"
29     exit 1
30     ;;
31 esac
32 
33 exit 0

The gps.init script is again simple and is very similar to the owfs.init script. When start is passed to it, a daemon process is started to execute the gps.py code. When stop is passed to it, it stops the daemon process. As with owfs.init, the restart command is just a simple way of issuing a stop followed by a start.

For this project, a Garmin GPS V was used. The GPS V is connected to a computer via an old fashion RS-232 serial port. Now, writing RS-232 serial port code is annoying. But again, we don't have to, thanks to the wondrous PyGarmin project (http://pygarmin.sourceforge.net/). PyGarmin provides a set of Python classes that implement the protocol used by Garmin GPS receivers. (This one of the great features of using Python: modules like this exist and make life much easier for developers.)

 1 #! /usr/bin/env python
 2 # $Id: gps.py 23 2004-07-22 04:35:36Z peter $
 3 
 4 
 5 import os
 6 import sys
 7 import time
 8 import csv
 9 from pygarmin import garmin
10 import util
11 
12 
13 GPSDevice      = '/dev/ttyS0'
14 GPSLogName     = 'gps.log'
15 GPSCollectRate = 3  # number of seconds between snapshots
16 
17 
18 def connect( device ):
19     phys = garmin.UnixSerialLink( device )
20     gps = garmin.Garmin( phys )
21     gps.pvtLink.dataOn( )
22     return gps
23 
24 
25 if __name__ == '__main__':
26     while 1:
27         try:
28             gps = connect( GPSDevice )
29             while 1:
30                 start_time = time.time( )
31                 position = gps.pvtLink.getData( )
32                 fullname = util.log_path( str( position.wn_days ), 
                                   GPSLogName )
33                 writer = csv.writer( file( fullname, 'a' ) )
34                 writer.writerow( ( start_time,
35                                    position.alt,
36                                    position.east,
37                                    position.epe,
38                                    position.eph,
39                                    position.epv,
40                                    position.fix,
41                                    position.leap_secs,
42                                    position.msl_height,
43                                    position.north,
44                                    position.rlat,
45                                    position.rlon,
46                                    position.tow,
47                                    position.up,
48                                    position.wn_days ) )
49 
50                 end_time = time.time( )
51                 time_difference = end_time - start_time
52                 if time_difference < GPSCollectRate:
53                     time.sleep( GPSCollectRate - time_difference )
54         except garmin.LinkException, e:
55             print 'received a LinkException:', e
56             print 'trying to reestablish the GPS connection'
57             time.sleep( GPSCollectRate )

The basic logic behind the gps.py code is pretty straight forward: connect to the GPS, read the current location data, write that data out to a comma separated file, and sleep for a bit before starting over again. The connect() function (line 18) connects to the GPS attached to the serial port specified by GPSDevice (line 13) and tells it to start collecting data (line 21.)

Once a connection is established, the code loops (line 29) through obtaining the current location data (line 31), writing that data out to a CSV file (line 34) and waiting for a period of time before reading the data again.

The whole connect, collect data, and save it loop is defined within a try/except block (lines 27-54). When a garmin.LinkException is caught, it indicates that there was a problem in communicating with the GPS. (From experience, this was typically a result of user error. While riding, I would sometimes press the power button instead of something else. This would mostly occur when I would try to manipulate the GPS while wearing riding gloves. The buttons on the GPS V are pretty small and leather gloves made it very difficult to press individual buttons.) So, the try/except block within a while loop (line 26) ensured that the process of collecting data would continue or at least attempt to continue in the event of serial line communication problems.

In a perhaps vain attempt at limiting possible loss of data, the CSV data file is changed every week. This is done by using the wn_days field (line 32) from the collected location data. The wn_days field provides the number of days that have occurred from UTC December 31, 1989 to the beginning of the current week. That gives the current GPS week number. By using the current GPS week number in the log file path, at most a weeks' worth of data would be lost. Or at least, that was the thought when I was originally putting this system together. In hind sight, I'm not sure that it provided all that much protection.

One very glaring mistake was the use of a timer within the code. The timer caused the code to wait for 3 seconds between reading GPS location data. The original thought was that the GPS location data was to be related to the video images captured and should thus be at the same frequency as the video image capture. A side effect of this is that using the GPS data to plot path traveled maps would be problematic as the resolution of the map was increased. Traveling at 75 MPH, the distance traveled in 3 seconds is 330 feet. This 330 feet compounds the inherent GPS location accuracy. Once more work is done on post processing the data, a better idea on the impact of this choice can be made.

Collecting video images along the route traveled was one of the goals for the project. One way of doing this would be to use a standard video camera and change tapes every hour. Riding an average of six hours a day for five weeks would result in some 200+ tapes. Considering that the cost of tapes alone would break the budget for this project and that the time needed afterward to edit would be fairly lengthly, a decision was made to work out how to record directly to disk.

The basic requirements for the camera were color video, waterproof or easily waterproofed, small, powered by a 12V DC source, and not that expensive. The first camera that was tried was the Apple iSight since I already owned one. Unfortunately, it ran into a waterproofing problem. The iSight generates a substantial amount of heat while operating, and I was concerned about putting it in a waterproof enclosure. Not knowing how much heat the camera can tolerate, I decided to look for a different camera.

Some online research yielded a number of different cameras know as helmet cameras or bullet cameras. Of the ones that are available, I settled on a Sony High Res CCD camera from RF Concepts. This is a really small camera that takes pretty good pictures, as shown in Figure Six.

Capturing the video was a big question for me and I was glad to find that the Video4Linux project provides great software for this type of work. I was also concerned about running out of disk space trying to capture 30 frames per second riding up to eight hours a day for four or five weeks. So, I decided to take periodic snapshots. I settled on capturing a video image once every 3 seconds. I also struggled for a bit regarding how to capture the video itself. I wanted to do all the work in Python but realized that there wasn't enough time before I leaving to allow me to write the code that would be needed. Instead, I decided to use Python to take snapshots using the v4lctl program that's part of the Video4Linux project. The result is the v4l.py script.

 1 #! /usr/bin/env python
 2 # $Id: v4l.py 25 2004-07-22 19:48:22Z peter $
 3 
 4 
 5 import os
 6 import sys
 7 import time
 8 import util
 9 
10 
11 V4LDevice    = '/dev/video0'
12 V4LCTL       = '/usr/bin/v4lctl -c ' + V4LDevice
13 SnapshotRate = 3  # number of seconds between snapshots
14 
15 
16 def command( cmd ):
17     cmd = V4LCTL + ' ' + cmd
18     ret = os.system( cmd )
19     
20 
21 def setup( ):
22     command( ' setnorm  NTSC' )
23     command( ' setinput Composite1' )
24     command( ' capture  grabdisplay' )
25     command( ' color    "50%"' )
26     command( ' hue      "50%"' )
27     command( ' bright   "50%"' )
28     command( ' contrast "50%"' )
29 
30 
31 def snapshot( file ):
32     command( ' snap jpeg full ' + file )
33 
34 
35 def collect_snapshots( ):
36     while 1:
37         start_time = time.time( )
38 
39         year, month, day, \
40             hour, minute, seconds,
41             weekday, yearday, dst = time.localtime( start_time )
42 
43         snapshot_name = '%d_%02d_%02d_%02d_%02d_%02d.jpg' % (
44             year, month, day, hour, minute, seconds )
45         fullname = util.log_path( os.path.join( '%d' % year,
46             '%02d' % month, '%02d' % day,   '%02d' % hour,
47             '%02d' % minute ), snapshot_name )
48         snapshot( fullname )
49 
50         end_time = time.time( )
51         time_difference = end_time - start_time
52         if time_difference < SnapshotRate:
53             time.sleep( SnapshotRate - time_difference )
54 
55 
56 if __name__ == '__main__':
57     setup( )
58     if len( sys.argv ) == 1:
59         collect_snapshots( )
60     else:
61         snapshot( sys.argv[ 1 ] )

The v4l.py code sets up the Video4Linux subsystem to find the camera and take NTSC type video. It then creates a snapshot image that uses a time stamp in the name to ensure uniqueness and order to the images. It also has the ability to take an individual snapshot which helped with debugging the hardware.