An example of one of those projects was for a plumber in Philadelphia who wanted to determine if it was safe to work in a basement or other poorly ventilated areas.

He came to our web site doing a search for ‘methane detectors’ and discovered the Methane CNG Gas Sensor – MQ-4 he also saw that we did custom design and prototypes.

He approached us and asked if we would build him a methane detector as he had no electronics experience but saw everything he wanted on our site.

As we had not worked with the gas detectors before and we were dying to try out one of the Arduino Pro Mini’s we gladly took him on as a client.

Methane gas is colorless and odorless it wont kill you if you breath it but in, but in a high enough concentration it may explode.

We started by putting everything together on a small breadboard:

Methane Sensor – Breadboard

The circuit was pretty simple – we used a breakout board for the methane detector and connected the output to one of the analog inputs of the Arduino, we also decided to use a pot so that the user could specify a cut-off level where the alarm would not sound.

We provided a green LED to show the system was operational and when the gas threshold was exceeded the red LED would light up and the buzzer would sound.

The code for this is very simple – read the voltage level on the output pin of the gas sensor, compare that to the voltage level of the pot. If the sensor voltage is higher then sound the alarm. We used a FTDI Breakout to program the Arduino.

void loop() 
{
  unsigned int ADCValue,REFValue;

  ADCValue = analogRead(0);
  REFValue = analogRead(1);
  if(ADCValue>REFValue)
    alarm=1;
  else
    alarm=0;
}

Note: The sensors need to be run (burnt in) for at least 24 hours to ensure that their readings are accurate.

We have a timer interrupt running on timer 2 – it checks alarm, which is a volatile int, and if it is high the red LED and the buzzed are activated, if low the green LED.

ISR(TIMER2_OVF_vect) 
{
  RESET_TIMER2;
  counter ++;
  if(alarm)
  {
    digitalWrite(buzz, counter & 0x01);
    digitalWrite(RED, counter & 0x01);
    digitalWrite(GREEN, 0);
  }
  else
  {
    digitalWrite(buzz, 0);
    digitalWrite(GREEN, counter & 0x01);
    digitalWrite(RED, 0);
  }
}

As you can see from the above code we are using PWM to turn the LED’s on and the buzzer – the buzzer is a piezo element so it needs to be pulsed to make a noise.

Unfortunately we cannot just ship the above system to the customer, breadboards don’t even travel well from office to lab, so we grabbed on of our breadboard equivalent solder boards and soldered all the components onto it.

Methane Sensor – Prototype

Now the customer can play around with the prototype. If the customer decides to add features this can be done very easily as the arduino still has a number of open ports.

Project parts:

Go to the tron.ix page on our store to find these educational books. We will be adding the whole series in the next week or so, we will also be creating a couple of kits based on these books. Soon you will be able to impress your classmates or friends with your electronics knowledge.

Make sure you have your Arduino and a USB cable before you continue.

The very first step will be to get an interface from your PC to the Arduino – you can get download any software you need at the Arduino ‘Getting Started’ page.

From the link above you will can click on the operating system you are using and you will be able to get a Step-by-Step guide to installing the software on your computer. The guide will also instruct you on how to install the correct drivers for the model of Arduino you have.

Once you have installed the driver and configured your connection to your Arduino you can run the ‘blink’ example. This will flash one of the LED’s on your Arduino board.

Play around with making the LED blink faster, stay on longer and off shorter or even flash Morse code by editing the following lines in the demo sketch.

void loop() {
  digitalWrite(led, HIGH);   // turn the LED on (HIGH is the voltage level)
  delay(1000);               // wait for a second
  digitalWrite(led, LOW);    // turn the LED off by making the voltage LOW
  delay(1000);               // wait for a second
}

void flash(int count,int duration)
{
  while(count-- > 0)
  {
    digitalWrite(led, HIGH);   // turn the LED on (HIGH is the voltage level)
    delay(duration);           // wait
    digitalWrite(led, LOW);    // turn the LED off by making the voltage LOW
    delay(duration);           // wait
  }
}

// the loop routine runs over and over again forever:
void loop() {
  flash(3,150); // . . . S
  flash(3,300); // - - - O
  flash(3,150); // . . . S
  delay(1000);  // wait for a second
}

You will see in the SOS code that we have added a function called ‘flash’. Creating a function makes it easier for you to execute a procedure that is repetitive in this case the function takes 2 parameters.  The first parameter is ‘count’ this specified how many times the LED’s must flash. The seconds parameter is ‘duration’ this specifies the duration in milliseconds that the LED should be on and off.

The loop function has also been changed – it now calls the flash function to flash the LED. For ‘S’ which is 3 short dots in Morse code it is instructing flash to flash 3 times at 150 milliseconds each time. For ‘O’ the duration is 300 milliseconds to reproduce a dash. We complete the SOS by sending the final ‘S’ and then pausing for 1 second before repeating the ‘SOS’.

If you are familiar with the C language you will notice that a sketch looks very similar to C – that’s because it is based on C. You can even create C++ Classes to use, but more on that in another tutorial.

Congratulations, you now have your Arduino up and running and have modified an example sketch to flash out a SOS.

You are ready to start exploring the real fun side of Arduino.

We have a new project that we are working on and it involves eink and ZigBee. Our eink device arrived today and we are dying to get it connected to an arduino. We will post more information when we get going.

This development device will also be available for sale in our store soon – just watch this space.

But which of the dozen or so modules do you want? What’s the difference between Series 1 and Series 2? Why are there so many antenna? Why are some of them Pro, and does this make the regular models feel inadequate? And most importantly why does Sparkfun have so many boards for XBee and which ones do I need?

There are lots of different types of modules which we are going to go over, but one of the nice things about these is that all the modules regardless of the series or type have similar pinouts. Power, ground, and your TX/RX lines are in the same place making the chips pretty interchangeable for most of the simpler applications. Some of the more advanced features are not always compatible, but for starters its not something to worry about. Now that you are ready to start learning about XBee and what it all means here is a breakdown of the XBee world.

What’s an XBee, what’s a Zigbee, what’s a Bumblebee?

• XBee – According to Digi “XBee modules are embedded solutions providing wireless end-point connectivity to devices. These modules use the IEEE 802.15.4 networking protocol for fast point-to-multipoint or peer-to-peer networking. They are designed for high-throughput applications requiring low latency and predictable communication timing.“ So basically XBee is Digi’s own Zigbee based protocol. In layman’s term they are wicked cool, and fairly easy to use wireless modules.
• Zigbee - An alliance and a standard of cost and energy efficient mesh networks. XBee uses the Zigbee standard and adds to it and wraps it up in their own neat little package. http://www.zigbee.org/.
• Bumblebee - A tuna company, an insect of the family Apidae and the genus Bombus, or a small yellow Autobot. Which ever definition you choose they are fairly awesome and completely irrelevant to our talk of wireless XBee modules.

Series What?

• XBee Series 1 (also called XBee 802.15.4) - These are the easiest to work with, they don’t need to be configured, although they can benefit from it. Because they are easy to work with we recommend these especially if you are just starting out. For point to point communication these modules work as well as the Series 2 but without all the work. A Series 1 module won’t say Series 1 on it, but it also won’t say Series 2. If it doesn’t say then your module is a Series 1. Series 1 and Series 2/2.5/ZB hardware are NOT compatible. Don’t try to mix and match, don’t even think about it, it won’t work, not even close. Nope, stop thinking about it…! Datasheet
• XBee Znet 2.5 (Formerly Series 2) Retired - These are the fun ones. Series 2 modules must be configured before they can be used. They can run in a transparent mode or work with API commands, but this all depends on what firmware you configure these with. These also can run in a mesh network making them highly configurable and awesome modules. It also makes them harder to use modules. These modules are in no way compatible with the Series 1 modules so stop thinking about trying! These modules are no longer sold but are being replaced with the mostly compatible ZB modules. Datasheet
• ZB (the current Series2ish module) - Basically the Znet2.5 hardware with new firmware. Meaning they can also run in a transparent mode or work with API commands. They can also run in a mesh network making them highly configurable and awesome modules. You can grab the new firmware and upgrade them yourself. The firmware between the two is not compatible (but is easily interchangeable) so you will have to pick which firmware you want to use on your network and stick with it. Download the conversion kit here. These are often call Series 2 modules, so if you hear someone talking about Series 2, they might be talking about these. It may not be the correct term, but it does distinguish these from the Series 1 modules which is usually all people want to know. These modules will not work in any way shape or form with the Series 1 so stop thinking about it. Stop it! Datasheet.
• 2B(the even more current Series2ish module) - These new modules improve on the hardware of the Series 2 modules improving things like power usage. They run the ZB firmware but because the hardware has been changed they can no longer run the Znet2.5 firmware. So if you are looking to add this to an existing 2.5Znet network beware. Currently some of our boards are 2B and others are ZB
• 900MHz - Technically not a series but it is a family just like the others. The 900s can run 2 different types of firmware, the DigiMesh firmware and the Point to Multipoint firmware. Digi actually sells both modules, the hardware is the same just with different firmware. Sparkfun only sells the point to multipoint version, but hey, you can change the firmware yourself. These modules should be more or less plug and play but of course can benefit from all the cool features you can configure.
• XSC - Basically these are 900 modules that sacrifice data rate for range. The regular 900 modules have a data rate of 156KBps (the others are all around 250Kbps) but the XSC module is only about 10Kbps. On the other hand if you attach a high gain antenna you can get a range of about 15 miles and 6 miles with a regular antenna. These modules do not require configuration out of the box and have some other differences including a different command set so make sure you check out the datasheet.

Antenna, Antennas, Antennae…

• Chip Antenna – Basically a small chip that acts as an antenna. Quick, easy, cheap, not in the way. These are being phased out in favor of trace antennas, which are essentially the same but printed directly to the circuit board.
• Wire Antenna – Well its a small wire sticking up, a little more of what you think of when you think of antenna.
• u.FL Antenna – A tiny connector to connect your own antenna, this is great if your object is in a box and you want your antenna outside the box.
• RPSMA Antenna – A bigger connector to connect your own antenna, once again great if your object is in a box and you want your antenna outside the box.

Regular, Pro and other things

• Regular vs Pro - There are a few difference between the regular XBees and the XBee Pros. The Pros are a bit longer, use more power and cost more money. That’s pretty much it. The greater power means longer range (1 mile instead of 300ft) so if you need the range or like to spend more money, then use the Pros, otherwise stick with the regular models. You can mix and match these on the same network.
• 900 vs 2.4 - Most of the Xbee modules operate at 2.4GHz, but there are a few that operate at 900MHz. Basically 900MHz can go a lot farther with a high gain antenna (up to 15miles for the Pro modules and a high gain antenna). Also the lower the frequency the greater penetration the signal has. 900MHz is also not allowed in many countries (although there are 868MHz versions available from Digi that are allowed in many other countries). You can NOT mix and match these on the same network.

XBee Device	Range	Power Consumption	Frequency	Protocol	Tx Power	Data Rate	Antenna
XBee 1mW Chip Antenna – Series 1	300 Ft	50mA @ 3.3v	2.4GHz	802.15.4	1mW	250kbps	Chip
XBee 1mW U.FL Connection – Series 1	300 Ft	50mA @ 3.3v	2.4GHz	802.15.4	1mW	250kbps	Ext./Not Included
XBee 1mW Wire Antenna – Series 1	300 Ft	50mA @ 3.3v	2.4GHz	802.15.4	1mW	250kbps	Wire
XBee 2mW PCB Antenna – Series 2	400 Ft	40mA @ 3.3v	2.4GHz	ZigBee Mesh	2mW	250kbps	PCB
XBee 2mW RPSMA – Series 2	400 Ft	40mA @ 3.3v	2.4GHz	ZigBee Mesh	2mW	250kbps	Ext./Not Included
XBee 2mW U.FL Connection – Series 2	400 Ft	40mA @ 3.3v	2.4GHz	ZigBee Mesh	2mW	250kbps	Ext./Not Included
XBee 2mW Wire Antenna – Series 2	400 Ft	40mA @ 3.3v	2.4GHz	ZigBee Mesh	2mW	250kbps	Wire
XBee Pro 50mW PCB Antenna – Series 2	1 Mile	295mA @ 3.3v	2.4GHz	ZigBee Mesh	50mW	250kbps	PCB
XBee Pro 50mW RPSMA – Series 2	1 Mile	295mA @ 3.3v	2.4GHz	ZigBee Mesh	50mW	250kbps	Ext./Not Included
XBee Pro 50mW U.FL Connection – Series 2	1 Mile	295mA @ 3.3v	2.4GHz	ZigBee Mesh	50mW	250kbps	Ext./Not Included
XBee Pro 50mW Wire Antenna – Series 2	1 Mile	295mA @ 3.3v	2.4GHz	ZigBee Mesh	50mW	250kbps	Wire
XBee Pro 60mW PCB Antenna – Series 1	1 Mile	215mA @ 3.3v	2.4GHz	802.15.4	60mW	250kbps	PCB
XBee Pro 60mW U.FL Connection – Series 1	1 Mile	215mA @ 3.3v	2.4GHz	802.15.4	60mW	250kbps	Ext./Not Included
XBee Pro 60mW Wire Antenna – Series 1	1 Mile	215mA @ 3.3v	2.4GHz	802.15.4	60mW	250kbps	Wire
XBee Pro 900 RPSMA	6 Miles	210mA @ 3.3v	900MHz	Multi-Point	50mW	156kbps	Ext./Not Included
XBee Pro 900 U.FL Connection	6 Miles	210mA @ 3.3v	900MHz	Multi-Point	50mW	156kbps	Ext./Not Included
XBee Pro 900 Wire Antenna	6 Miles	210mA @ 3.3v	900MHz	Multi-Point	50mW	156kbps	Wire
XBee Pro 900 XSC RPSMA	15 Miles	256mA @ 3.3v	900MHz	Multi-Point	100mW	9.6kbps	Ext./Not Included
XBee Pro 900 XSC Wire	15 Miles	256mA @ 3.3v	900MHz	Multi-Point	100mW	9.6kbps	Wire

Let’s face it, there are a a lot of different Arduino boards out there. How do you decide which one you need for your project? With this table, you can not only compare features between all the different Arduino boards we carry, but you can also see why these differences are important.

What is an Arduino?

Let’s first talk about what an Arduino really is. Arduino is an open-source electronics prototyping platform based on flexible, easy-to-use hardware and software. It’s intended for artists, designers, hobbyists, and anyone interested in creating interactive objects or environments. Or more simply, you load on some code and it can read sensors, perform actions based on inputs from buttons, control motors, and accept shields to further expand it’s capabilities. Really, you can do almost anything.

All Arduino boards have one thing in common: they are programmed through the Arduino IDE. This is the software that allows you to write and upload code. Beyond that, there can be a lot of differences. The number of inputs and outputs (how many sensors, LEDs, and buttons you can use on a single board), speed, operating voltage, and form factor are just a few of the variables.

Why are they different?

Some boards are designed to be embedded and have no programming interface (hardware) which you would need to buy separately. Some can run directly from a 3.7V battery, others need at least 5V. Check the chart below to find the right Arduino for your project. Be sure to read the glossary below as well for a discussion of terms. If you are still confused and need more help, feel free to contact our technical support department by emailing support@karlssonrobotics.com.

Item	µC	Input Voltage	System Voltage	Clock Speed	Digital I/O	Analog Inputs	PWM	UART	Bootloader	Programming Interface
Arduino Leonardo	ATmega32U4	7-12V	5V	16MHz	20*	12	7	1	Leonardo	USB native
Arduino Uno – R3	ATmega328	7-12V	5V	16MHz	14	6	6	1	Optiboot	USB via ATMega16U2
Arduino Pro 3.3V/8MHz	ATmega328	3.35 -12V	3.3V	8MHz	14	6	6	1	AtmegaBOOT	FTDI-Compatible Header
Arduino Pro 5V/16MHz	ATmega328	5 – 12V	5V	16MHz	14	6	6	1	AtmegaBOOT	FTDI-Compatible Header
Arduino Mega 2560 R3	ATmega2560	7-12V	5V	16MHz	54	16	14	4	STK500v2	USB via ATMega16U2
Mega Pro 3.3V	ATmega328	3.3-12V	3.3V	8MHz	54	16	14	4	STK500v2	FTDI-Compatible Header
Mega Pro 5V	ATmega328	5-12V	5V	16MHz	54	16	14	4	STK500v2	FTDI-Compatible Header
Arduino Mini 05	ATmega328	7-9V	5V	16MHz	14	6	8	1	AtmegaBOOT	Serial Header
Arduino Fio	ATmega328P	3.35 -12V	3.3V	8MHz	14	8	6	1	AtmegaBOOT	FTDI-Compatible Header or Wirelessly via XBee1
Mega Pro Mini 3.3V	ATmega2560	3.3-12V	3.3V	8MHz	54	16	14	4	STK500v2	FTDI-Compatible Header
Pro Micro 5V/16MHz	ATmega32U4	5 – 12V	5V	16MHz	12	4	5	1	DiskLoader	Native USB
Pro Micro 3.3V/8MHz	ATmega32U4	3.35 – 12V	3.3V	8MHz	12	4	5	1	DiskLoader	Native USB
LilyPad Arduino 328 Main Board	ATmega328	2.7-5.5V	3.3V	8MHz	14	6	6	1	AtmegaBOOT	FTDI-Compatible Header
LilyPad Arduino Simple Board	ATmega328	2.7-5.5V	3.3V	8MHz	9	4	5	02	AtmegaBOOT	FTDI-Compatible Header

¹The miniUSB connector on the Arduino Fio is used for battery charging only. An Xbee module is not included with this board.
²The LilyPad Simple Board does have one UART but the pins aren’t broken out to pads. Serial communication can be achieved through the FTDI header.
*The Arduino Leonardo has the same GPIO pin-count as the other “Uno” style boards but more of the pins play “double duty” as both analog and digital pins, thus the higher numbers.

Glossary of Terms:

µC (Microcontroller): The microcontroller is the heart (or, more appropriately, the brain) of the Arduino board. The Arduino development board is based on AVR microcontrollers of different types, each of which have different functions and features.

Input Voltage: This is the suggested input voltage range for the board. The board may be rated for a slightly higher maximum voltage but this is the safe operating range. A handy thing to keep in mind is that many of the Li-Po batteries that we carry are 3.7V meaning that any board with an input voltage including 3.7V can be powered directly from one of our Li-Po battery packs.

System Voltage: This is the system voltage of the board, i.e. the voltage that the microcontroller is actually running at. This is an important factor for shield-compatibility since the logic level is now 3.3V instead of 5V. You always want to be sure that whatever outside system with which you’re trying to communicate is able to match the logic level of your controller.

Clock Speed: This is the operating frequency of the microcontroller and is related to the speed at which it can execute commands. Although there are rare exceptions, most ATMega microcontrollers running at 3V will be clocked at 8MHz whereas most running at 5V will be clocked at 16MHz. The clock speed of the Arduino can be divided down for power savings with a few tricks if you know what you’re doing.

Digital I/O: This is the number of digital input/output pins that are broken out on the Arduino board. Each of these can be configured as either an input or an output, some are capable of PWM and some double as serial communication pins.

Analog Inputs: This is the number of analog input pins that are available on the Arduino board. Analog pins are labeled “A” followed by their number, they allow you to read analog values using the analog-to-digital converter (ADC) in the ATMega chip. Analog inputs can also be configured as more digital I/O if you need it!

PWM: This is the number of digital I/O pins that are capable of producing a PWM signal. A PWM signal is like an analog output, it allows your Arduino to “fake” an analog voltage between zero and the system voltage.

UART: This is the number of separate serial communication lines your Arduino board can support. On most Arduino boards, digital I/O pins 1&2 double as your serial send and receive pins and are shared with the serial programming port. Some Arduino boards have multiple UARTs and can support multiple serial ports at once. All Arduino boards have at least one UART for programming, but some aren’t broken out to pins that are accessible.

Flash Space: This is the amount of program memory that the chip has available for your to store your sketch. Not all of this memory is available as a very small portion is taken up by the bootloader (usually between 0.5 and 2KB).

Bootloader: If the microcontroller is the brain of the Arduino board, then the bootloader is its personality. Without the bootloader, it just wouldn’t be an Arduino. The bootloader lives on the ATMega chip and allows you to load programs through the serial port instead of having to use a hardware programmer. Because different Arduino board use different microcontrollers and programming interfaces, there are different bootloader programs on each. The source code for the bootloaders can be found in your Arduino distribution. All Arduino bootloaders will allow you to load code from the Arduino IDE.

Programming Interface: This is how you hook up the Arduino board to your computer for programming. Some boards have a USB jack on-board so that all you need to do is plug them into a USB cable, others have a header available so that you can plug in an FTDI Basic breakout or FTDI Cable. Other boards, like the Mini, break out the serial pins for programming but aren’t pin-compatible with the FTDI header. Any Arduino board that has a USB jack on-board also has some other hardware that enables the serial to USB conversion. Some boards, however, don’t need additional hardware because their microncontrollers have built-in support for USB.

Raspberry Pi’s:

Raspberry Pi

Adafruit Pi Boxes:

Adafruit Pi Box

While using the servo.h he discovered that he was getting jitter on his servo. The jitter was noticeable to the point that he was not able to proceed with his project. He tried a number of workarounds to resolve the jitter issues but discovered that the best solution would be to create his own code to control the servo.

He has kindly shared this, very well documented, code with us for the benefit of anyone else that may run into the same issue.

A description of the code and operation can be found in the code sample below.

//Code example for Arduino Uno by Bart Borghuis
//This program drives a servo motor using timer0 interrupts at 50kHz.
//Receipt of character '0' through the serial port sets the motor in the 'closed' position
//defined by motorstate0. Receipt of '1' sets the motor in the 'open' position defined by motorstate1.

//storage variables
boolean motorstate = 0, motorenabled=0;
int ledstate, ledcount=0, ledontime=10000, ledofftime=60000;
int motorcount=0, motortick=0, motorstate0=49, motorstate1=99, motormax=999;
int startbyte;
byte ledPin=13;

void setup(){
  Serial.begin(115200); 
  //set pins as outputs
  pinMode(8, OUTPUT);
  pinMode(ledPin, OUTPUT);
  digitalWrite(ledPin, HIGH);
  ledstate=1;
  ledcount=ledontime;

  cli();//stop interrupts

  //set timer0 interrupt at 2kHz
  TCCR0A = 0;// set entire TCCR2A register to 0
  TCCR0B = 0;// same for TCCR2B
  TCNT0  = 0;//initialize counter value to 0
  // set compare match register for 50khz increments
  OCR0A = 4;// = (16*10^6) / (50000*64) - 1 (must be <256)
  // turn on CTC mode
  TCCR0A |= (1 << WGM01);
  // Set CS11 and CS10 bits for 64 prescaler
  TCCR0B |= (1 << CS11) | (1 << CS10);   
  // enable timer compare interrupt
  TIMSK0 |= (1 << OCIE0A);
  
  sei();//allow interrupts
}//end setup

void loop(){
  if (Serial.available() > 0) {
      startbyte = Serial.read();
      switch (startbyte){
          case 48:
            motorenabled=1;
            digitalWrite(ledPin, LOW);
            motorstate=0;
            break;  
          case 49: 
            motorenabled=1;
            digitalWrite(ledPin, HIGH);
            motorstate=1;
            break;
     }     
   }
}


ISR(TIMER0_COMPA_vect){
//timer0 interrupt 50kHz to drive servo motor connect to pin 8
// pulse width is 1 ms in motor state '0' and 2 ms in motor state '1'
switch(motorenabled){
  case 1:
    motorcount++;
    switch(motorstate){
      case 0:
           if(motorcount>motorstate0){
             digitalWrite(8,LOW);
           }
           if(motorcount>motormax){
             motorcount=0;
             digitalWrite(8,HIGH);
           }
       break;
       case 1:
           if(motorcount>motorstate1){
             digitalWrite(8,LOW);
           }
           if(motorcount>motormax){
              motorcount=0;
              digitalWrite(8,HIGH);
           }
       break;
    }
    break;
  case 0:
    ledcount--;
     if(ledcount==0){
       switch(ledstate){
         case 0:
         ledstate=1;
         digitalWrite(ledPin, HIGH);
        ledcount=ledontime;
        break;
        case 1:
             ledstate=0;
         digitalWrite(ledPin, LOW);
        ledcount=ledofftime;
        break;
      }
    }
  }
}

Note these will go fast. If you missed getting one don’t worry, we will post another notification when we get our next shipment in the next few weeks.

As we have cleared our backlog – we will allow back-orders for the next quantity in the next few days.