Oxygen in the atmosphere removes electrons from the tin dioxide film, which decreases its conductivity (and increases its resistance). When other types of gases, particularly those that are chemically reducing, touch the tin dioxide film, electrons are injected into the material. This increases the conductivity (and lowers the resistance) of the tin dioxide layer. You can use your Arduino to measure that change in resistance.

It’s important to keep in mind that tin dioxide sensors tend to be broadly selective. While certain sensors may be marketed as being "alcohol" sensors or "carbon monoxide" sensors, they actually respond to more than just alcohol or carbon monoxide, respectively; they respond to a wide family of similar gases. Manufacturers can make the tin dioxide-based gas sensors more selective by adding various catalysts into the sensor head, or by using external filters. The datasheet provided with each sensor explains more completely how to adjust the sensitivity of each sensor for various gases.

There are electronic sensors for a wide range of gases. As we write this book in the summer of 2012, there are easy-to-use inexpensive sensors on the market to detect carbon monoxide, carbon dioxide, liquid petroleum gas, butane, propane, methane (natural gas), hydrogen, ethyl alcohol, benzene, volatile organic compounds, ammonia, ozone, hydrogen sulfide, and more. It’s not unreasonable to expect that it won’t be long before cheap sensors hit the market that can detect nitrogen oxides and other contaminants. All of these gases count as pollutants; in varying concentrations, all of them can be harmful.

We’re going to use the MQ-2 and MQ-6 sensors from Hanwei, Inc. in this gadget. Both detect combustible gases: the MQ-6 detects butane and liquefied petroleum gas (LPG), also called propane (both hydrocarbons), while the MQ-2 is sensitive to LPG, methane (the primary component of natural gas, and a potent greenhouse gas), and smoke. We feel that both sensors together are a great way to start measuring ground-level air pollution.

A heating element in the electronic circuit heats the metal, making it more reactive with atmospheric gases. As the various gases react with the metal, the resistance changes in proportion to the amount of that gas present in the air exposed to the sensor. This change in resistance is measured by the Arduino analog port. That’s basically it.

If we plug the heater directly into Arduino, we find ourselves with a problem. The heater consumes 800 mW, which works out to equal 200 mA (.8 W / 5 V = .2 A). A standard Arduino pin can only reliably source 20 mA (in other words, only about 10% of the power the heater needs). We have correspondence from the manufacturers indicating that the heater can be powered by connecting it to the +5 V Arduino pin, but frankly, we’re skeptical. We’ve got to come up with a way to use Arduino to control the amount of power that goes to the heating units, so that the heating unit is not on constantly, without actually having Arduino provide that power.

Both these problems—providing power to the heater and controlling that power—have a single solution, probably the greatest invention of the 20th century: the transistor.

Transistors are used to amplify electronic signals cheaply and efficiently, with very little noise, while giving off very little heat (Figure 2-3). Transistors also act as tiny, efficient digital switches. Since all computer activity breaks down into a series of binary "on and off" states represented by 1s and 0s, transistors by the millions, embedded into a silicon chip, control those on and off signals.

We really can’t overstate the importance of the transistor. We don’t have room in this book to discuss the details of how transistors work; suffice it to say that the lightweight, cheap electronic gadgets in our lives—handheld cell phones, computers, digital cameras, flat screen TVs, microwave ovens, cable television, touchtone phones, simple portable AM/FM radios, essentially anything more complicated than a flashlight—would be impossible without the transistor.

Figure 2-3. Various transistors. Source: Ulf Seifert.

The first thing you notice when you look at a transistor is that unlike almost every other electronic device we’ve seen so far, a transistor has three terminals. We can control the voltage between two of the terminals by applying a specific electric current or voltage to the third terminal. The three terminals are the base, the collector, and the emitter. The base is the controller; voltage applied here determines whether or not electricity flows from the collector to the emitter. The collector is the "source" of the electrical current, and the emitter is the output.

If we were to send varying levels of current from the base, we can regulate the amount of current flowing from the collector to the emitter. This is how a transistor acts as an amplifier: a very low signal coming into the base is repeated at a much larger voltage provided by the collector.

When we use a transistor as a switch, the circuitry is even simpler. A transistor switch is either fully on or fully off. A small data signal to the base determines whether the transistor is switched on or off. When it is switched on, current flows between the ground and the collector. This simple setup lets us use Arduino to turn on components that have a separate power supply.

Figure 2-4. Step one. Source: these images were created with Fritzing.

Figure 2-5. Step two.

Figure 2-6. Step three.

Figure 2-7. Step four.

Figure 2-8. Step five.

Figure 2-9. Step six.

Figure 2-10. Step seven.

This device takes an input current (up to 35 volts), and changes it to a stable, fixed +5 VDC. In our example, we’re using a standard 9 volt battery at the current source, but you can use just about anything: a 6 volt lantern battery, two 3.7 volt lithium polymer batteries connected in series, even a bunch of AA batteries. The total capacity of your power source should be your main determining factor: smaller batteries generally provide fewer amp-hours, meaning that the lifespan of your gadget can be cut short if you run out of power.

Don’t connect the battery until you actually need it, or add an ON-OFF switch to power it up when you’re ready to start taking readings.

You can find this sketch in the AMWA GitHub repository.

#include <SoftwareSerial.h>
#include <SD.h>
#include <EEPROM.h>
#include<stdlib.h>

// Liquid Crystal Display
// Define the LCD pins: We'll be using a serial-based LCD display
// which only required +3.3Volts, GND, and a single data line.
// databuff and displaybuff hold the data to be displayed
#define LCDIn 2
#define LCDOut 5
SoftwareSerial mySerialPort(LCDIn, LCDOut);


// Data Buffers for the LCD
char databuff1[16];
char databuff2[16];
char dispbuff[16];

// GAS SENSORS
// Analog input pin that reads the first gas sensor
const int gasPin1 = A5;

// Analog input pin that reads the gas sensor
const int gasPin2 = A4;

// The digital pin that controls the heater of gas sensor 1
const int heaterPin1 = 7;

// The digital pin that controls the heater of gas sensor 2
const int heaterPin2 = 9;

// LED connected to digital pin 13
const int ledPin = 13;

// value read from the sensor A5
int gasVal1 = 0;

// value read from the sensor A4
int gasVal2 = 0;

long warmup = 180000;           // enter time for heaters to warmup, in milliseconds.
// 180,000 milliseconds = 3 minutes

long downtime = 360000;       // enter delay between readings, in milliseconds.
// 360,000 milli seconds = 6 minutes

//EEPROM records require two bytes to store a 1024 bit value.
//Each gas sensor returns a value from 0-1024, taking 2 bytes.
//To store gas sensor data would require a record index,
//plus two bytes for the first gas sensor, two bytes for the second gas sensor
//For a total of five bytes per record.

// current EEPROM address
int addr =0;

//EEPROM record number
int record = 0;

//EEPROM record length
int reclen = 5;

//switch to tell if an SD card is present
int SDPresent = 1;

void setup()
{
  // initialize serial communications at 9600 bps:
  Serial.begin(9600);

  pinMode(heaterPin1, OUTPUT);  // sets the digital pins as output
  pinMode(heaterPin2, OUTPUT);
  pinMode(LCDOut, OUTPUT);

  //reset the LCD
  mySerialPort.begin(9600);
  mySerialPort.write(0xFE);
  mySerialPort.write(0x01);
  sprintf(databuff1,"Wakeup Test");
  sprintf(dispbuff,"%-16s",databuff1);
  mySerialPort.print(dispbuff);

  // Set up SD card, let us know if SD card is absent
  pinMode(10, OUTPUT);
  if (!SD.begin(4))
  {
    SDPresent =0;
    sprintf(databuff2,"NO SD CARD!!!");
    sprintf(dispbuff,"%-16s",databuff2);
    mySerialPort.print(dispbuff);
    Serial.println("NO SD CARD!!!");
    delay(6000);
  }
  delay(3333);
}

void loop()
{
  long scratch=0;   // scratch variable

  // set the timer
  unsigned long counter = millis();

  //turn first heater on
  digitalWrite(heaterPin1, HIGH);

  // wait 3 minutes for heater to heat up
  while(millis() < (counter + warmup))
  {
    sprintf(databuff1,"Unit1 Activated");
    sprintf(dispbuff,"%-16s",databuff1);
    mySerialPort.print(dispbuff);

    scratch = (int)((counter+warmup - millis())/1000);
    sprintf(databuff2,"Countdown: %3d", scratch);
    sprintf(dispbuff,"%-16s",databuff2);
    mySerialPort.print(dispbuff);

    Serial.println(scratch);
  }

  // read the analog in value:
  gasVal1 = analogRead(gasPin1);
  sprintf(databuff1,"read unit 1");
  sprintf(dispbuff,"%-16s",databuff1);
  mySerialPort.print(dispbuff);

  // shut off the first heater
  digitalWrite(heaterPin1, LOW);

  //turn second heater on
  digitalWrite(heaterPin2, HIGH);
  sprintf(databuff2,"turning on unit2");
  sprintf(dispbuff,"%-16s",databuff2);
  mySerialPort.print(dispbuff);

  // wait 3 minutes for heater to heat up
  while(millis() < (counter + warmup + warmup))
  {
    sprintf(databuff1,"Unit2 Activated");
    sprintf(dispbuff,"%-16s",databuff1);
    mySerialPort.print(dispbuff);

    scratch = (int)((counter+warmup+warmup - millis())/1000);
    sprintf(databuff2,"Countdown: %3d", scratch);
    sprintf(dispbuff,"%-16s",databuff2);
    mySerialPort.print(dispbuff);

    Serial.println(scratch);
  }

  // read the analog in value:
  gasVal2 = analogRead(gasPin2);
  sprintf(databuff2,"reading unit2");
  sprintf(dispbuff,"%-16s",databuff2);
  mySerialPort.print(dispbuff);

  // shut off the second heater
  digitalWrite(heaterPin2, LOW);

  //Display on LCD
  sprintf(databuff1,"Gas1:%4d",gasVal1);
  sprintf(dispbuff,"%-16s",databuff1);
  mySerialPort.print(dispbuff);
  sprintf(databuff2,"Gas2:%4d",gasVal2);
  sprintf(dispbuff,"%-16s",databuff2);
  mySerialPort.print(dispbuff);

//write to SD card
  if(SDPresent = 1)
  {
    writeDataToSD(databuff1, databuff2);
  }

  //Wait downtime and start again
  //to make more frequent measurements, change value of downtime
  while(millis() < (counter +downtime))
  {
  }
}

void writeDataToSD(String dataString1, String dataString2)
{
  // open the file. note that only one file can be open at a time,
  // so you have to close this one before opening another.
  File dataFile = SD.open("datalog.txt", FILE_WRITE);

  // if the file is available, write to it:
  if (dataFile)
  {
    Serial.println("Hooray, we have a file!");
    dataFile.print(millis());
    dataFile.print(",");
    dataFile.print(dataString1);
    dataFile.print(",");
    dataFile.println(dataString2);

    dataFile.close();

    // print to the serial port too:
    Serial.print(millis());
    Serial.print(",");
    Serial.print(dataString1);
    Serial.print(",");
    Serial.println(dataString2);

    //Print to LCD
    mySerialPort.print("Datafile written");
  }
}

You can connect Arduino to components that display data, as well as those that store data for later use.

#include <EEPROM.h>

// start reading from the first byte (address 0) of the EEPROM

int address = 1;
int record = 0;
unsigned int Sensor1 = 0;
unsigned int Sensor2 = 0;

int q;
int m;

void setup()
{
  Serial.begin(9600);
  Serial.println("Record#, Sensor1, Sensor2");
  for(int i =0; i<=95; i++)
  {
    readData();
  }
}

void loop()
{
  // There's no need for this program to loop.  We know what we want to do,
  // and we just did it in setup().
}

void readData()
{
  record = EEPROM.read(address++);
  Serial.print(record);
  Serial.print(",");
  q = EEPROM.read(address++);
  delay(20);
  m = EEPROM.read(address++);
  delay(20);
  Sensor1 = (q*256)+m;

  Serial.print(Sensor1);
  Serial.print(",");
  q = EEPROM.read(address++);
  delay(20);
  m = EEPROM.read(address++);
  delay(20);
  Sensor2 = (q*256)+m;

  Serial.print(Sensor2);
  Serial.print(",");
  q = EEPROM.read(address++);
  delay(20);
  m = EEPROM.read(address++);
  delay(20);

 }

Of course, there’s not just one way to build a gas detector. There are many different configurations you can try (such as more or different sensors) that will provide more detailed data, but what changes (if any) will you have to make to the circuit to be sure it works properly? Will you need to beef up the batteries, or try a totally new power source? Here are some other ideas to make your gas detector more versatile.

Now we come to the strangest part of this book: the warning not to leave your gas detector unattended, anywhere, ever. Here’s why:

In May 2012, Takeshi Miyakawa, a visual artist and furniture designer in New York City, placed a portable battery-powered light inside a translucent "I Love NY" plastic shopping bag, and hung it from a metal rod attached to a tree. When the lamp was on, the bag glowed from within. A friend of the artist said he did this "to lift people’s spirits. He was simply trying to say that he loves the city and spread that attitude around."

Unfortunately for Miyakawa, someone in the neighborhood saw a contraption with wires, batteries, and plastic boxes and called the New York Police Department’s bomb squad, which evacuated the area and took two hours to determine that a battery and a light was just a battery and a light. When the police tracked the device to Miyakawa, they arrested him and charged him with two counts of first-degree reckless endangerment, two counts of placing a false bomb or hazardous substance in the first degree, two counts of placing a false bomb or hazardous substance in the second degree, two counts of second-degree reckless endangerment, and two counts of second-degree criminal nuisance. A judge ordered him sent to Bellevue hospital for psychiatric evaluation, as well.

All for hanging a light in a tree.

Miyakawa’s experience is not unique, unfortunately. In another case, researchers from Carnegie-Mellon University built similar detectors to ours, and placed them at various points around the Pittsburgh area. While the sensors were enclosed in professionally made plastic cases, and were clearly labeled as an approved research project, once again the police bomb squad was called. (The students didn’t report being arrested. However, they did say it took a great deal of negotiation with the authorities to get their equipment back.)

The US Department of Homeland Security (DHS) urges people to "be vigilant, take notice of your surroundings, and report suspicious items or activities to local authorities immediately." As a result, homemade electronic gadgets that once upon a time (at least, in the lifetimes of the authors) might have been regarded as interesting curiosities are now treated as threats. Many people don’t understand hobby electronics, and are frightened by what they do not understand. Police believe they must treat every suspicious package as if it may be harmful.

The point of telling you all this is not to scare you from building monitoring devices, but to warn you that a home-built, Arduino-based gas sensor might, to the unknowing eye, look like a box of batteries and wires and a scary thing with blinking lights. Leaving something like this unattended, without permission, on property you don’t own, can get you into a world of trouble.

The following subsections are a couple ideas for solving this problem.