The program to the right tests whether you can control the meter.

You will need to adjust the range of pwmValue depending on your meter’s sensitivity. The meters used to design this project had different ranges. The meter in the parts list responds to a 0- to 5-volt range, so the preceding program moves it from its bottom to its top. The antique meter, on the other hand, responds to 0 to 3 volts, so it was necessary to limit the range of pwmValue to 0–165. When it was at 165, the meter reached its maximum. Note your meter’s minimum and maximum values. You’ll use them later to scale the air-quality reading to the meter’s range.

/*
    Voltmeter Tester
    Uses analogWrite() to control a voltmeter.
    Context: Arduino
*/
const int meterPin = 9;

int pwmValue = 0;  // the value used to set the meter

void setup() {
  Serial.begin(9600);
}

void loop() {
  // move the meter from lowest to highest values:
  for (pwmValue = 0; pwmValue < 255; pwmValue ++) {
    analogWrite(meterPin, pwmValue);
    Serial.println(pwmValue);
    delay(10);
  }
  delay(1000);
  // reset the meter to zero and pause:
  analogWrite(meterPin, 0);
  delay(1000);
}

This PHP script opens the AIRNow web page and prints it line by line. The fgetss() command reads a line of text and removes any HTML tags.

When you save this file on your web server and open it in a browser, you should get the text of the AIRNow page without any HTML markup or images. It’s not very readable in the browser window, but if you view the source code (use the View Source option in your web browser), it looks a bit better. Scroll down and you’ll find some lines like this:

Current Conditions
Air Quality Index (AQI)
observed at 17:00 EST
45

These are the only lines you care about.

<?php
/*
    AIRNow Web Page Scraper
    Context: PHP
*/
    // Define variables:
    // url of the page with the air quality index data for New York City:
    $url =
      'http://airnow.gov/index.cfm?action=airnow.showlocal&cityid=164';

    // open the file at the URL for reading:
    $filePath = fopen ($url, "r");

    // as long as you haven't reached the end of the file:
    while (!feof($filePath))
    {
        // read one line at a time, and strip all HTML and
        // PHP tags from the line:
        $line = fgetss($filePath, 4096);
        echo $line;
    }
    // close the file at the URL, you're done:
    fclose($filePath);
?>

To extract the data you need from those lines, you’ll need a couple more variables. Add this code before the fopen() command.

// whether you should check for a value
       // on the line you're reading:
       $checkForValue = false;

       // value of the Air Quality reading:
       $airQuality = −1;

Replace the command echo $line; in the program with the block of code at right.

This block uses the preg_match() command to look for a string of text matching a pattern you give it. In this case, it looks for the pattern Current Conditions. When you see that line, you know the next line is the number you want. When the PHP script finds that line, it sets the variable $checkForValue to true.

// if the current line contains the substring "Current Conditions"
        // then the next line with an integer is the air quality:
        if (preg_match('/Current Conditions/', $line)) {
           $checkForValue = true;
 }

Now, add the following block of code after the one you just added. This code checks to see whether $checkForValue is true, and whether the line contains an integer and nothing else. If so, the program reads the next line of text and converts it from a string to an integer value. It will only get a valid integer when it reaches the line with the AQI value.

if ($checkForValue == true && (int)$line > 0){
                         $airQuality = (int)$line;
                         $checkForValue = false;
        }

Finally, add the following lines at the end of the script, after the while loop. This prints out the air-quality reading and closes the connection to the remote site.

The result in your web browser should look like this:

Air Quality: 43

Now you’ve got a short string of text that your microcontroller can read. Even if the script got no result, the value −1 will tell you that there was no connection.

echo "Air Quality:". $airQuality;
    // close the file at the URL, you're done:
    fclose($filePath);

The program starts out by including the SPI and Ethernet libraries, just as in the previous project. Then define the output pins, the minimum and maximum values for the meter that you determined earlier, and the time between HTTP requests using constant integers.

/*
  AirNow Web Scraper
 Context: Arduino
 */
#include <SPI.h>
#include <Ethernet.h>
#include <TextFinder.h>

const int connectedLED = 2;          // indicates a TCP connection
const int successLED = 3;            // indicates a successful read
const int resetLED = 4;              // indicates reset of Arduino
const int disconnectedLED = 5;       // indicates connection to server
const int meterPin = 9;              // controls VU meter
const int meterMin = 0;              // minimum level for the meter
const int meterMax = 200;            // maximum level for the meter
const int AQIMax = 200;              // maximum level for air quality
const int requestInterval = 10000;   // delay between updates to the server

This project uses numeric IP addresses rather than names. If you need to find a host’s IP address, use the ping command mentioned in Chapter 3. For example, if you open a command prompt and type ping -c 1 www.oreillynet.com, (use -n instead of -c on Windows), you will get the following response, listing the IP address you need:

PING www.oreillynet.com (208.201.239.37): 56 data bytes
64 bytes from 208.201.239.37: icmp_seq=0 ttl=45 time=97.832 ms

If you can’t use ping (some service providers block it, since it can be used for nefarious purposes), you can also use nslookup. For example, nslookup google.com will return the following:

Server: 8.8.8.8

Address: 8.8.8.8#53

nslookup returns the Domain Name Server it used to do the lookup as well.

Non-authoritative answer:
Name: google.com
Address: 173.194.33.104

Any one of the addresses listed will point to it’s associated name, so you can use any of them.

Next, initialize a few array variables with the network configuration for the module.

byte mac[] = { 0x00, 0xAA, 0xBB, 0xCC, 0xDE, 0x01 };
IPAddress ip(192,168,1,20);
IPAddress server(208,201,239,101 );

Change these to match your own device and server.

The last global variables you need to add are for the EthernetClient class, and a few variables relating to the transaction with the server.

// Initialize the Ethernet client library
EthernetClient client;

boolean requested;           // whether you've made a request
long lastAttemptTime = 0;    // last time you connected to the server
int airQuality = 0;          // AQI value
boolean meterIsSet = false;  // whether the meter is set

setup() starts the serial and Ethernet connections, sets all the LED pins to be outputs, blinks the reset LED, and makes an initial attempt to connect to the server.

void setup() {
  // start the Ethernet connection:
  Ethernet.begin(mac, ip);
  // start the serial library:
  Serial.begin(9600);
  // set all status LED pins:
  pinMode(connectedLED, OUTPUT);
  pinMode(successLED, OUTPUT);
  pinMode(resetLED, OUTPUT);
  pinMode(disconnectedLED, OUTPUT);
  pinMode(meterPin, OUTPUT);

  // give the Ethernet shield a second to initialize:
  delay(1000);
  // blink the reset LED:
  blink(resetLED, 3);
  // attempt to connect:
  connectToServer();
}

The blink() method called in the setup blinks the reset LED so you know the microcontroller’s main loop is about to begin.

void blink(int thisPin, int howManyTimes) {
  //     Blink the reset LED:
  for (int blinks=0; blinks< howManyTimes; blinks++) {
    digitalWrite(thisPin, HIGH);
    delay(200);
    digitalWrite(thisPin, LOW);
    delay(200);
  }
}

The loop() contains all the logic laid out in Figure 4-11. If the client is connected to the server, it makes an HTTP GET request. If it’s made a request, it uses TextFinder to search the response for the air-quality string and then sets the meter. If the client isn’t connected to the server, it waits another two minutes until the request interval’s passed, and tries to connect again.

void loop()
{
  // if you're connected, save any incoming bytes
  // to the input string:
  if (client.connected()) {
    if (!requested) {
      requested = makeRequest();
    }
    else {
      // make an instance of TextFinder to search the response:
      TextFinder response(client);
      // see if the response from the server contains the AQI value:
      if(response.find("Air Quality:"))  {
        // convert the remaining part into an integer:
        airQuality = response.getValue();
        // set the meter:
        meterIsSet = setMeter(airQuality);
      }
    }
  }
  else if (millis() - lastAttemptTime > requestInterval) {
    // if you're not connected, and two minutes have passed since
    // your last connection, then attempt to connect again:
    client.stop();
    connectToServer();
  }

  // set the status LEDs:
  setLeds();
}

Both setup() and loop() attempt to connect to the server using the connectToServer() method. If it gets a connection, it resets the requested variable so the main loop knows it can make a request.

void connectToServer() {
  // clear the state of the meter:
  meterIsSet = false;

  // attempt to connect, and wait a millisecond:
  Serial.println("connecting...");
  if (client.connect(server, 80)) {
    requested = false;
  }
  // note the time of this connect attempt:
  lastAttemptTime = millis();
}

Once the client’s connected, it sends an HTTP GET request. Here’s the makeRequest() method. It returns a true value to set the requesting variable in the main loop, so the client doesn’t request twice while it’s connected.

The server replies to makeRequest() like so:

HTTP/1.1 200 OK
Date: Fri, 14 Nov 2010 21:31:37 GMT
Server: Apache/2.0.52 (Red Hat)
Content-Length: 10
Connection: close
Content-Type: text/html; charset=UTF-8

 Air Quality: 65

boolean makeRequest() {
  // make HTTP GET request and fill in the path to
  // the PHP script on your server:
  client.println("GET /~myaccount/scraper.php HTTP/1.1\n");
  // fill in your server's name:
  client.print("HOST:example.com\n\n");
  // update the state of the program:
  client.println();
  return true;
}

Change these to match your own server name and path.

Once the client’s found the air-quality string and converted the bytes that follow into an integer, it calls setMeter() to set the meter with the result it obtained. You might want to adjust the AQIMax value to reflect the typical maximum for your geographic area.

boolean setMeter(int thisLevel) {
  Serial.println("setting meter...");
  boolean result = false;
  // map the result to a range the meter can use:
  int meterSetting = map(thisLevel, 0, AQIMax, meterMin, meterMax);
  // set the meter:
  analogWrite(meterPin, meterSetting);
  if (meterSetting > 0) {
    result = true;
  }
  return result;
}

The last thing you need to do in the main loop is set the indicator LEDs so that you know where you are in the program. You can use the client.connected() status and the meterIsSet variable to set each of the LEDs.

That’s the whole program. Once you’ve got this program working on the microcontroller, the controller will make the HTTP GET request once every ten minutes and set the meter accordingly.

void setLeds() {
  // connected LED and disconnected LED can just use
  // the client's connected() status:
  digitalWrite(connectedLED, client.connected());
  digitalWrite(disconnectedLED, !client.connected());
  // success LED depends on reading being successful:
  digitalWrite(successLED, meterIsSet);
}