Effing the Ineffable

After describing how to hook up your CurrentCost meter to your PC, it’s now time to see what else we can hook it up to. An obvious candidate is the Arduino microcontroller. For this project I’m using an Arduino Diecimila, which can be obtained quite cheaply from tinker.it in the UK.

Despite building our TTL->RS232 adapter in the previous post, it turns out that we don’t actually need it to interface with the Arduino - as with most microcontrollers, it expects TTL-level inputs. This makes the wiring trivially simple - we merely need to hook up the ground and data leads from the CurrentCost meter to the ground and one of the digital pins on the Arduino. As a reminder, pin 6 on the RJ45 connector is ground, and pin 7 is our data lead.

The Arduino has one hardware serial port which we could connect the CurrentCost data lead up to, but as the CurrentCost device only runs at 9600 baud, it seems a shame to waste our only high-speed serial port. Instead, we’re going to use the SoftwareSerial library to emulate a serial port on one of the other digital I/O pins - for this example, I chose digital pin 3. And that’s it - just two wires to connect!

Now we have the CurrentCost meter hooked up to the Arduino, it’s time to get it to do something! A good first step it to simply check that the Arduino is getting data from the CurrentCost device - to do this we’re simply going to read data in on the software serial port, and output it on the hardware serial port, which by default will be sent over the USB link to the host PC. The sketch for this follows:

/*
  CurrentCost test sketch

  Example CurrentCost sketch that simply reads in data from the CurrentCost
  device via the software serial port and outputs that data over the hardware
  serial port.

  by Alexis Birkill
  written: 16 June 2008

*/

// Include the SoftwareSerial library so you can use its functions.
// We're using the software serial library as the Arduino only  has one
// hardware serial port, and it's a shame to waste it on a 9600bps device.
#include <SoftwareSerial.h>

// Define the pins used for the software serial port.  Note that we won't
// actually be transmitting anything over the transmit pin.
#define rxPin 3
#define txPin 4

// Set up the serial port
SoftwareSerial softSerial =  SoftwareSerial(rxPin, txPin);

void setup()  {
  // Define pin modes for tx and rx pins:
  pinMode(rxPin, INPUT);
  pinMode(txPin, OUTPUT);
  // Set the data rate for the SoftwareSerial port
  softSerial.begin(9650);

  // Set the data rate for the hardware serial port
  Serial.begin(9600);
}

void loop() {
  // Listen for serial data coming in...
  char someChar = softSerial.read();

  // And send it back out...
  Serial.print(someChar);
}

Simply upload this to your Arduino and then open the Arduino serial port at 9600 baud (the Arduino IDE has this functionality built in - look for the ‘Serial Monitor’ option in the toolbar). If all goes well, you should see XML data output roughly every six seconds.

The more eagle-eyed amongst you will notice that I’m configuring the software serial port at 9650 baud, rather than 9600 baud. When I initially tried 9600 baud, I found that I would get certain characters corrupted. I’m not sure whether the CurrentCost device timing is slightly out, or whether the SoftwareSerial library is slightly off, or a bit of both, but changing it to 9650 baud fixed it. That’s why this simple script is really useful to check that everything is working correctly.

Now we have a simple script working, it’s time to put our Arduino to work. This next script parses out the current wattage figure from the XML data (as most of the time that’s the data you want to see), and also applies some damping - the CurrentCost reading tends to fluctuate slightly, and it’s not worth reporting every minor change. Finally, we’ll also switch one of the digital outputs on if we exceed a certain power figure - this sketch uses pin 13, which on the Diecimila has an LED hooked up to it, but you could use it to drive a bell or buzzer to alert you that you’re using a lot of power - or many other cool things!

/*
  CurrentCost data parser

  Example CurrentCost parser that reads in the serial data from the
  CurrentCost device and outputs the current wattage over the hardware
  serial port.

  by Alexis Birkill
  written: 16 June 2008

*/

// Include the SoftwareSerial library so you can use its functions.
// We're using the software serial library as the Arduino only  has one
// hardware serial port, and it's a shame to waste it on a 9600bps device.
#include <SoftwareSerial.h>

// Define the pins used for the software serial port.  Note that we won't
// actually be transmitting anything over the transmit pin.
#define rxPin 3
#define txPin 4

// Define the pin that will go high when the wattage exceeds a certain limit.
#define alertPin 13

// Set up the serial port
SoftwareSerial softSerial =  SoftwareSerial(rxPin, txPin);

// Local variables
char wattsStr[5];
int watts = 0;
int previousWatts = 0;

// Damping factor to filter out minor fluctuations - a fluctuation up or down
// by less than this value will be ignored.
int dampingFactor = 10;

// Wattage at which to activate alert output
int alertLevel = 800;

void setup()  {
  // Define pin modes for tx and rx pins:
  pinMode(rxPin, INPUT);
  pinMode(txPin, OUTPUT);
  // Set the data rate for the SoftwareSerial port
  softSerial.begin(9650);

  // Set the data rate for the hardware serial port
  Serial.begin(9600);
}

void loop() {
  // Listen for serial data coming in:
  char someChar = softSerial.read();

  // This is a rather horrible but simple way of looking for the correct data
  // without bothering to store any unnecessary data in the Arduino's memory.
  // We could simply store the whole XML string and then parse it, but that
  // would take up a lot of memory unnecessarily.  Instead, we just look for
  // the right character sequence.
  if(someChar == '<') {
    someChar = softSerial.read();
    if(someChar == 'c') {
     someChar = softSerial.read();
     if(someChar == 'h') {
      someChar = softSerial.read();
      if(someChar == '1') {
       someChar = softSerial.read();
       if(someChar == '>') {
        someChar = softSerial.read();
        if(someChar == '<') {
         someChar = softSerial.read();
         if(someChar == 'w') {
          someChar = softSerial.read();
          if(someChar == 'a') {
           someChar = softSerial.read();
           if(someChar == 't') {
            someChar = softSerial.read();
            if(someChar == 't') {
             someChar = softSerial.read();
             if(someChar == 's') {
              someChar = softSerial.read();
              if(someChar == '>') {

               // We got the right sequence - that means that the next five
               // characters are the current wattage.
               wattsStr[0] = softSerial.read();
               wattsStr[1] = softSerial.read();
               wattsStr[2] = softSerial.read();
               wattsStr[3] = softSerial.read();
               wattsStr[4] = softSerial.read();

               // Convert it into a integer.
               watts = atoi(wattsStr);

               // Add some damping so we don't display minor fluctuations
               if(previousWatts + dampingFactor < watts || previousWatts - dampingFactor > watts)
               {
                 // Value has changed by more than the damping factor - output it!
                 Serial.println(watts);
                 previousWatts = watts;
               }

               // Check if we need to switch the alert output on.
               if(watts >= alertLevel)
               {
                 digitalWrite(alertPin, HIGH);
               }
               else
               {
                 digitalWrite(alertPin, LOW);
               }
              }
             }
            }
           }
          }
         }
        }
       }
      }
     }
    }
  }

}

And there we go - the basics of getting an Arduino to process CurrentCost data!

Filed under: Projects, Electronics on June 16th, 2008