One of the things i wanted for a long time is measuring temperature (room and outside) and display this via a graph on my website. I didn't want to pay a huge amount of money for the sensors so that stalled things for a while. A couple of weeks ago a collegue of mine found these nifty RS232 thermometers from a company called Papouch for a very reasonable price (the 14 euro is a bit deceptive since the total costs incl. BTW (VAT) and shipping will be around 20 euro per sensor). The fun thing about these sensors is that the are "intelligent", they present temperature directly on the serial line, so you don't have to do any fancy calculations. Also, since they are RS232 based it will work on any operating system. I ordered two probes for my computer at home, one to measure the room temperature and one for the outside temperature. The arrived after a week or two and i quickly plugged them in the serial ports, on Linux they are represented by:
/dev/ttyS0
/dev/ttyS1

There is a small program which comes with the sensors, tm.c, which is supposed to read from a sensor and show the results on screen, but that does not seem to work on my Fedora Core 3 machines. So i made a small kermit init script:

set modem type none   ; There is no modem
set carrier-watch off ; If DTR CD are not cross-connected
set line /dev/ttyS0   ; Device name
set speed 9600        ; Desired speed
set parity none       ; No parity
set stop-bits 2       ; 2 stop bits
set flow none         ; no flow-control
connect               ; Enter Connect (terminal) state

and saved this under .kermrc in my home directory, also i made sure i had all the necessary rights on the serial port devices (as root: chown my-userid /dev/ttyS[01]).
When i fired up kermit, i immediatly got some output, so the sensors worked fine.

I decided to write a program in perl which would be flexible enough to cater for all my future temperature needs. After a short quest on google i found that serial port communcations from perl are best done using: Device::SerialPort.
Since this module was not on my system yet, i had perl fetch it from CPAN and install it for me:

perl -MCPAN -e 'install Device::SerialPort'

This didn't complete since there was a problem with one of the tests and perl reported it wouldn't install without force. Well since i am the lazy type i thought i would try the module anyway, so:

cd ~/.cpan/build/Device-SerialPort-1.002/
make install

And that did the job. The first thing you always should do after installing a new module is read the documentation, it most often has ample examples in there to help you getting started:

perldoc Device::SerialPort

Since perl reads like a novel, i'll just give the code straight away:

PLAIN TEXT
PERL:
  1. #!/usr/bin/perl
  2. #
  3. # (c) 20060318 by Ewald
  4. # http://www.oiepoie.nl
  5.  
  6.  
  7. use Device::SerialPort;         # to read serial port data
  8. use Getopt::Std;                # to handle cmdline options
  9.  
  10. my $V="0.9 20060318";           # version and date of latest modification
  11. my $DEBUG = 0;                  # do we want debugging output?
  12. my $WAIT = 300;                 # how many seconds to wait between reads
  13. my $ONCE = 0;                   # run only once?
  14. my $UT = 0;                     # display timestamp in Unix format?
  15. my $DONE = 0;
  16. my $now;
  17. my $TS=1;                       # do we want timestamps at all? (yes)
  18. my $C=1;                        # display C to denote Celsius? (yes)
  19. my $P = "/dev/ttyS0";           # default serial port to monitor
  20.  
  21. my %Options;
  22. $ok = getopts('t:w:1uhdnc', \%Options);
  23.  
  24. if (defined $Options{h}) {
  25.         print "logger.pl version: $V\n";
  26.         print "Program to read temperature data from Papouch serial temp probe\n";
  27.         print "Possible options:\n";
  28.         print "-h       Help (this output)\n";
  29.         print "-d       print debugging output\n";
  30.         print "-c       Don't print C for celsius after values?\n";
  31.         print "-n       Don't display timestamps\n";
  32.         print "-1       Output temperature and exit\n";
  33.         print "-u       show timestamp in Unix format (seconds since epoch)\n";
  34.         print "-t x     read data from /dev/ttySx (default: $P) \n";
  35.         print "-w N     wait N seconds between readouts (default $WAIT)\n";
  36.         exit 0;
  37.         }
  38.  
  39. $ONCE  = 1 if defined $Options{1};
  40. $DEBUG = 1 if defined $Options{d};
  41. $TS    = 0 if defined $Options{n};
  42. $C     = 0 if defined $Options{c};
  43.  
  44. $WAIT = $Options{w} if defined $Options{w};
  45. $UT   = $Options{u} if defined $Options{u};
  46.  
  47. if (defined $Options{t}) {
  48.         $P = "/dev/ttyS";
  49.         $P .= $Options{t};
  50.         }
  51.  
  52. $DEBUG && print "monitoring serial port: $P\n";
  53. $DEBUG && print "wait interval is $WAIT\n";
  54. $DEBUG && print "run once? $ONCE\n";
  55. $DEBUG && print "Unix timestamps? $UT\n";
  56.  
  57. # Serial Port initialization
  58. my $port=Device::SerialPort->new($P) || die "cannot open $P: $!";
  59.  
  60. $port->user_msg(ON);
  61. $port->error_msg(ON);
  62. $DEBUG && $port->debug($DEBUG);
  63.  
  64. $port->baudrate(9600)    || die "failed setting baudrate";
  65. $port->parity("none")    || die "failed setting parity";
  66. $port->databits(8)       || die "failed setting databits";
  67. $port->stopbits(2)       || die "failed setting databits";
  68. $port->handshake("none") || die "failed setting handshake";
  69. $port->write_settings    || die "cannot write settings";
  70.  
  71. # unset RTS and DTR
  72. $port->rts_active(0);
  73. $port->dtr_active(0);
  74. sleep 1;                # just a little wait to be sure we get stable data later on
  75.  
  76. if (($port->can_modemlines) && $DEBUG) {
  77.         $ModemStatus = $port->modemlines;
  78.         if ($ModemStatus & $port->MS_RTS_ON) { print "RTS ON\n"; }
  79.         else { print "RTS OFF\n"; }
  80.         if ($ModemStatus & $port->MS_DTR_ON) { print "DTR ON\n"; }
  81.         else { print "DTR OFF\n"; }
  82.         print "\n";
  83.         }
  84.  
  85. # by setting RTS and DTR high we supply power to the device
  86. # and in return it will supply us with data
  87. $port->rts_active(1);
  88. $port->dtr_active(1);
  89.  
  90. if (($port->can_modemlines) && $DEBUG) {
  91.         $ModemStatus = $port->modemlines;
  92.         if ($ModemStatus & $port->MS_RTS_ON) { print "RTS ON\n"; }
  93.         else { print "RTS OFF\n"; }
  94.         if ($ModemStatus & $port->MS_DTR_ON) { print "DTR ON\n"; }
  95.         else { print "DTR OFF\n"; }
  96.         print "\n";
  97.         }
  98.  
  99. $port->read_char_time(0);     # don't wait for each character
  100. $port->read_const_time(1000); # 1 second per unfulfilled "read" call
  101.  
  102. while (!$DONE) {
  103.   my ($count,$saw)=$port->read(8);              # we should get 8 chars
  104.   if ($count> 0) {
  105.  
  106.         $port->rts_active(0);                   # power-off device for now
  107.         $port->dtr_active(0);
  108.  
  109.         $saw =~ s/([\+\-]\S+C)\r/$1/e;          # value will be something like: +020.9C^M or -001.3C^M
  110.                                                 # so we want to strip of the ^M (\r)
  111.         if (!$C) { $saw =~ s/(\S+)C/$1/e; }     # strip of the C char
  112.         if ($TS) {
  113.            if ($UT) {
  114.               $now = time;                      # UNIX timestamp
  115.               }
  116.            else {
  117.               $now = localtime time;            # human readable timestamp
  118.               }
  119.            printf "%s\t%s\n", $now,$saw;
  120.            }
  121.         else {
  122.            printf "%s\n", $saw;                 # output just the data
  123.            }
  124.  
  125.         if ($ONCE) {                            # are we done?
  126.            $DONE = 1;
  127.            }
  128.         else {
  129.            sleep $WAIT;                         # sleep a little while before reading the next value
  130.            $port->rts_active(1);                # power-on
  131.            $port->dtr_active(1);
  132.            }
  133.         }
  134.   else {
  135.         print "ERR: we got $count bytes of data\n";
  136.         }
  137. }
  138.  
  139. $port->rts_active(0);                   # power-off device
  140. $port->dtr_active(0);
  141. undef $port;

You can download the code from here: logger.pl

So now we got something which displays the output from the temperature sensors, but i wanted a nice graph of the information. Most people with a little Linux experience will see where this is going, rrdtool to the rescue!
Rrdtool is a very handy utility if you want to put anything (and i mean ANYthing) in a graph. It's name stands for "Round Robin Database Tool" and that is wat it uses. In a round robin database values are stored untill the specified storage is used up and then the oldest data gets overwritten with new entries.
So to get a graph of one day of temperature data which i sample every 5 minutes, i would have to define a round robin archive of 288 (24 x 12) entries. Apart from the day graph you also want week, month and year graphs and thats easilly specified in one go.

On Fedora Core 3 we can install rrdtool using yum like this:

yum install rrdtool

All dependencies are automagically resolved. Debian users of course have theire trusty apt-get to do this, there is emerge for Gentoo users, Yast for Suse, and so on. If you are a die-hard, you can fetch the code and compile it yourself but there is a lot to be said for package management. When you install the software, the perl modules are automatically installed with it.

In the code below you can see that there are two DataSources (DS) defined, one in-temp for the temperature sensor in the room, and out-temp for the outdoor sensor. For both DataSources we have 4 Round Robin Archives (RRA). The DS is of type GAUGE which is what you would use for temperature readout. Other options are COUNTER, DERIVE, ABSOLUTE and COMPUTE.
If you want to get started yourself with rrdtool, the best thing to do is read the rrdtutorial. Or of course get somebody elses code and adapt it to your own needs.

Here is the perl code to create all the rrd stuff:

PLAIN TEXT
PERL:
  1. #!/usr/bin/perl
  2. #
  3. # (c) 20060318 by Ewald
  4. # http://www.oiepoie.nl
  5.  
  6.  
  7. use RRDs;
  8.  
  9. sub CreateGraph
  10. {
  11. # creates the graph
  12. # input: $_[0]: interval (ie, day, week, month, year)
  13. #        $_[1]: $rrd
  14. #        $_[2]: $img
  15.  
  16.         my $rrd = $_[1];
  17.         my $img = $_[2];
  18.  
  19.         RRDs::graph "$img/logger-$_[0].png",
  20.                 "--lazy",
  21.                 "-s -1$_[0]",
  22.                 "-t Leiden temperature ",
  23.                 "-h", "200", "-w", "600",
  24.                 "-a", "PNG",
  25.                 "-v degrees C",
  26.  
  27.                 "DEF:intemp=$rrd/logger.rrd:in-temp:AVERAGE",
  28.                 "LINE2:intemp#FF0000:Room    Temperature",
  29.                 "GPRINT:intemp:MIN:  Min\\: %2.lf",
  30.                 "GPRINT:intemp:MAX: Max\\: %2.lf",
  31.                 "GPRINT:intemp:AVERAGE: Avg\\: %4.1lf",
  32.                 "GPRINT:intemp:LAST: Current\\: %2.lf degrees C\\n",
  33.  
  34.                 "DEF:outtemp=$rrd/logger.rrd:out-temp:AVERAGE",
  35.                 "LINE3:outtemp#0000FF:Outside Temperature",
  36.                 "GPRINT:outtemp:MIN:  Min\\: %2.lf",
  37.                 "GPRINT:outtemp:MAX: Max\\: %2.lf",
  38.                 "GPRINT:outtemp:AVERAGE: Avg\\: %4.1lf",
  39.                 "GPRINT:outtemp:LAST: Current\\: %2.lf degrees C\\n";
  40.  
  41.         if ($ERROR = RRDs::error) { print "$0: unable to generate $_[0] graph: $ERROR\n"; }
  42. }
  43.  
  44. # location of rrdtool databases
  45. my $rrd = '/var/rrd';
  46. # location where the images should go
  47. my $img = '/oiepoie/rrdtool';
  48.  
  49. # get temp for inside and outside sensors
  50. my $tempIN  = `/usr/local/bin/logger.pl -1 -n -c -t 1`;
  51. chop($tempIN);
  52. my $tempOUT = `/usr/local/bin/logger.pl -1 -n -c -t 0`;
  53. chop($tempOUT);
  54.  
  55. # if rrdtool database doesn't exist, create it
  56. if (! -e "$rrd/logger.rrd")
  57.         {
  58.                 print "creating rrd database ...\n";
  59.                 RRDs::create "$rrd/logger.rrd",
  60.                         "-s 300",
  61.                         "DS:in-temp:GAUGE:600:-20:100",
  62.                         "DS:out-temp:GAUGE:600:-20:100",
  63.                         "RRA:AVERAGE:0.5:1:576",
  64.                         "RRA:AVERAGE:0.5:6:672",
  65.                         "RRA:AVERAGE:0.5:24:732",
  66.                         "RRA:AVERAGE:0.5:144:1460";
  67.         }
  68.  
  69. # insert value into rrd
  70. RRDs::update "$rrd/logger.rrd", "-t", "in-temp:out-temp", "N:$tempIN:$tempOUT";
  71. if ($ERROR = RRDs::error) { print "$0: unable to update $rrd/logger.rrd: $ERROR\n"; }
  72.  
  73. # create graphs
  74. &CreateGraph("day",$rrd,$img);
  75. &CreateGraph("week",$rrd,$img);
  76. &CreateGraph("month",$rrd,$img);
  77. &CreateGraph("year",$rrd,$img);

Of course you have to make sure that you have write priviledge in the apropriate directories. Both programs do not need root priviledges (and hence should not be run as root just from a security perspective).

You can download the code from here: rrd_logger.pl

Add an entry in cron to run the stuff every 5 minutes:

*/5 * * * * /usr/local/bin/rrd_logger.pl > /dev/null

If you're curious what the output looks like,
it's right on my website