Red Box Robot Hookup Guide a learn.sparkfun.com tutorial

Available online at: http://sfe.io/t600

Redbox Robot

Here at SparkFun, we get a lot of compliments on our red boxes. They’re strong, stylish and hard to lose on a messy workbench. But, did you know that they also make pretty great robots? Okay, you can make a robot out of almost any box, but it won’t be as stylish. This kit has everything you need to transform your favorite cardboard box into a robotic buddy!

Cyber Monday Redbox Robot

Pre-Order KIT-14062

Bring one of our classic red boxes to life! We know that starting a robotics hobby can be expensive, so we wanted to put toge…

FavoritedFavorite10

Wish List

Kit Includes:

• SparkFun RedStick
• SparkFun Motor Driver – Dual TB6612FNG (1A)
• Hook-up Wire – White (22 AWG)
• Breadboard – Self-Adhesive (White)
• 2x Break Away Headers – Straight
• 3x 1500 mAh Alkaline Battery – AA
• Battery Holder 3xAA with Cover and Switch
• Mini Speaker – PC Mount 12mm 2.048kHz
• Ultrasonic Sensor – HC-SR04
• Hobby Gearmotor – 200 RPM (Pair)
• Wheel – 65mm (Rubber Tire, Pair)
• Super Bright LED – Red 10mm
• Double-Sided Tape (to attach motors to the box)

Covered in This Tutorial

This tutorial will guide you through the assembly, wiring and programming of an obstacle-avoiding robot. You will need to have some basic soldering experience, and you’ll need to cut a few holes in a cardboard box. Beyond that, you shouldn’t need any special tools or technical skill.

Materials Required

Besides the parts included in your kit, you’ll need to following tools:

• Soldering tools, including an iron and solder
• Scissors or a hobby knife
• Wire Strippers
• Googly eyes and other adornments (optional)

Suggested Reading

Building the Chassis

Before we can start to wire our robot, we’ll need to assemble the mechanical parts. Luckily, this robot is about as simple as it gets!

Empty out the box in which your kit came. That box is going to become the body for our robot. The included breadboard has a peel-and-stick backing, so let’s start by sticking that to the topside of the box, along the hinged side of the box, near the center. In order to connect the rest of the parts, you’ll need the strip of double-sided tape that came in your kit. Cut off about an inch of that tape, and use it to stick down the battery pack just below the breadboard, as pictured in the diagram below. Don’t worry about the parts stuck into the breadboard just yet. We’ll get to that after the mechanical portion is assembled.

Click image for a closer look

As you can see, there are a few places where it is suggested you cut a hole into the box so wires can be fed through. One hole that you can’t see is underneath the battery case so you can access the power switch on the underside. Otherwise, you could just turn it to “ON” and leave it there. Two other such holes are found on the bottom of the box where we’re going to attach the motors.

If you look at the hobby motors in the kit, you’ll notice that there is an axle running through them so that a wheel can be pressed onto either side. You’ll also notice that the wires are gathered on one side of the motor. It’ll be easiest to wire the motors if you make sure that they’re attached with the wires pointing in toward the middle of the box. Use the remaining length of double-sided tape to mount the motors on the bottom side, front corners of the box. Check out the diagram below for an idea of how it should look.

As there are only two motors on this robot, we’ll need to add something on the backside to keep it from just dragging around. In this case, we’re going to use a 10mm LED as a caster. Not only is this a nice, cheap way to keep your robot’s backside off the ground, but it’ll also allow us to add cool lighting effects! You shouldn’t need to glue the LED into place; just poke it through the cardboard and splay the legs out as pictured below. Later, we’ll solder a few wires to this LED, and that should hold it in place.

Once you have all the essentials taped into place, you can add some fun decoration to give your robot a little personality. Below, you can see that I’ve glued down a pair of googly eyes and drawn on a derpy smile with a magic marker.

Wiring the Motors

Now that our robot friend has a body (and maybe even a face) it’s time to start wiring things together. To ease assembly, we’ll be jumping everything together on a breadboard. Before we can do that, though, you’ll need to solder headers to the RedStick and the Motor Driver Board. I won’t cover that process here; if you’re just getting started with soldering, then check out this tutorial. Once everything has headers attached, press the parts into your breadboard as pictured below. Pay close attention to how many rows are free on either side of the breadboard; you’ll need them for the motor connections.

Having a hard time seeing the circuit? Click on the wiring diagram for a closer look.

Now that everything is in place, let’s add jumper wires to complete our circuit. There’s a spool of solid core wire included in your kit, which you’ll cut into short lengths and strip on either end. We’re going to make a lot of connections here, so the diagram might get messy. To make things easier to follow, I’ve broken it into stages. In case following a diagram isn’t your flavor, I’ve put together a table that outlines all of the connections. You can find it at the end of this section.

A quick note about the connections above: the motors and battery pack come with wire leads attached, which you should be able to press directly into the breadboard without having to add your own wire.

Notice in the diagram above that there are two wires connected to the battery terminals on the RedStick. You may be tempted to connect these wires to VCC and GND instead, but don’t do it! The battery connector actually passes through a booster circuit, so as your batteries drain, the RedStick won’t power down prematurely.

Making Moves

Now that you’ve made all of the connections you need to get the motors running, let’s get some code on that RedStick to spin our wheels! I’m going to assume for the purposes of this section that you have some experience with Arduino programming and that you’re already set up to load code onto the SparkFun RedStick. If you need a little help getting started, check out this tutorial.

In order to get code onto your RedStick, you will need to either remove it from the breadboard (carefully) or use a USB extension cable to plug it into your computer’s USB port.

The Arduino code below takes advantage of our library. If you are unfamiliar with installing an Arduino library, check out our tutorial.

Download the library using the link below, or grab the latest version from our GitHub repository.

TB6612FNG Arduino Library

This example code will make your robot do a little dance. This is a great way to make sure you’ve wired everything right so far. Besides, we’ve been staring at this thing long enough; it’s about time it did something!

language:c
/******************************************************************
TestRun.ino
TB6612FNG H-Bridge Motor Driver Example code
Michelle @ SparkFun Electronics
8/20/16
https://github.com/sparkfun/SparkFun_TB6612FNG_Arduino_Library

Uses 2 motors to show examples of the functions in the library.  This
causes a robot to do a little 'jig'.  Each movement has an equal and
opposite movement so assuming your motors are balanced the bot should
end up at the same place it started.

Resources:
TB6612 SparkFun Library
*****************************************************************/

// This is the library for the TB6612 that contains the class Motor and all the
// functions
#include <SparkFun_TB6612.h>

// Pins for all inputs, keep in mind the PWM defines must be on PWM pins
// the default pins listed are the ones used on the Redbot (ROB-12097) with
// the exception of STBY which the Redbot controls with a physical switch
#define AIN1 2
#define BIN1 7
#define AIN2 4
#define BIN2 5
#define PWMA 10
#define PWMB 6
#define STBY 9

// these constants are used to allow you to make your motor configuration
// line up with function names like forward.  Value can be 1 or -1
const int offsetA = -1;
const int offsetB = -1;

// Initializing motors.  The library will allow you to initialize as many
// motors as you have memory for.  If you are using functions like forward
// that take 2 motors as arguements you can either write new functions or
// call the function more than once.
Motor motor1 = Motor(AIN1, AIN2, PWMA, offsetA, STBY);
Motor motor2 = Motor(BIN1, BIN2, PWMB, offsetB, STBY);

void setup()
{
 //Nothing here
}


void loop()
{
   //Use of the drive function which takes as arguements the speed
   //and optional duration.  A negative speed will cause it to go
   //backwards.  Speed can be from -255 to 255.  Also use of the
   //brake function which takes no arguements.
   motor1.drive(255,1000);
   motor1.drive(-255,1000);
   motor1.brake();
   delay(1000);

   //Use of the drive function which takes as arguements the speed
   //and optional duration.  A negative speed will cause it to go
   //backwards.  Speed can be from -255 to 255.  Also use of the
   //brake function which takes no arguements.
   motor2.drive(255,1000);
   motor2.drive(-255,1000);
   motor2.brake();
   delay(1000);

   //Use of the forward function, which takes as arguements two motors
   //and optionally a speed.  If a negative number is used for speed
   //it will go backwards
   forward(motor1, motor2, 150);
   delay(1000);

   //Use of the back function, which takes as arguments two motors
   //and optionally a speed.  Either a positive number or a negative
   //number for speed will cause it to go backwards
   back(motor1, motor2, -150);
   delay(1000);

   //Use of the brake function which takes as arguments two motors.
   //Note that functions do not stop motors on their own.
   brake(motor1, motor2);
   delay(1000);

   //Use of the left and right functions which take as arguements two
   //motors and a speed.  This function turns both motors to move in
   //the appropriate direction.  For turning a single motor use drive.
   left(motor1, motor2, 100);
   delay(1000);
   right(motor1, motor2, 100);
   delay(1000);

   //Use of brake again.
   brake(motor1, motor2);
   delay(1000);

}

With this code compiled and running on your robot, you’ve made the first step toward bringing your red box to life. You’ve probably noticed, however, that it’s a little clumsy. It just runs right into anything in its path! The next thing we’re going to do is give it the ability to avoid those obstacles…

Avoiding Obstacles

Before we upload fresh code to take advantage of our robot’s ultrasonic sensor, we’ll need to wire the sensor to the RedStick. This sensor only requires four wires to work, and I’ve highlighted them in the diagram below.

Having a hard time seeing the circuit? Click on the wiring diagram for a closer look.

Once you’ve added these wires, it’s just a matter of uploading the example code below:

language:c
#include <SparkFun_TB6612.h>

// these constants are used to allow you to make your motor configuration
// line up with function names like forward.  Value can be 1 or -1
const int offsetA = -1;
const int offsetB = -1;

// Pins for all inputs, keep in mind the PWM defines must be on PWM pins
// the default pins listed are the ones used on the Redbot (ROB-12097) with
// the exception of STBY which the Redbot controls with a physical switch
#define AIN1 2
#define BIN1 7
#define AIN2 4
#define BIN2 5
#define PWMA 10
#define PWMB 6
#define STBY 9

// Initializing motors.  The library will allow you to initialize as many
// motors as you have memory for.  If you are using functions like forward
// that take 2 motors as arguements you can either write new functions or
// call the function more than once.
Motor motor1 = Motor(AIN1, AIN2, PWMA, offsetA, STBY);
Motor motor2 = Motor(BIN1, BIN2, PWMB, offsetB, STBY);

// Pins
const int TRIG_PIN = 11;
const int ECHO_PIN = 12;

// Anything over 400 cm (23200 us pulse) is "out of range"
const unsigned int MAX_DIST = 23200;

void setup() {

  // Setup all of our pins
  pinMode(TRIG_PIN, OUTPUT);
  digitalWrite(TRIG_PIN, LOW);
  pinMode(2, OUTPUT); digitalWrite(2, LOW);
  pinMode(4, OUTPUT); digitalWrite(4, LOW);
  pinMode(5, OUTPUT); digitalWrite(5, LOW);
  pinMode(7, OUTPUT); digitalWrite(7, LOW);
  pinMode(3, OUTPUT);
  pinMode(6, OUTPUT);
  pinMode(A4, OUTPUT);
  digitalWrite(A4, HIGH);

}

void loop() {

  // Start moving forward
  forward(motor1, motor2, 200);

  unsigned long t1;
  unsigned long t2;
  unsigned long pulse_width;
  float cm;

  // Hold the trigger pin high for at least 10 us
  digitalWrite(TRIG_PIN, HIGH);
  delayMicroseconds(10);
  digitalWrite(TRIG_PIN, LOW);

  // Wait for pulse on echo pin
  while ( digitalRead(ECHO_PIN) == 0 );

  // Measure how long the echo pin was held high (pulse width)
  // Note: the micros() counter will overflow after ~70 min
  t1 = micros();
  while ( digitalRead(ECHO_PIN) == 1);
  t2 = micros();
  pulse_width = t2 - t1;

  // Calculate distance in centimeters.
  cm = pulse_width / 58.0;

  // If an obstacle is detected fewer than 20 centimeters away,
  // run the motors backwards and then coin flip to decide which
  // way to turn before continuing on.
  if(cm<20){back(motor1, motor2, 250); delay(1000);
  if(flip()){left(motor1, motor2, 250);}else{right(motor1, motor2, 250);}
  delay(2500);}

  // Wait at least 60ms before next measurement
  delay(60);
}

// Coinflip function that randomly returns a 1 or 0
bool flip(){

  static uint32_t buf = 0;
  static uint8_t idx = 0;
  if (idx)
  {
    buf >>= 1;
    idx--;
  }
  else
  {
    buf = random();  // refill
    idx = 30;
  }
  return buf & 0x01;

}

If everything is working correctly, your robot should be dodging obstacles. More specifically, if an object comes within 20 centimeters of the front of the robot, the robot will reverse direction and turn randomly before continuing on its way. This is a nice self-preservation instinct for a robot to have. However, if science fiction movies have taught me anything, a small robot needs a cute voice to survive.

The Voice

There’s one more quick connection we’ll need to make before your robot can whistle. Wire one side of the mini speaker to the A4 pin on the RedStick and wire the other side to ground as illustrated below.

Having a hard time seeing the circuit? Click on the wiring diagram for a closer look.

The final update that we’re going to make to our code today is to add a fun little function I call “Whistle,” which picks nine random frequencies and beeps them out in quick succession to approximate a sort of wordless interjection. It doesn’t sound like much, but it adds a lot of personality.

language:c
#include <SparkFun_TB6612.h>

// these constants are used to allow you to make your motor configuration
// line up with function names like forward.  Value can be 1 or -1
const int offsetA = -1;
const int offsetB = -1;

// Pins for all inputs, keep in mind the PWM defines must be on PWM pins
// the default pins listed are the ones used on the Redbot (ROB-12097) with
// the exception of STBY which the Redbot controls with a physical switch
#define AIN1 2
#define BIN1 7
#define AIN2 4
#define BIN2 5
#define PWMA 10
#define PWMB 6
#define STBY 9

// Initializing motors.  The library will allow you to initialize as many
// motors as you have memory for.  If you are using functions like forward
// that take 2 motors as arguements you can either write new functions or
// call the function more than once.
Motor motor1 = Motor(AIN1, AIN2, PWMA, offsetA, STBY);
Motor motor2 = Motor(BIN1, BIN2, PWMB, offsetB, STBY);

// Pins
const int TRIG_PIN = 11;
const int ECHO_PIN = 12;

// Anything over 400 cm (23200 us pulse) is "out of range"
const unsigned int MAX_DIST = 23200;

void setup() {

  // Setup all of our pins
  pinMode(TRIG_PIN, OUTPUT);
  digitalWrite(TRIG_PIN, LOW);
  pinMode(2, OUTPUT); digitalWrite(2, LOW);
  pinMode(4, OUTPUT); digitalWrite(4, LOW);
  pinMode(5, OUTPUT); digitalWrite(5, LOW);
  pinMode(7, OUTPUT); digitalWrite(7, LOW);
  pinMode(3, OUTPUT);
  pinMode(6, OUTPUT);
  pinMode(A4, OUTPUT);
  digitalWrite(A4, HIGH);

}

void loop() {

  // Start moving forward
  forward(motor1, motor2, 200);

  unsigned long t1;
  unsigned long t2;
  unsigned long pulse_width;
  float cm;

  // Hold the trigger pin high for at least 10 us
  digitalWrite(TRIG_PIN, HIGH);
  delayMicroseconds(10);
  digitalWrite(TRIG_PIN, LOW);

  // Wait for pulse on echo pin
  while ( digitalRead(ECHO_PIN) == 0 );

  // Measure how long the echo pin was held high (pulse width)
  // Note: the micros() counter will overflow after ~70 min
  t1 = micros();
  while ( digitalRead(ECHO_PIN) == 1);
  t2 = micros();
  pulse_width = t2 - t1;

  // Calculate distance in centimeters.
  cm = pulse_width / 58.0;

  // If an obstacle is detected fewer than 20 centimeters away,
  // run the motors backwards and then coin flip to decide which
  // way to turn before continuing on.
  if(cm<20){back(motor1, motor2, 250); whistle(); delay(1000);
  if(flip()){left(motor1, motor2, 250);}else{right(motor1, motor2, 250);}
  delay(2500);}

  // Wait at least 60ms before next measurement
  delay(60);
}

// Coinflip function that randomly returns a 1 or 0
bool flip(){

  static uint32_t buf = 0;
  static uint8_t idx = 0;
  if (idx)
  {
    buf >>= 1;
    idx--;
  }
  else
  {
    buf = random();  // refill
    idx = 30;
  }
  return buf & 0x01;

}

// Make a series of cute random beeping sounds
int whistle(){
tone(A2,random(50,400)*10);
delay(100);
tone(A2,random(50,400)*10);
delay(100);
tone(A2,random(50,400)*10);
delay(100);
tone(A2,random(50,400)*10);
delay(100);
tone(A2,random(50,400)*10);
delay(100);
tone(A2,random(50,400)*10);
delay(100);
tone(A2,random(50,400)*10);
delay(100);
tone(A2,random(50,400)*10);
delay(100);
noTone(A2);
delay(100);
}

Assuming everything has gone well, your robot should be whistling an adorable little tune every time it encounters an obstacle. Consider it the Mouse Droid for your personal Death Star. Or perhaps it’s the first recruit for your robot army. Or maybe it’s just something to keep you company at home. Hey, whatever floats your boat, we’re not judging.

Resources and Going Further

Your robot is movin' and groovin'… but don’t stop there! You can still add more parts, more code, more personality! Check out the RedBot Experiment Guide for some ideas about what you can do with a simple two-wheeled robot.

Also, if you pimped your bot with some cool googly eyes or glitter, let’s see it! Take a picture and tweet it to @sparkfun

For more robotic fun, check out these other great SparkFun tutorials:

learn.sparkfun.com |CC BY-SA 3.0 | SparkFun Electronics | Niwot, Colorado

Holiday Lights Hookup Guide a learn.sparkfun.com tutorial

Available online at: http://sfe.io/t601

Light Up the Holidays

‘Tis the season, let’s get to decorating! Nothing looks as festive as a bunch of bright, colorful lights concentrated into a tight space. And for that, I heartily recommend an addressable LED strip. It’s very bright, super vivid, and easy to hookup. This kit has the bare essentials for adding a strip of LEDs to your holiday shrub, ugly sweater or boring family member.

Cyber Monday Light Up the Holidays

Pre-Order KIT-14060

'Tis the season to put colorful lights on everything! Okay, it's always the season to put colorful lights on everything, so w…

FavoritedFavorite10

Wish List

Kit Includes:

• 1 x SparkFun RedStick
• 1 x Battery Holder 4xAA with Cover and Switch
• 1 x LED RGB Strip - Addressable, Bare (1m)
• 4 x 1500 mAh Alkaline Battery - AA

Covered in This Tutorial

This tutorial covers all of the wiring and code necessary to light up a string of addressable LEDs with just a RedStick and a AA Battery Pack.

Required Materials

Besides the parts included in your kit, you’ll need to following tools:

• Soldering tools, including an iron and solder
• Wire Strippers

Suggested Reading

If you’ve never worked with addressable LEDs or with the RedStick, we recommend checking out these other guides first.

Wire Them Up

For the purposes of this tutorial, I’m going to assume that you have some very basic soldering experience. There are only a handful of connections that you’ll need to solder, so this isn’t a bad project to start with However, if you are using this as your introduction to soldering, we strongly suggest reading this tutorial first.

Addressable LED strips like the one in this kit tend to use a standardized 3-pin connector. This makes it easy to chain multiple LED strips together. Because the battery pack included with this project is not going to support a lot more than the 60 included LEDs, you may find it convenient to cut the female connector off the “out” end of the strip and solder it to the RedStick to make your LEDs detachable.

The diagram below illustrates the handful of connections that you’ll need to make. You’ll notice that the red and yellow wires from the LED strip are connected directly to the battery connector. You may be tempted to connect them to the GND and VCC pins on the RedStick, but don’t do that. The VCC pin draws current through the on-board voltage regulator, which isn’t rated for the high current that the LEDs require to operate. If powered from VCC, the regulator will definitely get hot and may fail altogether.

Click image for a closer look

Example Code

Once your LED strip is wired up, you can load some Arduino code onto the RedStick to animate the lights! For our example code, we’ll be making use of Adafruit’s fantastic NeoPixel library.

Click here to download a copy of both the example code, as well as the NeoPixel library. The library is located in the “Adafruit_NeoPixel” folder, and the example code is found in the “WS2812_Breakout_Example” folder.

You’ll need to install the library. For help there, check out our installing Arduino libraries tutorial.

We’ve broken down the example code into a few separate sketches that each have a festive animation. Since this is a holiday kit, I took the liberty of cooking up a few special addition animations as well:

Rainbow Cycle

This one is my favorite of the NeoPixel example animations. It scrolls through the entire rainbow of colors while evenly distributing the color spectrum across the LED strip.

language:c
#include <Adafruit_NeoPixel.h>
#ifdef __AVR__
  #include <avr/power.h>
#endif

#define PIN 2

Adafruit_NeoPixel strip = Adafruit_NeoPixel(60, PIN, NEO_GRB + NEO_KHZ800);

void setup() {
  strip.begin();
  strip.setBrightness(64);
  strip.show(); // Initialize all pixels to 'off'
}

void loop() {
rainbowCycle(20);
}

void rainbowCycle(uint8_t wait) {
  uint16_t i, j;

  for(j=0; j<256*5; j++) { // 5 cycles of all colors on wheel
    for(i=0; i< strip.numPixels(); i++) {
      strip.setPixelColor(i, Wheel(((i * 256 / strip.numPixels()) + j) & 255));
    }
    strip.show();
    delay(wait);
  }
}

// Input a value 0 to 255 to get a color value.
// The colours are a transition r - g - b - back to r.
uint32_t Wheel(byte WheelPos) {
  WheelPos = 255 - WheelPos;
  if(WheelPos < 85) {
    return strip.Color(255 - WheelPos * 3, 0, WheelPos * 3);
  }
  if(WheelPos < 170) {
    WheelPos -= 85;
    return strip.Color(0, WheelPos * 3, 255 - WheelPos * 3);
  }
  WheelPos -= 170;
  return strip.Color(WheelPos * 3, 255 - WheelPos * 3, 0);
}

Candy Chase

This is a little animation that I worked up based on the “Theater Chase” animation included in the NeoPixel example code. It creates a crawling lights effect in red on a white background, like an animated candy cane!

language:c
#include <Adafruit_NeoPixel.h>
#ifdef __AVR__
  #include <avr/power.h>
#endif

#define PIN 2

Adafruit_NeoPixel strip = Adafruit_NeoPixel(60, PIN, NEO_GRB + NEO_KHZ800);

void setup() {
  strip.begin();
  strip.setBrightness(64);
  strip.show(); // Initialize all pixels to 'off'
}

void loop() {
candyChase(100);
}

void candyChase(uint8_t wait) {
  for (int j=0; j<10; j++) {  //do 10 cycles of chasing
    for (int q=0; q < 3; q++) {
      for (uint16_t i=0; i < strip.numPixels(); i++) {
        strip.setPixelColor(i+q, 255,255,255);    //turn every pixel white
      }
      for (uint16_t i=0; i < strip.numPixels(); i=i+3) {
        strip.setPixelColor(i+q, 255,0,0);    //turn every third pixel red
      }
      strip.show();

      delay(wait);

      for (uint16_t i=0; i < strip.numPixels(); i=i+3) {
        strip.setPixelColor(i+q, 0);        //turn every third pixel off
      }
    }
  }
}

Snowflakes

This animation creates an array of randomly twinkling white pixels remenicant of snowfall.

language:c
#include <Adafruit_NeoPixel.h>
#ifdef __AVR__
  #include <avr/power.h>
#endif

#define PIN 2

Adafruit_NeoPixel strip = Adafruit_NeoPixel(60, PIN, NEO_GRB + NEO_KHZ800);

void setup() {
  strip.begin();
  strip.setBrightness(64);
  strip.show(); // Initialize all pixels to 'off'
}

void loop() {
    snowflakes(100);
}

void snowflakes(uint8_t wait) {

// Setup the pixel array
int pixel[60];
for(int p=0; p<60; p++){
  pixel[p] = random(0,255);
}

// Run some snowflake cycles
for (int j=0; j<200; j++) {

// Every five cycles, light a new pixel
if((j%5)==0){
  strip.setPixelColor(random(0,60), 255,255,255);
}

// Dim all pixels by 10
for(int p=0; p<60; p++){
  strip.setPixelColor(p, pixel[p],pixel[p],pixel[p] );
  pixel[p] =  pixel[p] - 10;
}
   strip.show();
   delay(wait);
}

}

Iceflakes

Not a real thing, I know… It’s “Snowflakes” but blue instead of white.

language:c
#include <Adafruit_NeoPixel.h>
#ifdef __AVR__
  #include <avr/power.h>
#endif

#define PIN 2

Adafruit_NeoPixel strip = Adafruit_NeoPixel(60, PIN, NEO_GRB + NEO_KHZ800);

void setup() {
  strip.begin();
  strip.setBrightness(64);
  strip.show(); // Initialize all pixels to 'off'
}

void loop() {
    iceflakes(100);
}

void iceflakes(uint8_t wait) {

// Setup the pixel array
int pixel[60];
for(int p=0; p<60; p++){
  pixel[p] = random(0,255);
}

// Run some snowflake cycles
for (int j=0; j<200; j++) {

// Every five cycles, light a new pixel
if((j%5)==0){
  strip.setPixelColor(random(0,60), 0,0,255);
}

// Dim all pixels by 10
for(int p=0; p<60; p++){
  strip.setPixelColor(p, 0,0,pixel[p] );
  pixel[p] =  pixel[p] - 10;
}
   strip.show();
   delay(wait);
}

}

Extending Battery Life

The 60 LEDs on your addressable LED strip can drain a lot of batteries really fast. At full brightness, the strip will pull over 2 amps!! With a capacity of only 1.5 amp-hours, the AA batteries included in this kit will only power the strip at full brightness, continuously, for under an hour. If you want to get more bang for your battery-buck, there are a few tricks you can use.

Cap the Brightness

60 LEDs in a linear meter is a lot of LEDs, so running them at full brightness is really… impressive. And mostly unnecessary. Luckily, the NeoPixel library includes a handy function called setBrightness(); which limits the brightness of an LED strip. You’ll notice that the examples in this tutorial all include the line strip.setBrightness(64);, which sets the strip brightness to about 25%. You can set it lower before noticing a huge difference in brightness, so play with that number until you find the right balance between brightness and battery life.

Take a Break

Sometimes a cool lighting effect is more impressive if it isn’t continuous. Try dropping a delay(); into the main loop so that there’s some downtime between animation cycles. Obviously, the less time you leave the LEDs on, the longer your batteries will last.

Cut it Short

Maybe you don’t need 60 LEDs. Maybe 30 would do just fine. You can cut a portion off the end of the strip with a pair of standard craft scissors. Just cut across the copper pads in between the LEDs, and now you have another small strip you could use elsewhere. You can always solder them back together if you change your mind!

Resources and Going Further

Now go forth and add lights to everything! It’s worth noting that the RedStick in this kit is powerful enough to address a lot more than 60 LEDs, but you’ll need to beef up the power supply before you start chaining strips together.

Also, we’d love to see what you did with your light kit! Take a picture and tweet it to @sparkfun.

For more blinky fun, check out these other great SparkFun tutorials:

learn.sparkfun.com |CC BY-SA 3.0 | SparkFun Electronics | Niwot, Colorado

IoT Hobby Kit Experiment Guide a learn.sparkfun.com tutorial

Available online at: http://sfe.io/t594

Introduction

The Internet of Things (IoT) is the network of connected physical objects, such as vehicles, buildings and people. These objects, or “things,” are often embedded with electronics to include sensors, actuators and microcontrollers that enable the devices to sense the environment around them, log data in real time, communicate with services or other devices, and be remotely controlled.

The SparkFun ESP8266 Thing Dev Board is a microcontroller board with a built-in WiFi radio, which makes it a fantastic development platform for IoT and home automation projects.

Lucky for us, we can use the Arduino IDE to program the Thing Dev Board, which makes life easy for programming and configuring our IoT projects. This guide will show you how to set up your Thing Dev Board and construct a few simple (but useful!) connected projects involving logging sensor data and controlling home appliances.

Added to your cart!

Cyber Monday IoT Hobby Kit

In stock KIT-14061

If you have been wanting to dive into the world of Internet of Things (IoT) but didn't know where to start, this kit will cer…

$49.95

FavoritedFavorite7

Wish List

Required Materials

If you don’t have an IoT Hobby Kit, don’t worry! You can put together your own kit with the following parts:

Suggested Reading

We recommend checking out the following guides before diving in with the IoT experiments:

• How to Solder
• How to Use a Breadboard
• What is an Arduino?
• How to Power a Project
• ESP8266 Thing Dev Board Hookup Guide

Soldering and Arduino Setup

Soldering

If your ESP8266 Thing Dev Board did not come with pre-soldered headers, you’ll need to attach them yourself. Solder male break-away headers or stackable headers to the Thing Dev Board.

Arduino

The ESP8266 community has created a library and bootloader that allows us to program ESP8266 chips and boards using Arduino (see this GitHub repository for more information).

Once you have the Arduino IDE installed, follow the directions on this page to install the ESP8266 library.

At the end of the installation guide, you should have the Thing Dev Board running the Blink sketch:

Configure ThingSpeak

For these examples, we’ll be using ThingSpeak.

ThingSpeak is an open source IoT data channel created by MathWorks (the same people who make MATLAB).

ThingSpeak allows us to read and write data to channels, which are logs of numbers, strings, etc. Each channel can have up to eight fields, which are groupings of similar data.

Create an Account

To use ThingSpeak, you’ll need to create an account. Don’t worry; it’s free. Head to ThingSpeak.com. At the top right of the page, click Sign Up.

Fill out the form and click Create Account. And that’s it! You’ll be presented with a welcome screen where you can make your first channel. We’ll do that in the next section.

Install ThingSpeak Arduino Library

In the Arduino IDE, go to Sketch > Include Library > Manage Libraries… Search for thingspeak and click Install. Note that ThingSpeak library v1.2.1 was used for this guide.

Experiment 1: Temperature and Humidity Logging

One of the most basic IoT projects is to log data from a sensor to an online channel, and we’re going to do just that. For the first experiment, we’ll capture temperature and humidity data from a sensor and post it to our ThingSpeak channel.

Parts Needed

• SparkFun ESP8266 Thing Dev Board
• Humidity and Temperature Sensor - RHT03
• Breadboard
• M/M Jumper Wires

Hardware Hookup

Connect the RHT03 to the Thing Dev board as shown:

Having a hard time seeing the circuit? Click on the wiring diagram for a closer look.

Create ThingSpeak Channel

Head to thingspeak.com, sign in, and navigate to Channels > My Channels.

Click New Channel, and fill out the required information, adding fields 2 and 3 to your channel.

Scroll down to the bottom of the page, and click Save Channel.

On the page that follows, copy down your Channel ID number (highlighted in the screenshot below).

Click on API Keys and copy your Write API Key.

The Code

In a new Arduino sketch, copy in the code below (make sure you have the ThingSpeak library installed!). In the code, find the section under // WiFi and Channel parameters, and change <YOUR WIFI SSID>, <YOUR WIFI PASSWORD>, <THINGSPEAK CHANNEL ID>, and <THINGSPEAK WRITE API KEY> to your WiFi network’s name, password, ThingSpeak Channel ID, and Write API Key, respectively.

language:c
/**
 * IoT Kit - Temperature and Humidity Logger
 * Author: Shawn Hymel (SparkFun Electronics)
 * Date: October 30, 2016
 *
 * Log temperature and humidity data to a channel on
 * thingspeak.com once every 20 seconds.
 *
 * Connections:
 *   Thing Dev |  RHT03
 *  -----------|---------
 *      3V3    | 1 (VDD)
 *        4    | 2 (DATA)
 *      GND    | 4 (GND)
 *
 * Development environment specifics:
 *  Arduino IDE v1.6.5
 *  Distributed as-is; no warranty is given.
 */

#include <ESP8266WiFi.h>
#include <SparkFun_RHT03.h>
#include "ThingSpeak.h"

// WiFi and Channel parameters
const char WIFI_SSID[] = "<YOUR WIFI SSID>";
const char WIFI_PSK[] = "<YOUR WIFI PASSWORD>";
unsigned long CHANNEL_ID = <THINGSPEAK CHANNEL ID>;
const char * WRITE_API_KEY = "<THINGSPEAK WRITE API KEY>";

// Pin definitions
const int RHT03_DATA_PIN = 4;
const int LED_PIN = 5;

// Global variables
WiFiClient client;
RHT03 rht;

void setup() {

  // Set up LED for debugging
  pinMode(LED_PIN, OUTPUT);

  // Connect to WiFi
  connectWiFi();

  // Initialize connection to ThingSpeak
  ThingSpeak.begin(client);

  // Call rht.begin() to initialize the sensor and our data pin
  rht.begin(RHT03_DATA_PIN);
}

void loop() {

  // Flash LED to show that we're sampling
  digitalWrite(LED_PIN, LOW);

  // Call rht.update() to get new humidity and temperature values from the sensor.
  int updateRet = rht.update();

  // If successful, the update() function will return 1.
  if (updateRet == 1)
  {

    // The tempC(), tempF(), and humidity() functions can be
    // called after a successful update()
    float temp_c = rht.tempC();
    float temp_f = rht.tempF();
    float humidity = rht.humidity();

    // Write the values to our ThingSpeak channel
    ThingSpeak.setField(1, temp_c);
    ThingSpeak.setField(2, temp_f);
    ThingSpeak.setField(3, humidity);
    ThingSpeak.writeFields(CHANNEL_ID, WRITE_API_KEY);
  }
  else
  {

    // If the update failed, try delaying for some time
    delay(RHT_READ_INTERVAL_MS);
  }

  // Turn LED off when we've posted the data
  digitalWrite(LED_PIN, HIGH);

  // ThingSpeak will only accept updates every 15 seconds
  delay(20000);
}

// Attempt to connect to WiFi
void connectWiFi() {

  byte led_status = 0;

  // Set WiFi mode to station (client)
  WiFi.mode(WIFI_STA);

  // Initiate connection with SSID and PSK
  WiFi.begin(WIFI_SSID, WIFI_PSK);

  // Blink LED while we wait for WiFi connection
  while ( WiFi.status() != WL_CONNECTED ) {
    digitalWrite(LED_PIN, led_status);
    led_status ^= 0x01;
    delay(100);
  }

  // Turn LED off when we are connected
  digitalWrite(LED_PIN, HIGH);
}

Run It!

When you upload and run the Arduino code on the Thing Dev Board, it should connect to your WiFi and begin sending data to ThingSpeak about once every 20 seconds. You’ll see data points appearing in the charts in your channel under the Private View tab.

Challenge

If you go to the Apps tab and select Plugins, you’ll be able to create an embeddable widget for your data channel. If you’re familiar with HTML, JavaScript and CSS, you can customize these widgets to do things like display a chart with multiple series.

See if you can create a gauge plugin, modify it so it shows the temperature in Fahrenheit, and display it on your channel.

Experiment 2: IoT Buttons

If you’ve seen Amazon’s IoT Button and wondered what you can use it for, we’ve got some possible solutions for you! First, though, we need to build our own IoT button, but why build one when you can build three?

Parts Needed

• SparkFun ESP8266 Thing Dev Board
• 3x 12mm Momentary Pushbutton
• 3x 10k Ohm Resistor
• Breadboard
• M/M Jumper Wires

Hardware Hookup

Connect the buttons to the Thing Dev board as shown:

Having a hard time seeing the circuit? Click on the wiring diagram for a closer look.

Create IFTTT Applet for Button A (send an email reminder)

If This, Then That (IFTTT) is a free web service that allows you to connect other web services together. For example, you can send yourself an email whenever a certain hashtag on Twitter is used. For this applet, we’ll send ourselves an email reminder whenever we push Button A connected to our Thing Dev Board.

To get started, head to ifttt.com, and create a new account. Once signed in, click on your username, and select New Applet.

You’ll be presented with the Applet Maker page. Click on the highlighted + this (the trigger for the event).

Search for “maker” and click on the Maker icon. This will allow us to receive HTTP requests from other websites (we’ll be sending requests from ThingSpeak).

The first time you click on the Maker channel, you’ll be asked to connect the Maker service to IFTTT. Follow the instructions on the site to do that.

When you finish connecting to the Maker channel, you’ll be presented with an option to choose the trigger.

Click on Receive a web request, and name the event “button_a”.

Click Create trigger, and you’ll be presented with another screen showing your applet creation progress.

Click on + that to define the action that occurs whenever your “button_a” web request trigger occurs. Search for “email”.

Click on the Email icon. On the next screen, click Send me an email. Leave the Subject line alone and change the body to:

Reminder: {{Value1}}

{{value1}} is a parameter that we will pass to IFTTT in our web request from ThingSpeak.

Click Create action. Review your applet, and click Finish.

We will set up a ThingSpeak channel and ThingHTTP app to send HTTP requests to our IFTTT applet, but for now, let’s create the IFTTT applets for the other two buttons.

Create IFTTT Applet for Button B (text yourself)

Follow the same steps above to set up a new Applet. Label the Event Name as button_b.

When asked for the That action, search for and choose SMS.

Click Connect and follow the instructions to connect your cell phone with IFTTT. Choose Send me an SMS and fill out some message to send yourself, like “I found you!”

Click Create Action and Finish.

Create IFTTT Applet for Button C (post a tweet)

For the final button, we’ll tweet a random number that was generated by the Thing Dev Board. Once again, follow the same steps to create a new applet, and call the Event Name button_c.

For That, search for and select Twitter.

When you select Twitter on IFTTT, you’ll be asked to connect your Twitter account. If you don’t have a Twitter account, you can create one at twitter.com.

Fill out the Tweet text with the following:

[{{OccurredAt}}] IoT Button generated a random number: {{Value1}}

Note that we can use variables like {{OccurredAt}} to show when the event happened. These can be found by clicking the + Ingredient button just under the Tweet text.

Create action, and select Finish.

If you navigate to My Applets, you can see all your applets. The three we just created should be turned on.

Find Your IFTTT Maker Channel Secret Key

In order to use the Maker Channel on IFTTT, we need to send HTTP GET requests to a special address with your unique secret key, which we’ll refer to as IFTTT_SECRET_KEY when we make our ThingSpeak app. To find it, navigate to My Applets in IFTTT, and click on the Services tab.

These are the services that you have connected to IFTTT. Click on Maker.

Click on Settings in the upper-right corner.

Copy down the string of characters that make up the last section of the URL (shown highlighted in the screenshot). This string is your IFTTT_SECRET_KEY and is unique to your account.

Create ThingSpeak Channel

Head to thingspeak.com, select My Channels, and create a new channel with the following parameters:

• Name: IoT Buttons
• Description: Anything you want
• Field 1: Button A
• Field 2: Button B
• Field 3: Button C

Save the channel, and you should be presented with the dashboard for your channel. Copy down your Channel ID (shown highlighted below). This will be referred to as your CHANNEL_ID later in this tutorial.

Create ThingSpeak ThingHTTP Actions

Head to thingspeak.com/apps, and select ThingHTTP.

This will allow us to create a custom HTTP request in order to trigger one of our IFTTT applets. Click New ThingHTTP, and fill out the fields with the following (making sure to replace <IFTTT_SECRET_KEY> with your unique IFTTT Maker Channel Key):

• Name: IoT Button A
• URL: https://maker.ifttt.com/trigger/button_a/with/key/<IFTTT_SECRET_KEY>
• Method: POST
• Content Type: application/json
• Body: {“value1”: “Take the dog out at noon!”}

When called, this action will make an HTTP POST request to ifttt.com with the given body. That body, a JSON object, is then passed along to the action (“THAT”) portion of the IFTTT applet. “value1” matches up with “value1” in the email, so “Take the dog out at noon!” will be added to the body of the email sent to us.

From there, you can click Save ThingHTTP.

Create another ThingHTTP with the following parameters. Don’t forget to change <IFTTT_SECRET_KEY> with your IFTTT Maker Channel Key.

• Name: IoT Button B
• URL: https://maker.ifttt.com/trigger/button_b/with/key/<IFTTT_SECRET_KEY>
• Method: GET

Save it, and make a third ThingHTTP with the following, changing <IFTTT_SECRET_KEY> to your IFTTT key and <CHANNEL_ID> to your ThingSpeak Channel ID.

• Name: IoT Button C
• URL: https://maker.ifttt.com/trigger/button_c/with/key/<IFTTT_SECRET_KEY>
• Method: POST
• Content Type: application/json
• Body: {“value1”: “%%channel_<CHANNEL_ID>_field_3%%”}

Click Save ThingHTTP.

Create ThingSpeak React App

Head back to thingspeak.com/apps, and select React. Click New React. We will use React apps to trigger our ThingHTTP app whenever data is posted to each of our channel fields. ThingHTTP will then trigger our custom IFTTT applet.

Fill out the following parameters for the React app:

• React Name: Button A React
• Condition Type: Numeric
• Test Frequency: On Data Insertion
• Condition (If channel): IoT Buttons (<CHANNEL_ID>)
• Condition (field): 1 (Button A), is equal to, 1
• Action: ThingHTTP
• Action (then perform): IoT Button A
• Options: Run action each time condition is met

Save your React app.

Create a new React app with the following parameters:

• React Name: Button B React
• Condition Type: Numeric
• Test Frequency: On Data Insertion
• Condition (If channel): IoT Buttons (<CHANNEL_ID>)
• Condition (field): 2 (Button B), is equal to, 1
• Action: ThingHTTP
• Action (then perform): IoT Button B
• Options: Run action each time condition is met

Save it, and create a third React app with the following:

• React Name: Button C React
• Condition Type: Numeric
• Test Frequency: On Data Insertion
• Condition (If channel): IoT Buttons (<CHANNEL_ID>)
• Condition (field): 3 (Button C), is greater than, 0
• Action: ThingHTTP
• Action (then perform): IoT Button C
• Options: Run action each time condition is met

Save your React app.

Arduino Code

Now that we have our data channels and IFTTT applet set up, it’s time to program the ESP8266 Thing Dev Board. Open up a new sketch in Arduino and paste in the code below. Change <YOUR WIFI SSID> to your WiFi’s network name, <YOUR WIFI PASSWORD> to your WiFi’s password, <YOUR THINGSPEAK CHANNEL ID> to your CHANNEL_ID, and <YOUR CHANNEL WRITE API KEY> to your ThingSpeak Write API Key (which you can find by going to your ThingSpeak IoT Buttons channel and clicking on the API Keys tab).

language:c
/**
 * IoT Kit - IoT Buttons
 * Author: Shawn Hymel (SparkFun Electronics)
 * Date: October 30, 2016
 *
 * Push one of three buttons to make something happen on the
 * Internet using IFTTT. Button C will generate a random number
 * between 1-100 to post to ThingSpeak.
 *
 * Connections:
 *   Thing Dev |  Button
 *  -----------|---------
 *       4     |    A
 *      12     |    B
 *      13     |    C
 *
 * Development environment specifics:
 *  Arduino IDE v1.6.5
 *  Distributed as-is; no warranty is given.
 */

#include <ESP8266WiFi.h>
#include "ThingSpeak.h"

// WiFi and Channel parameters
const char WIFI_SSID[] = "<YOUR WIFI SSID>";
const char WIFI_PSK[] = "<YOUR WIFI PASSWORD>";
unsigned long CHANNEL_ID = <YOUR THINGSPEAK CHANNEL ID>;
const char * WRITE_API_KEY = "<YOUR CHANNEL WRITE API KEY>";

// Pin definitions
const int BTN_A_PIN = 4;
const int BTN_B_PIN = 12;
const int BTN_C_PIN = 13;
const int LED_PIN = 5;

// Global variables
WiFiClient client;
int last_btn_a = HIGH;
int last_btn_b = HIGH;
int last_btn_c = HIGH;

void setup() {

  // Set up LED for debugging
  pinMode(LED_PIN, OUTPUT);

  // Connect to WiFi
  connectWiFi();

  // Initialize connection to ThingSpeak
  ThingSpeak.begin(client);

  // Seed the random number generator
  randomSeed(analogRead(A0));
}

void loop() {

  int btn_a;
  int btn_b;
  int btn_c;
  int rnd;

  // Look for a falling edge on button A with debounce
  btn_a = digitalRead(BTN_A_PIN);
  if ( (btn_a == LOW) && (last_btn_a == HIGH) ) {
    delay(30);
    if ( digitalRead(BTN_A_PIN) == LOW ) {
      digitalWrite(LED_PIN, LOW);
      ThingSpeak.writeField(CHANNEL_ID, 1, 1, WRITE_API_KEY);
    }
  }
  last_btn_a = btn_a;

  // Look for a falling edge on button B with debounce
  btn_b = digitalRead(BTN_B_PIN);
  if ( (btn_b == LOW) && (last_btn_b == HIGH) ) {
    delay(30);
    if ( digitalRead(BTN_B_PIN) == LOW ) {
      digitalWrite(LED_PIN, LOW);
      ThingSpeak.writeField(CHANNEL_ID, 2, 1, WRITE_API_KEY);
    }
  }
  last_btn_b = btn_b;

  // Look for a falling edge on button C with debounce
  // Randomly choose a number between 1-100 and post it
  btn_c = digitalRead(BTN_C_PIN);
  if ( (btn_c == LOW) && (last_btn_c == HIGH) ) {
    delay(30);
    if ( digitalRead(BTN_C_PIN) == LOW ) {
      digitalWrite(LED_PIN, LOW);
      rnd = random(1, 101);
      ThingSpeak.writeField(CHANNEL_ID, 3, rnd, WRITE_API_KEY);
    }
  }
  last_btn_c = btn_c;

  // Turn off LED
  digitalWrite(LED_PIN, HIGH);
}

// Attempt to connect to WiFi
void connectWiFi() {

  byte led_status = 0;

  // Set WiFi mode to station (client)
  WiFi.mode(WIFI_STA);

  // Initiate connection with SSID and PSK
  WiFi.begin(WIFI_SSID, WIFI_PSK);

  // Blink LED while we wait for WiFi connection
  while ( WiFi.status() != WL_CONNECTED ) {
    digitalWrite(LED_PIN, led_status);
    led_status ^= 0x01;
    delay(100);
  }

  // Turn LED off when we are connected
  digitalWrite(LED_PIN, HIGH);
}

Run It!

When you run the sketch on your Thing Dev board, you should be able to press one of the buttons. The buttons are as follows:

Having a hard time seeing the circuit? Click on the wiring diagram for a closer look.

For example, by pressing button B, you should receive a text on your phone.

When you press button C, the Thing Dev Board will generate a number between 1 and 100 and post it to your Twitter account.

Challenge

See if you can change the Button B functionality so that it will send you the temperature and humidity near the ESP8266 Thing Dev Board to your phone via SMS.

Experiment 3: Appliance Controller

Now that we’ve logged data and pushed some physical buttons to make virtual things happen, it’s time to make physical things happen when something virtual happens. OK, that’s a mouthful, but in essence, we’re going to turn on and off home appliances (120 VAC) from anywhere in the world (assuming we have an internet connection).

To make this work, we’ll have an IFTTT applet send an HTTP request to ThingSpeak to log a value in a data channel. Our ESP8266 Thing Dev Board will poll the ThingSpeak data channel for new values. If it finds one, it will turn the PowerSwitch Tail on or off and then send a request to ThingSpeak to clear the data channel.

Parts Needed

• SparkFun ESP8266 Thing Dev Board
• PowerSwitch Tail II
• 12mm Momentary Pushbutton
• 10k Ohm Resistor
• Breadboard
• M/M Jumper Wires

Hardware Hookup

Connect one button and the PowerSwitch Tail to the Thing Dev as shown:

Having a hard time seeing the circuit? Click on the wiring diagram for a closer look.

Create a ThingSpeak Data Channel

Head to ThingSpeak, and create a new channel. Name it Appliance Controller, and name Field 1 something appropriate (e.g., “Control”). On the channel dashboard, copy down the CHANNEL_ID, as we’ll need it later.

Get Your API Keys

From your channel’s dashboard, click on the API Keys tab. Copy down the WRITE_API_KEY and READ_API_KEY. We’ll need those later, too.

We’ll also need our ThingSpeak Account API Key, as that’s used to make delete requests to the data channel. In the top-right corner of ThingSpeak, click Account > My Account. Copy down the API Key found there. We’ll refer to this key as the <THINGSPEAK_ACCOUNT_API_KEY>.

Create IFTTT Applet

Navigate to IFTTT and create a new applet. For this section, search for weather.

You’ll be asked to connect the Weather channel. Follow the prompts to set your location to the nearest city. After that, select Sunset as the trigger.

For that, search for and select the Maker channel. Select Make a web request. Fill out the form with the parameters listed below, making sure to replace <WRITE_API_KEY> with your ThingSpeak Write API Key.

• URL: https://api.thingspeak.com/update
• Method: POST
• Content Type: application/x-www-form-urlencoded
• Body: api_key=<WRITE_API_KEY>&field1=1

Click Create action and Finish.

Arduino Code

With our channel and applet configured, let’s make some firmware to run on our ESP8266 Thing Dev. Copy in the code below, changing the parameters in the WiFi and Channel parameters section as noted.

language:c
/**
 * IoT Kit - Appliance Controller
 * Author: Shawn Hymel (SparkFun Electronics)
 * Date: November 11, 2016
 *
 * Set up an IFTTT applet to send an HTTP request to ThingSpeak
 * on a specific event, such as the sun setting. This sketch
 * monitors the channel and turns the attached appliance on or
 * off as requested before clearing the channel. A manual
 * override button can also toggle the appliance.
 *
 * Connections:
 *   Thing Dev | Button | PowerSwitch Tail II
 *  -----------|--------|---------------------
 *        4    |    A   |
 *       15    |        |       1 (+in)
 *      GND    |        |       2 (-in)
 *
 * Development environment specifics:
 *  Arduino IDE v1.6.5
 *  Distributed as-is; no warranty is given.
 */

#include <ESP8266WiFi.h>
#include "ThingSpeak.h"

// WiFi and Channel parameters
const char WIFI_SSID[] = "<YOUR WIFI SSID>";
const char WIFI_PSK[] = "<YOUR WIFI PASSWORD>";
unsigned long CHANNEL_ID = <YOUR THINGSPEAK CHANNEL ID>;
const char * READ_API_KEY = "<YOUR THINGSPEAK READ API KEY>";
const char * ACCOUNT_API_KEY = "<YOUR THINGSPEAK ACCOUNT API KEY>";

// Channel data definitions
const int CHANNEL_ERROR = 0;
const int APPLIANCE_ON = 1;
const int APPLIANCE_OFF = 2;

// Remote site information
const char HTTP_SITE[] = "api.thingspeak.com";
const int HTTP_PORT = 80;

// Pin definitions
const int LED_PIN = 5;
const int BTN_PIN = 4;
const int PST_PIN = 15;

// Global variables
WiFiClient client;
int appliance_state = 0;

void setup() {

  // Set up pins
  pinMode(LED_PIN, OUTPUT);
  pinMode(PST_PIN, OUTPUT);
  digitalWrite(PST_PIN, LOW);

  // Connect to WiFi
  connectWiFi();

  // Initialize connection to ThingSpeak
  ThingSpeak.begin(client);

  // For debugging
  Serial.begin(9600);

  // Send clear request to channel (start fresh)
  if (!clearChannel()) {
    Serial.println("Error connecting to ThingSpeak API");
  } else {
    Serial.println("Connected and listening!");
  }
}

void loop() {

  int val = -1;
  int btn;
  int last_btn = HIGH;
  unsigned long timestamp;
  unsigned long delay_time;

  // See if there was something posted to our channel
  val = ThingSpeak.readIntField(CHANNEL_ID, 1,READ_API_KEY);

  // If there is data on our channel, act on it and clear it
  if ( val > 0 ) {

    // If the value is a 1, turn on appliance
    if ( val == APPLIANCE_ON ) {
      Serial.println("Turning appliance on");
      appliance_state = 1;
      digitalWrite(PST_PIN, appliance_state);

    // If the value is a 2, turn off appliance
    } else if ( val == APPLIANCE_OFF ) {
      Serial.println("Turning appliance off");
      appliance_state = 0;
      digitalWrite(PST_PIN, appliance_state);
    }

    // Clear the data channel
    if ( !clearChannel() ) {
      Serial.println("Error: Could not clear channel!");
    } else {
      Serial.println("Channel cleared");
    }

    // Wait at least 15 seconds before polling the channel again
    delay_time = 15000;

  // No data. Try again later.
  } else {
    delay_time = 5000;
  }

  // Wait the required time before polling again
  timestamp = millis();
  while ( millis() < (timestamp + delay_time) ) {

    // Look for a falling edge on the button to toggle appliance
    btn = digitalRead(BTN_PIN);
    if ( (btn == LOW) && (last_btn == HIGH) ) {
      delay(30);
      if ( digitalRead(BTN_PIN) == LOW ) {
        appliance_state ^= 1;
        digitalWrite(PST_PIN, appliance_state);
      }
    }
    last_btn = btn;
    delay(1);
  }
}

// Attempt to connect to WiFi
void connectWiFi() {

  byte led_status = 0;

  // Set WiFi mode to station (client)
  WiFi.mode(WIFI_STA);

  // Initiate connection with SSID and PSK
  WiFi.begin(WIFI_SSID, WIFI_PSK);

  // Blink LED while we wait for WiFi connection
  while ( WiFi.status() != WL_CONNECTED ) {
    digitalWrite(LED_PIN, led_status);
    led_status ^= 0x01;
    delay(100);
  }

  // Turn LED off when we are connected
  digitalWrite(LED_PIN, HIGH);
}

// Send HTTP DELETE request to clear the channel
bool clearChannel() {

  // Attempt to make a connection to the remote server
  if ( !client.connect(HTTP_SITE, HTTP_PORT) ) {
    return false;
  }

  // Make an HTTP DELETE request
  client.print("DELETE /channels/");
  client.print(String(CHANNEL_ID));
  client.println("/feeds HTTP/1.1");
  client.print("Host: ");
  client.println(HTTP_SITE);
  client.println("Accept: */*");
  client.println("Accept-Encoding: gzip, deflate");
  client.println("Connection: close");
  client.println("Content-Type: application/x-www-form-urlencoded");
  client.println("Content-Length: 24");
  client.println();
  client.print("api_key=");
  client.println(ACCOUNT_API_KEY);

  return true;
}

Run It!

Save and upload the code to the Thing Dev Board. Plug in the PowerSwitch Tail to an outlet, and plug an appliance (e.g., a lamp) into the PowerSwitch Tail. Now, just wait for sunset (if you don’t want to wait for sunset, you can modify the IFTTT applet to trigger earlier; try the Challenge below).

Challenge

Download the IFTTT App for your smartphone. See if you can create an IFTTT applet that allows you to remotely turn a device on and off from your smartphone using the DO button.

Resources and Going Further

Monitoring temperature, interacting with web services and remotely controlling physical devices are just the beginning for IoT. These experiments have hopefully given you a taste for some of the things you can do with internet-connected devices. What other projects can you come up with?

Resources

• IoT Hobby Kit GitHub Repository
• ThingSpeak Documentation
• IFTTT Help Center

Going Further

Here are some other IoT projects you can use as inspiration:

learn.sparkfun.com |CC BY-SA 3.0 | SparkFun Electronics | Niwot, Colorado

9DoF Razor IMU M0 Hookup Guide a learn.sparkfun.com tutorial

Available online at: http://sfe.io/t567

Introduction

The SparkFun 9DoF Razor IMU M0 combines a SAMD21 microprocessor with an MPU-9250 9DoF (nine degrees of freedom) sensor to create a tiny, re-programmable, multi-purpose inertial measurement unit (IMU). It can be programmed to monitor and log motion, transmit Euler angles over a serial port, or to even act as a step-counting pedometer.

Added to your cart!

SparkFun 9DoF Razor IMU M0

In stock SEN-14001

The SparkFun 9DoF Razor IMU M0 combines a SAMD21 microprocessor with an MPU-9250 9DoF (9 Degrees of Freedom) sensor to create…

$49.95

FavoritedFavorite3

Wish List

The 9DoF Razor’s MPU-9250 features three, three-axis sensors – an accelerometer, gyroscope, and magnetometer – which gives it the ability to sense linear acceleration, angular rotation velocity, and magnetic field vector’s. The on-board microprocessor – Atmel’s SAMD21G18A– is an Arduino-compatible, 32-bit ARM Cortex-M0+ microcontroller also featured on the Arduino Zero and SAMD21 Mini Breakout boards.

In addition to pair of IC’s, the 9DoF Razor IMU includes a µSD card socket, LiPo battery charger, power-control switch, and a host of I/O break-outs for project expansion. It comes pre-programmed with example firmware and an Arduino-compatible bootloader, so you can customize the firmware and flash new code over a USB connection.

Covered In This Tutorial

This tutorial serves as both a primary documentation source and getting started guide for the SparkFun 9DoF Razor IMU M0. The first couple of sections document hardware and firmware features of the board, while the latter half of the tutorial demonstrates how to use the Arduino IDE and our MPU-9250 Arduino library to re-program the Razor IMU to your specific needs.

Bill of Materials

The 9DoF Razor IMU M0 comes populated with just about everything you could need to take advantage of the MPU-9250 9DoF sensor. There are just a handful of items – most of which you probably already have in your toolbox – you may need in addition to the board.

A micro-B USB cable can be used to both power and re-program the Razor. But, if you truly want to make the board mobile, you’ll need a single-cell Lithium-polymer (LiPo) battery, which can be recharged by plugging the 9DoF Razor into a USB supply. Additionally, if you want to log data, the 9DoF Razor IMU’s µSD socket supports any µSD card.

Added to your cart!

Lithium Ion Battery - 400mAh

In stock PRT-13851

This is a very small, extremely lightweight battery based on Lithium Ion chemistry, with the highest energy density currently…

$4.95

2

FavoritedFavorite3

Wish List

Lithium Ion Battery - 850mAh

Out of stock PRT-00341

These are very slim, extremely light weight batteries based on the new Polymer Lithium Ion chemistry. This is the highest ene…

11

FavoritedFavorite9

Wish List

Added to your cart!

USB microB Cable - 6 Foot

In stock CAB-10215

USB 2.0 type A to micro USB 5-pin. This is a new, smaller connector for USB devices. Micro USB connectors are about half the …

$4.95

7

FavoritedFavorite2

Wish List

Added to your cart!

MicroSD Card with Adapter - 8GB

18 available COM-11609

This is an 8 gig microSD memory card. It's perfect for massive datalogging without taking up a lot of space. These microSD ca…

$13.95

2

FavoritedFavorite6

Wish List

Finally, you may need soldering tools and headers or wire, if you want to take advantage of the 9DoF Razor IMU’s I/O and power breakouts.

Added to your cart!

Hook-Up Wire - Assortment (Stranded, 22 AWG)

In stock PRT-11375

An assortment of colored wires: you know it's a beautiful thing. Six different colors of stranded wire in a cardboard dispens…

$16.95

12

FavoritedFavorite18

Wish List

Added to your cart!

Female Headers

In stock PRT-00115

Single row of 40-holes, female header. Can be cut to size with a pair of wire-cutters. Standard .1" spacing. We use them exte…

$1.5

6

FavoritedFavorite28

Wish List

Added to your cart!

Solder Lead Free - 100-gram Spool

In stock TOL-09325

This is your basic spool of lead free solder with a water soluble resin core. 0.031" gauge and 100 grams. This is a good spoo…

$7.95

4

FavoritedFavorite14

Wish List

Added to your cart!

Soldering Iron - 30W (US, 110V)

In stock TOL-09507

This is a very simple fixed temp, quick heating, 30W 110/120 VAC soldering iron. We really enjoy using the more expensive iro…

$9.95

5

FavoritedFavorite14

Wish List

Suggested Reading

Feel free to jump right into using and developing on the 9DoF Razor IMU M0 – we’ve tried to make the board as easy to use regardless of you electronics experience level. If you’d like to do some pre-reading, though, here are a few tutorials we might recommend:

Hardware Overview

The 9DoF Razor IMU M0 is a double-sided assembly, which means there’s a lot going on on both sides of the board. Here’s an overview of what we’ll call the “top” of the board.

While the bottom of the board includes the various connectors, power control switch, and LEDs.

Powering the 9DoF Razor IMU M0

The Razor IMU is designed to work with either a USB power source or a single-cell Lithium-polymer (LiPo) battery. The black, PH-series JST connector should mate with any of the similar LiPo batteries in our catalog – just make sure they’re single cell (nominal voltage 3.7-4.2V).

Connect both USB and a LiPo to charge the battery.

If both USB and LiPo battery are plugged into the board simultaneously, the LiPo will charge at a rate of up to 450mA. Charge status is indicated by the yellow charge LED, which will turn off when the battery is fully charged.

Power from either the USB or LiPo battery sources are regulated down to 3.3V, which is used to power both the SAMD21 and MPU-9250. The regulator has a capacity for about 600mA, which means you should have plenty of current overhead left over, if you want to power other devices from the 3V3-labeled pins.

The VIN, VBAT, and GND pins can be used to supply the 9DoF Razor IMU’s 3.3V regulator, instead of the USB or LiPo JST inputs. Voltage on the VIN pin should not exceed 6V, and the VBAT pin should only be connected to a single-cell LiPo battery.

Finally, the ON/OFF switch, on the bottom side of the board, controls power between both input sources and the rest of the components on the board. While in the “OFF” position, the LiPo battery will still be able to charge, but no other components should be energized.

SAMD21 and Power Supply Pin Breakouts

We’ve broken out as many of the SAMD21’s I/O pins as the 9DoF Razor IMU’s small form factor would allow us. That includes pins 10-13, which can be used as an SPI interface, analog-to-digital converter inputs A0-A4, RX, TX, and the I²C pins, SDA and SCL.

You can solder headers or wire to these pins, to expand on the board’s features. For example, you can plug a BME280 breakout directly into the I²C port, and add altitude and temperature sensing to your IMU.

A number of our I²C-based breakouts use the same 4-pin footprint, so you can interface them directly!

The SAMD21’s single-wire debug (SWD) port is broken out on the top side of the board as well, in case you want to program the chip with a JTAG debugger. The pinout of this port matches the 10-pin Cortex Debug connector standard. A white “notch” indicates pin 1 of this port.

MPU-9250 Accel/Gyro/Mag Orientation

The orientation of the accelerometer, gyroscope, and magnetometer’s x-, y-, and z-axes are determined by the placement of the MPU-9250. For easy reference, we’ve documented these vectors on the top side of the board.

Note that the magnetometer’s x and y axes are flipped from those of the accelerometer and gyroscope, and the z-axis is inverted as well.

Getting Started With the Example Firmware

In addition to an Arduino bootloader, we’ve also loaded the 9DoF Razor IMU M0 with some example firmware – enough to at least prove that the sensor’s motion tracking works, and even do a little logging to a µSD card. To start using the example firmware, simply plug the Razor IMU into a computer.

After plugging the board in, it should show up as a serial port. On Windows, that looks something like COMX and on Mac, it should look like /dev/tty.usbserial-ABCD12.

After locating your board’s port, open up a serial terminal and set the baud rate to 115200 bps. The Arduino Serial Monitor works well for this purpose, or you can download one of our recommended terminal programs.

Upon opening the port, your 9DoF Razor IMU should immediately begin spouting out accelerometer, gyroscope, and magnetometer readings.

The format of this default string is:

<timeMS>, <accelX>, <accelY>, <accelZ>, <gyroX>, <gyroY>, <gyroZ>, <magX>, <magY>, <magZ>

The string can be modified by sending any of the following commands:

• (SPACE) – Pause/resume serial port printing
• a– Turn accelerometer readings on or off
• g– Turn gyroscope readings on or off
• m– Turn magnetometer readings on or off
• q– Turn quaternion readings on or off (qw, qx, qy, and qz are printed after mag readings)
• e– Turn Euler angle calculations (pitch, roll, yaw) on or off (printed after quaternions)
• c– Switch to/from calculated values from/to raw readings
• r– Adjust log rate in 10Hz increments between 1-100Hz (1, 10, 20, …, 100)
• A– Adjust accelerometer full-scale range. Cycles between ± 2, 4, 8, and 16g.
• G– Adjust gyroscope full-scale range. Cycles between ± 250, 500, 1000, 2000 dps.
• s– Enable/disable SD card logging

All settings are stored in non-volatile memory, so the next time you boot up your 9DoF Razor, it should output the same data you configured it to previously.

In addition to logging to your serial port, the firmware is also designed to log the data to a µSD card, if it’s present. Load one up, and you should end up with IMU log files the next time you plug the SD card into your reader.

Installing the 9DoF Razor Arduino Core

The 9DoF Razor IMU M0 is designed around the SAMD21 – the same processor on the Arduino Zero – which means adding Arduino support for the board is just a few clicks away. This section describes the steps you’ll need to take to install the SAMD cores into your Arduino library (that sounds scarier than it actually is).

Install Arduino SAMD Boards

First, you’ll need to install a variety of tools, including low-level ARM Cortex libraries full of generic code, arm-gcc to compile your code, and bossa to upload code via the bootloader. These tools come packaged along with Arduino’s SAMD board definitions for the Arduino Zero.

To install the Arduino SAMD board definitions, navigate to your board manager (Tools>Board>Boards Manager…), then find an entry for Arduino SAMD Boards (32-bits ARM Cortex-M0+). Select it, and install the latest version (recently updated to 1.6.8).

Downloading and installing the tools may take a couple minutes – arm-gcc in particular will take the longest, it’s about 250MB unpacked.

Once installed, Arduino-blue “Installed” text should appear next to the SAMD boards list entry.

Install SparkFun Board Definition

Now that your ARM tools are installed, one last bit of setup is required to add support for the SparkFun SAMD boards. First, open your Arduino preferences (File>Preferences). Then find the Additional Board Manager URLs text box, and paste the below link in:

https://raw.githubusercontent.com/sparkfun/Arduino_Boards/9DoF_M0/IDE_Board_Manager/package_sparkfun_index.json

Then hit “OK”, and travel back to the Board Manager menu. You should be able to find a new entry for SparkFun SAMD Boards.

This installation should be much faster; you’ve already done the heavy lifting in the previous section.

Select the Board and Serial Port

Once the board is installed, you should see a few new entries in your Tools>Board list, including SparkFun 9DoF Razor IMU M0, under the “SparkFun SAMD (32-bits ARM Cortex-M0+) Boards” menu.

Finally, select your 9DoF Razor’s port, by navigating back up to the Tools>Port menu.

In the next section, we’ll load up the example firmware, so you can customize it and build upon it as you create your own motion-sensing project.

Libraries and Example Firmware

In addition to the SAMD board definitions, the 9DoF Razor IMU M0’s example firmware requires an additional library: the SparkFun MPU-9250 Digital Motion Processing (DMP) library. You can grab the MPU-9250-DMP library from GitHub, or by clicking the link below:

Download the SparkFun MPU-9250 DMP Library

You’ll also need the FlashStorage Arduino library installed on your machine. This library allows your SAMD21’s excess flash memory to substitute for EEPROM – giving it non-volatile memory so it can retain your serial commands.

Download the FlashStorage Arduino Library

To install the libraries, unzip the ZIP files, and place the library folders into your Arduino sketchbook. For more help installing Arduino libraries, check out our Installing an Arduino Library tutorial.

After installing the libraries, open Arduino (or close and restart it if it was open).

Download and Upload the Example Firmware

The 9DoF Razor IMU M0’s example firmware can be found in our 9DoF Razor GitHub repository. Or you can click the button below to download it.

Download the 9DoF Razor IMU M0's Example Firmware

The firmware includes a pair of files – the standard .ino file with the main source, and a config.h file, which consists mostly of defines, which you can modify to quickly customize the firmware. Make sure both tabs are open in your Arduino IDE before attempting to compile and upload.

Once you’ve installed the libraries, loaded the code, and have the SparkFun 9DoF Razor M0 board selected, upload it to your board. You probably won’t see any new behavior on your 9DoF Razor IMU, but it’ll proof that you’ve got everything installed correctly.

Using the MPU-9250 DMP Arduino Library

Here are some quick tips to help you get started writing your own firmware for the 9DoF Razor IMU M0 using the SparkFun MPU-9250 DMP Arduino Library.

Set Up

As with any library, to call it into your sketch you’ll need to include it at the top. You’ll also need to create an object of type MPU9250_DMP– we’ll make one called imu, which will be used throughout the sketch.

language:c
#include <SparkFunMPU9250-DMP.h> // Include SparkFun MPU-9250-DMP library
//#include <Wire.h> // Depending on your Arduino version, you may need to include Wire.h

MPU9250_DMP imu; // Create an instance of the MPU9250_DMP class

Then, in the setup function initialize the MPU-9250 by calling imu.begin(). You can check the return value of this function to ensure that the IMU is correctly connected and was successfully initialized.

language:c
if (imu.begin() != INV_SUCCESS)
{
    while (1)
    {
        // Failed to initialize MPU-9250, loop forever
    }
}

Configuring the MPU-9250

Once you’ve initialized the MPU-9250, you can configure it to your hearts desire. You can use setSensors to enable/disable specific sensors in the IMU. Disabling the gyroscope and magnetometer, for example, can save loads of power consumption.

language:c
// Use setSensors to turn on or off MPU-9250 sensors.
// Any of the following defines can be combined:
// INV_XYZ_GYRO, INV_XYZ_ACCEL, INV_XYZ_COMPASS,
// INV_X_GYRO, INV_Y_GYRO, or INV_Z_GYRO
imu.setSensors(INV_XYZ_GYRO | INV_XYZ_ACCEL | INV_XYZ_COMPASS); // Enable all sensors

You can also set the full-scale range of both the accelerometer and gyroscope using the setAccelFSR and setGyroFSR functions. (The magnetometer only has one possible full-scale range – ±4912 µT.)

language:c
// Use setGyroFSR() and setAccelFSR() to configure the
// gyroscope and accelerometer full scale ranges.
// Gyro options are +/- 250, 500, 1000, or 2000 dps
imu.setGyroFSR(2000); // Set gyro to 2000 dps
// Accel options are +/- 2, 4, 8, or 16 g
imu.setAccelFSR(2); // Set accel to +/-2g

The gyroscope can be set to ranges of ±250, 500, 1000, or 2000 degrees per second (dps), and the accelerometer supports ranges of ±2, 4, 8, or 16 g.

Finally, you can configure the digital low pass filter (DLPF) and sample rate of the sensors:

language:c
// setLPF() can be used to set the digital low-pass filter
// of the accelerometer and gyroscope.
// Can be any of the following: 188, 98, 42, 20, 10, 5
// (values are in Hz).
imu.setLPF(5); // Set LPF corner frequency to 5Hz

// The sample rate of the accel/gyro can be set using
// setSampleRate. Acceptable values range from 4Hz to 1kHz
imu.setSampleRate(10); // Set sample rate to 10Hz

// Likewise, the compass (magnetometer) sample rate can be
// set using the setCompassSampleRate() function.
// This value can range between: 1-100Hz
imu.setCompassSampleRate(10); // Set mag rate to 10Hz

The sample rate of the accelerometer and gyroscope can reach 1kHz, while the maximum sample rate of the magnetometer is 100Hz. The corner frequency of the low-pass filter – which operates on the accelerometer and gyroscope only – can be set to 5, 10, 20, 42, 98, or 188Hz.

Reading from the MPU-9250

Once your IMU is configured to fit your needs, reading from the sensor is as simple as calling imu.update() and checking the ax, ay, az, ax, ay, az, ax, ay, and mz class variables (e.g. imu.ax, imu.gy, imu.mz, etc).

language:c
// Call update() to update the imu objects sensor data. You can specify
// which sensors to update by OR'ing UPDATE_ACCEL, UPDATE_GYRO,
// UPDATE_COMPASS, and/or UPDATE_TEMPERATURE.
// (The update function defaults to accel, gyro, compass, so you don't
// have to specify these values.)
imu.update(UPDATE_ACCEL | UPDATE_GYRO | UPDATE_COMPASS);

The variables can be converted from raw, signed 16-bit values to their sensor’s respective units by passing them to the calcGyro, calcAccel, and calcMag functions:

language:c
float accelX = imu.calcAccel(imu.ax); // accelX is x-axis acceleration in g's
float accelY = imu.calcAccel(imu.ay); // accelY is y-axis acceleration in g's
float accelZ = imu.calcAccel(imu.az); // accelZ is z-axis acceleration in g's

float gyroX = imu.calcGyro(imu.gx); // gyroX is x-axis rotation in dps
float gyroY = imu.calcGyro(imu.gy); // gyroY is y-axis rotation in dps
float gyroZ = imu.calcGyro(imu.gz); // gyroZ is z-axis rotation in dps

float magX = imu.calcMag(imu.mx); // magX is x-axis magnetic field in uT
float magY = imu.calcMag(imu.my); // magY is y-axis magnetic field in uT
float magZ = imu.calcMag(imu.mz); // magZ is z-axis magnetic field in uT

Using the Interrupt or Data-Ready

Instead of constantly polling the update function, you can use the MPU-9250’s interrupt output to tell you when new data is ready. First, in the setup area, you should call enableInterrupt. (Don’t forget to set your Arduino’s interrupt pin as an input as well!)

language:c
#define INTERRUPT_PIN 4 // MPU-9250 INT pin tied to D4
...
void setup()
{
    pinMode(INTERRUPT_PIN, INPUT_PULLUP); // Set interrupt as an input w/ pull-up resistor
    ...
    // Use enableInterrupt() to configure the MPU-9250's
    // interrupt output as a "data ready" indicator.
    imu.enableInterrupt();

    // The interrupt level can either be active-high or low. Configure as active-low.
    // Options are INT_ACTIVE_LOW or INT_ACTIVE_HIGH
    imu.setIntLevel(INT_ACTIVE_LOW);

    // The interrupt can be set to latch until data is read, or as a 50us pulse.
    // Options are INT_LATCHED or INT_50US_PULSE
    imu.setIntLatched(INT_LATCHED);
}

You can set the interrupt’s active level to high or low, and set it to latch until the sensor is read or to send a 50µs pulse.

Once configured, simply read the status of your Arduino’s interrupt pin. If it’s active, you’ll know to update the IMU’s sensors.

language:c
if ( digitalRead(INTERRUPT_PIN) == LOW ) // If MPU-9250 interrupt fires (active-low)
{
    imu.update() // Update all sensor's
    // ... do stuff with imu.ax, imu.ay, etc.
}

Alternatively – if you don’t want to use the interrupt pin – you can check the return value of dataReady, to check if new data is available. This function returns a boolean – true if new data is ready.

language:c
if ( imu.dataReady() ) // If new IMU data is available
{
    imu.update(); // Update all sensor's
    ...
}

Using the Digital Motion Processor

The MPU-9250’s digital motion processor (DMP) allows you to offload tasks like quaternion calculation, step-counting, and orientation-determining off to the IMU.

Configuring the Digital Motion Processor (DMP)

To use any of those functions, you first need to initialize the DMP by calling the dmpBegin function. This should be called after imu.begin().

dmpBegin’s first parameter specifies which features of the DMP you want to enable. It can be an OR’d combination of any of the following:

• DMP_FEATURE_PEDOMETER– Pedometer counts steps and the amount of time those steps were taken in.
• DMP_FEATURE_TAP– Single and/or double-tap detection in any of the three planes.
• DMP_FEATURE_ANDROID_ORIENT– Detects portrait, landscape, reverse portrait, and reverse landscape orientations.
• DMP_FEATURE_6X_LP_QUAT– 6-axis (accelerometer and gyroscope) quaternion calculation.
• DMP_FEATURE_LP_QUAT– Low-power (accelerometer only) quaternion calculation.
• DMP_FEATURE_GYRO_CAL– Gyroscope calibration. After 8 seconds of no motion, the gyroscope axes are re-calibrated to 0.
• DMP_FEATURE_SEND_RAW_ACCEL– Sends raw accelerometer data to the DMP’s FIFO buffer.
• DMP_FEATURE_SEND_RAW_GYRO– Sends raw gyroscope data to the DMP’s FIFO buffer.
• DMP_FEATURE_SEND_CAL_GYRO– Sends calibrated gyroscope data to the DMP’s FIFO buffer.

Note that the pair of quaternion-calculating features are mutually exclusive – only use one of those features at a time. The same goes for the calibrated and raw gyroscope data gathering features.

A second, optional parameter for dmpBegin is the update rate, which can be anywhere between 4 and 200 Hz. Here’s a quick example, demonstrating how to initialize the DMP to stream accelerometer, calibrated gyroscope, and quaternion data:

language:c
void setup
{
    imu.begin(); // Initialize the MPU-9250.

    // Initialize the digital motion processor
    imu.dmpBegin(DMP_FEATURE_SEND_RAW_ACCEL | // Send accelerometer data
                 DMP_FEATURE_GYRO_CAL       | // Calibrate the gyro data
                 DMP_FEATURE_SEND_CAL_GYRO  | // Send calibrated gyro data
                 DMP_FEATURE_6X_LP_QUAT     , // Calculate quat's with accel/gyro
                 10);                         // Set update rate to 10Hz.
}

Reading from the DMP

The DMP streams its data to the MPU-9250’s 512-byte first-in, first-out (FIFO) buffer, so to get data from the DMP, the FIFO must be updated. You can use the fifoAvailable function, to check how full the FIFO is. Then call dmpUpdateFifo to read from the top of the FIFO.

language:c
if ( imu.fifoAvailable() > 0 ) / Check for new data in the FIFO
{
    // Use dmpUpdateFifo to update the ax, gx, qx, etc. values
    if ( imu.dmpUpdateFifo() == INV_SUCCESS )
    {
        // The following variables will have data from the top of the FIFO:
        // imu.ax, imu.ay, imu.az, -- Accelerometer
        // imu.gx, imu.gy, imu.gz -- calibrated gyroscope
        // and imu.qw, imu.qx, imu.qy, and imu.qz -- quaternions
    }
}

Check out the Examples!

The MPU-9250 DMP library includes a handful of examples, which demonstrate everything from getting raw sensor data from the IMU to using the digital motion processor to track steps or orientation. Check out those examples under the File>Examples>SparkFun MPU-9250 DMP Arduino Library menu as you continue working with the library.

Resources and Going Further

Our GitHub repostiory for the SparkFun 9DoF Razor IMU M0, includes all of our hardware and firmware design files. You can check out the board’s schematic, Eagle PCB layout, or the example firmware over there.

For more on the 9DoF Razor IMU’s MPU-9250, here are a handful of resources worth checking out:

• Datasheet (PDF)
• Register Map (PDF)
• Embedded MotionDriver 6.12 Firmware & Library– The source and library blob for Invensense’s motion processing library, which supports the MPU-9250. (Registration with Invensense required.)
• SparkFun MPU-9250 Breakout– A small breakout for the MPU-9250, complete with an excellent hookup guide!

There are plenty of tutorials left, if you need some project inspiration. Check out some of these related tutorials:

learn.sparkfun.com |CC BY-SA 3.0 | SparkFun Electronics | Niwot, Colorado

MAX30105 Particle and Pulse Ox Sensor Hookup Guide a learn.sparkfun.com tutorial

Available online at: http://sfe.io/t577

Introduction

The SparkFun MAX30105 Particle Sensor is a flexible and powerful sensor enabling sensing of distance, heart rate, particle detection, even the blinking of an eye. This tutorial will get you up and running to get the raw data from the sensor.

Added to your cart!

SparkFun Particle Sensor Breakout - MAX30105

In stock SEN-14045

The SparkFun MAX30105 Particle Sensor is a flexible, powerful sensor enabling sensing of distance, heart rate, particle detec…

$12.95

FavoritedFavorite3

Wish List

Behind the window on the left, the MAX30105 has three LEDs. On the right is a very sensitive photon detector. The idea is that you obstruct the different LEDs, detecting what light shines back at the detector, and, based on the signature, you can tell the presence of different types of particles or materials (such as oxygenated blood or smoke from a fire).

Close up photo of the MAX30105 sensor.

Suggested Materials

You’ll need a handful of extra parts to get the MAX30105 breakout up-and-running. Below are the components used in this tutorial, if you want to follow along.

A microcontroller that supports I²C is required to communicate with the MAX30105 and relay the data to the user. The SparkFun RedBoard or Arduino Uno are popular options for this role, but just about any microcontroller development board should work. (The firmware examples use an Arduino library, if that serves as any extra motivation to use an Arduino.)

Added to your cart!

SparkFun RedBoard - Programmed with Arduino

In stock DEV-12757

At SparkFun we use many Arduinos and we're always looking for the simplest, most stable one. Each board is a bit different an…

$19.95

108

FavoritedFavorite73

Wish List

Added to your cart!

Arduino Pro Mini 328 - 5V/16MHz

In stock DEV-11113

It's blue! It's thin! It's the Arduino Pro Mini! SparkFun's minimal design approach to Arduino. This is a 5V Arduino running …

$9.95

99

FavoritedFavorite66

Wish List

Added to your cart!

Arduino Uno - R3

In stock DEV-11021

This is the new Arduino Uno R3. In addition to all the features of the previous board, the Uno now uses an ATmega16U2 instead…

$24.95

83

FavoritedFavorite68

Wish List

Added to your cart!

SparkFun SAMD21 Mini Breakout

Out of stock DEV-13664

If you’re ready to step your Arduino game up from older 8-bit/16MHz microcontrollers, the SparkFun SAMD21 Mini Breakout is …

$19.95

5

FavoritedFavorite10

Wish List

Four or five jumper wires and a breadboard help interface the sensor to your Arduino. To insert the breakout into the breadboard, you’ll need to solder headers or cut jumper wires to the pins. (Don’t forget a soldering iron and solder!)

Added to your cart!

Breadboard - Self-Adhesive (White)

In stock PRT-12002

This is your tried and true white solderless breadboard. It has 2 power buses, 10 columns, and 30 rows - a total of 400 tie i…

$4.95

26

FavoritedFavorite33

Wish List

Added to your cart!

Break Away Headers - Straight

In stock PRT-00116

A row of headers - break to fit. 40 pins that can be cut to any size. Used with custom PCBs or general custom headers. **Fea…

$1.5

20

FavoritedFavorite43

Wish List

Added to your cart!

Jumper Wires Premium 4" M/M - 20 AWG (30 Pack)

In stock PRT-13870

These are 101mm long 20AWG jumpers with male connectors on both ends. Use these to jumper from any female header on any board…

$1.95

FavoritedFavorite2

Wish List

Added to your cart!

Soldering Iron - 30W (US, 110V)

In stock TOL-09507

This is a very simple fixed temp, quick heating, 30W 110/120 VAC soldering iron. We really enjoy using the more expensive iro…

$9.95

5

FavoritedFavorite14

Wish List

Suggested Reading

The MAX30105 is designed for a handful of uses including Pulse Oximetry. If you’re unfamiliar with optical pulse detection there are some very good app notes from TI and NXP that have great starter information.

The MAX30105 communicates over I²C. We’ve got a great library to make it easy to use. And, we’re going to be using a breadboard to connect the breakout board to the RedBoard. If any of these subjects sound foreign to you, consider browsing through that tutorial before continuing.

MAX30105 Breakout Overview

The MAX30105 has three on-board LEDs (seen on the left). Maxim recommends these LEDs be powered from 5V, but we’ve found the LEDs work fine at 3.3V. The red and IR LEDs are guaranteed to work at 3.3V, but the green LED may need 3.5V. It’s best to try out your board at 3.3V and see if the green LED illuminates.

The IC itself runs at 1.8V, so we’ve included the interface logic to allow you to hook the MAX30105 Breakout Board to any board that has 5V, 3.3V, even 1.8V level I/O.

The GND/5V/SDA/SCL pin-out is the standard I²C connection on most of our products. This allows you to easily connect I²C boards to many of our platforms.

There are two jumpers on the back of the PCB:

• The PU jumper is used on many I²C boards to allow the user to disconnect the 4.7k Ohm pull-up (PU) resistors from the SDA and SCL lines. By default, this jumper is closed meaning there are 4.7k pull-up resistors on SDA and SCL. If this is the only device on the I²C bus, then this jumper should be left closed. If there are multiple I²C devices or breakout boards on the bus with pull-up resistors, then the traces in this jumper should be cut to remove the 4.7k Ohm resistors from the bus. If needed, the jumper can be re-soldered to close it again in the future.

• The INT jumper is used to control the pull-up resistor on the interrupt pin. The INT jumper is closed by default, which means a 4.7k resistor is pulling up the interrupt pin. The INT pin on the MAX30105 is an open drain pin. If there is only one board on your I²C bus, this jumper should be left closed. If there are multiple boards on the I²C bus sharing a single interrupt pin, this jumper can be cut to disconnect the pull up resistor.

Hardware Hookup

Four wires is all you need but consider using connecting the board with soldered wires instead of a breadboard!

Because this sensor can be used in a multitude of ways, consider how you’re going to use the MAX30105 before soldering. If you plan to use the sensor for pulse oximetry, we recommend soldering short wires to the board to enable some movement when the sensor is attached to a finger. If you’re more interested in static sensing like particle or air monitoring, consider soldering male headers to the board.

Here’s an example of using jumper wires to make a robust connection to the MAX30105 board.

These jumper wires contain stranded wire, which make them more flexible and less prone to breaking from repeated movement.

Pick four different color wires, and cut them to your desired length. We use red, black, yellow and blue to make things easy to identify.

Strip the ends of the wire, and solder them into their various spots. A connection to the INT pin is optional and not needed for the Arduino examples below.

Getting small gauge wires to stay in place can be tough. I like to use sticky tack to hold everything in place while I solder.

Sticky tack is your friend!

You can pick any colors you want, but using different colors for each pin will make it easier to distinguish between connections.

Recommended wire colors: Red-VCC, Black-GND, Yellow-SCL, Blue-SDA

Stranded wire is better at flexing than solid core wire. However, without stress relief, even these stranded wires may break due to lots of flexing.

Wires soldered into place

Adding a bit of hot-glue where the wires meet the PCB will make the board even more robust and resistant to damage when you start “speaking” with your hands.

Using the SparkFun MAX30105 Arduino Library

Let’s get right to it! We’ve written an Arduino library for the MAX30105 and MAX30102 (it should work with the MAX30101 as well), which takes care of all of the I²C communication, bit-shifting, register-writing, and sample-reading. The library supports the MAX30102 (Red and IR LEDs only) and the MAX30105 (Red, IR, and Green LEDs).

The easiest way to install the library is through the Arduino Library manager.

Type MAX30105 into the Search box and select the SparkFun Library.

Click on the SparkFun library to highlight it, then click on the Install button.

Once you’ve downloaded the library, you should see the Example sketches by navigating to

File > Examples > SparkFun MAX3010x Pulse and Proximity Sensor Library > Examples

While you’re there, go ahead and open Example1 Basic Readings.

If you’d rather grab the most recent version of the library from our SparkFun MAX3010x Sensor GitHub repository, you can do that too!

Download the SparkFun MAX3010x Arduino Library

Then follow along with our How to Install an Arduino Library tutorial for help installing the library. If you download the library’s ZIP file, you can use Arduino’s “Add ZIP Library…” feature to install the source and example files with just a couple clicks.

Example 1 - Reading Red/IR/Green

Once you’ve got the library installed, open the Example1 Basic Readings sketch. You can find it under

File > Examples > SparkFun MAX3010x Pulse and Proximity Sensor Library > Examples

Then load it onto your RedBoard or Uno. Open your favorite Serial Terminal to see the printed values.

This example outputs the raw values read by the sensor. With the sensor pointing up, use your hand to hover over the sensor. You should see a change in values as your hand reflects different amounts of light. Note that the IR readings will probably change before the Red and Green readings. IR is better at sensing distance changes.

Completely cover the sensor with your finger. Note the very large readings. This is one of the features that sets the MAX30105 from other reflectance sensors. The IC is capable of reading up to 18-bits or values up to 262,144. An extremely small change in light can be detected!

The MAX30105 is easy to use! Calling particleSensor.getGreen() will take a reading and return the reflected amount of green light.

Example 2 - Presence Sensing

Open the Example2 Presence Sensing sketch, and load it onto your RedBoard or Uno.

This example takes a handful of readings during setup and averages them together. It uses this average as a baseline. If the sensor detects a significant change from the average, then “Something is there!” is printed. This is useful when you need to detect if a ball drops through a channel or other photo-gate situations. It’s also handy for testing the range at which the sensor can detect something.

language:c
//Setup to sense up to 18 inches, max LED brightness
byte ledBrightness = 0xFF; //Options: 0=Off to 255=50mA
byte sampleAverage = 4; //Options: 1, 2, 4, 8, 16, 32
byte ledMode = 2; //Options: 1 = Red only, 2 = Red + IR, 3 = Red + IR + Green
byte sampleRate = 400; //Options: 50, 100, 200, 400, 800, 1000, 1600, 3200
int pulseWidth = 411; //Options: 69, 118, 215, 411
int adcRange = 2048; //Options: 2048, 4096, 8192, 16384

particleSensor.setup(ledBrightness, sampleAverage, ledMode, sampleRate, pulseWidth, adcRange); //Configure sensor with these settings

What is this block of code doing?

During setup this code initializes the sensor. There are many different options and configurations for the MAX30105. You can define as many or as few as you’d like. You can also skip them all:

language:c
particleSensor.setup(); //Configure sensor with default settings

The sensor will be configured with the default settings. The default settings work for most applications.

Example 3 - Temperature Sensor

Open the Example3 Temperature Sense sketch, and load it onto your RedBoard or Uno.

This example outputs readings from the on-board temperature sensor in both Celsius and Fahrenheit. The temp sensor is accurate to +/-1 C but has an astonishing precision of 0.0625 C.

The temperature is used internally by the sensor to calibrate its samples but can be useful if you need a sensitive and fast responding temp sensor.

Example 4 - Heart Beat Plotting

This is where the fun really begins! Hemoglobin reflects IR light really well, and the MAX3015 is capable of detecting such small changes in IR reflectance that it can detect blood flowing through your finger at different rates. Let’s graph it! Open the Example4 HeartBeat Plotter sketch, and load it on your Redboard or Uno.

For this demo, you’ll need a rubber band small enough to go through the mounting holes on the breakout.

Loop the band back onto itself, and pull gently. You want a little bit of pressure holding your finger against the sensor. If the end of your finger turns pale, you’ve tightened too much!

Graph of IR data - That’s my pulse!

Instructions:

1. Load code onto Redboard
2. Attach sensor to your finger with a rubber band
3. Open Tools->Serial Plotter
4. Make sure the drop down is set to 115200 baud
5. Checkout the blips!
6. Feel the pulse on your neck and watch it mimic the blips

Now that we have seen the blips, Example 5 will try to calculate the time between blips and show us beats per minute (BPM).

Example 5 - HeartRate

Open the Example5 HeartRate sketch, and load it on your Redboard or Uno.

This example runs a filter called the PBA or Penpheral Beat Amplitude algorithm on the IR data. This algorithm is able to pull out the blips from all the noise and calculate the time between blips to get a heart rate. The output is your instantaneous heart rate and your average heart rate (BPM).

As one might expect the human body isn’t as precise as a metronome. The time between pulses can vary quite a bit so this sketch takes a running average of 4 readings to try to smooth out the variance.

Trouble? Try moving the sensor to a different finger. The rubber rand should be snug but not tight. The algorithm takes a few seconds to determine the peaks and troughs, so each time you move the sensor, wait a few seconds for the readings to make sense.

Advanced Functions

The MAX30105 is highly configurable, and there are a large number of functions exposed in the library to the user. Checkout the MAX30105.h file for all the functions, but here are the major ones. Read the MAX30105 datasheet for more information.

The library supports the following functions:

• .begin(wirePort, i2cSpeed) - If you have a platform with multiple I²C ports, pass the port object when you call begin. You can increase the I²C speed to 400kHz by including I2C_SPEED_FAST when you call .begin() as well.
• .setup() - Initializes the sensor with various settings. See the Example 2 for a good explanation of the options.
• .getRed() - Returns the immediate red value
• .getIR() - Returns the immediate IR value
• .getGreen() - Returns the immediate Green value
• .available() - Returns how many new samples are available
• .readTemperature() - Returns the temperature of the IC in C
• .readTemperatureF() - Returns the temperature of the IC in F
• .softReset() - Resets everything including data and configuration
• .shutDown() - Powers down the IC but retains all configuration
• .wakeUp() - Opposite of shutDown
• .setLEDMode(mode) - Configure the sensor to use 1 (Red only), 2 (Red + IR), or 3 (Red + IR + Green) LEDs
• .setADCRange(adcRange) - Set ADC to be at 2048, 4096, 8192, or 16384
• .setSampleRate(sampleRate) - Configure the sample rate: 50, 100, 200, 400, 800, 1000, 1600, 3200

Interrupts

• .getINT1() - Returns the main interrupt group
• .getINT2() - Returns the temp ready interrupt

Enable/disable individual interrupts. See page 13 and 14 of the datasheet for an explanation of each interrupt:

• .enableAFULL()
• .disableAFULL()
• .enableDATARDY()
• .disableDATARDY()
• .enableALCOVF()
• .disableALCOVF()
• .enablePROXINT()
• .disablePROXINT()
• .enableDIETEMPRDY()
• .disableDIETEMPRDY()

FIFO

The MAX30105 has a 32 byte FIFO. This allows us do other things on our microcontroller while the sensor is taking measurements. See Example 6 for an explanation of how to poll the FIFO.

• .check() - Call regularly to pull data in from sensor
• .nextSample() - Advances the FIFO
• .getFIFORed() - Returns the FIFO sample pointed to by tail
• .getFIFOIR() - Returns the FIFO sample pointed to by tail
• .getFIFOGreen() - Returns the FIFO sample pointed to by tail

Resources and Going Further

For more on the MAX30105 Particle Sensor Breakout Board the Maxim MAX3010x, check out the links below:

• MAX30105 Breakout Board GitHub Repository– Home base for the sensor’s latest design files
• MAX30105 Breakout Board Schematic (PDF)
• MAX30105 Breakout Board Eagle Files (ZIP)
• MAX30105 Datasheet (PDF)
• SparkFun MAX3010x Sensor Library GitHub Repository– Source and example files for the Arduino library used in this tutorial.

How Can You Help?

The MAX30105 is a very powerful sensor but we’ve only scratched the surface of what it’s capable of. If you are an algorithms guru and have a better method for calculating heart rate, or SPO2, or particle detection we would love to hear from you! Please send us a link to your repo, and we’ll include it here.

For more sensor action, check out these other great SparkFun tutorials.

learn.sparkfun.com |CC BY-SA 3.0 | SparkFun Electronics | Niwot, Colorado

Importing Custom Images into Eagle a learn.sparkfun.com tutorial

Available online at: http://sfe.io/t606

Introduction

Creating custom artwork on your PCB can be a fun way to personalize your project, add a company logo, or go crazy with pin numbering fonts. In this tutorial, we’ll show you 3 different methods of importing custom images into Eagle. Note that each of the three ways has pros and cons.

We used Method #1 to import this badger face as a series of polygons in Eagle

We recommend trying Method #1 (SVG to Polygon) first. It is the most complicated, but, if it works, you’ll have a set of polygons for your custom image that are much easier to work with than the lines/rectangles created by methods 2 and 3. If that fails, try method 2 or 3 to import an image as a series of lines, but be warned that having that many shapes can slow down your computer.

Additionally, you can import an image with method 2 or 3 and then trace over them with polygons in Eagle.

Recommended Reading

Before starting with this tutorial, we recommend that you be familiar with the basics of Eagle CAD:

• How to Install and Setup EAGLE
• Using EAGLE: Schematic
• Using EAGLE: Board Layout
• Designing PCBs: Advanced SMD
• Designing PCBs: SMD Footprints

Method 1: SVG to Polygon

Importing a vector graphic directly into Eagle requires a bit of work, but we recommend trying it first because:

• Manipulating polygons in Eagle after importing is much easier than lots of tiny lines.
• Using polygons for custom graphics takes less memory and makes panelization much easier.

Download Inkscape

If you don’t already have it, download and install the latest version of Inkscape. You will need it for this method.

Draw or Import Image

Draw, download, import, etc. your desired image. Make sure it is a single color (we’ll use black) and saved as a vector graphic (e.g. SVG). In this example, we’ll import an SVG image made with Adobe Illustrator.

Change Image to Standard Size

Click the select tool (F1), and select Edit > Select All in All Layers (Ctrl + Alt + a).

Click the button to lock the height/width ratio.

Change the units to mm, and change height to 100.

Go to File > Document Properties…, select Resize page to content… drop down, and click Resize page to drawing or selection.

Massage Nodes

Convert the object to a path and select nodes:

• Path > Object to Path (Shift + Ctrl + c)
• Object > Ungroup (Shift + Ctrl + g) - Press this a number of times to make sure all objects have been ungrouped
• Select all nodes with the path editor tool (F2, Ctrl + a)

Add interpolated nodes and flatten beziers (we want straight lines for the polygon):

• Extensions > Modify Path > Add Nodes - Leave defaults, click Apply, and close the pop-up window
• Select the nodes again (F2, Ctrl + a)
• Extensions > Modify Path > Flatten Beziers - Leave defaults, click Apply, and close the pop-up window

Cut Closed Loops

Any shapes that have a closed loop or a “hole,” will need to be cut (Eagle doesn’t know how to create a polygon with a hole in it).

Draw a shape, such as a rectangle, that divides the hole.

Hold Shift, and select both the rectangle and your image. Select Path > Division (Ctrl + /). Repeat this process for any closed loops in your image, such as donuts, outlines, and letters like ‘o’ and ’d'. You should end up with a number of paths that make up your image.

Select all nodes with the path editor tool (F2, Ctrl + a). Click Path > Break Apart (Shift + Ctrl + k).

Export as Plain SVG

Click File > Save As, give your exported SVG file a name (make sure you include the .svg suffix!), and select Plain SVG (*.svg) from the Save as type: drop-down menu. Click Save.

Import SVG as Polygon in Eagle

Download the Eagle-ULPs repository as ZIP. Unzip the directory, and copy the file svg2poly.ulp to the [EAGLE Directory]/ulp directory.

Start Eagle, and either create a new footprint or open your layout where you want to import the graphic.

If you want to put the image at a particular point, enter the command:

mark

and click where you want the center of the image to appear. Then, run the command (you can change the ratio to whatever you want to scale the image appropriately):

run svg2poly -ratio 0.001

Select your plain SVG image, and it should be drawn on the tDocu layer. If the image does not show up properly, see the Troubleshooting section below.

Since these are polygons, you can modify and tweak them as needed to meet your PCB needs. Also, you can change the layer to something else, like tPlace to make it appear in the top silk!

Troubleshooting

If your image does not import correctly (it often doesn’t), there are a few tricks you can do to make it work.

First, figure out which sections of the image are not importing correctly, and divide them up more using the Cut Closed Loops method above. You can also try cutting closed loops in different ways. Make sure you select all nodes (F2, Ctrl + a) and Path > Break Apart (Shfit + Ctrl + k) before saving as a Plain SVG.

If certain sections are proving to be problematic, you can try deleting some of the nodes to see if that helps. If you delete nodes, you will need to select nodes in that section (F2) and Extensions > Modify Path > Flatten beziers. You then need to reselect all nodes in the image (F2, Ctrl + a) and Path > Break Apart (Shfit + Ctrl + k) before saving as a Plain SVG.

If all that fails, you can try manually drawing a new section in Inkscape. Don’t forget to Add Nodes, Flatten Beziers, and Break Apart before saving the new image.

Method 2: Import DXF

AutoCAD developed the Data Exchange Format (.DXF) to allow for sharing of files between AutoCAD and other programs. Lucky for us, newer versions of Eagle (7.7.0+) can also import DXF files. We can use that to add custom artwork to a layer.

Download Inkscape

If you don’t already have it, download and install the latest version of Inkscape. You will need it for this method.

Draw or Import Image

Draw, download, import, etc. your desired image. Make sure it is a single color (we’ll use black) and saved as a vector graphic (e.g. SVG). In this example, we’ll import an image made with Adobe Illustrator and saved as an SVG.

Change Image to Standard Size

Click the select tool (F1), and select Edit > Select All in All Layers (Ctrl + Alt + a).

Click the button to lock the height/width ratio.

Change the units to mm, and change height to 100.

Go to File > Document Properties…, select Resize page to content… drop down, and click Resize page to drawing or selection.

Massage Nodes

Convert the object to a path and select nodes:

• Path > Object to Path (Shift + Ctrl + c)
• Object > Ungroup (Shift + Ctrl + g) - Press this a number of times to make sure all objects have been ungrouped
• Select all nodes with the path editor tool (F2, Ctrl + a)

Add interpolated nodes and flatten beziers (we want straight lines for the polygon):

• Extensions > Modify Path > Add Nodes - Leave defaults, click Apply, and close the pop-up window
• Select the nodes again (F2, Ctrl + a)
• Extensions > Modify Path > Flatten Beziers - Leave defaults, click Apply, and close the pop-up window

Cut Closed Loops

Any shapes that have a closed loop or a “hole,” you’ll need to cut them (Eagle doesn’t know how to create a polygon with a hole in it).

Draw a shape, such as a rectangle, that divides the hole.

Hold Shift, and select both the rectangle and your image. Select Path > Division (Ctrl + /). Repeat this process for any closed loops in your image, such as donuts, outlines, and letters like ‘o’ and ’d'. You should end up with a number of paths that make up your image.

Select all nodes with the path editor tool (F2, Ctrl + a). Click Path > Break Apart (Shift + Ctrl + k).

Export as DXF

Click File > Save As, give your file a name (make sure to include the .dxf extension!), and select Desktop Cutting Plotter (R13) (*.dxf) from the Save as type: drop-down menu. Click Save.

Make sure use LWPOLYLINE type of output is selected, and click OK.

Import DXF in Eagle

Start Eagle, and either create a new footprint or open your layout where you want to import the graphic.

Enter the command

run import-dxf

Click Browse to select your DXF file. Select the target layer, and change the scale as desired.

Click OK and Run on the pop-up window to import the image. Because the outline is made of lines, you can delete, move, and add lines as needed.

Method 3: Import BMP

Importing a bitmap into Eagle is probably the easiest method, but the import process draws many rectangles on a separate layer, which can be difficult to modify. It is recommended that you use bitmaps as a template to draw lines or polygons in Eagle.

Create a Bitmap

Use your favorite drawing program to create a monochrome (black and white) image.

Save the image as a Monochrome bitmap.

Import Bitmap

Start Eagle, and either create a new footprint or open your layout where you want to import the graphic.

Run the command:

run import-bmp

Read the pop-up window warning, and click OK. Select your bitmap file, and click Open. Select the black color to be imported, and click OK.

Scale your image as necessary, and select the desired units (I kept “mil” for this example).

Click OK and Run script on the pop-up. Your image should be imported on the “200 200bmp” layer as a series of rectangles.

If you zoom in on the imported image, you’ll see that it is actually made up of a series of rectangle shapes. These can slow down your computer and be a pain to work with if you need to make changes in Eagle, but it is a simple and effective way to get an image into Eagle.

Resources and Going Further

Try playing with some of the layers in Eagle to make interesting effects in your artwork! For example, in the badger face from the Introduction, the face is on the tPlace (top silk) layer, but the eyes are on the Top (top copper) layer. When the boards are produced, the face is white, but the eyes come out silver, copper, or gold colored (depending on the finish used).

Resources

Check out these other resources to aid in graphic design on your PCBs.

• svg2poly Script Repository
• import-dxf Script Repository

Going Further

Want to share your custom artwork with others? Check out these tutorials on how to contribute to and make your own public GitHub repositories. What more advanced Eagle tips and Tricks? Learn how to take your design to the next levels with these other great SparkFun Eagle tutorials.

learn.sparkfun.com |CC BY-SA 3.0 | SparkFun Electronics | Niwot, Colorado

Building an Autonomous Vehicle: The Batmobile a learn.sparkfun.com tutorial

Available online at: http://sfe.io/t589

Answering the Why

Why build an autonomous vehicle for A+PRS?

Test driving the Batmobile

The thrill of taking a corner, extremely low to the ground, with your gut telling you these g-forces are not normal… that’s why we spend countless hours building these silly Power Wheels vehicles. The giggles and grins are unavoidable! These cars are so much fun to drive – and even more fun to race!

In 2016, SparkFun had its eighth annual Autonomous Vehicle Competition. This year saw the introduction of a new rule: you needed to carry a human (or a 20lb dead weight in the form of a watermelon if you were too chicken). To do this, my wife, Alicia, and I modified a Batmobile Power Wheels and combined it with a Razor chassis. The result was an extremely zippy electric go-kart that left a perma-grin on everyone who drove it.

Our goal was to create a vehicle that could quickly and easily switch between human driver and driverless modes so that we could compete in both PRS and A+PRS categories. In the end, Alicia placed a very respectable third place in the driver category, and I did not finish (DNF) in the autonomous category, running into numerous hay bales.

This tutorial attempts to document a six-month build process for an Autonomous + Power Racing Series (A+PRS) vehicle. Every autonomous vehicle is unique, and the requirements of each will vary from build to build.

Materials

You can see our overall budget, including a list of components and vendors here.

A+PRS Batmobile Material Spreadsheet

You can get all the code from our repo here.

A+PRS Batmobile GitHub Repository

Chassis

The AVC rules stipulate that you cannot spend more than $500 on your total budget and that you have to stay within certain size restrictions. We started trolling craigslist to see what was out there and immediately found a plethora of free or cheap “broken” Power Wheels. When a Batmobile for $25 popped up, we quickly snagged it.

Dusty with dog hair and dead spiders – it’s perfect!

The primary failure of all used Power Wheels is a dead battery. The Batmobile was no different; as soon as we put in a new 12V SLA (Sealed Lead Acid), it happily, albeit slowly, drove around. There is nothing magical about “Power Wheels” branded batteries; get the right voltage (usually 12V, sometimes 6V), and you can use almost any battery you’d like. While the stock chassis was capable of moving adults weighing in at around 200lbs, we knew it wouldn’t handle racing, so we decided to find a metal chassis to sit underneath.

Many PRS and AVC competitors are talented enough to weld their own chassis together. DIY welding is a great way to save money, but it may take weeks of fabrication. Because we planned to enter the autonomous field, we decided to find a ready-made chassis and spend our time building and debugging the autonomous bits.

Note the size of the motor and battery. Those are about to get much larger.

Razor is known for their kick scooters, but they’re in the electric go-kart market as well. We found a Razor Drifter Open Box for $165. The Drifter had the steering, brakes, wheels and chassis sorted out for us! Additionally, the Drifter came with a stock 24V battery, 250W motor and 250W motor controller.

Putting on a Hat

Once we had the Power Wheels and the Razor chassis, we had to combine the two.

A Power Wheels meets a Drifter

At some point you have to get out the reciprocating saw and severely modify your beautiful Power Wheels. We laid the Batmobile over the Razor and proceeded to chop off all the bits that got in the way.

Seats? Where we’re going, we don’t need seats!

Pleasingly, the Batmobile sits on top of the chassis under its own structural support. We didn’t need to add all-thread or other standoffs. Even though they don’t do anything, we reattached the original wheels just so it looked extra wacky.

Motor and Motor Control

Moar!

In 2016, A+PRS allowed 48V systems, so the first thing we did was remove the 24V motor and install a 1,000W 48V/21A motor. The PRS rules limit any system to 1,400W, so we could have gone larger had budget constraints not been kicking in fast. New mounting holes were drilled into the chassis, and a different gear had to be mounted to the end of the motor. But it all went well. The stock chassis even included a chain tensioner that proved invaluable!

The MY1020 48V motor we used is common on the PRS circuit and performed great. However, our original 1,000W motor controller (you should already be able to tell what’s coming) did not do so well. Our first tests of the 48V system in an open parking lot worked great until the motor controller overheated and failed. And when MOSFET-based motor controllers fail, they fail unsafe, meaning our vehicle decided to go to 100 percent throttle and stay there. This is why we have safety switches! Alicia and I were able to kill the vehicle before anyone got hurt.

This failure should have been prevented: a motor controller should be rated for at least 2 times what you calculate your maximum load will be. In our case, if we wanted to control a 1kW motor, we should have been using a motor controller rated to a constant 2kW load. Luckily, the A+PRS rules don’t require you to record how much money you spent (and burned up); you have to report only what is on the vehicle as it rolls on race day.

The new, larger 5kW motor controller

We quickly located a larger, 5kW motor controller (this one even had reverse!) and got it on order. This larger motor controller has been working swimmingly ever since. Find a motor controller with reverse. You’ll be tempted to drive your souped-up Power Wheels in weird places (like the SparkFun inventory aisles), and a reverse gear allows for hilarious 5-point turns.

Brakes

Go-kart drum brakes on eBay

The Razor chassis had the classic drum brake, perhaps the weakest link of the Razor. While the stock brake was probably the appropriate size for a 75lb child with stock 24V batteries, our brakes got really squishy once we added an additional 125lbs of meat bag, batteries and plastic bits. We rarely, if ever, used the brakes during races, but the PRS rules stipulate that your qualifying lap must end with the driver crossing the finish line and braking to a stop:

At the end of the hot lap, your car will have to come to a complete stop within 18ft of when its transponder crossed the start/finish line. Deliberately skidding, swerving or spinning out is not an acceptable method of braking for the brake test.

Alicia had to do an impressive combination of hard braking, swerving, skidding and sliding with such a dramatic flair that she wooed the judges into not noticing how dodgy our brakes were. We’ll have disc brakes installed before we roll in the 2017 race.

Batteries

Battery holder welded onto the front of the chassis

As part of the motor upgrade, we needed to increase the battery voltage to 48V. To save money, we reused the super common batteries that came with the 24V Razor chassis. Razor was smart; they looked at the SLA (Sealed Lead Acid) battery industry and picked the most common size. This just happened to be the same battery that goes into nearly every UPS on the planet. We purchased two additional UPS-size batteries (way cheaper than buying Razor-brand batteries) and wired them in series.

Four batteries combined in series

Taping the cells together and adding a bead of hot glue between the cells made the pack nicely rigid. A low-cost, polarized, high-current connector finished off the pack. We had an old strap lying around that made all the difference in the world; it’s a lot more comfortable carrying the pack one-handed by its handle than with two hands underneath.

Avoid fires and other bad things. Use polarized connectors for your batteries.

Wire

Soldering large-gauge wire

We originally spec’d out some really nice, super flexible silicone-sheathed 8AWG wire for power distribution. I don’t think we would do this again; 10AWG would have been fine, and probably even 12AWG. As 8-gauge is far less common, the wire and connectors are more expensive, and the larger gauge wire takes a lot more soldering heat – it’s just a pain to work with. If you need the current capacity, go for it, but for our extremely zippy, 48V 20A vehicle, 8-gauge wire was overkill.

If you decide to use super flexible, large gauge wire, spend some time on the internet reading about how to solder this type of wire.

The best technique I found:

• Make sure you’ve got heat shrink in place
• Turn your soldering iron up to 425C (way hotter than the 325C usually needed)
• Push the ends of wire together
• Wrap tightly with 30AWG wire wrap wire
• Liberally apply flux
• Heat and insert lots of solder until the joint turns silver

Here’s a good video demonstrating this technique:

Kill Switch

We documented how to build a wireless kill switch while making margaritas. It was a ton of fun, so we’ll skip the bits of the wireless kill switch system here.

Zroooommmm!

In addition to the wireless disconnect, we had a large, red mushroom kill switch that disconnected the battery with a pleasing and authoritative“thunk.” Pulling up on the mushroom button reconnects the battery to the system.

Batman logo or Bitman logo?

As a pleasant bonus feature, the mushroom kill switch got rid of the nasty sparks. When connecting the battery to the motor controller, there was such an inrush of current into the capacitors and electronics that the connector would spark. Once we got the kill switch installed, we could connect/disconnect batteries without these sparks.

Connector between kill switch and power bus

The top of the Batmobile was easily removed, but because it had the kill switch installed we needed a way to disconnect it easily from the power bus. We found a great high-power connector in a dead server UPS. These are often called “winch connectors”, because they are higher current. With this connector, we are able to quickly disconnect the kill switch and remove the top when we need to get at the inside of the vehicle.

Control Electronics

Power converters, motor kill relays, steering relays, locomotion controller and wireless communication

The control electronics are complex. We had a total of seven microcontrollers on this beast, plus three used in the distance sensors for a total of 216 bits of processing power. The system operated on an I²C bus with the brain sending commands to the locomotion controller and LCD and receiving data from the sensors.

The wiring underneath the Batmobile cover

For a previous 2010 AVC entry, I did everything on a single microcontroller. This made coding and debugging a challenge. On our 2016 entry, we focused each sub-system to do one thing very well.

The subsystems are broken down as follows:

• Brain Controller: A SAMD21 Mini was used to communicate with and process all the data from the distance sensors, GPS and compass, and to send out commands to control throttle and steering. It monitored a start switch and relayed debug information to an LCD.
• Locomotion Controller: An Arduino Pro Mini read the throttle, steering position, brake switch and autonomous rocket switch. It controlled motor speed and the linear actuator for steering.
• Wireless Kill Switch: An Arduino Pro Mini lived in the wireless kill switch, a requirement for the autonomous part of our Batmobile. To learn more about the wireless controller, check out our tutorial on how to build a wireless kill switch.
• A dedicated Arduino Pro Mini controlled the relays for the wireless kill switch system.
• Debug LCD: We counted our LCD screen as a microcontroller since it has an Arduino in it.
• Sensor Combinator: A SAMD21 Mini polled the serial GPS and I²C compass.
• Laser Controller: A SAMD21 Mini controlled the three serial-based laser distance sensors, combined the relevant information and responded to requests from the Brain.
• Three STM32s were the brains within the laser distance sensors.

Control Electronics - Brain

The Brain is a SAMD21 Mini. It sends commands over the I²C bus to the locomotion controller and debug LCD.

4-pin JST connector at the top of the image: We used a 4-wire bus (5V, GND, SDA, SCL) for communication and had various taps throughout the bus to allow devices to be attached. This worked really well and allowed for devices to be moved around when needed.

4-pin JST connector to the left: This was four wires to the button. To tell the vehicle to begin navigating under autonomous control, we used a metal momentary push button that illuminates when everything is online and happy. The human presses the button twice, and the car commences racing.

Big gray handle: This was the original forward and reverse knob that we reused to control the direction switch on the motor controller (two pins when shorted together caused one direction, when open caused the other direction).

The massive and poorly written control code for the Brain can be found here.

EEPROM for Waypoints

The SAMD21 does not have internal EEPROM. Because we needed to store GPS waypoints and other configuration data to non-volatile memory, we used an external I²C EEPROM. Yes, you can use something called emulated EEPROM on the SAMD21, but, every time you reprogram the board, you will overwrite anything previously stored in emulated EEPROM. The external EEPROM made it much easier to store and recall waypoints and settings without having to mash together in the main control code.

Control Electronics - Locomotion

Locomotion Controller hooked up

Note the polarized connectors and prodigious labeling! You DO NOT want to be guessing what gets plugged into where at 11 p.m. before race day. The Locomotion Controller code is available here, and the PCB layout here.

Because we eventually wanted this beast to be autonomous, we needed to put a controller in the middle between the throttle and the motor controller. We used an Arduino Pro Mini that did a huge variety of sensing and control:

• Read the throttle
• Output analog voltage to the motor controller
• Read the brake switch
• Read the steering position
• Controlled the linear steering actuator
• Read the human/robot control switch
• Received and responded to control commands over I²C

Don’t panic

The controller would monitor the rocket switch and brake switch. If a human ever pressed the brakes or turned off the rocket switch, the controller would go into safety shutdown and ignore any commands from the brain.

Steering was controlled using a 12V linear actuator over-voltaged to 24V for extra speed. Two relays controlled the forward/backward motion.

Steering position was obtained by cutting a hex wrench to about 1” and inserting that wrench into the bolt that rotates with the wheel. The wrench was then connected to a 10k trimpot using adhesive-lined heat shrink – this trick is known as the “poor man’s coupler:” a 3-wire ribbon connected the trimpot back to the locomotion controller. It worked well, but we had to keep the analog signal wire away from the power bus; otherwise, bad noise got into the ADC readings.

Chassis with the Batmobile raised to see the steering actuator

For future vehicles, we’re going to change this setup. It worked well enough, but once the bolt connected the actuator to the steering, you couldn’t drive the car; only the computer could. So rather than driving the car to the start line, we had to carry this 75lb beast. So painful. In the future, we plan to find a back-drivable actuator or maybe drive-by-wire.

Control Electronics - Displays

Throttle and displays

We cut notches in a 1” tube of PVC and mounted two displays in the Batmobile. The center display is the power meter. Nearly every A+PRS and PRS competitor used these super low-cost power meters to show the battery voltage. We had some issues with it, but it worked well enough. In the end, we noticed the drop in vehicle speed (indicating battery drain) long before we noticed the display was indicating a lower pack voltage. But, it did help us make decisions about when to pit (never!) because the nominal 48V pack voltage was dropping down to 42V where we could begin to damage the SLA.

The display on the right is the 20x4 character debug LCD. It’s basically a souped-up version of our 20x4 SerLCD display (it’s a prototype product, coming soon to a theater near you!).

Control Electronics - Sensors

GPS+Compass connected to SAMD21

The Sensor Combinator is a SAMD21 Mini that monitors a GPS receiver and an I²C compass. We decided to use a SAMD21 because it can be configured to have multiple hardware serial and I²C ports. This is needed if you want to isolate I²C devices from the main bus. We wanted the Brain to ask for the heading and get the heading; the Sensor Combinator took care of the low-level I²C function of the compass and heading calculations. Similarly, the Combinator listened to the serial stream from the u-blox based GPS module and parsed out all the needed Latitude/Longitude/SIV information.

The code for the Sensor Combinator can be found here.

Control Electronics - Lasers

Laser tape measures seen on the front of the car, wrapped in foil

We hacked three laser tape measures in order to get distance to any objection front, left or right of the car. Laser tape measures are getting cheaper, and while the read rate (3Hz at the best of times) is not great for LIDAR, it’s fast enough for basic, low-cost autonomy.

Laser Controller at front of car

Unfortunately, the laser tape measures threw off enough RF to interfere with our GPS module, so we wrapped the lasers in foil. These sensors deserve their own tutorial, which will be written soon.

Laser Controller with labels

Again we chose the SAMD21 Mini to help us control and combine the serial information coming from the three sensors. The Laser Controller would send the pertinent control strings to the tape measures and monitor the responses, combining them into distances for left/right/center. The Brain would request these values from the Laser Controller over I²C.

Note the prodigious amounts of labels and polarized connectors (JSTs work great!). This system required lots of debugging but worked well because we were able to quickly disconnect and reconnect various aspects of the system.

The code for the Laser Controller can be found here.

Problems

As with any project, we had a large number of problems and hurdles to overcome along the way. Here are a few that really hurt.

EMI and GPS

The Laser tape measures caused significant interference with GPS reception. We eventually moved the GPS module to the rear of the car, which improved positional accuracy. However, the motor caused interference with the compass.

DC Motor EMF

DC motors produce a ton of electromagnetic noise. We originally had the 48V battery powering the entire car. However, when the motor would kick on, it would cause enough ripple to make the Brain glitch and reset. We tried powering the I²C bus separately, but, because the Locomotion Controller needed to be attached to the motor controller, a GND connection had to be shared. The noise eventually found its way over the I²C bus. In the future we will optically isolate the I²C bus.

Lack of EEPROM

Because the SAMD21 doesn’t have internal EEPROM, we were unable to store GPS waypoints on the board. We fixed this by using an I²C-based EEPROM.

Switching Steering Between Driver/Driverless

It was difficult to attach and detach the linear actuator from the rack and pinion steering. Once the actuator was attached to the steering, a driver could not actively steer (for example, to the starting line). This could be fixed with a different actuator that could be back-driven, or we could go full monty and detach the steering column from the steering and have it control a trimpot that, in turn, controls the linear actuator (drive by wire).

Tips / Best Practices

Tip 1) Start early– These vehicles take a large amount of time. Get together with friends and start hacking. It’s a great labor of love, and drifting in a 15mph go-kart will make you giggle.

Tip 2) Get reverse– Get a motor controller with reverse. It will make it so you can drive your car where you want it instead of carrying your car where you need it.

Tip 3) Use connectors!– I’ve written about using connectors a few times. Use polarized connectors and a label maker to make it clear what plugs in where.

Tip 4) Size your motor and motor controller correctly– We blew our motor controller because it was underrated. A friend of ours smoked his motor because he was pushing too much current. Pick your system voltage and current, and then double the ratings wherever you can.

Tip 5) Beware of interference– These vehicles can pull 30 amps or more when accelerating, which can cause large electromagnetic fields. Keep unshielded cables and sensitive sensors away from power wires.

Tip 6) Wireless control and sensor logging– After you pick up your 75lb vehicle and drag it to the start line for the fifth time, you’ll understand the need for remote control. Create a wireless system that allows you to take over control of the vehicle from afar so you can drive it where you need it. And transmit the sensor data so you can see what the vehicle is doing.

Hope you enjoyed reading! See you at next year’s AVC!

learn.sparkfun.com |CC BY-SA 3.0 | SparkFun Electronics | Niwot, Colorado

HIH-4030 Humidity Sensor Hookup Guide a learn.sparkfun.com tutorial

Available online at: http://sfe.io/t591

Introduction

The SparkFun HIH-4030 Humidity Sensor Breakout measures relative humidity (%RH) from Honeywell’s HIH-4030 humidity sensor. The breakout allows you to connect the analog output of the sensor directly to an ADC on a microcontroller.

Added to your cart!

SparkFun Humidity Sensor Breakout - HIH-4030

In stock SEN-09569

This is a breakout board for Honeywell's HIH-4030 humidity sensor. The HIH-4030 measures relative humidity (%RH) and delivers…

$16.95

3

FavoritedFavorite9

Wish List

Voltage applied to the supply pins should be within 4-5.8 VDC, and optimally at 5V. The sensor will typically only consume about 200μA.

This tutorial serves as a introduction to the HIH-4030 and the SparkFun Humidity Sensor Breakout. It covers both the hardware and firmware requirements of the breakout to start receiving relative humidity (%RH) measurements as well as documenting example wiring, Arduino code and using the sensor in conjunction with a thermometer.

As we step through the Hookup Guide, you’ll find it useful to have the HIH-4030 Datasheet on hand.

Required Materials

To get the humidity sensor up and running, you’ll need the following parts. Further in the tutorial, you’ll learn how to incorporate a temperature sensor, specifically SparkFun’s Digital Temperature Sensor Breakout - TMP-102, for properly determining relative humidity (%RH). Note that adding a temperature sensor is optional, but its use will be highlighted in this tutorial.

Suggested Reading

Before getting started with the HIH-4030, you should ensure you are familiar with the following topics:

Hardware Overview

The RH sensor uses a laser trimmed, thermoset polymer capacitive sensing element with on-chip integrated signal conditioning. The sensing element’s multilayer construction provides excellent resistance to most application hazards such as condensation, dust, dirt, oils and common environmental chemicals.

Protective Tape Removal

The HIH-4030 comes with a protective tape on the cover (sensing face). This tape is kept in place during our soldering process here at SparkFun. When you receive your HIH-4030 Breakout, you’ll want to remove the protective tape.

Pinout

The three pin breakouts on the HIH-4030 Breakout board make it easy to measure relative humidity (%RH) as an analog voltage.

Voltage applied to the supply pins should be within 4-5.8VDC, optimally at 5V, making it perfect to power with your 5V / GND connections on your microcontroller shield like an Arduino or SparkFun Redboard. The data pin can be connected to an analog input of an Arduino, XBee, RaspberryPi, or any other IO device. The HIH-4030 has a low-power design. The sensor will typically only consume about 200μA.

Hardware Hookup

This product comes with the HIH-4030 soldered onto the breakout board. The pins of the 3-pin header are spaced by 0.1".

Before you can insert the HIH-4030 Breakout into a breadboard, you’ll need to solder either wires or a 3-pin header to the GND, OUT, and 5V on-board connections. If you plan on breadboarding, we recommend straight male headers. Here, right angle headers were used, which is another viable option.

Example Circuit with HIH-4030 Only

With the HIH-4030 Breakout, all you need is three wires between your microcontroller and the breakout board: Power, Ground, and Analog Output. This is a simplified circuit that should only be used to get your Humidity Sensor up and running. Here is an example hookup diagram demonstrating how to connect the board up to a SparkFun RedBoard:

Example Circuit with TMP102 Temperature Sensor

Determining Relative Humidity (RH%) requires knowing an accurate temperature. The previous circuit example does not utilize this feature, therefore, it will be necessary to to use your HIH-4030 Breakout in conjunction with a Temperature Sensor. For this Hookup Guide, we have used the TMP102 Breakout.

Added to your cart!

SparkFun Digital Temperature Sensor Breakout - TMP102

In stock SEN-11931

This is a breakout board for the incredibly small TMP102 digital temperature sensor. The TMP102 is a digital sensor (I2C a.k.…

5.9500$3.45

7

FavoritedFavorite16

Wish List

The TMP102 is a digital sensor that communicates over I²C, has a resolution of 0.0625°C, and is accurate up to 0.5°C. There is no on-board voltage regulator, so supplied voltage should be between 1.4 to 3.6V. Do not hook up the TMP102 VCC to 5V. You’ll want to use 3.3V on your Arduino or SparkFun RedBoard for this connection. As an additional resource, refer to the TMP102 datasheet.

Since this is an I²C device, the connections you’ll be most concerned with is the SDA (Data) and SCL (Clock) pins on either an Arduino or SparkFun RedBoard. Here is an example hookup diagram demonstrating how to connect the HIH-4030 Breakout with a TMP102 Digital Temperature Sensor board up to a SparkFun RedBoard:

Click the image for a closer look.

Using the SparkFun HIH-4030 Arduino Library

We’ve written an Arduino library for the HIH-4030, which takes care of all your user specifications and calculating of formula found in the datasheet. Grab the most recent version of the library from our SparkFun_HIH4030_Arduino_Library GitHub repository:

Download the SparkFun HIH-4030 Arduino Library

If you need any help with the installation process, check out the How to Install an Arduino Library tutorial. If you download the library’s ZIP file, you can use Arduino’s “Add ZIP Library…” feature to install the source and example files.

Using the HIH4030_HumiditySensor_Example

Once you’ve downloaded the library, open the HIH4030_HumiditySensor_Example by navigating to File>Examples>SparkFun Humidity Sensor Breakout - HIH4030>HIH4030_HumiditySensor_Example:

You’ll also want to make sure your board and port are correctly set in the Arduino IDE window before uploading the code:

Once the upload is complete, you can click over to the Serial Monitor. Make sure the baud rate is set to 9600 bps, and you should begin to see the Tempearture, Sensor Voltage, Relative Humidity and True Relative Humidity scroll across the screen:

Customizing Settings in Code

Initialization

To begin, make sure you include the SparkFun_HIH4030.h library. If using a temperature sensor, you’ll need to include Wire.h the Arduino I²C library:

language:c
#include <SparkFunDS1307RTC.h>
#include <Wire.h>

Temperature Sensor Settings

The code by default is using a static value for the temperature reading.

language:c
// Are You Using a Temperature Sensor? 1 = YES / 0 = NO
int tempSensor = 0;

You can change the temp variable from 25 degrees Celsius to any desired value to see how it affects the Relative Humidity (RH%).

It’s important to remember that True Relative Humidity (RH%) requires a known temperature for accurate measurement. As an example, the previous section, Hardware Hookup, demonstrated how to wire both the SparkFun Humidity Sensor Breakout - HIH-4030 and Digital Temperature Sensor Breakout - TMP102. However, you can also use other Temperature Sensors available on the SparkFun storefront: One-Wire Ambient Temperature Sensor - MAX31820, Temperature Sensor - TMP36, One Wire Digital Temperature Sensor - DS18B20, SparkFun Infrared Temperature Breakout - TMP006.

If you are utilizing a Temperature Sensor, you’ll want to modify the following code from the default 0 to a 1:

Humidity Sensor Settings

Two things that need to be defined for the SparkFun_HIH4030 Library is the Analog I/O Pin the HIH-4030 Sensor OUT is connected to and the voltage being supplied to the HIH-4030 Sensor. If your setup reflects the Hardware Hookup section, you can leave the values as is.

language:c
// Analog IO Pin Connected to OUT
#define HIH4030_OUT A0

// Supply Voltage - Typically 5 V
#define HIH4030_SUPPLY 5

Looking Inside the SparkFun_HIH4030 Library

vout( ) function

Since the output of the HIH-4030 Humidity Sensor is nearly linear, the analogRead() function is used and mapped to the correct range. This is where the value you defined for the Supply Voltage in your HIH4030_HumiditySensor_Example code comes into play.

language:cpp
// Read value from the sensor and convert to voltage value
float HIH4030::vout() {
    return (float)(analogRead(pin)) * supply / 1023;
}

getSensorRH( ) function

From the HIH-4030 Datasheet, a Voltage output equation is given on page 2.

With the previous vout() function and defined supply voltage, sensor RH can be calculated.

language:cpp
// Convert sensor reading into Relative Humidity (RH%)
//  using equation from Datasheet
// VOUT = (VSUPPLY)(0.0062(SENSOR RH) + 0.16),
//  typical at 25 degrees Celsius

float HIH4030::getSensorRH() {
    return ((vout() / (.0062 * supply)) - 25.81);
}

getTrueRH( ) function

The True Relative Humidity euqation is also given on page 2 of the HIH-4030 Datasheet which includes temperature compensation.

Aforementioned, True Relative Humidity required a known temperature for accurate measurement. The getTrueRH(float temperature) function will take the value of either your static temperature or sensor measurement, whichever is applicable, and calculate True RH.

language:cpp
// Get True Relative Humidity (RH%) compensated
//  with Static Temperature or Measured Temperature
// TRUE RH = (SENSOR RH)/(1.0546 - 0.00216T), T in degrees Celsius

float HIH4030::getTrueRH(float temperature) {
    return getSensorRH() / (1.0546 - (0.00216 * temperature));
}

Resources and Going Further

For more on the HIH-4030 Humidity Sensor, check out the links below:

• HIH-4030 Schematic (PDF)
• HIH-4030 Eagle Files (ZIP)
• HIH-4030 Datasheet (PDF)
• SparkFun HIH4030 Arduino Library GitHub Repository– Source and example files for the Arduino library used in this tutorial.

Need some inspiration for your next project? Check out some of these related tutorials:

learn.sparkfun.com |CC BY-SA 3.0 | SparkFun Electronics | Niwot, Colorado

Logging Data to Google Sheets with the Tessel 2 a learn.sparkfun.com tutorial

Available online at: http://sfe.io/t557

Introduction

My family just became the proud new owners of an upright piano. This piano was owned by my wife’s grandmother and is somewhat of a family heirloom. It comes with great emotional value, and it’s only natural that we want to take care of it. After moving the piano into our house (not an easy task), my wife made the important call to “the piano guy” to talk about tuning it, cleaning it and general care.

I was sitting close by and overheard the mentions of “temperature swing” and “humidity range.” If either fell within a certain range, the piano would need to be placed in a certain spot in the room versus another. Upon hearing this, a smile crept across my face, recognizing the birth of a new project. In fact, my wife literally told the man over the phone, “Temperature range? My husband can take care of figuring that out for you, and we will let you know.” He is going to get more than he bargained for!

Thus, I set about using the Johnny-Five Inventor’s Kit to log the temperature and humidity of the room.

Logging is Never a Question of Why, but How!

Collecting data in a reliable and useful way is always a challenge. When it comes to embedded electronics/computers, the challenge is not so much a matter of collecting a large volume of data as it is the challenge of storage size, formatting the data output and post processes.

This tutorial will focus on collecting data using a Tessel 2 and a single sensor that comes in the Johnny-Five Inventor’s Kit to monitor and log the air temperature and humidity in the piano room in my house.

As you will see in this project, managing data collection, formatting that data and processing it can be simplified by using Node.js and leveraging the huge community that supports it through its package manager called NPM.

We will look at two different ways to log this data, format it and bring it into Google Sheets to be able to graph it and share it easily with others.

More Than One Way to Skin a Cat

As with any electronics project, there is more than one way to do this! We are going to look at two different approaches to accomplish the same task using the Tessel 2. The main difference between the two methods being whether or not you have a WiFi/network connection.

This has been written as a “choose your own adventure” of sorts when it comes to the firmware for this project. One way is to use the file system and a USB drive; the other is to use an IoT service called IFTTT. Each script has its own section that will break down the code for you, and then we will tie up any loose ends.

Internet-Connected Method

If you have a connection to a the internat, either through WiFi or Ethernet, you can use the node module for If This Then That (IFTTT) to build an IFTTT recipe to send data to a Google Sheet using the Maker Channel. This is the preferred method if you are in a situation where you have network connection, as you will be able to view the data from your Google account in real time and see changes almost immediately.

Local, Offline Method

The second way to do the same thing but with a little more work on your part, is to set up the Tessel 2 to log the data to a USB mass storage device and then periodically pull the data from it and manually add it to a Google Sheet. This is obviously more work on your part, but in cases where there is poor or no network connection, it’s a great alternative.

Hardware Overview

Required Materials

We designed this project so that you could build it from the Johnny-Five Inventors Kit, which includes everything you will need with the exception of a USB mass storage device. Almost everyone has a “thumb drive” laying around, and this is a perfect use for it. If you don’t have one on hand, we have added a microSD card and USB reader to the parts list below. Either will work just fine!

If you don’t have a Johnny-Five Inventors Kit on hand, here is a wish list of parts so that you can buy them all separately.

The Tessel 2

The Tessel 2 is an open-source development board. It runs JavaScript and supports npm, which means scripts to control it can be built with Node.js. It’s a platform for experimenting, tinkering, prototyping and producing embedded hardware, perfect for the Internet of Things.

The BME280

The SparkFun BME280 Atmospheric Sensor Breakout is an easy way to measure stuff about the atmosphere around you: pressure, humidity and air temperature. All of this is combined into a petite package, called a breakout board.

The 3.3V breakout is power-efficient, using as little as 5µA (that’s 1/1000000 of an amp!) when idling and less than 1mA when it’s taking measurements.

In this experiment you will work with the BME280 to read the temperature, pressure and humidity of the room as well as your altitude based off of the atmospheric pressure. Finally, you will use your BME280 as the heart of a web-based weather dashboard application.

USB Thumb Drive

There isn’t much to be said about these little storage drives. You can find one pretty much anywhere. For the purposes of this project, we would recommend one that is smaller so that handling the project and fitting it into an enclosure isn’t cumbersome.

Preflight Check

If this is your first time using your Tessel 2 you will need to do a little setup first. Have no fear; it is relatively painless and shouldn’t take more than 20 minutes or so to install software and get you up and running! Check out the Getting Started with the Tessel 2 Guide to walk you through the process of:

• Installing the required software to develop for the Tessel 2
• Installing the T2-CLI tool
• Setting up the Tessel 2
• Creating a project directory (folder)
• Running a blink script to make sure it is working

Node.js Native Modules and NPM

If you have had experience with the Tessel 2, then you know that it is programmed with JavaScript and the Johnny-Five framework to be able to control the Input/Output (I/O) on the board. If you have never programmed with JavaScript before or the Tessel 2, we highly recommend that you check out the Johnny-Five Inventor’s Kit Experiment Guide for a more in-depth explanation and exploration.

To get you started with this specific project, let’s create a project directory as covered in the preflight check and install all of the needed node modules that we will use. We can do this through our console by using these commands:

language:console
mkdir loggerProject;
cd loggerProject;
npm init -y;
npm install johnny-five tessel-io node-ifttt-maker;

These commands do the following in order:

1. Create a directory (folder) called loggerProject
2. Change directory, or move into loggerProject
3. Initiate an npm project within loggerProject that creates a package.json file.
4. Install the needed libraries, which in this case are johnny-five, tessel-io and node-ifttt-maker using npm install. These will be placed in a directory called node_modules

With your setup complete, you are ready to set out on your new adventures of logging data!

Building the Circuit

Despite your method for logging the data, your circuit will be the same, with the exception of adding a USB storage device to one of the USB ports on the Tessel 2 for the offline method.

Build the BME280 Circuit

Having a hard time seeing the circuit? Click on the wiring diagram for a closer look.

This circuit is faily simple. Attach the BME280 breakout board to the breadboard so that it spans the center notch. Connect the BME280’s SCL (clock) pin to Tessel’s Port A, Pin 0. Connect the SDA (data) pin to the Tessel’s Port A, Pin 1. Connect 3.3V to the Tessel’s 3.3V pin and GND to GND.

Testing the BME280

Before we move on to the larger project, let’s take a second to test the BME280 to make sure it’s up and running. From the command line, create a new file called bmeTest.js by typing the following command:

touch bmeTest.js

Open your favorite code editor, and navigate to your bmeTestjs file to edit it. Type—or copy and paste—the following JavaScript code into your bmeTest.js file:

language:javascript
var Tessel = require("tessel-io");
var five = require("johnny-five");
var board = new five.Board({
  io: new Tessel()
});

board.on("ready", () => {
  var monitor = new five.Multi({
    controller: "BME280"
  });

  monitor.on("change", function() {
    console.log("thermometer");
    console.log("  celsius      : ", this.thermometer.celsius);
    console.log("  fahrenheit   : ", this.thermometer.fahrenheit);
    console.log("  kelvin       : ", this.thermometer.kelvin);
    console.log("--------------------------------------");

    console.log("barometer");
    console.log("  pressure     : ", this.barometer.pressure);
    console.log("--------------------------------------");

    console.log("altimeter");
    console.log("  feet         : ", this.altimeter.feet);
    console.log("  meters       : ", this.altimeter.meters);
    console.log("--------------------------------------");
  });
});

Type—or copy and paste—the following into your terminal:

t2 run bme.js

What You Should See

This is going to print a lot of data to your console, very quickly—so quickly that you likely won’t be able to make sense of it! Go ahead and exit the program by typing Command-C or Control-C. This will stop the script so you can read the output.

Code to Note

Once the board has emitted the ready event, hardware inputs are ready for interaction, so the first thing that occurs is an instantiation of a Multi object. Multi objects represent two or more components, usually sensors, that are packaged together and exposed via a single register. Multi and IMU (Inertial Measurement Unit) boards that combine multiple movement sensors like accelerometers, gyroscopes, etc.) are very similar; the latter is used for non-motion-related packages.

language:javascript
var monitor = new five.Multi({
  controller: "BME280"
});

Now that we have a monitorMulti instance, the next thing to do is register an event handler to be invoked whenever changes are detected in the sensor readings:

language:javascript
monitor.on("change", function() {
  // ...
});

Within that handler, we’re logging all of the relevant data properties for this multicomponent package:

language:javascript
console.log("thermometer");
console.log("  celsius      : ", this.thermometer.celsius);
console.log("  fahrenheit   : ", this.thermometer.fahrenheit);
console.log("  kelvin       : ", this.thermometer.kelvin);
console.log("--------------------------------------");

console.log("barometer");
console.log("  pressure     : ", this.barometer.pressure);
console.log("--------------------------------------");

console.log("altimeter");
console.log("  feet         : ", this.altimeter.feet);
console.log("  meters       : ", this.altimeter.meters);
console.log("--------------------------------------");

… which is a lot of data and will likely overwhelm the terminal, so be ready to type Command-C or Control-C to end the program.

OK, everything works! Let’s now explore how to log all of this data!

Firmware: Logging Data with `fs`

Node.js has a number of built in-modules to keep your project as modular and streamlined as possible. You can find the whole list of the modules available to you in the documentation for Node.js. Since Node is so modular, you still have to require even the modules that are included in the core itself.

The module that we are going to put to good use for logging to the USB drive is the File System module, or fs for short. This module enables you to interact with, modify, add and remove files on your computer’s file system (in this case your Tessel’s).

The Concept

The functionality of this project can be explained as such. We want the Tessel 2 to do the following things:

1. Create a .csv (comma separated value) file on the USB drive.
2. Read the values from the sensors using Johnny-Five and store them locally as variables.
3. Build a string that formats the values the way we would like them for easily importing into a spreadsheet.
4. Append the .csv file with the logging string we created.
5. Rinse (set the string back to “”) and repeat for the give data event frequency!

First of all, let’s head over to your terminal. In your working project directory, create a new JavaScript file called usbLog.js by entering the following command:

touch usbLog.js

The Code

You can now navigate to your new file in your text editor and copy and paste the following script into that file. Make sure you save after you have done that.

language:javascript
//require the file system module
var fileSys = require('fs');
//require the modules for hardware I/O
var five = require('johnny-five');
var t2 = require('tessel-io');

//create a new board object with io set to Tessel
var board = new five.Board({
  io: new t2()
});

//create a date object
var date = new Date();
//create a filePath string for location of USB drive.
var filePath = "/mnt/dev/sda0/" + String(date.now())+ '.csv';
//create a CSV header string to be added at the begining of the log.
var headerString = "Date,Air Temperature(F),Relative Humidity(%),Soil Moisture"
//create an empty logString
var logString = "";
//define the interval of logging in minutes, change this if you so choose.
const interval= 5;
//create a new file using the appendFileSync to keep things sychronous.
//create the variables for data as globals
var temp, humidity, moist;

//create the csv file with given path and append the header
fileSys.appendFileSync(filePath,headString,(error)=>{
  //if you get an error, log a message
  if(error){
     console.log('error setting up log file!');
  }
});

//when the board is ready...
board.on('ready', ()=>{
  //create a new multi object called atmos for the BME280
  var atmos = new five.Multi({
    controller: 'BME280',
    freq: (interval*60000)
  });

  //when atmos gets 'data'...
  atmos.on('data', ()=>{
    //store temperature and humidity
    temp = this.thermometer.fahrenheit;
    humidity = this.hygometer.relativeHumidity;

    logString = date.toISOString()+','+temp+','+humidity+','+moisture+'\n'
  //append the log file with the logString
  fileSys.appendFileSync(filePath,logSting,(error)=>{
     //if error, log message
     if(error){
      console.log('error logging to file!');
    }
    //else reset the logString to blank
    else{
      logString = '';
    }
  });
  });

});

Save your script, and insert your USB Thumb drive into a USB port in your Tessel 2. We recommend using the top USB drive because there are a number of thumb drives that may be wide enough to block the micro USB port you need to power the board, but your USB may work in the bottom one just fine. It doesn’t change how anything functions.

Once you have inserted your USB thumb drive and saved your script as usbLog.js, go ahead and deploy your code to your Tessel by running the following command in your console:

t2 run usbLog.js

Let the script run for a while while putting your finger over the BME280.

The Tessel will log values once every five minutes, so let it run for a good long while. Eat a cookie, read a magazine, lie back and relax while the Tessel does all of the work. Or you can change the logging interval for testing purposes.

Once you can’t stand it anymore and you want to get your hands on your data, go ahead and remove the USB storage device from the Tessel, and insert it into a computer.

An external drive should become visible; go ahead and open it. You should be greeted with a single file on your device, which should have a name of a very long number with a file extension of .csv. Open the file, and it should contain your data in CSV format!

With that you are ready to import the data into your Google Sheets file, but let’s pause for a bit and dive into what makes this code work!

Code to Note

Before we move on to the Google Sheets portion of this project, let’s take a deeper look into the code and how this was accomplished using Node.js and Johnny-Five.

language:javascript
var fileSys = require('fs');

Node.js is super modular; to do even simple things, many times you have to include native modules that come with Node.js. File System, or fs, is one of those modules. It is used any time you want to use other files in conjunture with your node project.

language:javascript
var five = require('johnny-five');
var t2 = require('tessel-io');

//create a new board object with io set to Tessel
var board = new five.Board({
  io: new t2()
});

When using Johnny-Five with single board computers (SBCs) you have to install and require a secondary module for working with that specific SBC’s I/O pins. In this case we are working with the Tessel 2, so we need to require the tessel-io module that we installed during setup. Then, when we create a board object, we specify the io of the board as a new t2().

language:javascript
var date = new Date();

If you have used any JavaScript before, you may be familiar with the Date object. We use it in this script to create a time stamp for our data, and even the log file name is based off of now() method, which retrieves the number of seconds since January 1, 1970, 00:00:00 UTC. Most importantly we use the toISOString() method to produce a user-friendly time and date stamp for our data-logging string.

language:javascript
fileSys.appendFileSync(filePath,headString,(error)=>{
  //if you get an error, log a message
  if(error){
     console.log('error setting up logging file!');
  }
});

To write data to the log file, we use the appendFileSync() method of the fs module. This takes two arguments: the first is the file path to the file you want to append (or add to), and the second is the data you want to append to the file as a string. You can find out more about the method and the differences between the synchronous and asynchronous versions of the method in the fs documentation.

We use this method twice! The first time writes the .csv header to the file at the very beginning of the script. Later we use it inside of the setInterval() function to log the individual lines of data every five minutes.

language:javascript
  //when atmos gets 'data'...
  atmos.on('data', ()=>{
    //store temperature and humidity
    temp = this.thermometer.fahrenheit;
    humidity = this.hygometer.relativeHumidity;

    logString = date.toISOString()+','+temp+','+humidity+','+moisture+'\n'
  //append the log file with the logString
  fileSys.appendFileSync(filePath,logSting,(error)=>{
     //if error, log message
     if(error){
      console.log('error logging to file!');
    }
    //else reset the logString to blank
    else{
      logString = '';
    }
  });
  });

Each sensor object has an event attached to it. In this case we are using the ‘data’ event. This event happens at a given time interval, which is controlled by the freq option in the board setup. In this case we set freq: (interval*60000). So, every five minutes or 5*60000 milliseconds the ‘data’ event gets called. When the data event is received by the sensor object, the event is triggered, and we then store the sensor values in the variables temp and humidity.

Every five minutes a new string gets built by concatenating the date string and the data points from the two variables, which are then terminated with a newline character (\n).

The string is then appended to the file, and, if there is no error in the process, the logString is reset to a blank string. This is then repeated every five minutes.

Getting the Data into Sheets

Now we have data in not so user-friendly CSV format … now what? Google Sheets to the rescue! If you have been under a rock for the past 10 years and haven’t heard that Google has an online suite of office tools at your disposal, today is the day we rectify that problem. The spreadsheet program is called “Sheets.”

If you don’t have a Google account, no problem. It’s easy to sign up for one, and it’s free! Once you are signed in to your Google account, click on the apps icon, which is the little grid of squares in the upper righthand corner. Select Sheets from that list.

From there, you will be greeted with a number of options for what to do in Sheets. You want to just create a blank sheet for now. Click on “blank” once in the program.

A new Sheets project will open. Select File > Import…. This will bring up a dialog box that you will need to use to navigate to your external USB drive and the .csv file that is on it. Select the file, and click Open.

From there you will get a slew of options about how you would like to import the data. We actually preformatted the data when we collected it, so this is all done. Go ahead and click through this window.

Your data will now appear as a sheet as shown! Wahoo, data in a table!

From here, it is a few simple steps to building a graph.

Using your cursor, select the Create Graph button, and it will bring up the graph options. You can select your graph type, and it will give you a preview of what it will look like. I selected a line graph:

Once you are happy with your graph selection, accept your graph. It will then show up in your sheet, where you can move it around and resize it.

With that you are done! You can do all sorts of further calculations and other graphs using Sheets. Or if there is something that you are missing and you’d prefer to use Microsoft Excel or another Office tool chain, feel free; they are all about as simple to import data into. The downside of doing this is that you have to make a new sheet or copy and paste data into this one every time you want to update it. This is where IFTTT comes into play!

Firmware: Logging with IFTTT

Now that you have been logging data locally and then physically transferring it to your computer and then into Google Sheets, it is now time to simplify the process using IFTTT and the Maker Channel.

If you have never heard of If This Then That (IFTTT), it is a simplified software and web automation tool. It allows you, the user, to build what are called recipes, which consist of two channels, or services, and a trigger. Basically, as the name implies, if (this happens) then (do something). The things that happen or do something are different connected web apps such as Google Drive, Slack, Twitter and Facebook – or even your Android phone. IFTTT allows you to connect all of these services in a simple way to harness the web to do work for you!

The Concept

This project is going to use IFTTT to do a lot of the work that we physically had to do in the File System version of this project. We will connect the Tessel 2 and its data to a Google Sheet using the IFTTT Maker Channel to send the data to sheets and populate the sheet in real time. Let’s take a deeper dive into how this works!

The IFTTT Maker Channel works through making web requests. Web requests are essentially a way for you to ask a server for information. We can use this to our advantage and make a statement through making a request. Let’s look at an example to make this a little clearer. Here is a web request URL used by the Maker Channel:

https://maker.ifttt.com/trigger/{event}/with/key/hhpANc1sDCoGpQ0-DfnbR_6g2WKLxwKSYvZDIRVGz5I?value1=123&value2=hello&value3=world

Let’s break this into chunks and make sense of it.

The first part probably looks familiar to you: https://maker.ifttt.com/. This is the domain (ifttt) with a subdomain of maker. This is the structure of all websites. If you want to navigate to Google, you type www.google.com (google is the domain).

The second part is a little trickier. It looks like this: /triger/{event}/with/key/. This is stating a category of the domain (trigger) and a subcategory, which is {event}, and other subcategories of /with/key. These are all used to categorize what is happening. Basically we are causing a trigger with a name of {event} followed by the key.

The string of random numbers and letters is a private and unique key, the one used to start the trigger. It is assigned to you when you sign up for the Maker Channel. This allows for unique and safe events to be triggered without someone accidentally triggering someone else’s project.

The final part of this puzzle is the query string ?value1=123&value2=hello&value3=world. A query string is the part of a URL that allows a request to look for specific data. Again, this is us making a statement through asking a question because we know what the server is looking for in terms of the questions asked. The Maker Channel allows us to send up to three different variables in this way, and they are named value1, value2 and value3. These values can be a string, a number, a Boolean state … as long as it is data, you can store it in one of these three buckets. The query string starts with a question mark (?), and each query value is separated by an ampersand (&).

Phew, that is a lot to take in! The good thing is that IFTTT does a lot for us, and there is also a Node.js module to help us on the code side of things. Let’s build the recipe first!

The IFTTT Recipe

Open a new browser window, and navigate to https://ifttt.com.

If you haven’t signed up for IFTTT, you can do so at this point. Don’t worry; we will wait for you.

Once you have signed up, you can start to build a recipe. You can start by clicking on the “Channels” menu button at the top of the page and then searching the channels for “Maker.”

When you find the Maker Channel, select it. You will end up on the landing page for the Maker Channel. To use the Maker Channel, you have to connect your IFTTT account to it. Cclick on the ‘Connect’ button.

Once your account is connected you will be assigned a key. This key will be really important as we start to use the Maker Channel. You can always come back to your account to copy and paste the key, but you can also copy and paste it into a text document for now.

Now, let’s create a recipe! Click on the ‘Create Recipe’ Button, and you will be confronted with the fun ‘If This Then That’ interface. The ‘This’ is a hyperlink. Click on it.

Search for and find the Maker Channel again, and select it. You only have one option in terms of triggers for the Maker Channel, to make a web request. Select that trigger.

From here, you name your trigger. We named ours ‘DataLog’.

When you accept a name, you will then get to select the ‘That’ of your recipe.

Search for ‘Google Drive’ for your ‘That’ event (it should be one of a few options).

Unlike the Maker trigger, where you only had a single option, the That for Google Drive has a number of options. You want to select the ‘Add Row to Spreadsheet’ option.

Ok, we are almost done! This next step allows you to name your spreadsheet and do some formatting of what the different columns of data will be. We will make a slight modification to the standard format by removing the event name from the rows, as this would be redundant and useless information for this example.

With that, the recipe is complete, and you should now be looking at an overview page.

This page will be accessible to you any time you come back to your IFTTT account under your recipes. You can then modify it as needed later on. Bam! You are done with your first IFTTT recipe! Now, let’s write some code to put it to good use.

The Code

How are we going to integrate JavaScript with IFTTT?

You may have guessed it – there is module for that!

We will be using the node-ifttt-maker module to make it as easy as possible to make web requests from the Tessel 2. First thing, we have to install the module into our project directory. If you haven’t done so already, open up your terminal and navigate to your loggerProject directory. To install the module, type the following command:

npm install node-ifttt-maker

At this point, you don’t need to install any other modules, as we have already installed johnny-five and tessel-io with our preflight check. You can now create a script for this project by typing the following into the terminal prompt:

touch iftttLog.js

With the file created, go ahead and open it in your text editor and type – or copy and paste – the following code into the file:

language:javascript
var five = require('johnny-five');
var t2 = require('tessel-io');

var IFTTT = require('node-ifttt-maker');

var ifttt = new IFTTT('<YOUR MAKER KEY>');

var board = new five.Board({
  io: new t2()
});

var temp, humidity;
const interval = 5;
board.on('ready',()=>{
  var atmos = new five.Multi({
    controller: 'BME280',
    freq: (interval*60000)
  });


  atmos.on('data', ()=>{
    temp = this.thermometer.fahrenheit;
    humidity = this.hygometer.relativeHumidity;

    var reqInfo= {
      event: 'gardenLog',
      method: 'GET',
      params: {
          'value1': temp,
          'value2': humidity,
       }
    }

  ifttt.request(reqInfo, (error)=> {
      if (err) {
        console.log(error);
      }
      else {
        console.log('---OK---');
      }
    });
  });
});

Make sure you save this file!

Open up your terminal window, and navigate to the project folder for this project to deploy the script to your Tessel 2. Type the following command to do so:

t2 run iftttLog.js

If everything is set up correctly, you should be greeted with the REPL prompt, and, in five minutes, you should get a ---OK--- logged. This should repeat every five minutes. Make dinner, sit back and crack open a cold one, or play a video game for a while to build up a few logs.

While you are building up a body of data in the ethers of your Google Drive, let’s take a closer look at the code that you just ran.

Code to Note

language:javascript
var IFTTT = require('node-ifttt-maker');
var ifttt = new IFTTT('<YOUR MAKER KEY>');

As with all Node.js modules, you need to require the node-ifttt-maker module. You then create an ifttt object of the IFTTT class, and you pass your maker key as a string to this. This is really nice because you only need to include your key once, and only once.

  language:javascript
  var reqInfo= {
  event: 'pianoLog',
  method: 'GET',
  params: {
      'value1': temp,
      'value2': humidity,
      }
   }

The Johnny-Five code is all the same from the previous version of this project. The main difference between the two scripts is what happens in the atmos.on() method. In this script, we create an object that contains all of the IFTTT web request information. This includes the event name as a string (pianoLog) and the method for making the request (do not change this from GET). It also includes the three parameters we want to log as value1, value2 (You can pass up to 3 values using the IFTTT Maker channel, for this example with are only using 2). We define each of these as the two variables temp and humidity, and they will be updated with those variable values each time the data event is fired. Building the object in this way will keep the actual request method cleaner and allows for a more straightforward way of defining things.

  language:javascript
  ifttt.request(reqInfo, (error)=> {
      if (err) {
        console.log(error);
      }
      else {
        console.log('---OK---');
      }
  });

The actual ifttt.request() method is pretty simple. You pass the reqInfo object that you just defined previously and then a callback that we use for error checking. If there is an error, it will log the error to the console, otherwise it logs ---OK--- to the console and the web request was successful!

Viewing Your Data in Sheets

You can now navigate to your Google Drive. In your Drive, you should now have a folder that is called IFTTT. Navigate to IFTTT, and open the Maker folder inside of that. You should now have a Sheets document named pianoLog or whatever you named your event.

Open your pianoLog sheet, and your logs should be visible in the spreadsheet similar to the following screen capture (with the exception of my notes where my kids decided to be smart and unplug the project):

You can now go through a similar process of graphing. This is similar to the USB drive method of logging in terms of graphing this data or using other analysis tools. Here is a the graph of my data over a few days of logging the data.

Final Touches

There are a number of things still to cover in terms of deploying this project. Here are a few thoughts that we have found work well for the Tessel 2.

Enclosures

If you are going to put this project outside for any length of time, you will need some sort of weatherproof enclosure so that you don’t leave the Tessel and the circuits you built in the elements (nothing good will come of that).

We have built a number of projects with the Tessel that use our Big Red Box enclosure. It has plenty of room, has a gasket edge and is weatherproof. It has plenty of space for the Tessel, a breadboard and batteries.

If you are in a hurry, or if you are going to be leaving the project outside for a shorter period of time, a Ziploc bag or Tupperware container works really well as a makeshift enclosure.

Powering Your Project

Powering a remote project is always tricky and probably the most difficult hurdle to overcome. Your easiest way to power the project is from a 5V USB wall adapter plugged into an outdoor power outlet, if you have one nearby. This will give it a consistent power supply as long as there is power to the outlet.

Your next option in terms of simplicity is a consumer USB LiPo rechargeable battery. These are becoming cheaper and cheaper these days, to the point where we find them as give-aways at events and in gift bags. The larger the battery in terms of milliamp hours, the better!

Probably the most technical way of running this project long term would be to build a LiPo battery solar charging system with a 5V DC/DC converter, a sunny buddy and a good-sized LiPo battery and solar panel, but that may be for another day and another tutorial. ;)

Added to your cart!

SparkFun Sunny Buddy - MPPT Solar Charger

In stock PRT-12885

This is the Sunny Buddy, a maximum power point tracking (MPPT) solar charger for single-cell LiPo batteries. This MPPT solar …

$24.95

4

FavoritedFavorite27

Wish List

Added to your cart!

Lithium Ion Battery - 6Ah

In stock PRT-13856

If you need some juice, this 6Ah Lithium Ion Battery is for you. These are very compact batteries based on Lithium Ion chemis…

$29.95

4

FavoritedFavorite7

Wish List

Added to your cart!

Solar Panel - 3.5W

In stock PRT-13782

Have a project that needs some good power? Do you like free power provided by our friend, Mr. Sun? Check out this high qualit…

$39

FavoritedFavorite4

Wish List

Added to your cart!

SparkFun DC/DC Converter Breakout

Out of stock BOB-09370

This is a breakout board for our non-isolated, [6A DC-to-DC Converter Module](http://www.sparkfun.com/commerce/product_info.p…

$29.95

3

FavoritedFavorite4

Wish List

Resources and Going Further

Exploring IFTTT

Whether you stick with this project to log weather data indoors, or are leaving it out in the woods collecting data for your next biology course, we highly recommend exploring the different channels on IFTTT and playing around with different recipes. You might be surprised what you can accomplish by just exploring and playing around with different channels.

For more Tessel fun, check out these other great SparkFun tutorials.

learn.sparkfun.com |CC BY-SA 3.0 | SparkFun Electronics | Niwot, Colorado

MicroView Hookup Guide a learn.sparkfun.com tutorial

Available online at: http://sfe.io/t477

Introduction

The SparkFun MicroView is the first chip-size Arduino-compatible module that lets you see what your Arduino is thinking by using a built-in Organic Light-Emitting Diode (OLED) display. In the heart of MicroView, there is an ATMEL ATmega328P and a 64x48 pixel OLED display, together with other passive components that allow the MicroView to operate without any external components other than a power supply. It fits nicely into a breadboard to make prototyping easy. The MicroView also has a full-featured Arduino library to simplify programming the module.

Added to your cart!

SparkFun MicroView - OLED Arduino Module

Only 8 left! DEV-12923

The MicroView is the first chip-sized Arduino compatible module that lets you see what your Arduino is thinking using a built…

$39.95

34

FavoritedFavorite61

Wish List

This guide will cover everything you need to know about the MicroView, including hardware information, quick-start experiments, library installation and usage, and advanced information such as making your own MicroView font.

Required Materials

The MicroView is a stand-alone system. However, you will need an external programmer to upload new code to the MicroView. The MicroView USB programmer is sold separately, so you can purchase one programmer while purchasing as many MicroView modules as you need. If you do not have one already, you will need a MicroView USB programmer to follow along with this tutorial.

Added to your cart!

SparkFun MicroView - USB Programmer

In stock DEV-12924

The MicroView is the first chip-sized Arduino compatible module that lets you see what your Arduino is thinking using a built…

$14.95

5

FavoritedFavorite17

Wish List

In addition to the MicroView and the USB programmer, you will need a few basic electronic components. Here is a complete list of the parts used in this tutorial.

Note that the USB extension cord is not necessary; the MicroView USB programmer can plug directly into a USB port. However, your USB port may be difficult to access, may be too tightly spaced for the programmer, or may result in the MicroView appearing upside down to you. In these instances, the USB extension cable comes in very handy. We carry both a 1.5-foot version and a 6-foot version.

Suggested Reading

If you have never worked with the Arduino development environment before or need a refresher, you may find the following links useful.

MicroView Overview

Let’s first familiarize ourselves with the MicroView and its pins. Below you’ll find a list of specifications as well as a graphical datasheet detailing the function(s) of each pin.

Hardware Specifications

• Input Voltage: 3.3VDC–16VDC
• Display: 64x48 OLED Display
• Microcontroller: ATmega328P
• Operating Voltage: 5V
• Digital I/O Pins: 12 (of which 3 provide PWM output)
• Analog Input Pins: 6
• Flash Memory: 32KB
• SRAM: 2KB
• EEPROM: 1KB
• Clock Speed: 16MHz

Pin Configuration

The MicroView has 16 “physical pins” that map to corresponding “Arduino pins” that can be referenced from within your Arduino sketch. For example, physical Pin 2 maps to the Arduino’s Analog Pin A5.

Pinout of MicroView on its side. The top of the MicroView is on the right. (Click image for closer look.)

The pin numbering for the MicroView increments as you move counter-clockwise.

The MicroView’s physical Pin 1 is denoted by a dot on the underside of the MicroView.

For more details on each pin’s function, please refer to the ATmega328P Datasheet.

Quick Start Tutorials

The MicroView comes with preinstalled code to get you learning right out of the box without having to do any programming. Using just a few components, you can learn the ins and outs of the MicroView.

Setting Up Your MicroView

Identify Pin 1 of MicroView based on the following diagram, or refer back to the MicroView Overview section.

In this guide, when there is a reference for Pin X of MicroView, it is referring to the above diagram’s pin number. For example, connect Pin 5 and Pin 8 of the MicroView.

First-Time Electronics Users

If this is your first time experimenting with electronics, you may want to read these other guides first.

MicroView with USB Programmer

The quickest way to get started is to use the USB programmer.

Insert the MicroView to the USB programmer. Then connect the female end of the USB extension cable to the factory USB programmer.

Note that it is much easier to connect a USB extension cable if the MicroView is inserted into the end of the breadboard.

Connect the male end of the USB extension cable to the computer. The MicroView will power on, and the demo will start.

MicroView without USB Programmer

If you would like to use the MicroView without the USB Programmer, you will need the following (please note that the 9V battery and snap connector will need to be purchased separately):

• 9V Battery
• 9V Snap Connector (Remove the Molex connector, replace both wires with male header pins if necessary)

Connect the required parts based on the diagram below. Plug in the battery connectors last. Once plugged in, the 9V battery will power the MicroView through the VIN pin (PIN 1).

As soon as the MicroView is powered, the demo will start.

Learn How to Use MicroView

The MicroView comes pre-programmed with a few simple built-in tutorials to help you get use to inserting jumper wires, resistors and an LED. Skip these tutorials if you are already familiar with them. They will begin after the visual demo.

Simple Tutorial 1

Follow the instruction displayed on the MicroView, and connect PIN 5 and PIN 8 of the MicroView with a jumper using the following diagram as reference:

Once you have successfully connected PIN 5 and PIN 8 of the MicroView, a “Well done!” message will be displayed. To proceed to the next simple tutorial, remove the jumper.

Simple Tutorial 2

Follow the instruction displayed on the MicroView, and connect PIN 3 and PIN 8 of the MicroView with a jumper using the following diagram as reference:

Once you have successfully connected PIN 3 and PIN 8 of the MicroView, a “Well done!” message will be displayed. To proceed to the next simple tutorial, remove the jumper.

Simple Tutorial 3

Follow the instruction displayed on the MicroView, and connect PIN 2 and PIN 8 of the MicroView with a jumper using the following diagram as reference:

Once you have successfully connected PIN 2 and PIN 8 of the MicroView, a “Well done!” message will be displayed. To proceed to the next simple tutorial, remove the jumper.

Simple Tutorial 4

Follow the instruction displayed on the MicroView, and connect PIN 4 and PIN 8 of the MicroView with a 330&ohm; resistor using the following diagram as reference:

Once you have successfully connected PIN 4 and PIN 8 of the MicroView with the resistor, a “Well done!” message will be displayed. To proceed to the next simple tutorial, remove the resistor.

Simple Tutorial 5

Follow the instruction displayed on the MicroView, and connect PIN 4 and PIN 8 of the MicroView with a 10K&ohm; resistor using the following diagram as reference:

Once you have successfully connected PIN 4 and PIN 8 of the MicroView with the resistor, a “Well done!” message will be displayed. To proceed to the next simple tutorial, remove the resistor.

Simple Tutorial 6

Follow the instruction displayed on the MicroView, connect PIN 5 and PIN 8 of the MicroView with a 330&ohm; resistor using the following diagram as reference:

With the resistor still at the same place, insert an LED with both of the pins at PIN 4 and PIN 5 of MicroView respectively using the following diagram as reference.

The MicroView is able to detect if the LED is inserted with the correct polarity, and it will begin blinking the LED.

If the LED does not blink, remove the LED and turn the pins the other way round and connect them to PIN 4 and PIN 5 of the MicroView.

With that, you are now ready to upload code and begin building the experiments in this guide.

If you would like to load the Demo Sketch back on to the MicroView after you have uploaded any other code, you can find the MicroViewDemo.ino sketch in the MicroView Library Examples.

MicroView Library Installation

The following section will cover all of the instructions to install the MicroView library and get started using the MicroView with the Arduino IDE.

In order to get your MicroView up and running, there a few easy steps you will need to follow:

1. Download the FTDI drivers
2. Install Arduino software and MicroView library
3. Select the right board
4. Run your first sketch

Driver Installation

If you have never used an Arduino or Arduino-compatible device on your computer before, you’ll likely need to install the drivers for the FTDI chip located on the MicroView USB programmer board. If you have never installed an FTDI driver before, please visit our FTDI driver installation tutorial. Once successfully installed, your MicroView should show up as a valid COM port in the Arduino IDE under Tools -> Ports.

Once you have finished the FTDI driver installation, you will need to prepare your MicroView to be inserted into the computer’s USB port.

If you’re using the USB programmer, insert the MicroView into the USB programmer now. Be sure to align Pin 1 of the MicroView with Pin 1 of the USB programmer. Once you have inserted the MicroView into the USB programmer, you can insert the USB programmer into the USB port of the computer as pictured below. If your computer does not have a right-sided USB port, please use a USB Cable Extension to extend the USB port to the front so that you can easily work with the MicroView.

As an alternative to the USB programmer, you can use a 5V FTDI Basic breakout or 5V FTDI cable instead. Connect the FTDI Basic breakout board as shown below, and you are ready to go.

Install Arduino IDE and the MicroView Library

If you have not installed the Arduino IDE already, now is the time to do so. Visit our Installing Arduino IDE tutorial for detailed instructions.

Download the library using the Arduino Library Manager (found in all versions of the Arduino IDE from v1.6.4 and on).

Click Sketch -> Include Library -> Manger Libraries to open the Library Manger. Once open, type “microview” in the search field. Install the SparkFun MicroView library by clicking on the library and then clicking the install button. Once installed, there should be a blue “installed” indicator next to the library.

You should now be able to find all the MicroView examples in your Arduino IDE sketchbook.

Board Selection

Once the Arduino IDE is up and running, you’ll need to select the correct board. Luckily, the MicroView is supported as an Arduino Uno variant, meaning no extra .brd files need to be installed to use the MicroView. Select Arduino Uno under Tools -> Boards.

In the Arduino IDE under Tools -> Ports, select the correct COM port. This is the port that was found in the Driver Installation section.

For advanced users who like to see MicroView as a board by itself in the IDE, add the following board definition to the boards.txt file. Depending on your setup, the boards.txt file is usually located in the arduino-version\hardware\arduino folder. Replace arduino-version with the right folder name for the Arduino version installed in your computer.

uview.upload.tool=avrdude
uview.bootloader.tool=avrdude
uview.name=MicroView
uview.upload.protocol=arduino
uview.upload.maximum_size=32256
uview.upload.speed=115200
uview.bootloader.low_fuses=0xff
uview.bootloader.high_fuses=0xde
uview.bootloader.extended_fuses=0x05
uview.bootloader.path=optiboot
uview.bootloader.file=optiboot_atmega328.hex
uview.bootloader.unlock_bits=0x3F
uview.bootloader.lock_bits=0x0F
uview.build.mcu=atmega328p
uview.build.f_cpu=16000000L
uview.build.core=arduino
uview.build.variant=standard

With the drivers and library installed and the correct settings selected in the Arduino IDE, it’s time to run our first program on the MicroView. The “Hello, World” sketch in the next section will be the first code we upload to the MicroView.

Example 1 - Hello, World!

The “Hello, World” sketch is common for programming of all types. For most embedded electronics, blinking an LED is the equivalent of printing out a “Hello, World” string. However, since the MicroView has its own display, we can actually print “Hello, World” to the screen as our first program.

Copy the following code, paste it into the Arduino IDE and click upload. Alternatively, you can open the HelloWorld sketch found under File -> Examples -> SparkFun MicroView -> Learning Kit -> HelloWorld.

language:c
#include <MicroView.h>

void setup() {
    uView.begin();              // start MicroView
    uView.clear(PAGE);          // clear page
    uView.print("Hello, World!");   // display string
    uView.display();
}

void loop () {}

Once uploaded, you should see “Hello, World” print out on the OLED screen.

Congratulations! You just uploaded your first MicroView sketch!

Let’s see what else we can program.

Example 2 - Basic Drawing

In this example, we’re going to try some basic drawing. This sketch demonstrates the MicroView’s many drawing functions, including pixels, lines, circles and rectangles.

It also introduces the setCursor() function, which allows you to move the cursor and print text or draw shapes at different locations other than the origin (0,0).

Copy the following code, paste it into the Arduino IDE and click upload.

language:c
#include <MicroView.h>

void setup() {
    uView.begin();
    uView.clear(PAGE);      // clear the page buffer
}

void loop() {
    uView.line(0,0,64,48);
    uView.circle(32,24,10);
    uView.rect(10,10,20,20);
    uView.pixel(50,5);
    uView.setCursor(0,40);
    uView.print(" MicroView");
    uView.display();        // display current page buffer
}

Once uploaded, you should see various images appear on the display.

Check out the MicroView Class Reference page for more information on drawing.

Example 3 - Widgets

This example introduces one of the MicroView’s most powerful programming tools: the widget. This sketch uses both the MicroViewSlider and the MicroViewGauge. These widgets are useful for displaying information from sensors, timers or other hardware, such as buttons or knobs.

Copy the following code, paste it into the Arduino IDE and click upload.

language:c
#include <MicroView.h>

MicroViewWidget *widget,*widget2;

void setup() {
    uView.begin();
    uView.clear(PAGE);
    widget= new MicroViewGauge(32,30,0,100);// draw Gauge widget at x=32,y=30,min=0, max=100
    widget2= new MicroViewSlider(0,0,0,100);// draw Slider widget at x=0,y=0,min=0, max=100
}

void loop() {
    for(int i=0; i<=100;i++) {
        widget->setValue(i);    // give a value to widget
        widget2->setValue(i);
        uView.display();        // display current page buffer
    }
}

Once uploaded, you should see a slider widget and a gauge widget run through the values 0–100 in a repeated loop.

Check out the MicroView Class Reference page for more information on widgets.

Example 4 - Drawing Bitmaps

This last example shows how to draw bitmap images to the MicroView. This is useful for creating splash screens of company logos, making sprites or just creating fun graphics for displaying information.

Before we can call the drawBitmap() function, we first need an image to draw. Remember, the screen resolution on the MicroView is 64x48 pixels, so images larger than that will not display correctly. To get a correctly sized image, there are a few methods:

1. Create a blank image in your favorite drawing program (Inkscape, Photoshop, Paint, etc.), setting the canvas size to 64x48 pixels. You can then draw your image by hand.
2. Find an appropriately sized image on the Internet.
3. Use a program to take an image and convert it to a bitmap.

Detailed instruction on how to make bitmap images is beyond the scope of this tutorial.

Once you have a bitmap, it’s time to convert it into an array that the MicroView can understand. You can use programs such as LCD Assitant (Windows only) or this homebrew conversion program (any OS that runs processing), created by SparkFun customer George Beckstein to convert your image into an array. With your array created, paste it into your code. Be sure to name it appropriately. Then call your array inside the drawBitmap() function.

language:c
#include <MicroView.h>


//------------------------------------------------------------------------------
// File generated by LCD Assistant
// http://en.radzio.dxp.pl/bitmap_converter/
//------------------------------------------------------------------------------
//This is the array that holds the Bitmap image. The easiest way to convert a bmp
//to an array is to use the LCD Assistant linked above.
uint8_t bender [] = {
0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0x7F, 0xBF, 0xDF, 0x5F, 0x5F, 0x5F, 0x5F,
0x5F, 0x5F, 0x5F, 0x5F, 0x5F, 0x5F, 0x5F, 0x5F, 0x5F, 0x5F, 0x5F, 0x5F, 0x5F, 0x5F, 0x5F, 0x5F,
0x5F, 0x5F, 0x5F, 0x5F, 0x5F, 0x5F, 0x5F, 0x5F, 0x5F, 0x5F, 0x5F, 0x5F, 0x5F, 0x5F, 0x5F, 0x5F,
0x5F, 0xDF, 0xBF, 0x7F, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0x07, 0xF9, 0xFE, 0x07, 0x01, 0x00, 0x00, 0xF8, 0xFE, 0xFF,
0xFF, 0xFF, 0x1F, 0x1F, 0x1F, 0xFF, 0xFF, 0xFE, 0xFC, 0xF8, 0xF0, 0xE0, 0x00, 0x00, 0x00, 0x00,
0xE0, 0xF0, 0xF8, 0xFC, 0xFE, 0xFF, 0xFF, 0x1F, 0x1F, 0x1F, 0xFF, 0xFF, 0xFF, 0xFF, 0xFE, 0xF8,
0x00, 0x00, 0x01, 0x07, 0xFE, 0xF9, 0x07, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFE, 0xF9, 0xE7, 0xDC, 0xB0, 0xA0, 0x40, 0x41, 0x47, 0x4F,
0x5F, 0x5F, 0x5F, 0x5F, 0x5F, 0x5F, 0x5F, 0x5F, 0x5F, 0x4F, 0x47, 0x43, 0x40, 0x40, 0x40, 0x40,
0x43, 0x47, 0x4F, 0x5F, 0x5F, 0x5F, 0x5F, 0x5F, 0x5F, 0x5F, 0x5F, 0x5F, 0x4F, 0x47, 0x43, 0x40,
0x40, 0xA0, 0xB0, 0xDE, 0xE7, 0xF9, 0xFE, 0x1F, 0x0F, 0x07, 0x73, 0x79, 0xFF, 0xFF, 0xFF, 0xFF,
0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0x7F,
0xBF, 0x5F, 0xEF, 0x0F, 0xEF, 0xEF, 0xDF, 0xDF, 0x1F, 0xDF, 0xDF, 0xDF, 0xDF, 0x1F, 0xDF, 0xDF,
0xDF, 0xDF, 0xDF, 0x1F, 0xDF, 0xDF, 0xDF, 0xEF, 0x0F, 0xEF, 0xDF, 0xBF, 0x7F, 0xFF, 0xFF, 0xFF,
0x7F, 0x7F, 0x7F, 0x7F, 0x7F, 0xFF, 0xFF, 0xFF, 0xBE, 0x9C, 0xC0, 0xE0, 0xF0, 0xF9, 0xFF, 0xFF,
0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xC0,
0xB7, 0x6F, 0xEE, 0x00, 0xDE, 0xDE, 0xDE, 0xDD, 0x00, 0xDD, 0xDD, 0xDD, 0xDD, 0x00, 0xDD, 0xDD,
0xDD, 0xC5, 0xC1, 0x00, 0xC9, 0xC5, 0xC1, 0x01, 0xC8, 0xC4, 0x42, 0x80, 0xC0, 0xE8, 0xE4, 0xE2,
0xE0, 0xE0, 0xEF, 0xEF, 0xE6, 0xF0, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
0xFF, 0xFF, 0xFE, 0xFE, 0xFD, 0xFD, 0xFD, 0xFB, 0xF8, 0xFB, 0xFB, 0xFB, 0xFB, 0xF8, 0xFB, 0xFB,
0xFB, 0xFB, 0xFB, 0xF8, 0xFB, 0xFD, 0xFD, 0xFC, 0xFE, 0xFE, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF
};


void setup() {
    uView.begin();
    uView.clear(PAGE);


    uView.drawBitmap(bender);
    uView.display();
}

void loop() {
}

Once this is uploaded, you should be greeted by a familiar fictional character.

There are several other example sketches included with the MicroView library. Try loading some of these other examples and figuring out what the code is doing.

OLED Memory Map

This section goes into more detail about how the OLED screen functions and how the MicroView library works with the screen’s controller. Read on to get a better understanding of how the MicroView prints and draws to the OLED screen.

The SSD1306 is the controller built into the MicroView’s OLED display. It has flexible yet complex segment and common drivers. Vast knowledge on memory addressing is required in order to use the SSD1306 controller.

MicroView’s library was written to hide away the complexities of the SSD1306 controller so that users can issue simple commands to control the display. Although the SSD1306 has a built-in RAM (memory) for the screen, when connected using the SPI method, the ATmega328P is not able to read the RAM (memory) of the SSD1306. Therefore, the software will not be able to manipulate the screen buffer to perform mathematical operations.

MicroView’s library overcomes this by allocating 384 bytes ( (64x48)/8 bits) of memory from ATmega328P as buffer. The library can now manipulate the screen buffer and then perform a bulk transfer from the ATmega328P’s memory to the internal memory of the SSD1306 controller.

The 384 bytes of screen buffer are declared in MicroView’s library as

language:c
static uint8_t screenmemory [] = {.total 384 bytes of data..};

and are arranged in a linear form representing the following 64x48 pixel coordinate system.

Based on the above illustration, for example, if a user wished to plot a pixel at the position of the black dot, where X=10 and Y=2, the user would issue the following command:

language:c
uView.pixel(10,2);

This command would then calculate the exact location of the screen buffer and set a BIT in the corresponding BYTE to the X,Y position.

Diagram showing how a linear screen buffer in the ATmega328P aligns with the OLED pixels.

Diagram showing the BITs in a BYTE of the screen buffer corresponding to the OLED’s X,Y position.

Based on the above illustration, a pixel turned on at X=2 and Y=3 means BYTE 2 of the screen buffer has data of 0x08 (hex).

Two pixels at X=2,Y=3 and X=2,Y=2 turned on means BYTE 2 of the screen buffer has data of 0x0c (hex).

The following C code shows a pixel-by-pixel way to draw a straight line of 5 pixels starting from 10,2 to 10,6.

language:c
uView.pixel(10,2);
uView.pixel(10,3);
uView.pixel(10,4);
uView.pixel(10,5);
uView.pixel(10,6);

The MicroView library allows you to draw lines by specifying the start and end coordinates. The above line could be drawn with this simple one-line command:

language:c
uView.line(10,2,10,6);

In order for the library to perform extremely fast mathematical operations on the screen buffer (more than 100 frames per second), calls to the drawing functions within the MicroView library do not immediately transfer the contents of screen buffer to the SSD1306 controller. A display() command is required to instruct the library to perform the bulk transfer from the screen buffer to the SSD1306 controller:

language:c
uView.display();

This function takes the whole screen buffer in the ATmega328P and transfers it (via SPI bus, programmed at 8Mhz) to the internal memory of the SSD1306. As soon as the memory is being transferred, the pixels corresponding to the screen buffer will show up on the OLED display.

Creating Fonts for MicroView

Though there are several different fonts that come programmed into the MicroView, you have the option to create your own fonts! Read on to find out how to do so.

In the OLED Memory Map section, we covered how the MicroView library allocates 384 bytes of RAM as screen buffer from ATmega328P to perform graphic operations before transferring this block of memory to the SSD1306 OLED controller’s memory. The following diagram shows how two 5x8 pixel characters are drawn on the screen buffer.

From the diagram, the “O” character appeared on ROW0, and took up 5 bytes of RAM from the screen buffer in the following order:

BYTE0 = 0x7e
BYTE1 = 0x81
BYTE2 = 0x81
BYTE3 = 0x81
BYTE4 = 0x7e

Character “A,” which was shown on ROW1, took up 5 bytes of RAM from the screen buffer in the following order:

BYTE64 = 0xfc
BYTE65 = 0x22
BYTE66 = 0x21
BYTE67 = 0x22
BYTE68 = 0xfc

A 8x16 font will take up 16 bytes of RAM from the screen buffer as shown in the next diagram:

With the 8x16 font using RAM from screen buffer’s ROW0 and ROW1, the data of the above diagram will occupy the screen buffer’s BYTE0 – BYTE7 and BYTE64 – BYTE71.

BYTE0 = 0xf8
BYTE1 = 0xfc
BYTE2 = 0x06
BYTE3 = 0x03
BYTE4 = 0x03
BYTE5 = 0x06
BYTE6 = 0xfc
BYTE7 = 0xf8
BYTE64 = 0xff
BYTE65 = 0xff
BYTE66 = 0x06
BYTE67 = 0x06
BYTE68 = 0x06
BYTE69 = 0x06
BYTE70 = 0xff
BYTE71 = 0xff

Manually plotting fonts and text is very tedious! It’s much easier to use the font-printing functions within the MicroView library. Displaying text in MicroView is as simple as: uView.print("Hello");

Although MicroView’s library includes four different types of font, these fonts might not suit your needs. By following these steps, you can make your own fonts and include them within the MicroView library:

1. Convert fonts to bitmap.
2. Generate font source file from bitmap.
3. Add font source file to MicroView library.

Converting Fonts to Bitmap

Once we understand how a character is being mapped to the MicroView’s screen buffer, we can choose to manually draw a font to the screen buffer or, alternatively, we can use software to convert a computer’s font to bitmap and then convert the bitmap into C char definition used by the MicroView library.

We have had good results using Codehead’s Bitmap Font Generator to convert a font into a bitmap. If you have had success with using other tools, please let us know, and we’ll update this article.

Let’s quickly run through a few simple steps to convert a computer’s font into a bitmap. Assuming we need the numbers 0 to 9 of the Courier font in 12x24 pixels, the following steps will generate the required bitmap:

1. Select “Courier” from the Font Details dropdown combo box.
2. Enter 48 as the Cell Height.
3. Enter 12 as the Cell Width.
4. Enter 128x32 as the Image Size (this Image Size need to be larger than 12x24x10(number of characters) ).
5. Enter 48 as the Start Character (48 ASCII code is the number 0).
6. Enter 200% as the Zoom.

From the generated result, it is clear that there is too much space on the left of the numbers and the glyphs are not taking full advantage of the 12x48 pixel cells.

Let’s further improve the font:

• Enter or slowly increase Font Height to a suitable value—in this case, 26
• Adjust the Position (X,Y) using the arrow button with option “Adjust All” selected (in this case, X=-4, Y=-1)

After the adjustment, we should see the following result:

This result is almost perfect except there is still empty space on the right of the “9” glyph and at the bottom of all the numbers. We can’t further improve the font spacing in Codehead Font Generator because it doesn’t allow custom image sizes, so we’ll correct the font in an image editor later.

Click File, then Export Bitmap (BMP), save the file as 12x24Font.bmp.

Using an image editor like Photoshop or GIMP, open the 12x24Font.bmp file, then make a selection to crop a 120x24 frame from the image.

If you want a WHITE text on BLACK background, you will need to INVERT the color now.

Save the image and then proceed to next step. You can also save the hassle by downloading the 12x24Font.bmp already prepared by us.

You have now successfully created a customized bitmap font!

Generating Font Source File from Bitmap

In order to convert the font from bitmap to C char definition, we will be using LCD Assistant. Run LCD Assistant and load the 12x24Font.bmp file previously saved.

Make sure that following options are correct:

• Picture preview is the right bitmap.
• Byte Orientation has Vertical selected.
• Width is 120, and Height is 24.
• Include Size not selected.
• Size Endianness has Little selected.
• Pixels/byte is 8.
• Table name is 12x14Font (can be any name).

Once all the options are correctly selected, click File, then save the output and type in the filename as 12x24Font.h.

Using a text file editor, open 12x24Font.h.

Locate

language:c
const unsigned char 12x24Font [] = {

and replace with

language:c
#ifndef FONT12X24_H
#define FONT12X24_H
#include <avr/pgmspace.h>
static const unsigned char font12x24 [] PROGMEM = {
// first row defines - FONTWIDTH, FONTHEIGHT, ASCII START CHAR, TOTAL CHARACTERS, FONT MAP WIDTH HIGH, FONT MAP WIDTH LOW (2,56 meaning 256)
    12,24,48,10,1,20,

FONT MAP WIDTH is basically the WIDTH of the BITMAP file used to generate the fonts. In this situation, the WIDTH of the BITMAP file is 120. So the HIGH number is 1, and the LOW number is 20.

Then replace

language:c
};

with

language:c
};
#endif

You should get the following result:

language:c
//------------------------------------------------------------------------------
// File generated by LCD Assistant
// http://en.radzio.dxp.pl/bitmap_converter/
//------------------------------------------------------------------------------

#ifndef FONT12X24_H
#define FONT12X24_H
#include <avr/pgmspace.h>
static const unsigned char font12x24 [] PROGMEM = {
    // first row defines - FONTWIDTH, FONTHEIGHT, ASCII START CHAR, TOTAL CHARACTERS, FONT MAP WIDTH HIGH, FONT MAP WIDTH LOW (2,56 meaning 256)
    12,24,48,10,1,20,
    0x1F, 0x1F, 0xE7, 0xE7, 0xE7, 0xE7, 0xE7, 0xE7, 0x1F, 0x1F, 0xFF, 0xFF, 0x9F, 0x9F, 0x9F, 0x9F,
    0x07, 0x07, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0x9F, 0x9F, 0xE7, 0xE7, 0xE7, 0xE7, 0xE7, 0xE7,
    0x1F, 0x1F, 0xFF, 0xFF, 0x9F, 0x9F, 0xE7, 0xE7, 0xE7, 0xE7, 0xE7, 0xE7, 0x1F, 0x1F, 0xFF, 0xFF,
    0xFF, 0xFF, 0xFF, 0xFF, 0x1F, 0x1F, 0x07, 0x07, 0xFF, 0xFF, 0xFF, 0xFF, 0x07, 0x07, 0xE7, 0xE7,
    0xE7, 0xE7, 0xE7, 0xE7, 0xE7, 0xE7, 0xFF, 0xFF, 0x7F, 0x7F, 0x9F, 0x9F, 0xE7, 0xE7, 0xE7, 0xE7,
    0xFF, 0xFF, 0xFF, 0xFF, 0x87, 0x87, 0xE7, 0xE7, 0xE7, 0xE7, 0xE7, 0xE7, 0x07, 0x07, 0xFF, 0xFF,
    0x1F, 0x1F, 0xE7, 0xE7, 0xE7, 0xE7, 0xE7, 0xE7, 0x1F, 0x1F, 0xFF, 0xFF, 0x1F, 0x1F, 0xE7, 0xE7,
    0xE7, 0xE7, 0xE7, 0xE7, 0x1F, 0x1F, 0xFF, 0xFF, 0x00, 0x00, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
    0x00, 0x00, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0x00, 0x00, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
    0xFF, 0xFF, 0x7F, 0x7F, 0x9F, 0x9F, 0xE7, 0xE7, 0xF8, 0xF8, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
    0xE7, 0xE7, 0xE7, 0xE7, 0x18, 0x18, 0xFF, 0xFF, 0x1F, 0x1F, 0x61, 0x61, 0x7E, 0x7E, 0x00, 0x00,
    0x7F, 0x7F, 0xFF, 0xFF, 0xE0, 0xE0, 0xE7, 0xE7, 0xE7, 0xE7, 0xE7, 0xE7, 0x1F, 0x1F, 0xFF, 0xFF,
    0x00, 0x00, 0xE7, 0xE7, 0xE7, 0xE7, 0xE7, 0xE7, 0x1F, 0x1F, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
    0x1F, 0x1F, 0xE1, 0xE1, 0xFE, 0xFE, 0xFF, 0xFF, 0x18, 0x18, 0xE7, 0xE7, 0xE7, 0xE7, 0xE7, 0xE7,
    0x18, 0x18, 0xFF, 0xFF, 0xF8, 0xF8, 0xE7, 0xE7, 0xE7, 0xE7, 0xE7, 0xE7, 0x00, 0x00, 0xFF, 0xFF,
    0xF8, 0xF8, 0xE7, 0xE7, 0xE7, 0xE7, 0xE7, 0xE7, 0xF8, 0xF8, 0xFF, 0xFF, 0xE7, 0xE7, 0xE7, 0xE7,
    0xE0, 0xE0, 0xE7, 0xE7, 0xE7, 0xE7, 0xFF, 0xFF, 0xE1, 0xE1, 0xE6, 0xE6, 0xE7, 0xE7, 0xE7, 0xE7,
    0xE7, 0xE7, 0xFF, 0xFF, 0xF9, 0xF9, 0xE7, 0xE7, 0xE7, 0xE7, 0xE7, 0xE7, 0xF8, 0xF8, 0xFF, 0xFF,
    0xFE, 0xFE, 0xFE, 0xFE, 0xE6, 0xE6, 0xE0, 0xE0, 0xE6, 0xE6, 0xFF, 0xFF, 0xF9, 0xF9, 0xE7, 0xE7,
    0xE7, 0xE7, 0xE7, 0xE7, 0xF8, 0xF8, 0xFF, 0xFF, 0xF8, 0xF8, 0xE7, 0xE7, 0xE7, 0xE7, 0xE7, 0xE7,
    0xF8, 0xF8, 0xFF, 0xFF, 0xFF, 0xFF, 0xE1, 0xE1, 0xFE, 0xFE, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
    0xF8, 0xF8, 0xE7, 0xE7, 0xE7, 0xE7, 0xE7, 0xE7, 0xF8, 0xF8, 0xFF, 0xFF, 0xFF, 0xFF, 0xE7, 0xE7,
    0xE7, 0xE7, 0xF9, 0xF9, 0xFE, 0xFE, 0xFF, 0xFF,
};
#endif

You have now successfully converted the bitmap font to a C header file!

Adding the Font Source File to MicroView Library

Move the edited 12x24Font.h file to MicroView’s library folder. You should be able to see the 12x24Font.h in the same folder as the rest of the MicroView’s files.

Using a text file editor, open MicroView.cpp, and perform the following steps:

Locate

language:c
// Add header of the fonts here.  Remove as many as possible to conserve FLASH memory.

Add after this line

language:c
#include <12x24Font.h>

Locate

language:c
// Change the total fonts included
#define TOTALFONTS      7

Change to

language:c
// Change the total fonts included
#define TOTALFONTS      8

Locate

language:c
const unsigned char *MicroView::fontsPointer[]={
    font5x7
    ,font8x16
    ,sevensegment
    ,fontlargenumber
    ,space01
    ,space02
    ,space03
};

Change to

language:c
const unsigned char *MicroView::fontsPointer[]={
    font5x7
    ,font8x16
    ,sevensegment
    ,fontlargenumber
    ,space01
    ,space02
    ,space03
    ,font12x24
};

The font that we have just added is at the 7th position starting from position 0 (font5x7) in the MicroView::fontsPointer array; therefore, the new font is now fontType 7. Save MicroView.cpp once you have made your changes.

Run the following sketch to test your new font:

language:c
#include <MicroView.h>

void setup() {
  uView.begin();
  uView.clear(PAGE);
  uView.setFontType(7);
  uView.print("1234");
  uView.display();
}

void loop () {
}

You have now successfully hacked MicroView’s library to add your own custom font!

MicroView Class Reference

Below you will find a complete list of available MicroView classes that can be called in your code.

Initialization

• void begin(void)—Initialization of MicroView Library.Setup IO pins for SPI port then send initialization commands to the SSD1306 controller inside the OLED.

• void end (void)—Power off the OLED display. Reset display control signals and prepare the SSD1306 controller for power off, then power off the 3.3V regulator.

Display Actions, Settings and Orientation

• void display(void)—Transfer display memory. Bulk move the screen buffer to the SSD1306 controller’s memory so that images/graphics drawn on the screen buffer will be displayed on the OLED.

• void clear(* uint8_t mode)—Clear screen buffer or SSD1306’s memory. To clear GDRAM inside the LCD controller, pass in the variable mode = ALL and to clear screen page buffer pass in the variable mode = PAGE.

• void clear(* uint8_t mode, * uint8_t c)—Clear or replace screen buffer or SSD1306’s memory with a character. To clear GDRAM inside the LCD controller, pass in the variable mode = ALL with c character and to clear screen page buffer, pass in the variable mode = PAGE with c character.

• void invert(boolean inv)—Invert display. The WHITE color of the display will turn to BLACK, and the BLACK will turn to WHITE.

• void contrast(* uint8_t contrast)—Set contrast. OLED contrast value from 0 to 255. Note: Contrast level is not very obvious.

• void setCursor(* uint8_t x, * uint8_t y)—Set cursor position. MicroView’s cursor position to x,y.

• void flipVertical(boolean flip)—Vertical flip. Flip the graphics on the OLED vertically.

• void flipHorizontal(boolean flip)—Horizontal flip. Flip the graphics on the OLED horizontally.

• uint8_t getLCDWidth(void)—The width of the LCD return as byte.

• uint8_t getLCDHeight(void)—The height of the LCD return as byte.

Display Scrolling

• void scrollRight(* uint8_t start, * uint8_t stop)—Right scrolling. Set row start to row stop on the OLED to scroll right. Refer to OLED Memory Map section for explanation of the rows.

• void scrollLeft(* uint8_t start, * uint8_t stop)—Left scrolling. Set row start to row stop on the OLED to scroll left. Refer to OLED Memory Map section for explanation of the rows.

• void scrollVertRight(* uint8_t start, * uint8_t stop)—Right vertical scrolling. Set column start to row stop on the OLED to scroll right. Refer to OLED Memory Map section for explanation of the columns.

• void scrollVertLeft(* uint8_t start, * uint8_t stop)—Left vertical scrolling. Set column start to row stop on the OLED to scroll left. Refer to OLED Memory Map section for explanation of the columns.

• void scrollStop(void)—Stop the scrolling of graphics on the OLED.

Font Functions

• uint8_t getFontWidth(void)—Get font width. The current font’s width return as byte.

• uint8_t getFontHeight(void)—Get font height. The current font’s height return as byte.

• uint8_t getTotalFonts(void)—Get total fonts. Return the total number of fonts loaded into the MicroView’s flash memory.

• uint8_t getFontType(void)—Get font type. Return the font type number of the current font.

• uint8_t setFontType(* uint8_t type)—Set font type. Set the current font type number (i.e., changing to different fonts based on the type provided).

• uint8_t getFontStartChar(void)—Get font starting character. Return the starting ASCII character of the current font; not all fonts start with ASCII character 0. Custom fonts can start from any ASCII character.

• uint8_t getFontTotalChar(void)—Get font total characters. Return the total characters of the current font.

Drawing Pixels

• void pixel(* uint8_t x, * uint8_t y)—Draw pixel. Draw pixel using the current fore color and current draw mode in the screen buffer’s x,y position.

• void pixel(* uint8_t x, * uint8_t y, * uint8_t color, * uint8_t mode)—Draw pixel with color and mode. Draw color pixel in the screen buffer’s x,y position with NORM or XOR draw mode.

Drawing Lines

• void line(* uint8_t x0, * uint8_t y0, * uint8_t x1, * uint8_t y1)—Draw line using current fore color and current draw mode from x0,y0 to x1,y1 of the screen buffer.

• void line(* uint8_t x0, * uint8_t y0, * uint8_t x1, * uint8_t y1, * uint8_t color, * uint8_t mode)—Draw line using color and mode from x0,y0 to x1,y1 of the screen buffer.

• void lineH(* uint8_t x, * uint8_t y, * uint8_t width)—Draw horizontal line using current fore color and current draw mode from x,y to x+width,y of the screen buffer.

• void lineH(* uint8_t x, * uint8_t y, * uint8_t width, * uint8_t color, * uint8_t mode)—Draw horizontal line using color and mode from x,y to x+width,y of the screen buffer.

• void lineV(* uint8_t x, * uint8_t y, * uint8_t height)—Draw vertical line using current fore color and current draw mode from x,y to x,y+height of the screen buffer.

• void lineV(* uint8_t x, * uint8_t y, * uint8_t height, * uint8_t color, * uint8_t mode)—Draw vertical line using color and mode from x,y to x,y+height of the screen buffer.

Drawing Rectangles

• void rect(* uint8_t x, * uint8_t y, * uint8_t width, * uint8_t height)—Draw rectangle using current fore color and current draw mode from x,y to x+width,y+height of the screen buffer.

• void rect(* uint8_t x, * uint8_t y, * uint8_t width, * uint8_t height, * uint8_t color, * uint8_t mode)—Draw rectangle using color and mode from x,y to x+width,y+height of the screen buffer.

• void rectFill(* uint8_t x, * uint8_t y, * uint8_t width, * uint8_t height)—Draw filled rectangle using current fore color and current draw mode from x,y to x+width,y+height of the screen buffer.

• void rectFill(* uint8_t x, * uint8_t y, * uint8_t width, * uint8_t height, * uint8_t color, * uint8_t mode)—Draw filled rectangle using color and mode from x,y to x+width,y+height of the screen buffer.

Drawing Circles

• void circle(* uint8_t x, * uint8_t y, * uint8_t radius)—Draw circle with radius using current fore color and current draw mode at x,y of the screen buffer.

• void circle(* uint8_t x, * uint8_t y, * uint8_t radius, * uint8_t color, * uint8_t mode)—Draw circle with radius using color and mode at x,y of the screen buffer.

• void circleFill(* uint8_t x0, * uint8_t y0, * uint8_t radius)—Draw filled circle with radius using current fore color and current draw mode at x,y of the screen buffer.

• void circleFill(* uint8_t x0, * uint8_t y0, * uint8_t radius, * uint8_t color, * uint8_t mode)—Draw filled circle with radius using color and mode at x,y of the screen buffer. Uses the Bresenham circle algorithm with a few modifications to paint the circle without overlapping draw operations.

MISC Drawing

• void drawChar(* uint8_t x, * uint8_t y, * uint8_t c)—Draw character c using current color and current draw mode at x,y.

• void drawChar(* uint8_t x, * uint8_t y, * uint8_t c, * uint8_t color, * uint8_t mode)—Draw character c using color and draw mode at x,y.

• void drawBitmap(void)—Draw bitmap image stored elsewhere in the program to the OLED screen.

• void setColor(* uint8_t color)—Set the current draw’s color. Only WHITE and BLACK available.

• void setDrawMode(* uint8_t mode)—Set current draw mode with NORM or XOR.

MicroViewWidget

• MicroViewWidget(uint8_t newx, uint8_t newy, int16_t min, int16_t max)—MicroView widget parent class. The MicroViewWidget class is the parent class for child widget like MicroViewSlider and MicroViewGauge.

• uint8_t getX()—Get widget x position.

• uint8_t getY()—Get widget y position.

• void setX(uint8_t newx)—Set widget x position.

• void setY(uint8_t newy)—Set widget y position.

• int16_t getMinValue()—Return the minimum value of the widget.

• int16_t getMaxValue()—Return the maximum value of the widget.

• int16_t getValue()—Return the current value of the widget.

• void setMinValue(int16_t min)—Set minimum value. The minimum value of the widget is set to the variable passed in.

• void setMaxValue(int16_t max)—Set maximum value. The maximum value of the widget is set to the variable passed in.

• void setValue(int16_t val)—The current value of the widget is set to the variable passed in, and the widget is drawn with the new value.

• void setValue(int16_t val, boolean doDraw)—The current value of the widget is set to the variable passed in. The widget is drawn with the new value if the doDraw argument is true.

• uint8_t getValLen()—Return the number of characters that would be printed using uView.print(value) for the current value.

• uint8_t getMaxValLen()—Return the maximum number of characters that would be printed using uView.print(value) for the current value range.

• virtual void draw()—Draw widget value overridden by child class.

• virtual void drawFace()—Draw widget face overridden by child class.

• void reDraw()—MicroView Widget reDraw routine. Redraws the widget.

• void drawNumValue(int16_t value)—Draw a signed decimal numeric value at the current cursor location. The value is right justified with leading spaces, within a field the length of the maximum possible for the widget’s value range.

MicroViewGauge

• MicroViewGauge(uint8_t newx, uint8_t newy, int16_t min, int16_t max)—MicroViewGauge class initialization. Initialize the MicroViewGauge widget with default style.

• MicroViewGauge(uint8_t newx, uint8_t newy, int16_t min, int16_t max, uint8_t sty)—Initialize the MicroViewGauge widget with style WIDGETSTYLE0 or WIDGETSTYLE1. Add WIDGETNOVALUE to the style to suppress displaying the numeric value (e.g., WIDGETSTYLE0 + WIDGETNOVALUE).

• void draw(void)—Draw widget value. Convert the current value of the widget and draw the ticker representing the value.

• void drawFace(void)—Draw widget face. Draw image/diagram representing the widget’s face.

MicroViewSlider

• MicroViewSlider(uint8_t newx, uint8_t newy, int16_t min, int16_t max)—MicroViewSlider class initialization. Initialize the MicroViewSlider widget with default style.

• MicroViewSlider(uint8_t newx, uint8_t newy, int16_t min, int16_t max, uint8_t sty)—Initialize the MicroViewSlider widget with style WIDGETSTYLE0 or WIDGETSTYLE1 or WIDGETSTYLE2 (like 0, but vertical) or WIDGETSTYLE3 (like 1, but vertical). Add WIDGETNOVALUE to the style to suppress displaying the numeric value (e.g., WIDGETSTYLE0 + WIDGETNOVALUE).

• void draw(void)—Draw widget value. Convert the current value of the widget and draw the ticker representing the value.

• void drawFace(void)—Draw widget face. Draw image/diagram representing the widget’s face.

MISC Under-the-Hood Functions

• void checkComm(void)—Listen for serial command. Instruct the MicroView to check for serial command from the UART.

• virtual size_t write(* uint8_t)—Override Arduino’s Print. Arduino’s print overridden so that we can use uView.print().

• void data(* uint8_t c)—SPI data. Send 1 data byte via SPI to SSD1306 controller.

• void setColumnAddress(* uint8_t add)—Set SSD1306 column address. Send column address command and address to the SSD1306 OLED controller.

• void setPageAddress(* uint8_t add)—Set SSD1306 page address. Send page address command and address to the SSD1306 OLED controller.

• void doCmd(* uint8_t index)—Parse command. Command stored in serCmd array will be parsed to performed draw functions.

• void command(* uint8_t c)—Send 1 command byte.

• void command(* uint8_t c1, * uint8_t c2)—Send 2 command bytes.

• void command(* uint8_t c1, * uint8_t c2, * uint8_t c3)—Send 3 command bytes.

• uint8_t * getScreenBuffer(void)—Get pointer to screen buffer. Return a pointer to the start of the RAM screen buffer for direct access.

MVSPIClass Reference (MicroView SPI)

• static void begin()—SPI Initialization. Set up SCK, MOSI, SS and DC pins for SPI transmission.

• static void end()—End SPI.

• static void wait()—Wait for SPI serial transfer complete.

• static void transfer(byte _data)—Transfer data byte via SPI port.

• static void packetBegin()—Set up to begin a SPI packet transmit. Set up SPI for transmitting. Prepare the SPI interface for transmitting 1 or more bytes of commands and/or data.

• static void packetEnd()—End an SPI packet transmission:

  • Wait for the last byte to finish being transmitted.
  • Set DC to command mode (even if already set that way, just in case).
  • Set SS high.
  • Disable SPI mode (causing SCK and MOSI to go low).

• static void attachInterrupt()

• static void detachInterrupt()

• static void setBitOrder(uint8_t)—Set SPI port bit order with LSBFIRST or MSBFIRST.

• static void setDataMode(uint8_t)—Set the SPI data mode: clock polarity and phase. mode - SPI_MODE0, SPI_MODE1, SPI_MODE2, SPI_MODE3.

• static void setClockDivider(uint8_t)—Set the clock divider of the SPI; default is 4Mhz.

  • rate: SPI_CLOCK_DIV2 SPI_CLOCK_DIV4 SPI_CLOCK_DIV8 SPI_CLOCK_DIV16 SPI_CLOCK_DIV32 SPI_CLOCK_DIV64 SPI_CLOCK_DIV128

Resources and Going Further

Check the links below for more information about the MicroView.

• Schematic
• Eagle Files
• Demo Video - Side-Scroller Shooter
• MicroView Bootloader Installation
• GitHub (Design Files & Example Code)
• GitHub (Library)

Now that you have a basic understanding of how the MicroView works, what will you create? Need some inspiration?

Learn the ins and outs of electronics using the MicroView with the SparkFun Inventor’s Kit for MicroView.

Build your own digital compass that displays the current heading on the MicroView.

learn.sparkfun.com |CC BY-SA 3.0 | SparkFun Electronics | Niwot, Colorado

Mini GPS Shield Hookup Guide a learn.sparkfun.com tutorial

Available online at: http://sfe.io/t578

Introduction

The Mini GPS Shield is a mini version of the SparkFun GPS Logger Shield. While the GPS Logger Shield was designed to work with the Arduino RedBoard, the Mini GPS Shield was designed to work with the Arduino Mini/Micro boards.

Added to your cart!

SparkFun Mini GPS Shield

In stock GPS-14030

The SparkFun Mini GPS Shield equips your Arduino Mini with access to a GPS module, µSD memory card socket and all of the oth…

$12.95

FavoritedFavorite1

Wish List

Just like its big brother, the Mini GPS Shield equips your Arduino Mini with access to a GPS module and µSD memory card socket for data logging. The board also uses a level shifter, so there’s no need to worry about the logic voltage of your Arduino Mini.

Check out the video below to see the Mini GPS Shield in action.

Required Materials

For this guide, you’ll need the following:

The wish list above has the 5V Arduino Pro Mini, but the 3.3V Pro Mini, Pro Micro, SAMD21 Mini, or ANY of our Arduino Mini form factor boards will work just as well.

Suggested Reading

If you have never worked with the Arduino Pro Mini or similar platforms before, we suggest having a look at the following tutorials before continuing.

If you have never worked with GPS before, have a look at our GPS Basics tutorial.

Hardware Overview

Let’s go over the Mini GPS Shield in detail.

The Mini GPS Shield will work with any of our Arduino Mini boards. The board uses 3.3V logic, however the logic level converter on the shield allows you to use 5V boards just as easily.

Connecting the GPS

The shield comes with a 6-pin JST connector to connect the GP-735 GPS module. If you already have a GPS module, the JST pins are broken out and labeled to allow you to use just about any GPS module that works down to 3.3V.

NOTE: The RX and TX labels correspond to the data direction on the board. RX should be connected to the GPS TX pin and TX should be connected to the GPS RX pin.

Using the LED

One of the problems of GPS is the time it takes to get your first position reading. Each module is different, but a typical GPS fix takes around 30 seconds. Another downfall is getting a strong enough signal from the the satellites in orbit, which can increase the time it takes to get a position fix. Because of the uncertainty in the time it takes to get a position fix, we included an LED attached to digital pin 7. We’ll see in the code below, how to use the LED to illuminate when we have locked in a position.

Software or Hardware Serial?

The GP-735 has a UART that makes communicating with the GPS very easy. Unfortunately, in many cases, the UART is tied up sending debug messages back to our computer. To get around this, we used software serial. Software serial, gives your microcontroller a software defined UART so you can communicate to your GPS while still sending the messages back to your computer. There are other times where you may need to use only the hardware serial, for example if your microcontroller is low on program memory. For this reason, we made switching between hardware and software serial easy, by including a switch that’s labeled HW-UART for hardware serial on digital pins 0 and 1, and SW-UART for software serial on digital pins 4 and 5. You can learn more about serial communication here.

GPS Power Saving

The Mini GPS Shield was designed to work with the GP-735 GPS module. If you want to save power, you can pull digital pin 6 LOW, and it will disable power to the GPS. To enable power, you can either pull digital pin 6 HIGH or leave it floating.

The GP-735 does not have accessible non-volatile memory. This means that when you disconnect power, any settings (baud rate, update rate, etc) will not be saved. If you don’t want to reconfigure these settings every time, you’ll need to use a backup battery. The backup battery won’t be used in the examples below, but, if you need to use it, those pins are labeled VBATT along with a “+” and “-” corresponding to the respective pins. The voltage of VBATT should be between 1.5V and 3.5V.

To Snap or not to Snap

You may have noticed the v-score next to the microSD connector. If you need the board to be as small as possible and aren’t planning on using a microSD card, you can easily remove the extra board material by providing a little bit of force to bend the board and snap it off. If you are going to use an SD card, we recommend leaving it on so an accidental bump won’t damage or dislodge your microSD card.

Hardware Hookup

Before you can attach your shield, you will need to solder some headers to both the GPS Shiled and the Arduino Pro Mini. We recommend soldering female headers to the Pro Mini and straight male headers for the shield.

Attaching the shield to an Arduino Mini, is very easy but there is one thing to keep in mind: standard Arduino boards, like the SparkFun RedBoard, have pin offsets that make plugging a shield into the board simple, while the mini boards have symmetrical pins, which means it’s very easy to plug the shield in the wrong way. Plugging the shield in backwards won’t damage either board, but it is something that could be easy to overlook.

The orientation of the shield is pictured below. The correct orientation has the GPS connector on the same side as the USB or FTDI connection and the microSD card over the crystal or reset button.

Arduino Examples

Now that we have everything connected, lets get started with some code. Before we start writing code though, we do need to install a library to parse the GPS messages. If you haven’t worked with downloading Arduino libraries before or you just need a quick refresh, check out our tutorial on installing Arduino libraries. The library we need is called TinyGPS++ from Mikal Hart, you can download and install the libary from the link below.

TinyGPS++ Library

Now that we have the library installed, let’s look at the code.

In this first example, we’ll test our our GPS and make sure we’re able to get a signal from the satellites.

language:c
/******************************************************************************
Mini_GPS_Shield_Serial_Example.ino
Example using the Mini GPS Shield with the GP-735
Alex Wende @ SparkFun Electronics
October 12th 2016
~

This sketches uses the Mini GPS Shield with the
GP-735 (https://www.sparkfun.com/products/13670). The Arduino reads the data
from the GPS module on the defined software serial pins, and prints data on
to the serial window.

Resources:
SoftwareSerial.h (included with Arduino IDE)
TinyGPS++.h

Development environment specifics:
Arduino 1.0+
Hardware Version 10

This code is beerware; if you see me (or any other SparkFun employee) at
the local, and you've found our code helpful, please buy us a round!

Distributed as-is; no warranty is given.
******************************************************************************/

#include <TinyGPS++.h>
#include <SoftwareSerial.h>

#define RX_PIN  4 // GPS TX
#define TX_PIN  5 // GPS RX
#define LED_PIN 7 // GPS Fix LED
#define GPS_BAUD  9600  // GP-735 default baud rate

TinyGPSPlus gps;

SoftwareSerial ss(RX_PIN,TX_PIN);

void setup() {
  Serial.begin(115200); // Begin serial communication with computer
  ss.begin(GPS_BAUD); // Begin serial communication with GPS

  pinMode(LED_PIN,OUTPUT);

  Serial.println("Date       Time        Latitude   Longitude   Alt    Course Heading Speed");
  Serial.println("(MM/DD/YY) (HH/MM/SS)     (deg)       (deg)  (ft)                   (mph)");
  Serial.println("-------------------------------------------------------------------------");
}

void loop() {
  char gpsDate[10];
  char gpsTime[10];

  if(gps.location.isValid()){ // GPS has a fix
    digitalWrite(LED_PIN,HIGH); // Turn LED on

    sprintf(gpsDate,"%d/%d/%d", gps.date.month(),gps.date.day(),gps.date.year()); // Build date string
    sprintf(gpsTime,"%d/%d/0%d", gps.time.hour(),gps.time.minute(),gps.time.second());  // Build time string

    Serial.print(gpsDate);
    Serial.print('\t');
    Serial.print(gpsTime);
    Serial.print('\t');
    Serial.print(gps.location.lat(),6);
    Serial.print('\t');
    Serial.print(gps.location.lng(),6);
    Serial.print('\t');
    Serial.print(gps.altitude.feet());
    Serial.print('\t');
    Serial.print(gps.course.deg(),2);
    Serial.print('\t');
    Serial.println(gps.speed.mph(),2);
  }
  else  // GPS is looking for satellites, waiting on fix
  {
    digitalWrite(LED_PIN,LOW);  // Turn LED off
    Serial.print("Satellites in view: ");
    Serial.println(gps.satellites.value());
  }
  smartDelay(1000);
}

// Delay ms while still reading data packets from GPS
static void smartDelay(unsigned long ms)
{
  unsigned long start = millis();
  do
  {
    while(ss.available())
    {
      gps.encode(ss.read());
    }
  } while(millis() - start < ms);
}

Our second example is very similar to our first example. In this example though, instead of displaying the GPS data in just the serial window, we’ll also log the data to a microSD card. Note that this example makes use of the built-in SD library in the Arduino IDE.

language:c
/******************************************************************************
Mini_GPS_Shield_Data_Log_Example.ino
Example using the Mini GPS Shield with the GP-735
Alex Wende @ SparkFun Electronics
October 12th 2016
~

This sketches uses the Mini GPS Shield with the
GP-735 (https://www.sparkfun.com/products/13670) and a microSD card. The
Arduino reads the data from the GPS module on the defined software serial
pins, and saves the data to a SD card.

Resources:
SoftwareSerial.h (included with Arduino IDE)
SD.h (included with Arduino IDE)
SPI.h (included with Arduino IDE)
TinyGPS++.h

Development environment specifics:
Arduino 1.0+
Hardware Version 10

This code is beerware; if you see me (or any other SparkFun employee) at
the local, and you've found our code helpful, please buy us a round!

Distributed as-is; no warranty is given.
******************************************************************************/

#include <SPI.h>
#include <SD.h>
#include <TinyGPS++.h>
#include <SoftwareSerial.h>

#define RX_PIN  4 // GPS TX
#define TX_PIN  5 // GPS RX
#define LED_PIN 7 // GPS Fix LED
#define CHIP_SELECT 10  // uSD card
#define GPS_BAUD  9600  // GP-735 default baud rate

TinyGPSPlus gps;
File myFile;
SoftwareSerial ss(RX_PIN,TX_PIN);

void setup() {
  Serial.begin(115200); // Begin serial communication with computer
  ss.begin(GPS_BAUD); // Begin serial communication with GPS

  pinMode(LED_PIN,OUTPUT);

  Serial.print("Initializing SD card...");

  // see if the card is present and can be initialized:
  if (!SD.begin(CHIP_SELECT)) {
    Serial.println("Card failed, or not present");
    // don't do anything more:
    return;
  }
  Serial.println("card initialized.");

  myFile = SD.open("data.txt", FILE_WRITE); // Create or open a file called "data.txt" on the SD card
  if(myFile)
  {
    if(myFile.size() == 0)  // Only create the header if there isn't any data in the file yet
    {
      myFile.println("Date\t\tTime\t\tLatitude\tLongitude\tAlt\tCourse\tSpeed");
      myFile.println("MM/DD/YYYY\tHH/MM/SS\tdeg\t\tdeg\t\tft\t\tmph");
      myFile.println("-------------------------------------------------------------------------------------");
    }
    myFile.close(); // Close the file to properly save the data
  }
  else {
    // if the file didn't open, print an error:
    Serial.println("error opening test.txt");
  }
}

void loop() {
  char gpsDate[10], gpsTime[10];

  if(gps.location.isValid()){ // GPS has a fix
    digitalWrite(LED_PIN,HIGH); // Turn LED on
    myFile = SD.open("data.txt", FILE_WRITE); // Open file "data.txt"
    if(myFile)
    {
      // Get date and time
      sprintf(gpsDate,"%d/%d/%d", gps.date.month(),gps.date.day(),gps.date.year());
      if(gps.time.second() < 10){
        sprintf(gpsTime,"%d/%d/0%d", gps.time.hour(),gps.time.minute(),gps.time.second());
      }
      else
      {
        sprintf(gpsTime,"%d/%d/%d", gps.time.hour(),gps.time.minute(),gps.time.second());
      }

      // Save data to SD card
      myFile.print(gpsDate);
      myFile.print('\t');
      myFile.print(gpsTime);
      myFile.print('\t');
      myFile.print(gps.location.lat(),6);
      myFile.print('\t');
      myFile.print(gps.location.lng(),6);
      myFile.print('\t');
      myFile.print(gps.altitude.feet());
      myFile.print('\t');
      myFile.print(gps.course.deg(),2);
      myFile.print('\t');
      myFile.println(gps.speed.mph(),2);

      // Print GPS data to serial window
      Serial.print(gpsDate);
      Serial.print('\t');
      Serial.print(gpsTime);
      Serial.print('\t');
      Serial.print(gps.location.lat(),6);
      Serial.print('\t');
      Serial.print(gps.location.lng(),6);
      Serial.print('\t');
      Serial.print(gps.altitude.feet());
      Serial.print('\t');
      Serial.print(gps.course.deg(),2);
      Serial.print('\t');
      Serial.println(gps.speed.mph(),2);
    }

    myFile.close(); // Close the file to properly save the data
  }
  else  // GPS is looking for satellites, waiting on fix
  {
    digitalWrite(LED_PIN,LOW);  // Turn LED off
    Serial.print("Satellites in view: ");
    Serial.println(gps.satellites.value());
  }

  smartDelay(1000);
}

// Delay ms while still reading data packets from GPS
static void smartDelay(unsigned long ms)
{
  unsigned long start = millis();
  do
  {
    while(ss.available())
    {
      gps.encode(ss.read());
    }
  } while(millis() - start < ms);
}

Troubleshooting Tips

If you’re testing your GPS inside, make sure you’re next to a window. One of the problems with GPS is the radio waves have a difficult time passing through roofs and ceilings, so, the closer the GPS is to being outside, the better. If you still aren’t reading from enough satellites to get a position fix, try pointing the GPS antenna in a different direction.

Due to the symmetrical pins of the mini boards, installing the shield backwards is an easy mistake to make. The correct orientation has the GPS connector on the same side as the USB or FTDI connection and the microSD card over the crystal and reset button. See the Hardware Hookup section for a picture of the correct orientation.

If you are unable to access the SD card, make sure your card is installed with the pins facing down and that you’ve initialized the SD card’s chip select as pin 10 when you call SD.begin(CHIP_SELECT).

Resources and Going Further

For more information about the Mini GPS Shield, check out the links below:

• Mini GPS Shield GitHub Repository
• Mini GPS Shield Schematic
• Mini GPS Shield EAGLE Files

Going Further

Now that you’ve got the Mini GPS Shield up and running, what project are you going to use this shield for? Need a little inspiration? Check out some of these tutorials!

• GPS Wall Clock– This project uses a GPS module to create a wall clock that you never need to set!
• GPS Differential Vector Pointer– In this tutorial you’ll learn how to use GPS receivers to have two objects, a base and a target, point towards one another. This can be used to aim sensors, antennas, lasers, etc. from one object to another over long distances.

learn.sparkfun.com |CC BY-SA 3.0 | SparkFun Electronics | Niwot, Colorado

Night-Light Pennant with LilyMini ProtoSnap a learn.sparkfun.com tutorial

Available online at: http://sfe.io/t579

Introduction

In this project we’ll control LEDs using the LilyMini ProtoSnap. With the code stored on the LilyMini, our projects can now have more advanced behaviors, and interactions are even reprogrammable. We’ll sew the LilyPad components on a pennant shape and customize the theme and decoration.

Design and build time: 3 - 4 hours

This is Project 4 from the LilyPad Sewable Electronics Kit, take a look at the other projects in the kit:

• Project 1: Glowing Pin
• Project 2: Illuminated Mask
• Project 3: Light-Up Plush

Suggested Reading

If this is your first sewable electronics project, we recommend you read our LilyPad Basics tutorial.

For a primer on the LilyMini ProtoSnap, check out this detailed guide.

Materials and Tools

Let’s go over all of the things you’ll need to sew your project together.

Added to your cart!

LilyPad Sewable Electronics Kit

In stock KIT-13927

The LilyPad Sewable Electronics Kit lets you explore the wonderful world of electronic sewing (e-sewing) and e-textiles throu…

$99.95

FavoritedFavorite3

Wish List