Arduino has a built-in analog-to-digital converter, so you can read the MQ-2 with a call to analogRead(). Use the potentiometer on the breakout board to adjust its sensitivity.

Figure 4-2. MQ-2 sensor circuit for Arduino

// mq_x_smoke_sensor.ino - print smoke level to serial
// (c) BotBook.com - Karvinen, Karvinen, Valtokari

const int sensorPin = A0;
int smoke_level = -1;   // 

void setup() {
  Serial.begin(115200); // bit/s
  pinMode(sensorPin, INPUT);
}

void loop() {
  smoke_level = analogRead(sensorPin);  // 
  Serial.println(smoke_level);
  if(smoke_level > 120) {       // 
    Serial.println("Smoke detected");
  }
  delay(100); // ms
}

Figure 4-3. Lento alarm designed by Paola Suhonen

The Raspberry Pi needs an external analog-to-digital converter (ADC) to read the MQ-2. Similar to other analog resistance sensors (see Compound Eye Code and Connections for Raspberry Pi), you can use a cheap MCP3002 chip for this conversion.

Figure 4-4. MQ-2 sensor circuit for Raspberry Pi

# mq_x_smoke_sensor.py - print smoke level
# (c) BotBook.com - Karvinen, Karvinen, Valtokari
import time
import botbook_mcp3002 as mcp   # 

smokeLevel = 0

def readSmokeLevel():
        global smokeLevel
        smokeLevel = mcp.readAnalog()   # 

def main():
  while True:   # 
    readSmokeLevel()    # 
    print("Current smoke level is %i " % smokeLevel)    # 
    if smokeLevel > 120:
      print("Smoke detected")
    time.sleep(0.5) # s

if __name__ == "__main__":
  main()

There is a good reason why fire alarms are attached to the ceiling instead of the floor. Smoke is usually created by fire, so it’s warmer than the air around it. Warming makes gases less dense or, in other words, lighter.

Figure 4-5. Smoke goes up

Use the smoke and gas sensor code and extinguish a match next to it. How high can you hold the extinguished match and still get a reading? When you reach the same level with the sensor you won’t likely see any difference to normal air. As the experiment title says: smoke goes up. This is why there is nothing to measure if you let the warm smoke escape to heights above the sensor.

A Breathalyzer is used for checking whether a person has alcohol in his blood. More specifically, ethanol, the alcohol found in wine, beer, and liquor.

The MQ-3 alcohol sensor looks a lot like the other MQ series gas sensors. (see Figure 4-6).

Figure 4-6. MQ-3 alcohol sensor

Just as the gas exchange in lungs brings in oxygen and gets rid of carbon dioxide, some blood alcohol is released in the air you exhale. This is the alcohol measured by an alcometer.

The more ethanol in your blood, the more there is in the air you exhale. Blood alcohol content gives a good indication how drunk a person is.

Even though more alcohol in blood makes the same person more drunk, the drunkenness differs from person to person. For making laws, a typical value is chosen as the limit. For example, the limit for DUI charges in Finland is 0.5%.

Officially accepted alcometers are calibrated periodically to get reliable readings. Alcometers use a built-in formula to estimate blood alcohol content from exhaled air alcohol content.

Figure 4-7 shows the Arduino circuit for the MQ-3, and the Arduino sketch is shown in Example 4-3. You can find the Raspberry Pi circuit in Figure 4-8 and the Python code in Example 4-4.

Figure 4-7. MQ-3 sensor circuit for Arduino

// mq_3_alcohol_sensor.ino - print alcohol value and limit digital info.
// (c) BotBook.com - Karvinen, Karvinen, Valtokari


const int analogPin = A0;
const int digitalPin = 8;

int limit = -1;
int value = 0;

void setup() {
  Serial.begin(115200);
  pinMode(digitalPin,INPUT);
}

void loop()
{
  //Read analog value
  value = analogRead(analogPin);
  //Check if alcohol limit is breached
  limit = digitalRead(digitalPin);
  Serial.print("Alcohol value: ");
  Serial.print(value);
  Serial.print(" Limit: ");
  Serial.println(limit);
  delay(100);
}

Figure 4-8. MQ-3 sensor circuit for Raspberry Pi

# mq_3_alcohol_sensor.py - read digital output from alcohol sensor
# (c) BotBook.com - Karvinen, Karvinen, Valtokari

import time
import botbook_gpio as gpio

def readLimit():
  limitPin = 23
  gpio.setMode(limitPin,"in")
  return gpio.read(limitPin)


def main():
  while True:
    if readLimit() == gpio.HIGH:
      print("Limit breached!")
    time.sleep(0.5)

if __name__ == "__main__":
  main()

Drinking alcohol while trying to learn electronics would be slightly counterproductive. The good news is that you don’t need a bottle of whiskey to test your sensor. You can get impressive readings by using other products that have alcohol in them. Mouthwash and liquor candy worked really well for us.

Use the Breathalyzer code and open the serial monitor. Chew some candy or take a sip of mouthwash (don’t swallow it) and breathe into the sensor. The readings should instantly jump up. You can still get higher-than-normal levels from readings you take several minutes later.

In this project, you’ll learn:

This is an example of a project that’s easy with Raspberry Pi. Sending email automatically from Raspberry Pi is no different from automatically emailing on any Linux system.

Python is known for having “batteries included,” in that there is a library for everything. Email sending is trivial using existing libraries. Similarly, there are libraries for sending and receiving data over the Web using the HTTP protocol.

What about social media? You could adapt the program to send messages to Twitter, Facebook, or similar “social media” services. But all of these use protocols that though they are built on open technologies, are proprietary and create lock-in to their services. Those giants have rules on how they run their service—rules that could unilaterally change any day. For example, Twitter could change the number of requests you’re permitted each day or remove the functionality you’ve grown to depend on. Don’t build your sand castle on someone else’s private beach. Or at least know the score before you make the decision.

Connect the MQ-2 smoke sensor to Raspberry Pi, as shown in MQ-2 Code and Connection for Raspberry Pi. It’s a good idea to test the smoke sensor with just the sensor code (Example 4-2) first.

Once you’re sure it works, you can advance to sending emails in your code. Test your email credentials normally before using them in this program. For example, you could enter them into a regular mail user agent (MUA) such as Thunderbird, KMail, Claws, or, in the worst case, Outlook. Even though the example uses a Gmail account, any mail account will work.

Do you still remember how email works? In the time of Gmail and other webmail clients, it’s too easy to forget the basics.

Here we’ll describe the workings of email from the point of a mail user agent running on your local computer, not webmail. To keep things simple, we’ll just show key points in an example case.

It’s essential to remember that sending and receiving email involves two different servers (the sender’s and the recipient’s). It’s common that the sending and receiving server are in different networks, even on different continents.

When you click Send in your mail user agent, your computer contacts your SMTP server. The SMTP can be in your local network, run by your ISP (such as smtp.verizon.net or smtp.comcast.net) and may accept all connections originating within its network without password or login. Or it could be run by your email provider (such as smtp.gmail.com, mail.gmx.com), and require TLS/SSL encryption and login. When your email is accepted, the SMTP server will deliver your message to the recipient.

When your recipient checks her mail, her mail user agent contacts an IMAP server. This is run by her email provider (such as Gmail or GMX) or her ISP. Reading private email of course requires a login and password, and common sense dictates that one should use encryption (SSL/TLS) when connecting (most email providers require encryption). From the IMAP server, a mail user agent can download message headers and full copies of messages. And when someone sends you an email, the reverse happens: her mail user agent contacts her SMTP server, delivers it to your mail server, and when you check your mail, you retrieve your copy of the email from your IMAP server.

A typical way to build a similar project with Arduino would use an external computer. The Arduino would read the smoke sensor and communicate this value to a desktop computer using serial over USB. On the desktop computer, a Python program could read serial (with the pySerial API) and send the email just as shown in the next example.

But even with an Ethernet or WiFi shield, it would be difficult for you to send mail from Arduino. Although the email protocol is, on its surface, fairly simple, there are enough possible surprises when sending an email that it would be hard to write a reliable SMTP library for Arduino (also, many servers require SSL, and the Arduino Uno and similar models don’t support this).

Obviously, it is easier to do this project with Raspberry Pi, or a similarly capable microcontroller board such as the BeagleBone (or the Arduino/Linux hybrid Arduino Yún).

We used a general-purpose enclosure for packaging our email smoke alarm (see Figure 4-10). These boxes look ascetic but are available widely, and their rubber covered ready-made holes make modifications fast and easy.

Figure 4-10. General-purpose enclosure

A hole for the smoke sensor is the only one you need to drill (see Figure 4-11). Others can be made by carefully applying a sharp knife to the rubber-covered openings. Actually, you could use those for the sensor also, but as they tend to look pretty rough we prefer to use them for the cables only. A 19 mm drill bit was a perfect match for the sensor and we didn’t need any adhesives to keep it in place, as shown in Figure 4-12.

Figure 4-11. Hole for the smoke sensor

Figure 4-12. Sensor in place

To prevent the Raspberry Pi from moving around inside the box, we secured it with Velcro to the bottom, as shown in Figure 4-13. This way it’s easy to remove it for debugging or to use in other projects.

Figure 4-13. Raspberry Pi’s Velcro attachement

We glued a mini breadboard to the bottom of the lid of the box (see Figure 4-14). Then, we used a zip tie to keep the jumper wires in a neat bundle.

We made one large hole (~2 cm) to the side for the LAN and power cables (see Figure 4-15). We wanted the smallest possible holes in the final gadget, so in our version we don’t have inlets for the other cables (see Figure 4-16).

Figure 4-14. Mini breadboard with zip-tied wires

Figure 4-15. Hole for the cables

Figure 4-16. Cables attached

Now just close the lid and you’re ready for some testing as shown earlier in Figure 4-9. And while placing your alarm, remember which way the smoke goes.

Your gadget now has an “electrical nose.” Using the family of MQ sensors, you can detect gases that are poisonous (CO), flammable (hydrocarbons), explosive (hydrogen), or that reveal intoxication (ethanol in breath).

In the project, you wrote a Python program to react to changes in the environment. You can adapt this program to react to events from other sensors. Alternatively, the reaction could be things other than email, such as contacting a web service or activating an output.

Gas sensors detect things that are difficult or impossible for our human senses to see. In the next chapter, you’ll sense a more visible phenomenon, touch.