SparkFun USB to serial UART Boards Hookup Guide a learn.sparkfun.com tutorial

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

Introduction

SparkFun has a line of USB to serial UART bridge products designed to allow a user to communicate with a serial UART through a common USB port. It is harder to find computers with serial UART ports on them these days, but super common to find serial devices. Many of the official Arduino and clones share a common interface. This interface is essentially the 6 pin Single-In-Line (SIL), 0.1” pitch version of FTDI’s TTL-232R cables.

The key change from the FTDI cables to our Arduino compatible boards is that we swapped pin 6 from RTS to DTR. This change was required to match Arduino’s method of resetting the ATmega328P using the DTR signal.

Arduino compatible pinout is slightly different from the FTDI cable (pin 6)

Advantages

Having a detachable USB to UART bridge comes with several advantages over boards like the Arduino Uno.

• Removing the computer interface makes the board smaller.
• You only need to buy the circuit once and can program many Arduinos.
• The bridge circuitry draws power (up to 500 mW) that’s not needed in many installed applications. Removing this parasitic drain makes your project more power efficient & your batteries last longer.

Suggested Reading

Before we get started, you might want to review this other tutorial:

• Installing FTDI Drivers

Hardware Tour

The interface to this line of boards is simple. One side has a TTL-232R cable compatible 6 pin SIL, 0.1” pitch female header. This side connects to the Arduino (TTL serial UART) board. We often use right angle headers on the Arduino Pro Mini to make connecting a serial bridge trivial. Our boards have silkscreen labels of where the black and green wires of the FTDI TTL-232R cables would be.

Fritzing diagram showing the connection between a USB to UART bridge and a Pro Mini

6 pin SIL, 0.1” pitch header at top of PCBA

The other side has a USB mini-B or USB micro-B jack. A standard USB cable is used to connect this jack to a host computer.

This line of products comes in a few forms. Here is a table comparing the most common options.

Table 1. Comparison of common SparkFun offerings

<sup>1. [5V is taken directly from V_BUS and is only limited by the USB host controller.]↩
2. [This 3.3V regulator is powered directly from V_BUS and is only limited by the USB host controller.]↩</sup>

Connecting the USB to Serial UART Boards

These bridges have two connections. On one end there is a USB device connection. See table 1 for more details on the exact connector for the specific product. This interface is USB 1.1 / USB 2.0 full-speed compatible. A standard USB A to some sort of B cable is used to connect the bridge to the computer.

The other connection is a 0.1" pitch female header designed to connect to the microcontroller. Many of our products come with a compatible row of plated-through holes. These are designed to have 0.1" male headers soldered in. Some cases will best be served with straight headers, other with right-angle headers. The desired connection varies from design to design as discussed here. Some products come prepopulated with these headers.

Prepopulated FTDI header example

Resources and Going Further

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

PicoBuck Hookup Guide V12 a learn.sparkfun.com tutorial

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

Introduction

Please note that this tutorial is for the newest version of the PicoBuck, V12. If you have an older version of the PicoBuck, please refer to this tutorial.

Developed in collaboration with Ethan Zonca of protofusion, the PicoBuck is a small-size, triple-output, constant current LED driver. By default, each channel is driven at 330mA; that current can be reduced by either presenting an analog voltage or a PWM signal to the board. Version 12 of the board adds a solderable jumper that can be closed to increase the maximum current to 660mA. It also increased the voltage rating on the various components on the board, allowing the board to be used up to the full 36V rating of the AL8805 part.

Suggested Reading

Here are some topics you should know before using the PicoBuck. Have a look if you need more information.

• LEDs
• Resistors
• Voltage
• Current
• Electric Power
• Pulse Width Modulation

PicoBuck Overview

Since the PicoBuck is a constant current driver, the current drawn from the supply will drop as supply voltage rises. At 12V, the PicoBuck drives the three LEDs on our Rebel Triple Play board at 350mA per LED while drawing less than 350mA total from the power supply.

Three signal inputs are provided for dimming control. You can use the PWM signal from an Arduino or your favorite microcontroller to dim each channel individually, or you can tie them all to the same PWM for simultaneous dimming. A separate ground pin (labeled GND) is provided to reference against the controlling module for accuracy. The pin spacing for the two pairs of pins is 0.1", but the two pairs are slightly 0.2" apart, to allow for a 2.54mm pitch screw terminal pair to be used, or for a five-position standard 0.1" header with the middle pin removed. Dimming can be done by an analog voltage (20%-100% of max current by varying voltage from .5V-2.5V) or by PWM (so long as PWM minimum voltage is less than .4V and maximum voltage is more than 2.4V) for a full 0-100% range.

Signal Inputs

The power supply pads are sized for 3.5mm screw terminals, as are the output pads. Each output is independent from the other two.

Power Input

Output Pads

A small jumper is provided for each channel to allow you to increase the drive strength from 330mA to 660mA. More information on this can be found below.

Solder Jumpers

Two mounting holes for 4-40 or M3 screws are provided on either side of the board. They are perforated so they can be easily snapped off with a pair of pliers, if a smaller footprint is desired.

Mounting Holes

It is possible to increase the maximum current of the PicoBuck board up to 1A per channel; to do so, replace the three current sense resistors with smaller values. To calculate the new value for the resistor, use this formula:

I_LED = 0.1 / R_set

Thus, for a 1A current, you’d want a 0.1Ω resistor. Don’t forget to be wary of current ratings. At 1A, the sense resistor will be dissipating 1/10W, so you probably want a resistor of at least 1/8W rating. The package is a standard 0805.

Current Set Resistors

Closing the Current Setting Jumpers

As you can see from the image above, the solder jumper doesn’t need to be closed particularly neatly. All of the pads in its vicinity are connected to it anyway, so if you glob a little extra solder on, it’s no big deal. Just be careful not to actually short the resistors, as in the rightmost circuit!

Dimming with a Microcontroller

As mentioned earlier, the PicoBuck’s three channels can be individually dimmed by either varying the input voltage of the channel from 0-2.5V or using a PWM signal. The PWM signal from an Arduino board is perfectly suited for this.

Connecting one LED per channel

Here’s a diagram showing how to connect the PicoBuck to an Arduino.

Also note that each channel must be independently connected to the + and - connections of the LED it is to drive! Do not connect the + or - connections of any two channels together.

More than one LED per channel

Multiple LEDs can be connected in series, as shown, and the supply voltage should be at least 2-3V higher than the sum of the forward voltages of the LEDs.

Multiple LEDs can be connected per channel; they should be connected in series, as shown above, and the power supply voltage must be at least 1-2V higher that the sum of the forward voltages of the LEDs.

For instance, our blue 3W LEDs have a forward voltage of 3.2V to 3.8V. To be on the safe side, use the highest voltage in the range. If you want to connect four of them, you’d need a power supply of ~17V or greater (3.8V + 3.8V + 3.8V + 3.8V = 15.2V; add 2V of “head room”).

Since 17V is greater than the Arduino can tolerate on its input, we have to provide an external supply for the Arduino as well. This can be the standard 5V USB supply.

It’s perfectly acceptable to mix colors either between channels or on one channel, so long as all of the LEDs can handle the current (330mA or 660mA, depending on the jumper setting). Just make sure that the power supply voltage is high enough to handle the sum voltages of the highest voltage string. There is also no requirement that the three strings of LEDs have the same forward voltage of LEDs across them; you could have one white LED on channel 1, two red LEDs on channel 2, and four green LEDs on channel 3.

Code example

Code for controlling this device is trivial; simply use the analogWrite() function to adjust the brightness via PWM.

Resources and Going Further

Thanks for reading. Below are all the documents and links you’ll need to learn even more about the PicoBuck.

• PicoBuck Schematic
• PicoBuck GitHub Repository
• AL8805W5 Datasheet
• Protofusion Page

For more LED fun, check out these other SparkFun tutorials:

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

LED Cloud-Connected Cloud a learn.sparkfun.com tutorial

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

Introduction

Make a rainbow colored cloud light that you can control from your phone. You can even have it change color based on the weather outside.

These are the clouds from episode 3 The Fellowship of the Things, which you can watch below if you haven’t already.

Required Materials:

To follow along with this tutorial, you’ll need the following materials.

Other parts you will need:

• long hook-up wire for cloud power (I used stereo wire)
• Paper lanterns (white)
• Pillow filling (I used polyfil)
• Lots of hot glue and a hot glue gun
• Fishing wire
• A wooden dowel for support
• A power source; you will need something that can put out at least 5V and 4A, but for the best results you can get a pricier 6V 8A power source.

Optional part included: Thing dev board (in the wishlist, but only needed if you want to hook up to your phone and/or weather info)

Suggested Reading:

If any of these subjects sound unfamiliar, considering reading the following tutorials before continuing on.

• Through Hole Soldering
• Using the Arduino Pro Mini
• ESP8266 Thing Dev Board Hook-up guide
• Installing the Arduino IDE
• Installing an Arduino library
• WS2812 breakout hook-up guide

Physical Cloud Making

We will begin by assembling the clouds.

Start with an open white paper lantern, and glue on pieces of polyfil in small sections until you have covered the whole lantern.

Some tricks for making the cloud look cool when it is lit up is to swirl the polyfil before you glue it on or do other fun crazy shapes.

When you have covered it fully (don’t worry about the top and bottom holes right now), you may want to take a flashlight, and check to see what the lantern looks like when lit up. Cover any bare spots you see.

Flashlight lighting up polyfil covered paper lantern.

Repeat this process for as many lanterns as you would like. The more lanterns, the larger your clouds will be. Just keep in mind you’ll need a power supply that can handle all the LEDs in each lantern. Paper lanterns of different sizes can create a cloud that looks more realistic.

The 5m RGB LED strips fill about five lanterns, so if you want to make your cloud larger or have more than one cloud, you are going to want more RGB LED strips and power sources (you can use the same Pro Mini and ESP8266 Thing Dev Board to power multiple clouds and RGB LED strips).

Once you have the all of your lanterns covered in polyfil, you can tie them together with the fishing wire. This was accomplished by picking a lantern that I wanted to be the highest point of the cloud and tying the tops of the other lanterns to the top of the one I chose. This will give you room for the cloud to look like it is “bobbing” and “shifting”, but if you want it to be more secure, you can tie the lanterns more tightly to each other and even tie the bottoms together as well.

Now that your lanterns are tied together, you can secure them to a wooden dowel so that the cloud is easier to transport and hang.

At this point, set your cloud up near your workstation so that you can easily install the lights and see what the cloud looks like lit up. Take this opportunity to add or take away polyfil as you see fit.

Electronics Assembly Part 1

This section will cover building the Pro Mini Circuit. We will add the Internet-connected portion in Part 2.

Connect the components as follows:

Please note that we are soldering all these components to a solderable breadboard. Feel free to build the circuit on a breadboard first to test everything out.

Click the image for a closer look.

* Pins not listed are not used.

Take a button, and cut off two legs that are diagonal to each other so that it doesn’t cause a short circuit.

Some things to note here is that I have put a 1000 microfarad capacitor between the LED power and ground. This is good practice, and helps distribute the current better, so that you don’t accidentally blow out your first LED. This should be done on any string of wires as a precautionary measure. I have also placed a 330&ohm; resistor between the DIN of the LEDs and the microcontroller. This is another good measure to protect the addressable LEDs.

The Pro Mini will need to be powered separately from the LEDs, and this can be done through the Mini USB port of an FTDI Basic. (If you don’t want it to run off your computer you can get this USB wall charger). You can also solder wires directly to the Pro Mini’s VIN pin.

Code Part 1

The following code allows you to run the lights off of the Pro Mini so that you can scroll through the different pre-programmed lighting sequences.

Plug in the Pro Mini, choose Pro Mini as your device, select the corresponding COM port, and then press the “Run on Arduino” button.

If the codebender embed doesn’t load for you, you can download the example code from our GitHub repository.

Once you have tested that your code works with your soldering job, you may want to take some hot glue and cover the wires leading to your barrel jack, just to make sure nothing shorts and to create a stronger connection.

Electronics Assembly Part 2

This section will cover adding a SparkFun thing to your project so that it can connect to the Internet.

You can keep all the soldering done in part 1, but just add a SparkFun Thing board to allow for use with your phone as well as to pull weather data.

Connect the components as follows:

Click the image for a closer look.

* Pins not listed are not used.

Again, same notes as part 1: adding a capacitor and resistor, and powering the Pro Mini and Thing from the wall (read part 1 for all the details).

One additional note, for ease of programming both the Pro Mini and the SparkFun Thing board, you may want to solder in female headers where the Thing board will sit and male headers to the Thing board, so that you can easily take it out to program both.

Code Part 2

Since you have two boards with microcontrollers, you will have to program each one separately.

Pro Mini Code:

Remember, put “Arduino Pro or Pro Mini (5V 16 MHz) w/ ATmega328” as your device, select the COM port that it is plugged into your computer on, and hit the “Run on Arduino” button to program.

If the codebender embed doesn’t load for you, you can download the example code from our GitHub repository.

To hook up the Thing board to the Internet, we will be using the Blynk app. To get the code we need to program the Thing board with you will need to download the Blynk app onto your phone.

Once you have the app, create an account (if you don’t have one already), and go to “create new project”. There you can name your project, set your hardware to “ESP8266” and you can email or just copy that authentication token, which we will need to paste in the SparkFun Thing code.

In your project that you just created, you are going to want to put three LED light widgets, three button widgets, a ZERGBA widget, and an LCD widget.

To get these things onto your project board, touch the screen and the left side should show things that you can place. Drag them over to wherever you’d like. Once they are placed on your board, you can click on them to assign them pins. All of ours are going to be assigned to virtual pins in the table below. There is also a step by step photo setup to help you:

Blynk app Photo Setup Walkthrough:

(remember to email yourself the Auth Tolken or you can come back to this page after you to get it.)

Swipe to the left to get the widget box menu, to pick new modules:

Once you have selected a module, it will appear on your project board. To attach it to a pin and change its setting, click on it:

Repeat those steps for all the modules attached to the pins you will need (as seen below):

After you have created all the LEDs, Buttons, the ZERGBA, and the LCD and assigned them to the correct virtual pins, you can arrange your modules to look like this:

And now your blynk project is ready!

SparkFun Thing Code:

To program the SparkFun ESP8266 Thing, we have to get a little more complex. Since it is a newer board, it is yet to be supported on Codebender, but they are working on it! We will update this tutorial once such an option is available.

Thus, to program this board you will need to have the Arduino IDE on your computer. You will need a special add on to be able to choose the ESP8266 board, and you can get the instructions for that in this tutorial. You will also need to download the github libraries for Blynk, Adafruit’s Neo-Pixel Libraries, and lastly add the github libraries for this project. If you have never worked with the Arduino IDE or need a refresher on how to install github libraries I would take a look at our tutorials on them:

• Installing Arduino IDE
• Installing an Arduino Library

Once you have done all of that, you can open the Thing code in the cloudcloud project, change the wifi and password to your network, add your Auth token from the Blynk app, and upload it to your SparkFun Thing to your computer. If you want weather for a city other than Niwot (which you probably do) you can change that in the code as well.

When uploading the code, remember to choose “SparkFun ESP8266 Thing” as your board under the Tools tab. Also check that you have the “Upload using: serial”, “CPU frequency: 80 MHz”, and “Upload speed: 115200” chosen under the Tools tab as well. Make sure you Thing board switch is ‘ON’. Then choose the COM port that your Thing board is hooked up to, and press the Upload button.

(*If you are having errors when you try to upload of undefined libraries, make sure that you have added the file states.h to your project. If after that you are still having issues, it might be the version of the Adruino IDE that you are running, we wrote this on version 1.6.5 and recommend running it on that version.)

Once that is finished uploading, unplug the Thing board from your computer, hook it back up to the circuit, power your Pro Mini (that is also powering the Thing board), and your LED strip. Make sure your Thing board switch is turned on, and wait 30-60 secs. Open up your Blynk app, and run the project you created by pressing play in the top right corner. You should be all hooked up and able to control your lights from the app.

Phew, that was a lot of stuff, but we got through it! Now you can power your lights and your Pro Mini (that is also powering the Thing board) and power up your Blynk app and control your clouds!

Installing the Lights in the Clouds

Now that we have the lights up and running, we can place them into the cloud and test out how it looks.

Evenly distribute the lights between all the paper lanterns and look at the light distribution, and adjust accordingly.

After I felt good about the distribution, I tied the LED strip to the top of each paper lantern. Note that the LED strip isn’t very secured in the lantern. The reason for this is that I didn’t see a difference if I secured them or not. Since they will always be hanging in the same way, they aren’t going to shift very much, so just securing a part to the lantern seemed sufficient to me.

After the LED strip was in the cloud, I looked around and filled any bald spots on the lantern with more polyfil that I could now see due to the lights. I also covered any exposed LED strip with polyfil that I rolled to be more dense.

You can glue the polyfil on while the Cloud is lit to get a better idea of what it looks like.

After you have filled in all the uneven spots of the cloud with polyfil, you can install your cloud where you like and enjoy it’s colorful awesomeness!

Resorces and Going Further

Thanks for reading! Here are the links to all the resources used in this tutorial.

• Arduino IDE
• Blynk app

Github Libraries:

• Blynk
  
• SparkFun ESP8266 Thing Board
  
• Adafruit’s Neo-Pixel
  
• Conected Cloud Controller

Codebender Libraries:

• Pro Mini button scrolling code
  
• Pro Mini part of connected cloud
  

Interested in some more crafty electronics projects? Take a look at some of our other tutorials:

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

MicroSD Breakout With Level Shifter Hookup Guide a learn.sparkfun.com tutorial

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

Introduction

The MicroSD Breakout With Level Shifter makes it easy to add mass storage to your project, whether you’re working with a 3.3V system or a 5V system.

Figure 1. Shifting µSD Breakout Board

Required Materials

To follow along with this hookup guide, you will need the following:

Suggested Reading

If any of these subjects sound unfamiliar, considering reading the following tutorials before continuing on.

• What is an Arduino? - New to Arduino? Start here.
• Installing the Arduino IDE - A refresher on using the Arduino environment.
• Arduino Shield Basics - Covers shields from a general standpoint.
• Serial Peripheral Interface (SPI) - This tutorial shows you how to communicate with an SD card over SPI.
• SD Cards and Writing Images - Learn the basics of SD and microSD cards.

Hardware Overview

The SparkFun Shifting µSD Breakout is quite similar to the SparkFun microSD Transflash Breakout, but with the additional feature of being 3.0V to 5.0V tolerant for ease of use. No more discrete level shifting is required. That also makes it great for direct use with a single cell LiPo battery or similar.

One thing that makes this product stand out is that it is SPI_FULL_SPEED stable. Some errors were seen in our testing with other products, but none have been caught using this board. We didn’t have NIST do our testing. We can’t rule out the influence of environmental factors or the host processor used, but if we were looking for stability and reliability at high speed, we’d use this board.

If your processor is capable of it, this board supports the use of even the fastest UHS µSD cards. We only tested to 25MHz, but it should be good to two to four times that. Today most Arduino type µControllers are only capable of SPI_HALF_SPEED (6Mbps). Consider this board if you want a little future proofing or have a faster setup. The Arduino SD library is capable of SPI_FULL_SPEED (25Mbps).

The SparkFun Shifting µSD is also a bit unique from its competitors in that it level translates all of its outputs back to the level of the hardware it’s connected to. Other parts make the fairly safe assumption that the inputs on the processor will read 3.3V as a high. This may not always be the case, and isn’t an assumption this board relies on, so you don’t have to bother worrying about it.

Assembly

There are numerous ways to wire up an equivalent circuit to the one used in this guide. That will all depend on the type of Arduino you are using, the availability of a breadboard, or the types of wires you have laying around. The required materials list above assumes you have access to one of the most popular Adrduino form factors and you will wire it directly to the Shifting µSD board with jumper wires. No breadboard required, and only minimal soldering to get a connection to the µSD board.

Here is how you would wire up the Shifting µSD to a RedBoard or Arduino Uno. From the Ardino SPI library: Warning: if the SS pin ever becomes a LOW INPUT then SPI automatically switches to Slave, so the data direction of the SS pin MUST be kept as OUTPUT. This is pin 10, so be careful.

Shifting µSD board wired to 5V RedBoard

Code Example

The example code for this product is a simple file logger that allows the user to write to a file on the µSD card using the Arduino IDE Serial Monitor (57600 baud). When the board boots you should see the following in the Serial Monitor:

Initializing SD card...Initialization done.
demoFile.txt doesn't exist. Creating.
Opening file: demoFile.txt
Enter text to be written to file. 'EOF' will terminate writing.

The last line of that bock of text is important to note. Your work is written to the µSD card every 20 characters, but to make sure everything is written append EOF to your writing. Doing so writes everything remaining in the buffer to the file and reads back the contents of the file.

EOF

demoFile.txt:
Test line of text.
Bacon ipsum dolor amet beef picanha drumstick alcatra brisket, short ribs sirloiBacon ipsum dolor amet beef picanha drumstick alcatra brisket, short ribs sirloin.

One thing to note is that the UART buffer on the Arduino might limit the number of characters entered on a single line. In one test I noticed that my Arduino only accepted 164 bytes before loosing data, but I’ve seen that vary a bit.

language:c
#include <SPI.h>
#include <SD.h>

File fd;
const uint8_t BUFFER_SIZE = 20;
char fileName[] = "demoFile.txt"; // SD library only supports up to 8.3 names
char buff[BUFFER_SIZE+2] = "";  // Added two to allow a 2 char peek for EOF state
uint8_t index = 0;

const uint8_t chipSelect = 8;
const uint8_t cardDetect = 9;

enum states: uint8_t { NORMAL, E, EO };
uint8_t state = NORMAL;

bool alreadyBegan = false;  // SD.begin() misbehaves if not first call



void setup()
{
  Serial.begin(57600);
  while (!Serial);  // Wait for serial port to connect (ATmega32U4 type PCBAs)

  // Note: To satisfy the AVR SPI gods the SD library takes care of setting
  // SS_PIN as an output. We don't need to.
  pinMode(cardDetect, INPUT);

  initializeCard();
}



void loop()
{
  // Make sure the card is still present
  if (!digitalRead(cardDetect))
  {
    initializeCard();
  }

  if (Serial.available() > 0)
  {
    readByte();

    if (index == BUFFER_SIZE)
    {
      flushBuffer();  // Write full buffer to µSD card
    }
  }
}



// Do everything from detecting card through opening the demo file
void initializeCard(void)
{
...

Troubleshooting

Arduino has troubleshooting tips on their Notes on the Arduino SD Card Library page, including instructions for formatting new cards (if needed) and using the library with other Arduino boards.

Resources and Going Further

Now that you know how to add more storage to your Arduino projects, it’s time to get out there and create something amazing. Need some inspiration? Check out these other SparkFun tutorials.

• SD cards are a great way to add more storage to Internet of Things projects. You can add a microSD Shield to a WiFly Shield to serve up larger web pages or hold more data. You can also use the CC3000 Shield, which has a microSD card slot built in.
• Need more power than your Arduino can provide? Check out the Edison, which also has a microSD card Block to add more storage to larger projects.
• Logging data is a common use for SD cards. Take your logging project to the next level with the Logomatic.

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

Photon Remote Temperature Sensor a learn.sparkfun.com tutorial

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

Introduction

The scientific method allows us to examine the universe and its natural phenomena. Through collection and analysis of data, we discover historical trends to make predictions about future events. One such phenomenon that greatly impacts our daily, and long-term, lives is temperature. This tutorial shows you how to build your own remote temperature sensor that automatically uploads data to the data.sparkfun.com web service. This is a perfect, hands-on project for teaching, or learning, the difference between daily temperature fluctuations and average temperature over time, a particularly crucial distinction when discussing climate change.

This system uses the Particle Photon as the control device, a handy lil' microcontroller that easily connects to WiFi. The Photon reads in temperature data from the SparkFun TMP102 digital temperature sensor, then uploads the data to a web server for remote data acquisition and, if desired, subsequent analysis and plotting.

For all you visual learners, check out a video of the project below:

First, A Note About Temperature!

In our macroscopic world, temperature is a seemingly simple concept – we intrinsically understand fundamental differences between hot objects and cold objects. Often we can estimate temperature just by looking at the object; if our stove burner is glowing red, we know that it is likely very hot and we should avoid touching it.

The standard definition of temperature is a measure of the average amount of heat, or thermal energy, of the particles in a substance. Since temperature is an average measurement, typically the size of the sample is irrelevant. For example, a small pot of boiling water will be at the same temperature as a large pot of boiling water (as long as you’re at the same altitude!).

On the microscopic scale, temperature is a fairly complex phenomenon that corresponds to the molecular speed of individual atoms. In other words, temperature is a measure of the kinetic energy of the atoms that make up a particular substance. In general, for a given substance, the solid phase will have the lowest temperature because the atoms are mostly rigid, followed by the liquid phase in which atoms have more kinetic energy, and then the gaseous phase with the most energetic atoms. However, since mass is also a form of energy, less massive molecules need to have more kinetic energy to be at the same temperature as more massive molecules. This is why all three phases can exist at the same average temperature (e.g. gaseous oxygen, liquid water, solid metal).

Want to learn more about temperature? Check out this great resource.

Materials

To follow along with this project at home, you’ll need the following:

Electronics

• Particle Photon microcontroller
• SparkFun Photon Battery Shield
• TMP102 Digital Temperature Sensor
• 2.5 W Solar panel
• Polymer Lithium Ion Battery - 6 Ah
  • Please note that the Battery Shield is intended to charge single-cell LiPo batteries. Using the triple-cell 6Ah battery will give you a longer battery life, but be aware that each cell may not be charged at the same rate.
  • If you live in a sunnier climate than Seattle, you can use a lower capacity battery (e.g. 2000 mAh battery).
  • Be careful with the JST connectors, and avoid pulling the wires, particularly when removing them. Check out this tutorial for an easy way to remove them.
• Six (6) Header pins
• Surface Mount DC Barrel Jack
• Four (4) Male-to-Female Breadboard Jumper Wires (or use 22-gauge insulated wire)
• Breadboard (and/or PCB board)

Here’s a wish list of most of the parts mentioned above for your convenience.

Casing and Installation

• For electronics: Project box or waterproof tupperwear

  There are tons of options for cases, just be sure it is durable, waterproof, and not made of metal (will block the WiFi signal).

• Stand for solar panel (e.g. metal post, garden sign, plant holder, tripod, etc.)

  While a stand is somewhat optional, it allows you to point the panel towards the sun and adjust it throughout the year to obtain maximum incident solar radiation. Check out your local thriftstore for inexpensive items to use as a stand. Be sure the stand and attached panel will withstand the elements (including wind). Alternatively, you can attach the solar panel directly to the temperature sensor case.

Tools

• Soldering iron and supplies
• Wire Strippers
• Multimeter
• Epoxy, or other electrically insulating adhesive
• Velcro (to adhere solar panel to stand)
• Drill or waterproofing electrical tape (for getting solar panel cable into case)

Recommended Reading

The goal of this tutorial is to give you enough information to get your remote temperature sensor up and running as quickly as possible, regardless of your background and experience with the components used in this project. As such, this tutorial provides only a brief mention of the underlying hardware and software elements. Check out the guides below for more in-depth information, including the I²C communication protocol used by the TMP102 sensor and the Phant library used by the data.sparkfun.com web service.

Hardware

• Guide to setting up the Particle Photon
• Guide for developing on the Photon
• Hookup Guide for Photon Battery Shield
• Tutorial to hooking up the TMP102 for Arduino
• Datasheet for the TMP102
  • Datasheets are your friend! It is highly recommended to review this datasheet, at the very least to get more familiar with datasheets.

Software

• The TMP102 temperature sensor uses I²C (Inter-Integrated Circuit) communication protocols. If you are new to this, here is a handy overview of the I²C protocol.
• This tutorial uses the data.sparkfun.com web server to host the temperature data stream.
  • Here’s a guide on pushing data to the data.sparkfun.com host..
  • Here’s a tutorial on using HTTP to log data.

Build It!

Let’s begin assembling our circuit.

1. Set up the Particle Photon.

   Go to the Photon set up page and follow the instructions to set up your Photon for WiFi. The Photon LED will slowly pulse (aka breathe) light blue (cyan) when it is successfully connected to WiFi. Run through a practice program to check that the Photon is working as expected. The classic Blink sketch is always a good choice.

   To program the Photon, we used the Particle Build Web IDE (Integrated Development Environment). Visit the Particle website to guide you through this process.

2. Locate your specific Photon “Device ID” and the “Access Token”. Store in a convenient, and secure, location.

   The device ID can be found in Particle Build by clicking the ‘>’ next to your device name.

   Find your Device ID under the “Devices” tab, by clicking the carrot next to your Photon.

   Your access token can be found under the “Settings” tab.

   Find your access token under the “Settings” tab.

3. Solder header pins to the SparkFun temperature sensor (TMP102).

4. Solder the DC barrel jack onto the bottom of the Photon Battery Shield.

5. Plug the Photon into the Photon Battery Shield. Be sure that the rounded edges of the Photon line up with the rounded lines on the battery shield. Connect the battery and solar panel to the respective connectors. Check that the Photon powers on and connects to WiFi.

6. Connect the TMP102 temperature sensor to Photon battery shield pins with the breadboard jumper wires (or stranded 22 gauge insulated wire).

   The green wire corresponds to the SDA pins, yellow wire to the SCL pins.

   This project only needs four (4) of the six (6) pins on the TMP102: VCC, GND, SDA and SCL. If you want to connect multiple temperature sensors using the I²C lines, you can use the ADDR0 pin to changes the device address for each sensor (See the I²C communication tutorial for help with this).

   Connect TMP102 VCC pin to the Photon 3.3V source and GND to a Photon GND pin. Connect the TMP102 SDA pin to the Photon D0 pin and the SCL pin to the Photon D1 pin.

   You can keep the final system on a breadboard or transfer it to a PCB board.

Program It!

Read in the TMP102 Temperature Sensor

The program provided below is designed to function essentially as-is, with only a few minor changes necessary to get the system up and running. Unless you want to add more sensors, or use different sensors, you do not need to change the program code to read in the TMP102 temperature data. That said, if you are new to electronics, or I²C communication, it is still helpful to understand the basics of how the TMP102 sends data, particularly when debugging.

Quick Overview of TMP102 Data Signal

The TMP102 temperature sensor uses I²C communication, a two-wire serial interface. The two lines are SDA (Data) and SCL (Clock). The corresponding Photon pins are D0 (SDA) and D1 (SCL). The program below uses the default address of 72 (code variable TEMP102_ADDRESS) for the TMP102 sensor.

The TMP102 sensor outputs two bytes in binary (code variable BYTES_TO_READ). The first byte is the most significant byte (MSB), and the second byte is the least significant byte (LSB). The first 12 bits (out of 16) are used to indicate temperature, where one LSB is 0.0625 °C. The program is commented where these operations occur.

Review the TMP102 data sheet for more information.

Set up a Data Host

This system uses the data.sparkfun.com web service to log the TMP102 temperature data. You can remotely access the temperature data using the public URL generated when you create your data stream. To use the program provided in the next section, follow the procedure below to set up a data stream on the data.sparkfun.com server.

1. Create a data stream on the data.sparkfun.com service by clicking the Create button.

2. Fill in your desired title and description.

3. For the fields section, input “temp” and “unit”. It is imperative to use these exact field names (all lower case) or the data will not upload unless you change the respective field names in the program.

4. Save the data stream. This will redirect you to the stream’s key page. Copy all of this information and store in a secure location.

   A quick overview of the keys:

   Public Key– This is a long hash that is used to identify your stream and provide a unique URL. This key is publicly visible, meaning that anyone who visits your stream’s URL will be able to see this hash.

   Private Key– The private key is necessary to post data to the stream. Only you should know this key.

   Delete Key– This key deletes the stream, so normally you’ll want to avoid this key. Only use this key if you need to fix the field names or if you truly want to delete the data stream.

   Fields– In our program, our fields are “temp”, which corresponds to the temperature reading in degrees Celsius, and “unit”, to let us know that our reading is in degrees Celsius. These fields set specific values and create a new log of data.

5. The timestamp generated is given in the UTC (Universal Time Coordinate) timezone. The easiest way to handle this timezone is to convert it to your local timezone once you’ve downloaded the data.

6. To monitor the Photon output, use the Particle driver download as described in the“Connecting Your Device” Photon tutorial.

   To view the particle serial monitor, in the command prompt type particle serial monitor. This is extremely helpful for debugging and checking to be sure the Photon is posting data to your host. The program provided in the next section includes print statements that indicate the status of the data acquisition and upload process to help facilitate the setup process. You can also use any of the serial terminals mentioned in our Serial Terminal Baiscs tutorial to view serial data from your Photon.

System Code

What you need to change in the program:

1. Copy and paste your data stream public key to the array called publicKey[].

   const char publicKey[] = "INSERT_PUBLIC_KEY_HERE";

2. Copy and paste your data stream private key to the array called privateKey[].

   const char privateKey[] = "INSERT_PRIVATE_KEY_HERE";

What you may want to change in the program:

1. The posting rate (code variable postingRate) sets how often the temperature data is uploaded to the data stream. The current post rate is ~ 20s (20000 ms). You can set a different value in line 23 of the program, reproduced below. The maximum post rate allowed by the data.sparkfun.com host is about one data point every 10 seconds (100 posts every 15 minutes).

   const unsigned long postingRate = 20000; //post rate to data.sparkfun.com (time in milliseconds)

2. The temperature unit (currently in °C).

   To upload data in °F, multiply temp (line 47) by 1.8 and add 32, as shown below.

   int temp = (((( MSB << 8) | LSB) >> 4) * 0.0625)*1.8 + 32;

   Be sure to update the output unit from “C” to “F” in line 51:

   postToPhant(temp, 'F');

3. If you are comfortable with code, feel free to change anything else you want!

Photon Remote Temperature Sensor Program

You can grab the code from below, or you can get the most up to date files from the GitHub repository.

Photon Remote Temp Sensor GitHub Repository

language:c
//This code was written by Ace Levenberg <acelevenberg@gmail.com> and Jennifer Fox <jenfoxbot@gmail.com>
/*
 * ----------------------------------------------------------------------------
 * "THE BEER-WARE LICENSE" (Revision 42):
 * <jenfoxbot@gmail.com> and <acelevenberg@gmail.com> wrote this file.  As long as you retain this notice you
 * can do whatever you want with this stuff. If we meet some day, and you think
 * this stuff is worth it, you can buy me a beer in return.
 * ----------------------------------------------------------------------------
 */


// This #include statement was automatically added by the Particle IDE.
//This library is used to push data to the data.sparkfun.com server.
#include "SparkFunPhant/SparkFunPhant.h"

const char server[] = "data.sparkfun.com"; // Phant destination server
const char publicKey[] = "INSERT_PUBLIC_KEY_HERE"; // Phant public key
const char privateKey[] = "INSERT_PRIVATE_KEY_HERE"; // Phant private key

Phant phant(server, publicKey, privateKey); // Create a Phant object


const unsigned long postingRate = 20000; //Post rate to data.sparkfun.com (time in milliseconds)
unsigned long lastPost = millis();

const int TEMP102_ADDRESS = 72; //Address of TMP102
const int BYTES_TO_READ = 2; //Number of bytes to read in from TMP102 (should always be 2)

void setup() {
    Wire.begin(); //Initialize serial communication library
    Serial.begin(9600);
}

void loop() {
    if (Wire.isEnabled()) //Check if receiving a signal from I2C pins
    {
        if (lastPost + postingRate < millis()) //Wait to post until ~ 20s has lapsed
        {
            Serial.print("Requesting from :");
            Serial.println(TEMP102_ADDRESS);
            Wire.requestFrom(TEMP102_ADDRESS, BYTES_TO_READ);
            if (Wire.available() == BYTES_TO_READ)
            {
                Serial.println("Reading!");
                byte MSB = Wire.read();
                byte LSB = Wire.read();
                int temp = ((( MSB << 8) | LSB) >> 4) * 0.0625; //Remove 4 empty bits from 2nd byte (see datasheet),
                //combine 1st byte and 2nd byte then use conversion factor to get temp in deg. C (see datasheet)
                Serial.print("Temp is :");
                Serial.println(temp);
                postToPhant(temp, 'C'); //Post temperature data and unit (deg C) to your data stream at data.sparkfun.com (See lines 68 and on)
                lastPost = millis();
            }
            else
            {
                Serial.println("Unable to read the temperature"); //Used for debugging TMP102 output
            }
        }
    }
    else
    {
        Serial.println("Wire is not enabled make sure to call Wire.begin()"); //Used for debugging I2C protocol
    }
}

//Thanks Jim Lindblom <jim@sparkfun.com> for the sample code and Phant library.
int postToPhant(int temp, char unit){

    phant.add("temp", temp); //Data stream field name "temp"
    phant.add("unit", unit); //Data stream field name "unit"
    TCPClient client;
    char response[512];
    int i = 0;
    int retVal = 0;

    if (client.connect(server, 80)) // Connect to the server
    {
        // Post message to indicate connect success
        Serial.println("Posting!");

        // phant.post() will return a string formatted as an HTTP POST.
        // It'll include all of the field/data values we added before.
        // Use client.print() to send that string to the server.
        client.print(phant.post());
        delay(1000);
        // Now we'll do some simple checking to see what (if any) response
        // the server gives us.
        while (client.available())
        {
            char c = client.read();
            Serial.print(c);    // Print the response for debugging help.
            if (i < 512)
                response[i++] = c; // Add character to response string
        }
        // Search the response string for "200 OK", if that's found the post
        // succeeded.
        if (strstr(response, "200 OK"))
        {
            Serial.println("Post success!");
            retVal = 1;
        }
        else if (strstr(response, "400 Bad Request"))
        {   // "400 Bad Request" means the Phant POST was formatted incorrectly.
            // This most commonly ocurrs because a field is either missing,
            // duplicated, or misspelled.
            Serial.println("Bad request");
            retVal = -1;
        }
        else
        {
            // Otherwise we got a response we weren't looking for.
            retVal = -2;
        }
    }
    else
    {   // If the connection failed, print a message:
        Serial.println("connection failed");
        retVal = -3;
    }
    client.stop();  // Close the connection to server.
    return retVal;  // Return error (or success) code.
}

Test, Encase and Install

1. Plug battery and solar panel into Photon battery shield. Check that the Photon successfully powers on, connects to WiFi (the Photon LED will be breathing cyan), and sends temperature data to your data stream (accessible via the public URL).

2. Coat electrical connections in epoxy or other (ideally waterproof) adhesive.

   Please note that epoxy is very permanent. If you intend to modify the project or use the components for another project in the future, use an adhesive method that is removable, like hot glue.

3. Place electronics (except solar panel) in project case. Determine where the solar panel cable will enter the case. Use waterproofing electrical tape to seal area around solar panel cable or a drill hole in the case for the solar panel cable (coat exterior in waterproofing tape or epoxy). If you place the temperature sensor inside the case, ensure that there is sufficient air ventilation to avoid turning the project case into a sauna.

   Be sure that the wires are not stretched or bent much as this will cause breakage over time.

4. Seal any remaining holes or other air gaps with waterproofing electrical tape or epoxy. If you are sealing the project case lid, it is highly recommended to use a removable sealant like the waterproofing electrical tape to access the electronics in the future.

5. Connect solar panel to stand.

   The stand in this example is a towel rack found at a local thrift store. This was perfect for my needs because 1) it was very inexpensive and 2) the rings are adjustable, which allows me to change the orientation of the solar panel to point it towards the maximum incident solar radiation (aka sunlight) depending on where it is installed outdoors and the current season (since the sun’s path changes depending on the seasons).

   There are tons of options for a stand! Peruse your garage/basement/attic/cupboards/closets or check out the outdoor section of a local thrift store or hardware store. Look for objects that can withstand nature’s elements, will maintain ridigity, and can support the solar panel weight.

6. Once the case and stand are complete, connect the battery and solar panel to the Photon battery shield. Check that the Photon is adequately powered, connected to WiFi (pulsing light blue), and is uploading data to your data.sparkfun.com data stream.

   The battery used in this tutorial has a capacity of 6Ah (Amp-hours), which means it can provide 6A for 1 hour. The Photon microcontroller average power consumption is between 80 - 100 mA. Assuming maximum current draw of 0.1A, this means that the battery can power the system for ~60 hours (2.5 days) without any charge from the solar panel. This is ideal/necessary for cloudy locations (like Seattle where this project was designed and built) or for remote sites that are difficult to access on a daily basis.

   If you use a different battery, calculate the total number of hours the battery can power the Photon, without being charged by the solar panel. Do this by dividing the battery capacity (given in Amp-hours) by the Photon maximum current draw (0.1A). Since the sun hides behind the other side of the planet at night, be sure that your battery can provide power for at least 10-12 hours.

7. Install the system within reach of the WiFi signal for which it is configured – the Photon will flash green if it is not connected to WiFi.

   Be sure to place the temperature sensor in a shady location, avoiding direct sunlight, as incident solar radiation will increase the temperature measurement.

8. Place the solar panel in the sunniest spot available at your chosen location. Determine the optimum solar angle for your panel, and point the solar panel in that direction. You’ll want to change this angle over the course of the year as the sun’s angle changes (higher in the summer, lower in the winter, also highly dependent on location). Here’s a great online calculator to help you determine the optimal solar angle in your particular city.

Data Acquisition and Analysis

The data.sparkfun.com service allows you to download your data in a few different formats, so pick the format that is easiest for you to handle. Most common data analysis programs, including Excel, R, and Python, can handle CSV (Comma Separated Values) files.

Below is one method to plot your data using a program written for the R platform, a free statistical software environment.

1. Download your data in CSV file format (button is located at the top of the data stream).

2. In the R workspace, run the program below to generate a plot and basic analysis of your data. You can also get the most up to date files from the GitHub repository.

Photon Remote Temp Sensor GitHub Repository

#Photon Remote Temperature Sensor Data Plot and Analysis
#Code written by Jennifer Fox 


tempPlot = function(file = ''){
    default = "C:\\test\\*.txt"

    #Load in CSV text file
    if (file == '') file = file.choose()

    #Set data into matrix
    headers = c("Temp_C", "Unit_C", "Timestamp")
    temp_raw = read.table(file, sep = ",", quote = "", skip = 1, fill = TRUE, col.names = headers)

    #Add in degrees Fahrenheit
    tempF = matrix(nrow = length(temp_raw[,1]), ncol = 2, byrow = TRUE)
    tempF[,1] = temp_raw[,1]*1.8+32
    tempF[,2] = "F"
    temp_raw[,c("Temp_F","Unit_F")] = c(as.numeric(tempF[1:length(tempF[,1]),1]), tempF[,2])
    temp = temp_raw[,c(1,2,4,5,3)]

    #Convert UTC timestamp into local (sensor) timezone
    timestamp_raw = temp$Timestamp
    ts_placeholder = gsub("T", "", timestamp_raw)
    timestamp = gsub("Z", "", ts_placeholder)
    UTC_timezone = as.POSIXct(timestamp, tz="UTC")
    my_timezone = format(UTC_timezone, tz = Sys.timezone()) #Sys.timezone() outputs the local timezone

    #Replace temp data with local timezone
    temp$Timestamp = my_timezone

    #Plot temperature data
    plot(as.POSIXct(temp$Timestamp), temp$Temp_C, main = "Temperature (°C) vs. Time", ylab = "Temperature (°C)", xlab = "Time", xaxt = "n", pch = 20)
    axis.POSIXct(1, my_timezone, labels = TRUE) #Use the "format" argument to adjust the axis label (e.g. to print hours use: format = "%H:00" )
    dev.new()
    plot(temp$Timestamp, temp$Temp_F, main = "Temperature (°F) vs. Time", ylab = "Temperature (°F)", xlab = "Time", xaxt = "n", pch = 20)
    axis.POSIXct(1, my_timezone, labels = TRUE)

    #Calculate and output basic statistical analysis
    end_date = temp$Timestamp[1]
    start_date = temp$Timestamp[length(temp$Timestamp)]
    t_F = summary(as.numeric(temp$Temp_F))
    t_C = summary(as.numeric(temp$Temp_C))

    cat("Data Stream Start Date:", as.character(start_date), "\n", "Data Stream End Date:", as.character(end_date), "\n\n")
    cat("Summary of Temperature Data (°C)", "\n", "Average (Mean) Temperature: ", t_C["Mean"] ,"\n", "Minimum Temp: ", t_C["Min."], "\n", "Maximum Temp: ", t_C["Max."], "\n")
    cat("Summary of Temperature Data (°F)", "\n", "Average (Mean) Temp: ", t_F["Mean"] ,"\n", "Minimum Temp: ", t_F["Min."], "\n", "Maximum Temp: ", t_F["Max."], "\n")
}

The following shows the plots from the set of data collected during this project.

Click image for a closer look.

Education Extension

Building this remote temperature sensor teaches practical, hands-on skills in hardware and software engineering. Beyond direct project-based learning, there are tons of ways to extend this project for classroom and other citizen science activities. Here are a few ways to use this system to teach fundamental scientific concepts.

What is Temperature?

This system measures temperature at a very specific, and known, location, which allows us to combine our direct observations with experimental data. Create your own experiment to change the temperature reading by changing the outside environment, keeping everything else the same.

For example, move the temperature sensor into direct sunlight, and gather data over a specific time interval, then move the temperature sensor back into the shade for the same amount of time. Analyze how the temperature reading changes and compare it to your own observations of outside temperature. Experiment with different ways to change the temperature reading. Be creative*, and see what tests your students think up!

* Avoid water contact unless you’ve thoroughly coated the electrical connections in epoxy or other waterproof adhesive.

Heat Capacity: Comparison of Temperature and Heat

Build the temperature sensor case to be air-tight, then use different material types and/or sizes of enclosures to analyze the difference between temperature and heat. Different materials have different heat capacities, or the amount of heat needed to raise the material’s temperature by one degree. In other words, materials absorb and retain heat at varying rates. This helps us understand that heat is a form of energy, while temperature is a measure of that energy.

For each case, place sensor in direct sunlight and leave overnight. Determine how quickly the temperature sensor reading increases and decreases. A high heat capacity material will slowly increase and decrease in temperature, whereas a low heat capacity material will quickly heat up and cool off. Create plots of the temperature changes for various cases to determine what types of materials, and what sizes, retain heat the most. Find patterns between different material types and use those patterns to determine why certain materials have higher heat capacities.

Analysis of Data Trends: Long-Term vs. Short-Term

The difference between daily temperature and average temperature is a crucial concept in understanding climate change. It also provides a real-world application of the difference between long- and short-term trends. Fortunately, the data.sparkfun.com service makes this analysis simple and straightforward, the hardest part is waiting! It is also suggested to have a back-up battery if you live in a cloudy climate (like Seattle).

For this science lesson, gather data for a minimum of two (2) to three (3) months, ideally through a seasonal change. Download the data and find the average (mean) temperature by day, week, and month. Select a few 24-hour periods to plot temperature, and compare daily fluctuations with your calculated averages. See if you can use the temperature data to pinpoint the changing seasons!

Resources and Going Further

• Having trouble with the Photon? Check out the Community Forum to see issues raised by other folks or to post a question of your own.
• Add more sensors! Here’s a link to a variety of sensors available at SparkFun.
• Check out this awesome Photon Weather Shield project for a full-fledged weather monitor.
• Here’s another great Photon project tutorial to hook up an accelerometer, gyroscope, and magnetometer!

Looking for more weather fun? Check out these other SparkFun tutorials:

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

Bus Pirate v3.6a Hookup Guide a learn.sparkfun.com tutorial

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

Introduction

The Bus Pirate is an electronics prototyping dream. It’s packed with many of the tools needed when getting a project up and running. The Bus Pirate can perform a variety of test equipment functions such as measuring voltage and frequency as well as generating PWM signals.

Most of the functionality of the Bus Pirate revolves around serial protocols. The Bus Pirate can communicate on 1-wire, 2-wire, 3-wire, UART, I²C, SPI, and HD44780 LCD protocols. It also has a bitbang mode for other or custom options.

This guide is intended to be a quick overview and cover a few things not explicitly covered in the Bus Pirate documentation provided by Dangerous Prototypes.

Suggested Reading

The following concepts will be mentioned in this guide. If you are unfamiliar with any of them, check out the corresponding tutorial.

• Serial Communication
• I2C Communication
• Serial Peripherial Interface (SPI)
• Pulse-width Modulation (PWM)
• Serial Terminal Basics

Board Overview

Bus Pirate Ports

The Bus Pirate has 3 ports. This first is the ICSP port for directly programming the PIC microcontroller at the heart of this product. Since there is a bootloader and a reflashing utility, you shouldn’t ever have to use this port.

The second port is a mini-B USB jack. Connect this to a computer with a standard A to mini-B cable. This provides the power to the board and allows you to communicate with Bus Pirate.

The third port is the most interesting. It’s a shrouded 0.1" pitch 2x5 pin header. We sell a handy cable to connect the Bus Pirate to the system you are developing, debugging, or reverse engineering. Here is a graphic that shows maps the IO functions to the colors of the cable.

Pin header image based on Dangerous Prototypes (CC BY-SA)

The following table describes in a little more detail the purpose of each pin. It’s sorted in the same order as the conductors on the cable. The power supplies can be switched on or off in software, and each can supply up to 150mA to power your project.

Using the Bus Pirate

The Bus Pirate has two interface modes, binary scripting mode, and user terminal mode.

Binary Scripting Mode

Binary scripting mode allows applications and/or scripts to control the Bus Pirate. This interface could be used to write a GUI, automated testing, etc. It’s more work to get up and running, but it is more powerful. The following code block is a minimal Python script that can serve as a starting place to use the binary access mode on most platforms. It puts the Bus Pirate into binary mode, sends a command, and then prints out a response. It doesn’t actually ‘do anything’ beyond that though; it’s only a framework.

On my Mac I run a command like: ./binaryModeDemo.py -p /dev/tty.usbserial-AL00ESEJ. The default baud rate for the Bus Pirate is 115200. For help, run python binaryModeDemo.py --help. It should run on any platform running a Python interpreter. Some tweaks might be necessary if running a non-2.7 version of Python.

language:python
#!/usr/bin/env python
# encoding: utf-8"""
Example code to interface the Bus Pirate in binary mode
Brent Wilkins 2015

This code requires pyserial:
    $ sudo pip install pyserial
or:
    $ sudo easy_install -U pyserial
"""
import sys
import serial
import argparse

commands = {
        'BBIO1': '\x00',    # Enter reset binary mode
        'SPI1':  '\x01',    # Enter binary SPI mode
        'I2C1':  '\x02',    # Enter binary I2C mode
        'ART1':  '\x03',    # Enter binary UART mode
        '1W01':  '\x04',    # Enter binary 1-Wire mode
        'RAW1':  '\x05',    # Enter binary raw-wire mode
        'RESET': '\x0F',    # Reset Bus Pirate
        'STEST': '\x10',    # Bus Pirate self-tests
}

def arg_auto_int(x):
    return int(x, 0)

class FatalError(RuntimeError):
    def __init__(self, message):
        RuntimeError.__init__(self, message)

def main():
    parser = argparse.ArgumentParser(description = 'Bus Pirate binary interface demo', prog = 'binaryModeDemo')

    parser.add_argument(
            '--port', '-p',
            help = 'Serial port device',
            default = '/dev/ttyUSB0')

    parser.add_argument(
            '--baud', '-b',
            help = 'Serial port baud rate',
            type = arg_auto_int,
            default = 115200)

    args = parser.parse_args()

    print '\nTrying port: ', args.port, ' at baudrate: ', args.baud

    try:
        port = serial.Serial(args.port, args.baud, timeout=0.1)
    except Exception as e:
        print 'I/O error({0}): {1}'.format(e.errno, e.strerror)
        print 'Port cannot be opened'
    else:
        print 'Ready!'
        print 'Entering binary mode...\n'

        count = 0
        done = False
        while count < 20 and not done:
            count += 1
            port.write(commands.get('BBIO1'))
            got = port.read(5)  # Read up to 5 bytes
            if got == 'BBIO1':
                done = True
        if not done:
            port.close()
            raise FatalError('Buspirate failed to enter binary mode')

        # Now that the Buspirate is in binary mode, choose a BP mode
        port.write(commands.get('RESET'))
        while True:
            got = port.readline()
            if not got:
                break
            print(got),

        """
        port.write(commands.get('SPI1'))
        got = port.read(4)
        if got == 'SPI1':
            print 'Entered binary SPI mode'
        else:
            raise FatalError('Buspirate failed to enter new mode')"""

        port.close()


if __name__ == '__main__':
    try:
        main()
    except FatalError as e:
        print '\nA fatal error occurred: %s' % e
        sys.exit(2)

User Terminal Mode

Terminal mode is likely the interface of choice for most users, at least to start. It provides an interactive menu system for configuring the Bus Pirate. All one needs to use it is a terminal emulator.

The first thing to note is how to get help or list all of the commands. At the prompt enter ?.

Help:

HiZ>?
General                                 Protocol interaction
---------------------------------------------------------------------------
?       This help                       (0)     List current macros
=X/|X   Converts X/reverse X            (x)     Macro x
~       Selftest                        [       Start
#       Reset                           ]       Stop
$       Jump to bootloader              {       Start with read&/%     Delay 1 us/ms                   }       Stop
a/A/@   AUXPIN (low/HI/READ)            "abc"   Send string
b       Set baudrate                    123
c/C     AUX assignment (aux/CS)         0x123
d/D     Measure ADC (once/CONT.)        0b110   Send value
f       Measure frequency               r       Read
g/S     Generate PWM/Servo              /       CLK hi
h       Commandhistory                  \       CLK lo
i       Versioninfo/statusinfo          ^       CLK tick
l/L     Bitorder (msb/LSB)              -       DAT hi
m       Change mode                     _       DAT lo
o       Set output type                 .       DAT read
p/P     Pullup resistors (off/ON)       !       Bit read
s       Script engine                   :       Repeat e.g. r:10
v       Show volts/states               .       Bits to read/write e.g. 0x55.2
w/W     PSU (off/ON)            <x>/<x= >/<0>   Usermacro x/assign x/list all
HiZ>

Example

Here is a quick example of reading a register from a device on the I²C bus. I had an LSM303C Breakout laying on my desk, so I’ll use it. Any I²C device will work a similar way. Here is a picture of all of the connections required to get the breakout board powered an communicating. This board runs on 3.3V, so we will power it with the red wire.

Note: By default VDD & VDD_IO on the LSM303C breakout are connected and either could have been used to power the board.

Fritzing diagram of Bus Pirate connected to LSM303C

Bus Pirate cable attached to the LSM303C Breakout

On Mac or Linux, I typically run picocom. You can use about any terminal emulator you like. I connect with a command such as picocom -b115200 /dev/tty.usbserial-AL00ESEO. The default baudrate of the Bus Pirate is 115200 baud, and the hardware I have in hand shows up at /dev/tty.usbserial-AL00ESEO. The first step is to select the correct mode. We say above from the help that m is the ‘Change mode’ command. This will show the 9 mode options.

HiZ>m
1. HiZ
2. 1-WIRE
3. UART
4. I2C
5. SPI
6. 2WIRE
7. 3WIRE
8. LCD
9. DIO
x. exit(without change)

We want I²C, so we will enter 4:

(1)>4
Set speed:
 1. ~5KHz
 2. ~50KHz
 3. ~100KHz
 4. ~400KHz

Let’s select 400KHz mode, because we can, so why not?

(1)>4
Ready

To power the board we need to enable the power regulators with ‘W’ (‘w’ will disable):

I2C>W
Power supplies ON

At this point you might also want to enable pull-up resistors. To do so you need to connect the VPU pin to the correct voltage supply. Then ‘P’ will connect the resistors. The LSM303C Breakout already has pull-up resistors, so we can skip this step. We are ready to start communicating with the IC.

Let’s take a look at the LSM303C datasheet to see what it expects to see on the I²C bus:

It looks like as the master we need to send a start condition then a slave address with the read/write bit clear for a write. The LSM303C should then acknowledge receipt (ACK). Next we need to send the address of the register or interest. The slave/LSM303C should ACK. Next we need to send a repeated start condition (same thing as a normal start condition), followed by the slave address with the r/w bit set to do a read. The LSM303C should respond, and we as the master don’t acknowledge. The sequence ends with a stop condition.

Looks like we need more details such as the addresses. The LSM303C datasheet gives the 7-bit slave address to be 0011101b (0x1D) for the accelerometer and 0011110b (0x1E) for the magnetometer.

I²C Slave Addresses

To use these addresses we need to append the read/write bit to the end. In our case if we want to read from the accelerometer we need to shift 0b0011101 left once and or that with 0x01 to indicate a read. The shift yields 0b0111010 and OR-ing that result with 1 results in 0b0111011 (0x3B). If we had OR-ed with 0x00 for a write we would have got 0b0111010 (0x3A) for the write address. Let’s use a Bus Pirate macro to see if those addresses exist on the bus:

I2C>(1)
Searching I2C address space. Found devices at:
0x3A(0x1D W) 0x3B(0x1D R) 0x3C(0x1E W) 0x3D(0x1E R)

Sure enough, we can see a write address at 0x3A, and a read address at 0x3B! Now we need to know the address of a register to read from. The WHO_AM_I_A (0x0F) register always contains 0x41, so that makes an easy read to verify.

Who Am I Register Details

Let’s put all of those addresses into Bus Pirate syntax and in the format that the LSM303C will respond to. Start condition [, write address 0x3A, register address 0x0F, repeated start condition [, read address with read command 0x3B r, and end it all with a stop condition ]. Here is how the Bus Pirate responds to that input:

I2C>[0x3a 0x0f [0x3b r]
I2C START BIT
WRITE: 0x3A ACK
WRITE: 0x0F ACK
I2C START BIT
WRITE: 0x3B ACK
READ: 0x41
NACK
I2C STOP BIT
I2C>

The Bus Pirate read 0x41, which is what that register is supposed to contain!

Other Commands

There are a lot of other commands available via the user terminal mode. Here is a quick reference to them and how they respond.

Convert base of one byte (=X)

DIO>=0x7E
0x7E = 126 = 0b01111110

Reverse one byte (|X)

DIO>|0b100110
0x64 = 100 = 0b01100100

Self-test (~) - Runs in HiZ mode only

HiZ>~
Disconnect any devices
Connect (Vpu to +5V) and (ADC to +3.3V)
Space to continue
Ctrl
AUX OK
MODE LED OK
PULLUP H OK
PULLUP L OK
VREG OK
ADC and supply
5V(5.01) OK
VPU(5.00) OK
3.3V(3.35) OK
ADC(3.43) OK
Bus high
MOSI OK
CLK OK
MISO OK
CS OK
Bus Hi-Z 0
MOSI OK
CLK OK
MISO OK
CS OK
Bus Hi-Z 1
MOSI OK
CLK OK
MISO OK
CS OK
MODE and VREG LEDs should be on!
Any key to exit
Found 0 errors.

Reset (#)

HiZ>#
RESET

Bus Pirate v3a
Firmware v5.10 (r559)  Bootloader v4.4
DEVID:0x0447 REVID:0x3046 (24FJ64GA002 B8)
http://dangerousprototypes.com

Jump to bootloader ($)

HiZ>$
Are you sure? y
BOOTLOADER

Delay (&/%)

HiZ>&
DELAY 1us
HiZ>%
DELAY 1ms

Auxiliary Pin (a/A/@)

DIO>a
AUX LOW
DIO>A
AUX HIGH
DIO>@
AUX INPUT/HI-Z, READ: 1

Set baudrate (b)

HiZ>b
Set serial port speed: (bps)
 1. 300
 2. 1200
 3. 2400
 4. 4800
 5. 9600
 6. 19200
 7. 38400
 8. 57600
 9. 115200
10. BRG raw value

(9)>9
Adjust your terminal
Space to continue

Auxiliary assignment (c/C)

HiZ>c
a/A/@ controls AUX pin
HiZ>C
a/A/@ controls CS pin

Measure ADC (d/D)

once:

1-WIRE>d
VOLTAGE PROBE: 3.33V

continuous:

DIO>D
VOLTMETER MODE
Any key to exit
VOLTAGE PROBE: 0.00V

g - 3.3V PWM on auxpin (blue wire)

DIO>g
PWM disabled
DIO>g
1KHz-4,000KHz PWM
Frequency in KHz
(50)>
Duty cycle in %
(50)>
PWM active

HiZ>=0x1010
0x10 = 16 = 0b00010000

HiZ>o
 1. HEX
 2. DEC
 3. BIN
 4. RAW

Modes:

HiZ>m
1. HiZ
2. 1-WIRE
3. UART
4. I2C
5. SPI
6. 2WIRE
7. 3WIRE
8. LCD
9. DIO
x. exit(without change)

(1)>

Resources and Going Further

Now that you have had a brief overview of the Bus Pirate, take a look at the official documentation and the Dangerous Prototypes SVN repository.

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

SparkFun LED Array (8x7) Hookup Guide a learn.sparkfun.com tutorial

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

Introduction

The LED Array (8x7) is a set of 56 LEDs arranged in a nice 8x7 grid. It relies on Charlieplexing to control individual LEDs, which means less GPIO pins are used (as opposed to a traditional grid format). This guide will walk you through connecting the LED array and using some code examples to make those LEDs light up. We even wrote a library to help you display some simple graphics and scrolling text!

Required Materials

To follow along with this guide, you will need the following additional parts:

Suggested Reading

If any of these subjects sound unfamiliar, considering reading the following tutorials before continuing on.

• What is an Arduino?
• Installing the Arduino IDE
• Installing an Arduino Library
• How to Use a Breadboard
• How to Solder - Through-hole Soldering

Board Overview

How Charlieplexing Works

To understand how the LED Array (8x7) works, we need to first learn a little about Charlieplexing. The name came from Charlie Allen at Maxim Integrated, who proposed the solution in 1995 for controlling multiple LEDs with less pins from a microcontroller.

The technique relies on using the ability for microcontroller pins to enter into a high impedance state (tri-state) and thus prevent current from entering or leaving that pin. Let’s take a 3-pin example. With Charlieplexing, we can have 6 LEDs attached to 3 pins: n x (n - 1) = 3 x (3 - 1) = 6.

We need to use the microcontroller’s ability to tri-state pins to make this work. If we make pin 1 an output and high, pin 2 output and low, and pin 3 high impedance (“Hi-Z”), then D1 will light up.

If we switch it and make pin 2 high and pin 1 low, then D3 will light up.

And if we make pin 3 high, pin 2 low, and pin 1 Hi-Z, D6 will light up.

This works because we can make the unused pins high impedance from the microcontroller. High impedance mode looks like an open circuit, so current does not flow into or out from the Hi-Z pins.

If we cycle through all 6 permutations quickly enough, we can trick our eyes into thinking that all the LEDs are on. If we leave selected LEDs off, we can create simple images with our LED array!

The LED Array 8x7

The 8x7 LED array takes our 6-LED example and expands it out to 56 LEDs and 8 pins. We can cycle through all 56 permutations of the pins to turn each LED on individually, and if we cycle fast enough, we can create simple images and text (at least according to our eyes).

Hardware Setup

The LED Array can be connected many ways so long as you have 8 pins available on your Arduino. For this example, we are going to use a RedBoard and pins 2-9. Solder 8 male header pins facing away from the LEDs:

Attach the LED Array to a breadboard and connect pins 2-9 on the RedBoard to pins A-H, respectively:

Note that you can also solder right-angle headers to the LED Array and RedStick or Pro Mini (again, pins A-H attached to pins 2-9) to achieve a seamless look:

Codebender Example

Now that we have the LED Array connected to our Arduino, we can run a simple test to make sure it is working. This example doesn’t require any additional libraries. Simply plug the shield into your Arduino, and upload the example code. Should you want to read how to install the libraries manually with Arduino, skip to the next section.

Plug your RedBoard, UNO, Pro Mini, RedStick, or other 168/328-based Arduino into an available USB port. Make sure the correct board and the associated COM port are selected in the Codebender box below. Click “Run on Arduino”.

Your LED Array should scroll “Hello World.”

Arduino Library

If the Codebender example did not work, you can also manually download the LED Array 8x7 Arduino library. To start, we’ll need the Chaplex library:

Download the Chaplex library

Additionally, we need the LED Array 8x7 Arduino library, which you can download as a ZIP file from GitHub or directly from this link:

Download the SparkFun LED Array 8x7 Arduino library

Once you have both libraries downloaded, follow this guide to install them in Arduino.

Open the Arduino IDE, and select File > Examples > SparkFun LED Array 8x7 > Demo. Select your Arduino and serial port, and upload the program.

You should see the LED array scroll through some example text and graphics.

Resources and Going Further

Here are a few resources you may find useful as you use your LED Array:

• SparkFun LED Array 8x7 Github Repo - PCB design files
• SparkFun LED Array 8x7 Arduino Library GitHub Repo - Library source code and example code

For some inspiration on how to use your LED Array, check out these tutorials:

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

ESP8266 Powered Propane Poofer a learn.sparkfun.com tutorial

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

Introduction

Is there anything more fun to look at than a big (controlled) fire? For most of history, pyrotechnic effects have been adding an edge to everything from the Olympic games to the KISS Reunion Tour (surely, these are defining moments in the history of man) But while the ancient Greeks preferred to light their fires with an exhausted, torch-bearing athlete, I’m much more interested in lighting fires from the comfort of my sofa. Enter: The ESP8266 Thing Dev Board. Now we’re cookin' with gas…

This could be us but you haven’t built a flame-thrower.

Required Materials

Along with all the components necessary to build the propane poofer (discussed later), you will also need the following electronics to replicate this project:

Suggested Reading

If you have not worked with the ESP8266 before this project, we highly recommend reading our ESP8266 Thing Dev Board Hookup Guide before tackling this project.

Flame Throwing 101

Propane poofers are a comprehensively solved engineering problem. A quick Google search reveals more designs for propane-powered flame effects than you can shake a stick at. It also becomes apparent, in short order, that the Burning Man festival attracts quite the collection of semi-professional pyros. Browsing these designs, I’ve found that while there are a lot of variations, the basic structure of a propane poofer stays fairly constant:

This is the go-to design for propane flame-cannons, the so-called “accumulator cannon”. In an accumulator cannon, a fuel source is regulated to a relatively low pressure and fed into accumulator tanks (often, they’re modified propane cylinders). These accumulators allow several cannons to be fed from one large gas source. Each cannon has a pilot on a low pressure regulator which burns constantly to provide a source of ignition when it’s time to make a fireball. When the time comes, the solenoid valve at the end of the accumulator is opened, allowing the accumulator to empty through the barrel and be ignited by the pilot. Because the accumulator was allowed to pressurize, you can fire multiple accumulator cannons on the same tank simultaneously without worrying about a big pressure drop in the system.

Because I was building a single portable cannon, I decided to modify this design a little bit. Here’s what I came up with:

My fuel source would be a pair of disposable propane cylinders, like the kind used in camping stoves and torches. These are small, lightweight and inexpensive… plus, I could buy them by the armful at my local hardware supply. Two such tanks would feed my cannon. Once I had decided on the gist of my design, I started shopping for parts…

Building the Poofer

Between Amazon and the hardware store, I was able to put together the following parts list:

From the hardware store plumbing section

• 2"x12" Threaded Pipe Nipple
• 2" Coupler (x2)
• 2"x1" Bushing (x2)
• 1" Threaded Pipe Nipple (x2)
• 1"x1/2" Reducer
• ½" Threaded Pipe Nipple
• ½"x1/4" Reducer
• ¼" Threaded Pipe Nipple
• 1 ¼" Reducer
• ¼" Threaded Plug

From various Amazon sellers

• ¼" FFF Brass Tee
• ¼" MMM Brass Tee
• ¼" Solenoid Valve (x2)
• ¼" Brass Gas Bottle Adapter

With all of the parts collected, it’s time to assemble the cannon! Here are a few exploded diagrams (no pun intended) to detail how everything fits:

Click images for a larger view.

As you can see, I built the expansion chamber by using a series of reducer fittings to connect a foot-long section of 2" pipe to the outlet of the gas bottles. I replaced the pilot with an electrical ignitor, eliminating the need for a low pressure regulator and a separate fuel line. I also decided to move the solenoid valves to the section before the tee junction allowing me to individually open each bottle to the expansion chamber. Let’s have a closer look at this tee junction:

You may wonder why I included a female tee between the expander and the male tee only to plug the unused port. Originally, there was a large solenoid valve on the output end of the cannon, allowing the expander to be used as an accumulator. I had a ¼" pressure transducer threaded into that port to monitor the interior pressure of the expansion chamber. It turned out that bringing the expander up to tank pressure and purging it through a 1" solenoid was not only deafeningly loud but generated a stream of uncarborated gas that was nearly impossible to light reliably. When I removed the big solenoid valve, I also removed the pressure transducer (as that section of the cannon became open to atmosphere).

The nozzle end of the cannon is designed to encourage the escaping gas to spread and mix with the surrounding air. I drilled a hole in the side of the reducer fitting in order to secure the Silicon Nitride Ignitor. The leads for the ignitor run down the side of the expansion chamber where they’re wrapped in heat tape to protect them from the fire.

Because this cannon doesn’t have a pilot, it’s necessary to give a short burst from one tank into the expansion chamber in order to start an open flame at the end of the barrel. As gas slowly leaks from the expander through the nozzle and carborates near the ignitor, it will maintain a low flame. When it’s time to fire a big poof, you simply open both bottles to the chamber for about half a second and whoosh!

Wire it up

If the propane bottles are the heart of this operation then the ESP8266 Thing is definitely the brains. The Thing board will allow us to connect to the flame cannon and fire it from a safe distance. Because the Thing can’t source anywhere near the voltage or current necessary to fire the solenoid valves or light the igniter, we’ll switch them using our Beefcake Relay kits. Our 12VDC power source needs to be portable, rechargable and capable of supplying a decent amount of current so I used a sealed lead-acid battery for a home alarm system. You can pick these up at most home improvement stores.

Here’s what the whole project looks like once it’s wired up:

I’m using the SLA battery as the power supply for the entire rig. The Thing board is perfectly tolerant of the 12V supply from the battery, but in order to fire the relays, I needed a 5V source as well. I sloppily wired in a 5V regulator which provided plenty of power at 5V to effectively switch the Beefcake Relays. Each relay’s signal line was connected to a GPIO pin on the Thing, I chose 4, 0 and 13 only because they’re side-by-side. Finally, the high side of the 12V line is switched by each relay before reaching the igniter and the two solenoid valves.

In order to recharge the SLA battery, I just throw it on my bench supply at about 14V until it stops drawing current. There are fancier ways to do this, but I’m happy with my system. I didn’t find an external antenna necessary for the Thing to work at significant range thanks to the on-board trace antenna. If you want extra range, however, you can cut the antenna trace, add a U.fl to RP-SMA pigtail and screw on one of our big rubber duck antennas.

To keep the electronics safe and dry, I put them in a plastic ammunition box that I picked up at the hardware store. A bundle of cables comes through a hole in the side of the box and connects to the cannon. The whole unit doesn’t weigh too much, and you can lean the cannon against the box to stabilize it.

Programming the Thing

The firmware that we’re using for the Thing board is based on the AP Web Server example code. This example code sets the Thing board up as a wireless access-point and serves a simple webpage to any connected client. Most of the magic is in the ESP8266WiFi library, so the sketch itself isn’t very long at all. Let’s take a look at it:

language:c

#include <ESP8266WiFi.h>

//////////////////////
// WiFi Definitions //
//////////////////////
const char WiFiAPPSK[] = "sparkfun";

/////////////////////
// Pin Definitions //
/////////////////////
const int VENT1_PIN = 4; //
const int VENT2_PIN = 0; //
const int IGNITION_PIN = 13; //

WiFiServer server(80);

void setup()
{
  initHardware();
  setupWiFi();
  server.begin();
}

void loop()
{
  // Check if a client has connected
  WiFiClient client = server.available();
  if (!client) {
    return;
  }

  // Read the first line of the request
  String req = client.readStringUntil('\r');
  Serial.println(req);
  client.flush();

  // Match the request
  int val = -1;
  if (req.indexOf("/vent1/1") != -1)
    val = 0;
  else if (req.indexOf("/vent2/1") != -1)
    val = 2;
  else if (req.indexOf("/vent_all/1") != -1)
    val = 3;
  else if (req.indexOf("/ignition/1") != -1)
    val = 4;
  else if (req.indexOf("/ignition/0") != -1)
    val = 5;

  // Set GPIO according to the request

  if (val == 0){
    digitalWrite(VENT1_PIN, 1);
    delay(500);
    digitalWrite(VENT1_PIN, 0);}

  else if (val == 2){
    digitalWrite(VENT2_PIN, 1);
    delay(500);
    digitalWrite(VENT2_PIN, 0);}

  else if (val == 3){
    digitalWrite(VENT1_PIN, 1);
    digitalWrite(VENT2_PIN, 1);
    delay(500);
    digitalWrite(VENT1_PIN, 0);
    digitalWrite(VENT2_PIN, 0);}

  else if (val == 4){
    digitalWrite(IGNITION_PIN, 1);}

  else if (val == 5){
    digitalWrite(IGNITION_PIN, 0);}

  client.flush();

  // Prepare the response. Start with the common header:
  String s = "HTTP/1.1 200 OK\r\n";
  s += "Content-Type: text/html\r\n\r\n";
  s += "<!DOCTYPE HTML>\r\n<html>\r\n";

  if ( digitalRead(IGNITION_PIN) == 0 ){
  s += "Ignitior is currently turned OFF.";}
  else{
  s += "Ignitior is currently turned ON.";}
  s += "<br><br>\r\n"; // Go to the next line.

  s += "<a href = \"/ignition/1\">Glow Ingition On</a><br>\r\n";
  s += "<a href = \"/ignition/0\">Glow Ingition Off</a><br>\r\n";
  s += "<a href = \"/vent1/1\">Vent Tank 1 (500ms)</a><br>\r\n";
  s += "<a href = \"/vent2/1\">Vent Tank 2 (500ms)</a><br>\r\n";
  s += "<a href = \"/vent_all/1\">Vent Both Tanks (500ms)</a><br>\r\n";

  s += "</html>\n";

  // Send the response to the client
  client.print(s);
  delay(1);
  Serial.println("Client disonnected");

  // The client will actually be disconnected
  // when the function returns and 'client' object is detroyed
}

void setupWiFi()
{
  WiFi.mode(WIFI_AP);

  // Do a little work to get a unique-ish name. Append the
  // last two bytes of the MAC (HEX'd) to "Thing-":
  uint8_t mac[WL_MAC_ADDR_LENGTH];
  WiFi.softAPmacAddress(mac);
  String macID = String(mac[WL_MAC_ADDR_LENGTH - 2], HEX) +
                 String(mac[WL_MAC_ADDR_LENGTH - 1], HEX);
  macID.toUpperCase();
  String AP_NameString = "ESP8266 Flame Cannon " + macID;

  char AP_NameChar[AP_NameString.length() + 1];
  memset(AP_NameChar, 0, AP_NameString.length() + 1);

  for (int i=0; i<AP_NameString.length(); i++)
    AP_NameChar[i] = AP_NameString.charAt(i);

  WiFi.softAP(AP_NameChar, WiFiAPPSK);
}

void initHardware()
{
  Serial.begin(115200);
  pinMode(VENT1_PIN, OUTPUT);
  digitalWrite(VENT1_PIN, LOW);
  pinMode(VENT2_PIN, OUTPUT);
  digitalWrite(VENT2_PIN, LOW);
  pinMode(IGNITION_PIN, OUTPUT);
  digitalWrite(IGNITION_PIN, LOW);

}

Because this code is essentially an expanded version of the example code, I won’t dive into it too deeply here. That being said, let’s look at what’s changed:

Matching Requests

While the example code was only looking for 3 possible valid requests, we’ll be looking for any of 5: Ignition On, Ignition Off, Vent Tank 1, Vent Tank 2 and Vent All. We handle these requests by assigning a value to each like this:

language:c
  if (req.indexOf("/vent1/1") != -1)
    val = 0;
  else if (req.indexOf("/vent2/1") != -1)
    val = 2;
  else if (req.indexOf("/vent_all/1") != -1)
    val = 3;
  else if (req.indexOf("/ignition/1") != -1)
    val = 4;
  else if (req.indexOf("/ignition/0") != -1)
    val = 5;

When we send our response, we’ll include hyperlinks for each of these requests.

Setting the GPIO

language:c
 if (val == 0){ // Vent Tank 1
    digitalWrite(VENT1_PIN, 1);
    delay(500);
    digitalWrite(VENT1_PIN, 0);}

  else if (val == 2){ // Vent Tank 2
    digitalWrite(VENT2_PIN, 1);
    delay(500);
    digitalWrite(VENT2_PIN, 0);}

  else if (val == 3){ // Vent All
    digitalWrite(VENT1_PIN, 1);
    digitalWrite(VENT2_PIN, 1);
    delay(500);
    digitalWrite(VENT1_PIN, 0);
    digitalWrite(VENT2_PIN, 0);}

  else if (val == 4){ // Ignition On
    digitalWrite(IGNITION_PIN, 1);}

  else if (val == 5){ // Ignition Off
    digitalWrite(IGNITION_PIN, 0);}

Each valid request has an associated GPIO call to open or close a relay. The “Vent Tank” requests simply close the relay for half a second, and then release it. Requests made to the ignitor set it to either the on or off position until further notice.

Formulating a Reply

Our server’s reply will always be a list of hyperlinks that make it easy to quickly fire valid requests. At the top of the list, we’ll add an indicator to let us know whether we have the ignitor turned on. Each line of the html response is appended to a string object and sent to the server library to be relayed to the client. The html reponse, without the weird formatting, looks like this:

  HTTP/1.1 200 OK
  Content-Type: text/html<!DOCTYPE HTML><html>

  Ignitior is currently turned ON.<br><a href = "/ignition/1">Glow Ingition On</a><br><a href = "/ignition/0">Glow Ingition Off</a><br><a href = "/vent1/1">Vent Tank 1 (500ms)</a><br><a href = "/vent2/1">Vent Tank 2 (500ms)</a><br><a href = "/vent_all/1">Vent Both Tanks (500ms)</a><br></html>

Make Fire!

This thing is ready to breathe fire! But first, a checklist:

• Make sure your propane bottles are securely connected.
• Listen for possible leaks.
• Connect the battery leads to power up the system.
• Get a safe distance away.
• Connect to the flamethrower’s WiFi network on your phone or laptop.
• Navigate to 192.168.4.1/ignition/0
• Press “Glow Ignition On”
• Give the igniter a few seconds to heat up.
• Press “Vent Tank 1 (500ms)”
• Wait for a flame to start

The cannon is now lit and ready to fire. Clear the area and press “Vent All” for an awesome fireball! Be sure to give the cannon some time to rest between firings. Each time you fire the cannon, the solenoid valves are flooded with freezing cold liquid propane, and too much continuous operation can damage the valves, possibly locking them open.

Kudos to Sarah for holding the cannon while I was holding the trigger

Resources and Going Further

There are nearly unlimited resources online for people looking to build fire toys. Thanks to festivals like Burning Man and events like Maker Faire, there are plenty of places people can go to show off their incendiary creations, and that means a big community has grown up around them. Here are a few places worth checking out if you’re interested in building pyro effects:

• Poofer Supply - Small online shop that sells bits and bobs for fire toys. Even if you’d rather shop on Amazon, it’s a good place to start and find out what’s available.
• Foxfur Amused Blogpost - A nice little build that I referenced while working on my poofer.
• Burning Man Fire Effects Community - Awesome Facebook group for people who like to build fire effects.
• Engineering Roundtable - With Chris Taylor’s sound responsive torch!

Going Further

For more information on the Thing board and other connected projects, check out these tutorials!

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

MyoWare Muscle Sensor Kit a learn.sparkfun.com tutorial

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

Introduction

As announced previously, Advancer Technologies started a Kickstarter campaign to produce an updated version of their Muscle Sensor v3 board. The MyoWare™ Muscle Sensor (AT-04-001) is the latest electromyography (EMG) sensor from Advancer Technologies. Here is an overview of the MyoWare product line and how to use it.

Figure 1. MyoWare main sensor board

MyoWare Muscle Sensor

A new version means new features. Here is a breakdown of the new features added to the MyoWare Muscle Sensor Board:

Single-supply— MyoWare won’t need ± voltage power supplies! Unlike the previous sensor, it can now be plugged directly into 3.3V - 5V development boards.

Embedded Electrode Connectors— Electrodes now snap directly to MyoWare, getting rid of those pesky cables and making the MyoWare wearable!

RAW EMG Output— A popular request from grad students, the MyoWare now has a secondary output of the RAW EMG waveform.

Polarity Protected Power Pins— The #1 customer request was to add some protection so the sensor chips don’t burn out when the power is accidentally connected backwards.

ON/OFF Switch— Speaking of burning out the board, Advancer Technologies also added an on-board power switch so you can test your power connections more easily. It’s also handy for saving power.

LED Indicators— Advancer Technologies added two on-board LEDs one to let you know when the MyoWare’s power is on and the other will brighten when your muscle flexes.

For more information, please have a look at the official MyoWare Muscle Sensor datasheet.

What is electromyography (EMG)?

An EMG is used to record (graph) the electrical activity (electro) of muscles (myo).

Embedded Electrode Connectors

The embedded electrode connectors allow you to stick the board right to the target muscle and avoid the hassle of wires.

Embedded electrode connectors

The embedded snap connectors mate well with our Biomedical Sensor Pad (10 pack).

Cable Shield

There may still be cases where you want to mount the sensor pads away from the other hardware. For these cases, we sell the MyoWare Cable Shield.

MyoWare Cable Shield

The cable shield provides a jack where you can attach the three electrode cable shown here.

Three electrode cable

Instead of attaching the sensor pads to the MyoWare Muscle Sensor, attach them to the end of the cable. Both sets of contacts are connected, so make sure to only use one pad for each (Reference, End, and Middle).

Power Shield

MyoWare Power Shield

The MyoWare Power Shield is designed to take two coin cell batteries such as some standard CR2032s. They are connected in parallel for extended capacity at a nominal 3.0V. One thing to note is that due to the size of the batteries, the remote cable header can’t be passed through. If you need access to these connections, this Power Shield must be stacked above the board(s) that need access.

Battery power allows for a cleaner signal and also eliminates the possibility of creating a dangerous current path to the power grid.

Proto Shield

MyoWare prototyping shield

The MyoWare Proto Shield passes all signals to a bit of protoboard. Use this area to solder on whatever custom circuitry you can come up with.

The Cable Shield and the Proto Shield have two rows of 3-pin plated through holes on each end. This allows ‘standard’ 0.1" headers to be used to stack them with other boards. Use the outer rows to connect to the Muscle Sensor, connect these two boards with the inner rows. The outer row on the top can also be used to stack another shield on top for a total of 4 boards in a stack.

Putting it All Together

As mentioned above, there are two ways to attach the sensor pads to a user. They can be attached directly to the sensor board, or to the the end of a cable via the MyoWare Cable Shield.

In the image below, the left most electrode connection should be connected to the muscle being measured. This is equivalent to using the red insulated conductor on the cable. The mid muscle electrode on the right breaks out on the black snap. The reference electrode has continuity with the blue snap on the cable.

MyoWare sensor layout

As shown in the image above, there are three rows of three 0.1" spaced plated through holes. On the right is the power supply +Vs, & ground, along with the processed output signal (holes 1, 2, & 3).

Along the long edge near the mid muscle electrode snap are the thru-holes for remote electrode connection (holes 4, 5, & 6).

On the opposite end are three ‘outputs’. Hole 7 is the raw, unprocessed EMG signal. Hole 8 is the switched power. Power goes into the board via hole 1, is switched, and comes back out hole 8 ( if you believe in passive sign convention (PSC) ). Hole 9 is the ground reference for the switched power.

The shields come with assorted support for these pins. Some shields such as the Power Shield don’t support the remote connections. If you need access to these pins the boards that use or can pass them through must go lower in the stack. Both the Cable Shield and the Proto Shield have this connection capability.

MyoWare Power Shield (top view)

MyoWare Cable Shield (bottom view)

MyoWare Proto Shield (top view)

Take note of the second row of holes on the Cable and Proto shields. This allows for stacking multiple shields using standard 0.1" headers.

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

19

FavoritedFavorite31

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

5

FavoritedFavorite25

Wish List

The MyoWare sensor should be populated with female headers. The shield desired to mate with the MyoWare sensor should then have male headers populated on the outer bottom rows to mate with the female headers. The top side of this shield can then be populated with female headers. The next board in the stack will then need male headers on the bottom inside. This shield can have female headers mounted to the outside row on the top side.

To make stacking easier, the MyoWare Muscle Sensor Kit (Coming Soon!) will include 3-pin stackable headers (Coming Soon!). Using these on all of the shields allows for easy stacking in more configurations.

3 pin stackable header

Resources and Going Further

Thanks for reading. For more information on the MyoWare product line, please visit the following links.

• Official MyoWare™ datasheet
• Advancer Technologies Website
• MyoWare GitHub Repository For more cool projects and ideas, check out the following SparkFun tutorials.

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

Blynk Board Arduino Development Guide a learn.sparkfun.com tutorial

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

Introduction

After successfully provisioning a SparkFun Blynk Board, and exhausting all of the examples in the Blynk Board Project Guide, you may be asking yourself: “What’s next?” The answer to that question is: “It’s completely up to you!” Now that you’re a professional Blynker, you have all of the tools necessary to create a Blynk project of your own!

This tutorial demonstrates how to add Blynk Board support to the Arduino IDE, so you can get started writing and uploading Blynk firmware of your own. If you really liked the BotaniTweet project from the Project Guide, but just wanted to tweak a few things, this tutorial will provide you with the tools necessary to start down that road.

Install FTDI Drivers

The Blynk Board uses a specialized chip called an “FTDI” to convert USB data to a more simple serial interface. It’s over this serial interface that the Blynk Board downloads new code.

If you’ve never used an FTDI-based device before, you’ll probably need to install drivers on your computer. Our How to Install FTDI Drivers tutorial should help get your drivers installed, whether you’re on a Mac, Windows, or Linux machine.

Install FTDI Drivers

Once you’ve installed the drivers, your Blynk Board should show up on your computer as either COM# (if you’re on a Windows machine) or /dev/tty.usbserial-######## (if you’re on a Mac/Linux computer), where the #’s are unique numbers or alphabetic characters.

Install the Blynk Board Arduino Addon

To use the Blynk Board in Arduino, you’ll need to install a few additional files on top of the core Arduino program. Fortunately for us, Arduino’s new Board Manager feature makes that just a few copy/pastes and button-clicks away!

Install the Blynk Board Addon

We’ll use the Arduino Board Manager feature to help set the IDE up for the Blynk Board. Follow the steps below to instill the IDE with Blynk Board compatibility.

Step 1: Give Arduino the Link

To tell Arduino where to get the board definitions from open the Arduino preferences, which you’ll find under the File>Preferences menu.

Then copy this URL:

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

And paste it into the “Additional Board Manager URLs” text box.

Step 2: Install the Definitions

With the link pasted in. Hit OK in the preferences box. Then navigate to Tools>Board>Boards Manager….

In the window that pops open next, search for “Blynk”. The “SparkFun ESP8266 Boards” menu entry should be the only survivor.

Select that, and click Install. The process may take a couple minutes to download, as the tools are about 100MB.

Step 3: Select the Blynk Board

After the board manager successfully grabs the Blynk Board definitions, look under the Tools>Board menu again – you should see a menu entry for SparkFun Blynk Board.

Select that, and you’re just about there. Time to load some Blynk code!

Get a Blynk Auth Token

The Blynk Board Arduino addon includes the Blynk Arduino library, so you should have almost everything you need to start Blynking.

Almost…

Every Blynk project is assigned a unique 32-byte string called the “auth token”, which allows your hardware communicate with a specific project in the app. When you upload a new program to the Blynk Board, you need to program the auth token into it on top of any other code you may want to add.

To get a new Blynk auth token, you have two options: use the same project from before, or create a new project.

Option 1: Getting the Code From a Previously Created Blynk Project

Reusing a Blynk project is a great way to save energy, as long as you don’t mind deleting or modifying a few widgets.

To find an existing Blynk project’s auth token, stop the project, then hit the hexagon-shaped nut in the upper right corner to open the project settings.

On the settings page, scroll down a bit to find the “Auth Token” section, where you’ll find a long, incomprehensible 32-character string, and a couple handy buttons. Tap the E-MAIL button, to have the code e-mailed to your Blynk-connected email address.

Turn your computer towards your inbox, and look for an email from dispatcher@blynk.cc.

Keep the auth token handy! You can hit “OK” (iOS) or the upper-left back arrow (Android) to exit your project’s settings page.

Option 2: Create a New Blynk Project

If you want to start fresh, with a new Blynk project, begin by backing out to the Blynk project navigator screen – hit the upper-left “back” button if you’re in a project.

Next, scroll as far to the right of the project navigator screen as you can, and find the Create New Project button.

Clicking that will lead you to the “Project Settings” page. Name your project, and set the Hardware Model to SparkFun Blynk Board.

Most importantly on this screen, tap E-Mail under the Auth Token to send yourself a copy of the 32-byte string.

Finally, tap Create Project to find yourself on a blank Blynk project.

Set Up the Blynk Project

This example Blynk program only specifies functionality for the RGB LED, but you can use any of the hardware pins regardless of what the firmware specifies.

Configure the Button, LED, and ADC

You can use the button widget to drive the tiny, blue, pin 5 LED. Configure it as either push or pull, just make sure the pin is set to 5.

The Blynk Board’s physical button can trigger a value widget. Set the widget’s pin to 0.

Finally, you can use either a gauge or value widget to display the value of the ADC. Just make sure to set the pin to ADC.

Configure the zeRGBa

To use the zeRGBa widget, add it, set the switch to Merge and set the pin to V0.

Your project may look a little something like this when it’s all configured:

Load an Example Program

With the Blynk auth token at hand, and the project set up, you’re armed with all of the information you’ll need to get your board Blynking again.

Configure the Code

Copy and paste this code into your Arduino IDE, but don’t upload it yet!

language:c
#define BLYNK_PRINT Serial    // Comment this out to disable prints and save space
#include <ESP8266WiFi.h>
#include <BlynkSimpleEsp8266.h>
#include <Adafruit_NeoPixel.h>

////////////////////
// Blynk Settings //
////////////////////
char BlynkAuth[] = "Your_Auth_Token";
char WiFiNetwork[] = "Your_WiFi_Network";
char WiFiPassword[] = "Your_WiFi_Password";

///////////////////////
// Hardware Settings //
///////////////////////
#define WS2812_PIN 4 // Pin connected to WS2812 LED
#define BUTTON_PIN 0
#define LED_PIN    5
Adafruit_NeoPixel rgb = Adafruit_NeoPixel(1, WS2812_PIN, NEO_GRB + NEO_KHZ800);

BLYNK_WRITE(V0) // Handle RGB from the zeRGBa
{
  if (param.getLength() < 5)
    return;

  byte red = param[0].asInt();
  byte green = param[1].asInt();
  byte blue = param[2].asInt();

  uint32_t rgbColor = rgb.Color(red, green, blue);
  rgb.setPixelColor(0, rgbColor);
  rgb.show();
}

void setup()
{
  // Initialize hardware
  Serial.begin(9600); // Serial
  rgb.begin(); // RGB LED
  pinMode(BUTTON_PIN, INPUT); // Button input
  pinMode(LED_PIN, OUTPUT); // LED output

  // Initialize Blynk
  Blynk.begin(BlynkAuth, WiFiNetwork, WiFiPassword);
}

void loop()
{
  // Execute Blynk.run() as often as possible during the loop
  Blynk.run();
}

Before uploading the code, you’ll need to adjust three variables towards the top of the sketch:

1. Paste your Blynk auth token over Your_Auth_Token, setting the BlynkAuth variable.
2. Paste your WiFi network name over Your_WiFi_Network, setting the WiFiNetwork variable.
3. Paste your WiFi password over Your_WiFi_Password, setting the WiFiPassword variable
   • If the network is open, leave the string empty ("").

Upload the Code

Before uploading, you’ll need to configure the serial port– the “COM#” or “/dev/tty.usbserial-########” number you discovered way back at the FTDI driver-installation phase. Knowing that, navigate to Tools>Port and select your port number.

We also suggest increasing the upload rate to 921600. You’ll find that setting under the Tools>Upload Speed option.

This is the moment of truth! Once the code has been configured, hit the Upload button (the right-pointing arrow).

Your computer may take a minute-or-so to compile the code, and send it over to the Blynk board. Arduino should inform you if the upload was successful or not. If not – double check the board and port settings, and give it another try. Sometimes that’s all it takes.

Check the Serial Monitor

If the code successfully uploads, open the serial monitor– the magnifying glass icon, in the upper right portion of the Arduino IDE.

This window will pass some handy debug information. It’ll tell you if the Blynk Board successfully connected to your WiFi network and the Blynk server.

If you see a “Ready” message – you should be good to Blynk! Do some zeRGBa'ing, press some buttons, and adjust some analog inputs! You’re well on your way to making your own Blynk projects.

Resources & Going Further

Now that you have an Arduino-programmable, Blynking Blynk Board, what new amazing IoT project are you going to make? Need some inspiration? Check out some of these tutorials:

If you need general Blynk Board or Blynk App resources, these may help:

• SparkFun Blynk Board Resources
  • Blynk Board GitHub Repository
  • Blynk Board Schematic
  • Blynk Board Eagle PCB Design Files
  • Blynk Board Arduino Firmware
• Blynk Resources
  • Blynk Homepage
  • Blynk Getting Started Guide
  • Blynk Documentation
  • Blynk Arduino Library

If you need any technical assistance with your Blynk Board, don’t hesitate to contact our technical support team via either e-mail, chat, or phone.

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

Blynk Board Project Guide a learn.sparkfun.com tutorial

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

Introduction

So you’ve provisioned your SparkFun Blynk Board– connected it to your Wi-Fi network and started using the zeRGBa to control the RGB LED – now what? Time to build some projects!

Project 12 of this guide: creating a sentient, tweeting plant.

This tutorial will walk you through fourteen Blynk projects, which range from blinking an LED with a smartphone to setting up a tweeting, moisture-sensing house plant.

All of the projects in this guide are pre-loaded into the Blynk Board. That means you don’t have to write any code – just drag and drop some Blynk widgets, configure some settings and play! This tutorial will help familiarize you with both the Blynk Board hardware and the Blynk app, so, once you’re ready, you can jump into customizing the Blynk Board code and creating a project of your own.

Before we really dive into those projects, though, let’s familiarize ourselves with the Blynk Board and all of the components it features. Click the “Next Page” button below to proceed to the Blynk Board Overview section (or click “View as Single Page” to load the entire tutorial in all of its glory).

Blynk Board Overview

You’re probably already familiar with the most important Blynk Board component – the shiny RGB LED – but there’s a whole lot more included with the board. Throughout these projects you’ll explore everything the Blynk Board has to offer, but here’s a quick overview:

Meet the Blynk Board Pins

The Blynk Board interfaces with the outside world using input/ouput (I/O) “pins”– tiny “fingers” that can either control real-world objects, like motors or LEDs, or read in values from sensors (for example light or position).

Each of the Blynk Board’s pins are accessible via the large, metal-encircled holes on the edge of the board. These large holes are designed to interface with alligator clip cables– a staple interface cable for beginner and advanced electrical engineers alike.

Alligator clips clipped onto the Blynk Board, interfacing it with the physical world.

Each of the Blynk Board alligator-clippable-pins are labeled with white text towards the center of the board. The Blynk Board pins can be broken down into a few categories: general-purpose (GP), analog input, and power output.

General Purpose Input/Output (GPIO) Pins

There are eight “general-purpose” input/output (GPIO) pins. These are the “worker-bees” to the Blynk Board’s main processor “queen”. You can use them to control outputs – like LEDs or motors – or as inputs, gathering data from buttons, switches, encoders, and more.

We recommend against using the RX and TX pins unless you really need them, but the rest are free for interfacing with the rest of the world as you desire!

Analog Input (ADC) Pin

A very special pin labeled “ADC” sports the Blynk Board’s analog-to-digital converter (ADC). This pin translates analog voltages to the digital 1’s and 0’s a computer can understand.

This pin is mostly used to read the values of real-world sensors – you can connect it to light sensors, motion sensors, flex sensors, and all sorts of other physical-world-sensing electronic components.

Power Outputs

In addition to the Blynk Board’s I/O pins, the power rails are also broken out to alligator-clip pins. These are the pins labeled “VIN”, “3.3V”, and “GND”.

You’ll get very accustomed to using these pins – especially the ground pin. They have all sorts of uses – ranging from powering motors to providing a reference voltage for a potentiometer.

Recommended Materials

While the Blynk Board includes a variety of inputs and outputs, we could never fit as much onto the board as we’d like. This page lists the handful of wires, sensors, LEDs, and other electronic components that tie-in well with the Blynk Board projects.

If you have the Blynk Board IoT Starter Kit, you’re probably already set up with most of these components. (Everything except the PowerSwitch Tail, in fact.)

Project 1: Blynk Button, Physical LED

Enough reading, time for blinking/Blynking! Our first project explores one of the most fundamental concepts in electronics and programming: digital input and output. A digital signal has a finite number of states – in fact, it usually only has two possible conditions: ON (a.k.a. HIGH, 1) or OFF (a.k.a. LOW, 0).

Using Blynk’s Button widget, we can send a digital signal to the Blynk Board. If we attach that input to the right output on the Blynk board, we can use the HIGH/LOW signal to turn an LED on or off.

Blynk Setup

By now you should already have a Blynk project – complete with an LED-controlling zeRGBa – running on your phone. We’re going to continue using this project for our experimenting in this guide.

Removing Widgets

Since we’ll be using the same project throughout, you’ll eventually want to make some space for more/bigger widgets. So to begin, let’s clear the project out (don’t worry, the zeRGBa and LCD are coming back soon!).

To delete widgets from your a Blynk project, follow these steps:

1. If your project is still running, stop it by clicking the square stop button in the upper right-hand corner.
2. Tap the zeRGBa widget to open its settings.
3. Scroll down to the bottom of the zeRGBa settings and press the red delete button.
4. Confirm the deletion – on iOS click Delete Widget, on an Android hit “OK” on the popup dialog.

Follow the same set of steps to remove the LCD widget from the project.

Adding a Button to Pin 5

Let’s start by adding a simple button widget. Here’s how:

1. Make sure your project is not running– the upper-right icon should be a triangular play button.
2. Touch anywhere in the blank, gray project space. A toolbox should open up on the right side with all of your widgets to choose from.

3. Select the Button widget by tapping it. You'll find it at the top of the "Controllers" list.
4. Tap and hold the button widget to drag it anywhere within the project space. You've got a lot of room to work with right now.

5. Touch the Button Widget to bring up the settings page, and modify these values:
1. Name: "LED"– While the widget is a button, we'll be using it to control an LED.
2. Output: 5– in the "Digital" list.
3. Color: Click the red circle to change the color of the button. Try blue, since we're toggling a blue LED!
4. Mode: Take your pick. Try them both!

6. Confirm the settings.
   • If you're using an Android, hit the back arrow in the upper-left corner
   • If you're using an iOS device, hit the OK button.

Now that the button is all configured, run the project by tapping the play button in the upper-right corner of the screen.

Blynk Run

Once the project is running, tap your new-blue button widget. When the widget is set to ON, the tiny blue LED should also turn on.

Going Further: Adding an Offboard LED

While it’s a useful status indicator, that blue LED is so small it’s barely visible above the shine of the RGB LED. Combining a couple alligator clip cables, with a 330Ω resistor, and an LED of your choice, you can offboard the Blynk Board’s LED control.

Added to your cart!

LED - Assorted (20 pack)

In stock COM-12062

We all know that you can never get too many LEDs. Don't worry, we've got you covered. This is a pack of basic red, yellow, bl…

$2.95

5

FavoritedFavorite19

Wish List

Added to your cart!

Alligator Test Leads - Multicolored (10 Pack)

In stock PRT-12978

Alligator clips (or Crocodile clips, if you prefer) are likely to be the most useful thing on your workbench besides the work…

$2.95

3

FavoritedFavorite11

Wish List

Added to your cart!

LED Rainbow Pack - 5mm PTH

In stock COM-12903

Sometimes when you have too many choices, it's hard to make a good decision. In fact, there are times when you just want a ba…

$2.95

2

FavoritedFavorite10

Wish List

Added to your cart!

Resistor 330 Ohm 1/6 Watt PTH - 20 pack

In stock COM-11507

1/6 Watt, +/- 5% tolerance PTH resistors. Commonly used in breadboards and perf boards, these 330Ohm resistors make excellent…

$0.95

2

FavoritedFavorite5

Wish List

First, locate the LED’s positive, anode pin– you’ll be able to identify it by the longer leg.

Bend the long leg out 90°, then twist it together with one of the legs of the 330Ω resistor (either end, resistors aren’t polarized).

Next grab two alligator clip cables– one black, the other green (although the color doesn’t matter, using black for the ground wire is a nice convention to follow). Clamp one end of the black cable to the LED, and clamp one end of the other cable to the resistor.

Plug the other end of the black cable into the “GND” pin, and the other end of the green cable to the “5” pin.

Now flick the Blynk app’s LED button again. Not only will the blue LED toggle, but your offboard LED should too! If the LED isn’t turning on, try swapping the alligator clip cables around on the LED and resistor legs.

Changing the Digital Pins

Now try driving the offboard LED using pin 12. Move the green alligator clip from the “5” pin to the “12”.

You’ll also need to either add another button widget, or change the settings of the one you’ve already laid down.

Feel free to repeat the same experiment on pins 13 and 15! Avoid pins 0 and 16 for now, they’ll be used as inputs later in this tutorial.

Project 2: Physical Button, Blynk LED

In the previous experiment, we used the button widget to receive a digital input and produce a digital output– pressing a button on the app toggled an LED on the board. Now let’s do the opposite – use a button on the Blynk Board to toggle an “LED” in the app.

This project introduces the LED widget– a simple tool for indicating the digital status of a Blynk Board input.

Blynk Setup

There should still be plenty of room in the Blynk Board project for the LED widget. You can either keep the button widget from the previous project, or remove it to save a little space. If it’s not bugging you, we suggest keeping the button widget around– you’ll be re-configuring and using it again soon.

Add an LED Widget to V1

Like the button widget before, follow these steps to add an LED widget:

1. If your project is running touch the sqaure button in the upper-right corner to stop it.
2. Touch anywhere in the blank project space to open the widget box.
3. Select the LED widget near the top of the "Displays" section.

4. Drag and position the LED widget anywhere in your project space.
5. Touch the LED widget to open up the Settings dialog, and adjust these values:
1. Name: "Btn" (not "Button" for reasons...)
2. Pin: V1. Any pin beginning with a "V" will be found under the "Virtual" list.
3. Color: Touch the red circle to change the color of your LED. You can even set it up as a mythical black LED.

Touch the Play button in the upper-right corner to start the project back up.

Blynk Run

With your project running, push down on the little gold circle of the Blynk Board’s push-button.

While you’re holding the button down, you should see the Blynk project’s LED illuminate. Depending on lagtime, the LED may take a couple seconds to notice the button is pressed. Releasing the button will turn the LED back off.

Going Further: Launch a Rocket

Blynk LED widgets are great for indicating the digital status of any input pin, or any other virtual pin. You can tie just about any digital input into the 0 pin on the Blynk Board.

For example, grab a couple alligator clips and a rocket-launcher-style toggle switch, then connect them up like this:

Be careful not to allow the two alligator clips to touch – it’s a tight fit, but it works!

Then connect the black wire to GND and the colored cable to 0.

Now, turning on the LED is even more satisfying! When the toggle switch is set to “ON”, the LED should illuminate.

Project 3: Slide-Dimming LEDs

Now that you’re an expert on digital inputs and outputs, it’s time to throw a curveball with analog signals. Analog values can take on any shape and be any value among the infinite possibilities in our world.

As with digital signals, the Blynk Board can also produce analog outputs or read in analog inputs. By producing an analog input, the Blynk Board can dim an LED, instead of being left with either turning it on or off.

To produce analog outputs, we’ll use the Slider widget in the Blynk app. The slider allows you to precisely set the value of an output on the Blynk Board – it’s not just ON or OFF. Now, you can set a value between 0-255, 0-1023, -8 to +8, or whatever else you please.

Blynk Setup

Once again, you should have plenty of room left in your project – only delete widgets if you want to clean up a bit. However, if you still have the button triggering the pin 5 blue LED, you’ll need to disconnect it in order to use a slider on the pin.

Disconnect the Button From Pin 5

1. Stop the project.
2. Touch the button to bring up its settings.
3. Change the pin to the dash (–) and hit OK a couple times.

If you still have a button controlling pin 5, disconnect it by clearing the pin setting.

The button will remain in your project – you won’t lose any energy – but it’ll be disconnected from any digital or virtual pins for now. Pressing it while the project is running won’t have any effect.

Connect a Slider Widget to Pin 5

1. Touch anywhere in the blank project space to open the widget box.
2. Select the Slider near the top of the "Controllers" section.
3. Drag and position the Slider widget anywhere in your project space.
4. Touch the Slider widget to open up the Settings dialog, and adjust these values:
1. Name: "LED Dimming"– we're using it to control the LED
2. Pin: 5– under the "Digital" list
3. Range: 0⟷255, covering the full PWM output range.
4. Color: Touch the red circle to change the color of your slider.

Confirm the settings, and run the project.

Blynk Run

Once the project is running, try grabbing the slider and gradually moving it from one side to the other. The small, blue LED should brighten and dim as you do so. The closer the slider value is to 0, the dimmer it will be. 255 is 100% ON and 0 is totally off.

You can also give the large slider a try. Both sliders accomplish the same task, but the large sliders tend to provide a bit more precision over the pin’s value.

Going Further: RGB Precision Control

Sliders can take on all sorts of applications in a Blynk project. In addition to directly controlling a digital pin’s PWM value, they can be used to provide a range of input to firmware running on the Blynk Board.

In fact, we’ve set up virtual pins 2, 3, and 4 to individually control the red, green, and blue channels of the RGB LED. Try adding three more sliders:

Run the project, and slide around. You may find that the three individual sliders provide more precise control over the mixed color of the RGB LED compared to the zeRGBa widget.

Brightness Control

Time for another admission of guilt: We’ve been holding back the full awe – and terror – of the Blynk Board’s RGB LED. In fact, we’ve been limiting the LED brightness to about 12.5% of it’s full power.

To set the maximum range of the RGB LED add a slider to V15– you can re-purpose the small slider widget controlling the pin 5 LED, if you’d like. Name it “Brightness”, and once again set the range to 0-255.

Play with all four sliders to see the full range of colors you can create. Just be careful! That LED really can get blindingly bright.

Dimming LEDs isn’t all the sliders are good for. Later projects will use them as input control, setting values like Twitter timers, moisture thresholds, and sensor update rates.

Project 4: Temperature and Humidity Values

Blynk’s Value widget is the workhorse of many-a-Blynk project. Set to a digital pin, it can display the real-time HIGH or LOW values of the pin. Set to the proper virtual pin, it can display as much information as you can fit into four characters.

In this project, we’ll use two-or-three Blynk value widgets to read how hot your Blynk Board is running and find out whether it’s hydrated enough.

This is the first project to use the Blynk Board’s on-board temperature and humidity sensor– the tiny, white scare adjacent to the “12” pin. This is the first step towards creating environment-sensing projects – for example, you could wire up a relay to turn a fan on or off depending on the local weather conditions.

Blynk Setup

Clean up your Blynk Board project as necessary, make sure the project is stopped, and add three new value widgets.

Add Three Value Widgets to V5, V6, and V7

The Value widgets are located at the top of the “Displays” category. Once in the project, set the widgets up like this:

As always, feel free to adjust your widget colors to your heart’s delight.

The frequency setting controls how often the Blynk app asks the Blynk Board for updated values. You can set it anywhere from four times a second (250ms) to a little less than a minute. Don’t set it to push, though, as the Blynk Board firmware isn’t configured to “push” these values to the app.

For these virtual pins, the range (defaulted to 0-1023) won’t have any effect on the displayed value – you can ignore them.

Once you’ve set all three value widget’s up, run the project.

Blynk Run

A second-or-so after you hit Play, you should see the three values begin to update. “Temp F” and “Temp C” display the temperature in Fahrenheit and Celsius, respectively, while “Humidity” displays the relative humidity as a percentage.

The most effective way to interact with this project is to get up close to the white temperature/humidity sensor and blow on it. Your breath should quickly raise the humidity reading, before it slowly drops back down. Or, if you can take your Blynk Board outside, go check the environment readings against your local weatherman.

Going Further

Continue to play around with the value widget settings to get a feel for the update rate. Try setting it as fast as possible (250ms) – the Blynk Board should be able to keep up.

You can use the value widget for just about any Blynk input built into the firmware. For example, try setting either the “Temp F” or “Temp C” widgets to V1 (you may have to disconnect the LED first). Now, when you press the button, you’ll reinforce the idea that 255 is equivalent to 100% ON, and 0 is completely off.

Or – if you want to get a jump-start on the next project – set one of the value widget’s pin’s to ADC0, under the “Analog” list. What are these 0-1023 values all about? All of you questions will be answered in the next project!

Project 5: Gauging the Analog-to-Digital Converter

To read in analog inputs, the Blynk Board uses a special-purpose pin called an analog-to-digital converter (ADC). An ADC measure the voltage at a set pin and turns that into a digital value. The ADC on the Blynk Board produces a value between 0 and 1023 – 0 being 0V/LOW/OFF, 1023 being 3.3V/HIGH/ON, and 512 being somewhere in the middle ~1.65V.

There are a variety of widgets that can be used to display the voltage at the ADC pin. In this project, we’ll use the Gauge widget, which provides the real-time reading on the ADC pin in a nice, proportional manner.

Hardware Setup

The Blynk Board’s ADC input is floating– not electrically connected to any circuitry. Without something connected to the pin, the voltage may wildly fluctuate, so to produce a reliable, steady voltage, we’ll need to wire it up.

There are a huge variety of analog-signal producing electronic components out there, but the most traditional is a potentiometer. “Pots” come in all sorts of shapes and sizes from rotary to linear to soft.

Added to your cart!

Trimpot 10K with Knob

In stock COM-09806

There are lots of trimpots out there. Some are very large, some so small they require a screwdriver. Here at SparkFun, we jus…

$0.95

6

FavoritedFavorite14

Wish List

Added to your cart!

Slide Pot - X-Large (10k Linear Taper)

In stock COM-09119

A simple slide potentiometer can go a long way. Rated at 10kOhm and 0.5W. Comes with solder tab connections. The taper profil…

$2.95

FavoritedFavorite6

Wish List

Added to your cart!

Rotary Potentiometer - 10k Ohm, Linear

In stock COM-09939

An adjustable potentiometer can open up many interesting user interfaces. Turn the pot and the resistance changes. Connect VC…

$0.95

6

FavoritedFavorite10

Wish List

Added to your cart!

SoftPot Membrane Potentiometer - 50mm

In stock SEN-08680

These are very thin variable potentiometers. By pressing down on various parts of the strip, the resistance linearly changes …

$4.95

1

FavoritedFavorite3

Wish List

To really get the most out of this project, consider grabbing a sliding linear potentiometer and three alligator clip cables. Wire up the bottom of the slide pot like below – red cable on the pin labeled “1”, yellow connected to “2” and black connected to “3”.

Then route the other ends of the alligator-clip cables like below – red to 3.3V, black to GND, and yellow to ADC.

The yellow cable – terminating on the ADC pin – will carry a voltage that varies between 0V (GND) and 3.3V, depending on the position of the slide pot.

Blynk Setup

The Gauge widget takes up a good chunk of room, so you may need to remove some previous widgets before adding it. Keep a value widget from the previous experiment – we’ll use it to display the calculated voltage.

Connect a Gauge to ADC

You’ll find the Gauge widget under the “Displays” section. Once it’s added, modify the settings like so:

We’re reading directly from the ADC – the Blynk Board’s analog-to-digital converter input. The 10-bit ADC produces a value between 0 and 1023, which is a value proportional to a voltage between 0 and about 3.3V. So, an ADC reading of 0 equates to 0V, 1023 equals 3.3V, and 512 is about 1.75V.

Repurpose a Value Widget to V8

If you don’t want continuously do that voltage-converting math in your head, modify a value widget to display V8, and set the name to Voltage.

The Blynk Board will convert the ADC reading to an equivalent voltage for you.

Blynk Run

Run the project, and watch for the gauge to settle in on a value. If you have a potentiometer wired up, the reading should remain rather steady. Try moving the wiper up and down.

There are a huge variety of analog-signal producing electronic components out there. You could wire up an accelerometer, stick the circuit on a washer/dryer, and check the analog readings to observe if your laundry is done or not. Or wire up a force-sensitive resistor, hide it under your doormat, and check if anyone’s at the front door.

Later in this guide, we’ll wire the ADC up to a Soil Moisture sensor and connect your houseplant to your twitter account, so it can notify the world when it’s thirsty.

Project 6: Automating With the Timer

A large chunk of Internet-of-Things projects revolve around home automation– a classic example of which is automatically switching your lights on and off. Using the Blynk Timer widget, you can trigger specific outputs to fire at any time of the day – even if your app is closed and your smart device is off!

The timer’s pair of settings include a start time and a stop time. When the start time is triggered, the timer’s configured pin turns HIGH. When the stop time is met, the pin goes back into a LOW state.

Blynk Setup

All you’ll need for this project is the simple but powerful Timer widget.

Add a Timer Widget on V9

Add the Timer widget to your project – you’ll find it under the “Controllers” list. Then tap the widget to open up the settings page.

Depending on what you have plugged into the board, there are a variety of options available to you on the Pin setting. For now, let’s use it to trigger an RGB light show. Set the Timer’s pin to V9, which is configured to start Rainbow Mode on the Blynk Board’s RGB LED.

Alternatively, you can use it to toggle any digital pin – like the pin 5 blue LED, or an external LED on pins 12 or 13.

For experimenting purposes, set the start time to about a minute from now, and the stop time to 30-60 seconds later. Once you get a feel for the timer, you can start using it more strategically.

As usual, give it any name and color you please.

Blynk Run

Once you’ve set your timer up, run the project. Hopefully you get it running before the timer’s programmed Start Time! If not, stop and increase the start time another 30 seconds-or-so.

The timer has a hidden feature in run mode: if you tap it you can switch between the start-time display and a countdown display. Countdown display mode is especially handy while your just testing around.

Once the timer triggers it will fade in and out to indicate the pin is on. If the timer’s fading, your pin should be active. Watch the RGB do its hypnotic rainbow dance.

Once the timer hits the Stop Time, the LED should return to its previous duties – waiting to shine another day (literally, you better adjust the start time again).

Going Further: Controlling Lamps With the Power-Switch Tail

The PowerSwitch Tail is one of our favorite general-purpose components in the catalog. With a simple HIGH/LOW signal from the Blynk Board, you can use the PowerSwitch Tail to control power to any device you would otherwise connect to a wall outlet. Best of all, it’s completely enclosed and totally safe.

Added to your cart!

PowerSwitch Tail II

In stock COM-10747

Want to control a standard wall outlet device with your micro controller, but don't want to mess with the high voltage wiring…

$28.95

3

FavoritedFavorite7

Wish List

First, use your screwdriver to securely wire the jumpers into the PowerSwitch Tail’s “+IN” and “-IN” pins (leave the “Ground” pin unconnected). Then clip alligator cables to the ends of those wires. Wire the “-IN”-connected cable to the Blynk Board’s GND pin, and the “+IN” cable to the Blynk Board’s pin 12.

Plug a lamp, fan, or any device you’d like to automate into the PowerSwitch Tail’s 3-prong female connector. Then connect male 3-prong connector into the wall.

Then set up a new timer – this time connected to pin 12. Adjust the start and stop times, and have the Blynk Board make sure your lights are off when you’re out of the house.

Project 7: The LCD's Wealth of Information

The 16x2 Liquid-Crystal Display– a 16-column, 2-row LCD, which can display any combination of up to 32 alphanumeric characters – is one of the most commonly recurring components in electronic projects. It’s simple to use, and has they ability to convey a wealth of information pertaining to your project.

Blynk’s LCD widget is similarly useful in displaying diagnostic and other Blynk-project information. In this project, we’ll the LCD widget to display everything from the Blynk Board’s temperature and humidity readings, to the length of time it’s been up-and-running.

Blynk Setup

This project requires the LCD widget as well as three button widgets, which you can repurpose from the previous projects.

Connect an LCD Widget to V10

Add an LCD widget from the “Displays” section of the widget box, and tap it to bring up the settings page.

Before adjusting anything else, slide the Simple/Advanced slider to Advanced. Then set the pin to V10, and adjust the background and text color as you please (can’t beat white text on black).

Add Button Widgets to V11, V12, and V13

Set the three buttons up to trigger virtual pins 11, 12, and 13. Leave them in Push mode:

Blynk Run

Once the button’s are set, you’re ready to run. Until you hit one of the three buttons, the LCD may print a greeting message. But that will quickly fade once you trigger V11, 12 or 13.

Although it takes up a lot of room initially, you can see how valuable the LCD is – and the wealth of information and text it can display. While the Value widgets are limited to four characters, the LCD can display up to 32!

Project 8: Joystick Joyride

Joysticks are a staple input for a variety of control systems, including arcade gaming, RC-car driving, drone guiding, and assistive-tech maneuvering. They produce two pieces of data: position components along x- and y-axes. Using that data, a project can compute an angle between 0 and 360°, and use it to drive another mobile mechanism.

Blynk’s take on the joystick is analogous to a physical joystick – as you move the center-stick around, it’ll send x- and y-axis values between 0 and 255 to the Blynk Board. What are we going to to do with that data? Spin a motor!

Added to your cart!

Servo - Generic (Sub-Micro Size)

In stock ROB-09065

Here is a simple, low-cost, high quality servo for all your mechatronic needs. This servo is very similar in size and specifi…

$8.95

6

FavoritedFavorite6

Wish List

To be more exact, we’re going to use the joystick to drive a servo motor. Servo’s are specialized motors with a built-in feedback system, which allows for precise control over the motor’s position. Instead of rotating continuously, like DC motors, a servo will move to a position you tell it to, and stop (unless it’s a continuous rotation servo. They’re useful for projects which require complete control over movement, like opening or closing a door to an automatic pet-feeder.

Hardware Setup

Most servo motor’s are terminated with a 0.1"-pitch 3-pin female header. To interface it with your Blynk Board, plug in a few male-to-male jumper wires into the servo socket (if you have the “connected” jumper wires, peel off a strip of three wires). Then clip a few alligator clip cables onto the ends of those wires.

Connect the cable wired to the servo’s black wire to GND, red to VIN, and the white signal wire to pin 15.

Press one of the servo motor’s mounts onto the motor head, so you can better-see the spin of the motor.

Blynk Setup

In addition to the Joystick widget, this project can also optionally use a gauge (or value), and a slider. The slider controls the servo motor’s maximum angle, the gauge displays the calculated servo position (especially handy if you don’t have a servo connected).

Connect the Joystick to V14

Add a Joystick widget from the “Controllers” section. Slide the Split/Merge switch to Merge, and set the pin to V14. It’s not required, but we recommend setting autoreturn to off.

Connect a Slider to V16

If you have a slider in your project, you can re-purpose it to adjust the servo’s maximum angle. Set the pin to V16, and modify the range to make it easy to set your servo’s maximum value.

Connect a Gauge or Value Widget to V17

Finally, the project produces a virtual output on V17 displaying the servo’s current angle. You can use a Value or Gauge widget to show this value. Neither are required – but it does provides feedback if you don’t have a servo motor attached.

Modify the range of the gauge, or else you might not get the right feel for the servo’s position.

Blynk Run

Once everything’s set up, run it and joystick!

As you rotate the stick, the servo should noisily reposition itself along the angle you’ve set.

In the background the Blynk Board firmware is grabbing the x and y values of the joystick, doing some trigonometry on them to calculate an angle (in degrees), and pushing that calculation back out to V17.

Going Further

Once you’ve got the servo rotating, connect something physical up to it! How about an automatic fish feeder?

Scrounge around for a bottlecap, and screw it into the servo’s single-arm.

Then slot the servo arm onto your servo motor head, and check the motion of the bottlecap – you may need to re-position the cap to get the rotation you need.

Now when you rotate the joystick, you’ll have a mobile-food-dumping apparatus – perfectly sized for a goldfish!

Project 9: Graphing Voltage

Electrical engineers love measuring voltage. Whether we’re using a multimeter to get a real-time view into a line’s potential, or a monitoring a periodic signal’s shape using an oscilloscope, monitoring voltage can be critical to project-debugging.

While we can’t really re-create an oscilloscope’s signal-triggering in Blynk, we can chart the Blynk Board’s voltage-over-time using the Graph widget. The graph widget periodically pulls in data from a virtual or physical pin, and creates either a bar or line graph representing how that input changes over time. You can set the graph to draw as fast as four times per second, or as slow as once-a-minute.

Hardware Setup

The Blynk Board’s input voltage will range anywhere from 3.7 to 6V – well outside the acceptable input range of 0-3.3V. So, to properly measure the input voltage, we’ll need to step it down using a voltage divider. Although it sounds complex, a voltage divider is actually just a pair of resistors sitting in between one voltage and another.

To create a voltage divider, first grab a couple 10kΩ resistors, and twist them together at the ends. Clip a yellow alligator clip to the twisted legs of the resistors, and connect red and black alligator cables to either of the other two legs.

Wire the other ends of the cables to ADC (yellow), VIN (red), and GND (black).

Voltage: divided. A voltage divider made out of two 10kΩ resistors will cut the voltage in half. So if the Blynk Board’s input voltage is 5V, the voltage at the ADC pin will only be 2.5V.

Blynk Setup

In addition to the graph widget, you can optionally add two value widget’s to help get a better view into the Blynk Board’s voltage measuring.

Connect the Graph to V20

You’ll find the Graph widget under the “Displays” section of the widget box. Add it, then tap it to configure. Set the pin to V20, and adjust the range to something like 0-6. Bump the update frequency up to 250ms.

You can play with the Bar/Line switch, but a line graph seems to work best for this type of data.

Monitor the ADC and V8 With Value’s

For a bit more insight into the Blynk Board’s ADC reading, consider adding a couple value widgets to monitor the ADC pin and V8– the calculated ADC voltage.

Blynk Run

See how steady that USB supply is. Try zooming the graph in, so the minimum is 4 and maximum is 6. The more “wiggles” in the signal, the noisier your supply is.

Fortunately, the Blynk Board regulates that input voltage, to create a nice, steady 3.3V supply. In fact, if you want to measure the 3.3V supply, simply swap the red cable from VIN to 3.3V. Is it steadier than the VIN supply?

Going Further

The graph widget should work for any of the Blynk Board’s output values. Try changing it to V5 or V6– see how the temperature fluctuates over time. You may need to adjust the graph’s range to actually see the line.

Plotting the Blynk Board’s Fahrenheit temperature output.

Try plugging other Blynk Board outputs you’ve already used into the Graph widget. Make some interesting curves!

Project 10: Charting Lighting History

Blynk’s History Graph widget takes the standard graph to the next level. It allows you to compare a widget’s value to data from hours, days, weeks, even months back.

In this project, we’ll plug readings from a light sensor into the History Graph. After you’ve let the project run for a while, you’ll be able to track the sun rise/set time, or find out if someone’s been snooping in a room when they’re not supposed to be.

Hardware Setup

To measure ambient light, we’re going to use a light-sensitive resistor called a photocell. When it’s pitch-black, the photocell morphs into a large, 10kΩ resistor, but when light shines on the cell, the device’s resistance drops closer to 1kΩ.

Added to your cart!

Mini Photocell

In stock SEN-09088

This is a very small light sensor. A photocell changes (also called a [photodetector](http://en.wikipedia.org/wiki/Photodetec…

$1.5

6

FavoritedFavorite22

Wish List

To create a voltage for the Blynk Board’s ADC, using the photocell’s variable resistance, we need to pair it with a second resistor. The photocell and resistor will combine to create a variable voltage divider.

That second resistor should be somewhere in the middle of the photocell’s resistance range – right about 5kΩ. There aren’t any 5k&Omgea; resistors in the IoT Starter Kit, but it does include the means to create one! By combining two equal resistors in parallel, we can cut their total resistance in half.

So, to create a 5kΩ resistor, grab two 10kΩ resistors, and twist them together in parallel – that is, twist the ends of both resistors together, so the bodies are touching each other. Then twist one leg of the photocell together with one shared leg of our new 5kΩ resistor.

Clip a yellow alligator cable to the middle legs – the behemoth that is two resistors and a photocell leg twisted together. Then clip a red cable onto the photocell’s leg, and a black cable onto the other resistor leg.

On the Blynk Board – as you’re probably used to by now – clip the yellow to ADC, red to 3.3V, and black to GND.

This circuit will produce a higher voltage in the light and a lower voltage in the dark.

Blynk Setup

This Blynk project combines the History Graph widget with a Value widget to display the real-time light reading.

Configure a Value Widget

Before adding the graph, add a Value widget and configure it to read from V18.

Set the update rate to 1 second, and name the widget “Light.”

Add a History Graph Widget

Once the Value widget is in place, add a History Graph widget. In the settings, configure any one of the four PIN’s to V18.

The textbox adjacent to the pin should automatically update to “Light” (or whatever the Value widget is configured as).

There is one quirk with the History Graph widget – it won’t directly pull or request a variable’s value. It relies on widgets like Value or Gauge to get the latest value from a virtual or physical pin.

Blynk Run

After running the project, begin by monitoring the Value widget’s reading – it should vary between 0 and 1023. See how high you can get the value reading by shining a light on it. (Hint: your phone might just have a bright LED to shine on the photocell.)

Then cover up the photocell, or turn off your lights, and see how low you can get the reading. Or! Add a zeRGBa, turn the brightness up to max, and have the Blynk Board feed back into its own light sensor.

To really get the most out of the history widget, you need to leave the project running for at least an hour. If it’s about time to hang it up for the night, leave your Blynk project plugged in and graphing. Maybe you’ll catch someone sneaking in and turning the light on!

Going Further

You can add up to four values to the History Graph – play around with the other three pins to see what other interesting info you can graph.

You may have to remove some of the previous pins to adjust the graph’s scale.

Celsius temperature and humidity – usually around the same order of magnitude – pair nicely on the graph together. Use the legend so you don’t forget which is which!

Project 11: Terminal Chat

The word “terminal” may instill images of 80’s hacker-kids playing a game of Global Thermonuclear War or 90’s Mr. Anderson’s following white rabbits, but, retro as they may sound, engineers still use terminals on a daily basis.

The Blynk Terminal widget allows you to pass endless information to and from the Blynk Board. It can be incredibly handy – in fact, we’ll use it in all four of the final projects to enter email addresses, pass debug information, and name your Blynk Board.

In this project, we’ll use the terminal on your Blynk app, and a terminal on your Blynk Board-connected computer to set up a “chat program.”

Hardware Setup

There aren’t any external components to connect to your Blynk Board in this experiment, but you may need to do some extra legwork to set up a terminal on your computer.

Install FTDI Drivers, Identify Your Serial Port

The Blynk Board uses a specialized chip called an “FTDI” to convert USB data to a more simple serial interface. If you’ve never used an FTDI-based device before, you’ll probably need to install drivers on your computer. Our How to Install FTDI Drivers tutorial should help get your drivers installed, whether you’re on a Mac, Windows, or Linux machine.

Install FTDI Drivers

Once you’ve installed the drivers, your Blynk Board should show up on your computer as either COM# (if you’re on a Windows machine) or /dev/tty.usbserial-######## (if you’re on a Mac/Linux computer), where the #’s are unique numbers or alphabetic characters.

Download, Run, and Configure the Terminal

There are a huge variety of software serial terminals out there. If you don’t already have one, read through our Serial Terminal Basics tutorial for some suggestions.

Download a Terminal

Once you’ve selected terminal software – and found your Blynk Board’s serial port number – open it and set the baud rate to 9600. The Serial Terminal Basics tutorial linked above should have directions for configuring the serial port.

Using TeraTerm to communicate with the Blynk Board over a serial interface.

Don’t be alarmed if your Blynk Board resets when you open the terminal. It may also print some debug messages as it re-connects – they’re handy, but nothing you’ll really need to concern yourself with.

Once the port is open, swap back over to your Blynk project. Time to install another terminal!

Blynk Setup

Just one widget this time: the Terminal. We’ll be using the Terminal widget for the rest of this tutorial, so make it cozy, and don’t delete it.

Add a Terminal Widget

Find the terminal widget under the “Displays” list of the widget box.

Once added, tap the terminal to enter the settings screen. Set the terminal widet’s pin to V21. Keep “Input Line” and “Auto Scroll” set to ON.

Pick any screen and background color you please – how about green background and black text, to get a little oppo-matrix style going.

That’s it. Now run the project.

Blynk Run

Try typing something in your computer terminal – you should see those same characters almost instantly pop up on your Blynk project’s terminal.

Computer terminal example - text sent by the Blynk Board/App.

Then try typing something into the Blynk terminal. They should show up on your computer.

The Blynk Terminal has the full transcript of our confusing conversation.

Now have a conversation with yourself! Or share the project and chat with a friend.

Project 12: BotaniTweeting

For over ten years now, Twitter has been the microblog-of-choice for human and machine alike. While the rich-and-famous use-and-abuse twitter to reach their millions of followers, twitter-enabled projects like our old Kegerator or bots like Stupidcounter have found their own use for the service.

Blynk’s Twitter widget is one of three notification-enabling devices in the app. After connecting it to a Twitter account, the widget will give your Blynk Board a voice on the world-wide-web.

This project, inspired by the Botanicalls Kit, will set your Blynk Board up as a fully-configurable plant soil moisture monitor. Plugged into your favorite house plant, the Blynk Board will give it a voice – so it can shout to the world when it’s thirsty.

Hardware Setup

Our handy Soil Moisture Sensor will be the hardware focus of this experiment.

Added to your cart!

SparkFun Soil Moisture Sensor

Out of stock SEN-13322

The SparkFun Soil Moisture Sensor is a simple breakout for measuring the moisture in soil and similar materials. The soil moi…

$4.95

2

FavoritedFavorite24

Wish List

At its core, this two-probed sensor is simply a resistance sensor. Wet soil is less resistive than dry soil, so a parched, dry plant will produce a lower voltage than a wet, sated one.

In addition to the soil moisture sensor, you’ll need jumper wires, alligator clip cables, and a screwdriver

Hook Up The Soil Moisture Sensor

There are a few hoops to jump through to get the moisture sensor connected to your Blynk Board. To begin, grab a screwdriver, and three jumper wires – black, red, and yellow.

Flip the board over to see the terminal labels. Plug the yellow wire into the “SIG” terminal, black wire into “GND”, and red into “VCC”. Use the small flathead screwdriver bit to securely tighten the jumper wires into the connector.

Once the jumper wires are secured, clamp alligator clip cables onto the other ends – match up the colors if you can!

Finally, clamp the other ends of the alligator clips to 3.3V (VCC/red), GND (GND/black), and the ADC (SIG/yellow).

The higher the reading on the ADC, the wetter (and happier) your plant is.

Blynk Setup

This project requires five widgets: Twitter, Terminal, a Value, and two Sliders. Hopefully you’ve got the Terminal – and maybe a few others – from previous projects. Here’s how to set them up:

Set Up the Twitter Widget

Add the Twitter widget from the “Notifications” list. Move it anywhere you’d like, and tap it to configure.

Hit Connect Twitter, and the app will take you to a foreign screen, where you can log in to your Twitter account. This is an OAUTH connection from Blynk to your Twitter account – if you ever want to disconnect Blynk from your account, you can do so in the Apps section of your account settings.

Once you’ve logged in, and allowed Blynk access to your account, the Twitter widget should have a @YOUR_ACCOUNT link in the settings page. Confirm the settings, and head back to the project.

Set Up the Terminal

As with the previous project, the Terminal should be connected to V21, make sure “Input Line” is turned ON.

Give the terminal any color(s) you’d like.

Set Up the Sliders

A pair of sliders are used to set your plant’s moisture threshold and the minimum tweet rate. Add, or re-configure two sliders (large or regular) as so:

The minimum tweet rate slider sets the minimum number of minutes between tweets. The Twitter widget can’t tweet more often than once-a-minute, so make sure that’s the bare-minimum of the slider. Set the maximum to as long as you’d like between tweets (e.g. 60 minutes, 720 minutes [12 hours], etc.)

If the reading out of the soil moisture sensor falls below the minimum threshold, it will begin tweeting as often as it’s allowed (by the tweet rate), until the reading goes back up.

Set up the Value

Finally, add or re-configure a value widget to monitor the ADC pin. You’ll need that as you hone in on a good threshold value.

Blynk Run

Once you’ve got all of those widgets set up, run the project. Plug your moisture sensor into your plant, and check the ADC reading.

If your soil is nice-and-moist, the reading should be somewhere around 700-800. Try watering your plant – see if the reading goes up.

To verify that the project is functioning and tweeting, set the threshold to 1023 and set the tweet limit to 1. Within a minute-or-so, you should see a new tweet on your timeline.

So far, so good. Now the tricky part. You need to set the moisture threshold to a “dry soil” value. It’ll be under the current value a bit. If you’re moisture is reading out at about 750, try setting the threshold to 740. Then you play the waiting game (or take a heaterizer to your plant’s soil). When the soil dries up, your plant should tweet.

Going Further: Setting the Plant’s Name

Why the terminal? To name your plant! Come up with a unique, identifiable name for your plant. Then, in the terminal, type $MY_PLANTS_TWITTER_NAME and hit enter. Make sure to type the “$” first, the terminal will catch that, and begin tweeting with your new name next time your plant gets thirsty.

Now when your plant tweets, it’ll identify which one it is.

Project 13: Push Door, Push Phone

Push notifications: you either love them or hate them (or it varies, depending on the app sending them), but they can come in handy every once-in-a-while. The Blynk Push widget allows your Blynk Board to send your phone periodic push notifications, so you’re the first to be made aware of a state change in the board.

This project combines a Door Switch Sensor with the push widget. When the door’s state changes – whether it opens or closes – you’ll be the first…well…at least the second to know!

Hardware Setup

This project is based around a Magnetic Door Switch– a truly magical door-state sensor.

Added to your cart!

Magnetic Door Switch Set

27 available COM-13247

This is the Magnetic Door Switch Set, a small reed switch assembly specifically designed to alert you when doors, drawers, or…

$2.95

FavoritedFavorite25

Wish List

This door switch is what we call a reed switch– a magnetically-actuated electronic switch. There are two components to the device: the switch itself, and a simple magnet. When the two components are in close proximity, the switch closes. And when they’re pulled far enough apart, the switch opens up. These switches are commonly used as part of a burglar alarm system or as a proximity-detecting device.

Wire Up the Door Switch

To connect the door switch to your Blynk Board, you’ll just need a couple alligator clip cables – how about red and green. Clamp a red wire to one of the switch’s wires, and the green wire to the other.

Then clamp the other end of the red wire to 3.3V and the green wire to 16.

We’ve got a pull-down resistor on pin 16. So when the switch is open, it reads as LOW, but when the switch closes the pin connects directly to 3.3V and reads as HIGH.

Blynk Setup

This project uses three widgets: Push (of course), Terminal, and Value. Here’s how to set them up:

Add the Push Widget

You’ll find the Push widget under the “Notifications” list, towards the bottom. After adding it, tap it to configure its settings.

Notifications work differently in iOS and Android devices. If you’re using an Android device, your settings will look like above. You can turn the “Notify when hardware goes offline” setting on or off at your discretion – it can be handy in other projects. The Priority setting can be set to HIGH, but it will end up draining your phone’s battery a little faster.

The iOS settings look like this:

Again, both of these sliders are left to your discretion. Enabling background notifications will likely take a bit more battery-life out of your phone.

Configure the Terminal

If you’ve still got the Terminal widget from previous projects, great – leave it be. If not, configure it to use pin V21.

Configure the Value Widget

Finally, set the value widget to V25. This widget will display the up-to-date state of your door switch sensor.

Blynk Run

Once everything’s added, run the project! Try putting the two door switches close together, or pulling them apart. A few things should happen:

• The Terminal will print a debug message – stating that the door opened or closed.
• The Value widget should display the up-to-date state of the door.

And! Hopefully, your phone will pop up a notification that the switch’s state changed. Unfortunately (or fortunately, depending on how much you enjoy notifications), the Blynk app limits project notifications to once-a-minute. If you open and close the door to fast, you might get the first notification, but for the next minute you’ll need to check the terminal or value widgets.

As with the previous project, you can set the name of your board by typing $BOARD_NAME. That name will be added to the notification that pops up on your phone.

Going Further

Tape or screw the door switch sensor to something! If you’ve got the IoT Starter Kit, you may already have something to test it out on.

The unique red SparkFun box has been re-purposed as a project enclosure in countless projects. Or you can use it to store your valuables.

With a Blynk-enabled alarm – you’ll be notified whenever someone’s sneaking into your box!

Project 14: Status Emails

The final notification-creating Blynk gadget is the Email widget, which allows you to tailor an Email’s subject and message, and send it to anyone’s inbox. It’s a great power; use it responsibly. Don’t go creating a Blynking spam bot!

This project gathers data from all of the sensor’s we’ve been using in these projects, combines them into an Email message, and sends that message to an Email address of your choice (set using the Terminal widget).

Blynk Setup

This project uses three widgets: Email, Terminal, and a Button.

Add the Email Widget

Find the Email widget under the “Notifications” list, towards the bottom of the widget box.

You’re understandably conditioned to tap the Email widget to configure it, but that’s not necessary this time. The Email widget doesn’t have any settings! All it does is provide your Blynk Board with Email-sending ability.

Configure a Terminal Widget

As with the previous experiments, we’ll be using the Terminal widget as an general-purpose string input/output device. If you’ve still got the Terminal widget from previous projects, great – leave it be. If not, configure it to use pin V21.

Most importantly, the Terminal widget will be used to enter an Email address, otherwise the Blynk Board will have nowhere to send your data.

Connect a Button to V27

Finally, we’ll use a button to trigger the sending of an Email. Add or reconfigure a button to activate V27. Make sure it’s a Push button.

Blynk Run

After running the project, tap into the Terminal input box. Type an exclamation point (!), then type your (or a friend’s) email address. Hit enter, and the Blynk Board should respond with a message verifying the email address you entered.

Now all that’s left is to tap the “Send Email!” button, and check your inbox. A status update should be dispatched to your inbox.

Don’t go mashing on the “Send Email!” button, now. The Email widget is limited to sending at most one email a minute. If you’re too trigger-happy, the Terminal will let you know when you can next send an email.

Resources & Going Further

Finished all the projects? Wondering where you go from here? Now that you’re a professional Blynker, consider re-programming the Blynk Board to create a unique project of your own! Check out our Programming the Blynk Board in Arduino tutorial to find out how to level up your Blynking!

Or, if you’re looking for more general Blynk Board or Blynk App resources, these may help:

• SparkFun Blynk Board Resources
  • Blynk Board GitHub Repository
  • Blynk Board Schematic
  • Blynk Board Eagle PCB Design Files
  • Blynk Board Arduino Firmware
• Blynk Resources
  • Blynk Homepage
  • Blynk Getting Started Guide
  • Blynk Documentation
  • Blynk Arduino Library

If you need any technical assistance with your Blynk Board, don’t hesitate to contact our technical support team via either e-mail, chat, or phone.

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

Blynk Board Bridge Widget Demo a learn.sparkfun.com tutorial

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

Introduction

The Bridge Widget available in the Blynk app allows for Device-to-Device communication. No app is required to be running. This demo shows a few ways the Bridge widget can be used for app to app communications, app to board communications, and board to board communications.

For full functionality two mobile devices and two SparkFun Blynk Boards are required. If you aren’t interested in app to app communications, only one mobile device will be required. Mobile devices can be running Android or iOS.

Hardware Hookup

No need to futz with extra hardware to prove concepts. You software people out there might appreciate this. Once you have the built in button controlling the built in LED, it’s a simple matter of changing one or two values and clipping on extra hardware.

For this tutorial all you need to do is provide power the the Bylnk Boards. This is easiest two ways; USB, or a 4.2V LiPo battery (1S).

SparkFun Blynk Board powered with a single cell LiPo battery

Powering the device with a USB cable connected to your development machine is the easiest way to prototype. Load new code and it just runs.

SparkFun Blynk Board powered with a USB micro-B cable

Mobile Apps

To create a mobile app first make sure you have the mobile app. If you don’t please install the version for your OS from one of these two sources:

Exact instructions are beyond the scope of this tutorial. Once you have the app installed, login, or create a new account.

Bylink app login screen

Once you have logged in select the large Create New Project button.

Empty Blynk project

This will bring you to where you get to name the project, select the hardware that you will be connecting to, and get your authentication token. This token (7DF0F1DE119F48149EFF64BC7B2FBD11 in this example) will be very important later on. I find that emailing it to myself is easier than typing it out. It will be sent to the email account that you registered with when you created your account.

Default project settings

I gave my project a name that matches the sketch designed to work with it. This is unnecessary, but helps keep confusion to a minimum. Once you select some SparkFun hardware you will note that the theme changes.

Configured project

Select the CREATE PROJECT option to create and open the project.

Empty project

Now that you have an empty project canvas to work with it’s time to start adding UI elements. Let’s start with the Terminal widget. You find this by double tapping the canvas and scrolling the sidebar until you see the widget of interest.

Terminal widget in Widget Box

Select the widget and the Widget Box will close and the widget will appear in the next available slot on the canvas.

Placed terminal widget

Now that you have a terminal widget in place find the button widget in the Widget Box.

Button widget the Widget Box

Follow the same procedure to place the Bridge widget. It can be found in the other section of the Widget Box at the bottom.

Bridge widget placed

Once all of the widgets are placed (or one by one) it’s time to configure the widgets. Let’s start by configuring the Terminal widget. Give it a name/label. It doesn’t matter what cAsE you enter it in, it will be converted to upper CASE.

Labeling Terminal widget

In order to interact with a widget you need to assign a pin to it. Some widgets use real, physical pins, while others use virtual pins. All of the UI in this example uses virtual pins. In this case I’ve chosen to connect the terminal to virtual pin 0. I left the other settings for the Terminal widget at their default values.

Configured Terminal widget

The procedure is the same for the Button widgets as it is for the Termial widget. Give them names/labels, and select a pin to communicate through. I think case I’m using virtual pin zero to control the local LED connected to GP5. The reason for using a virtual pin rather than a physical pin will be explained in the firmware section.

Configured Button widget to control the local LED

You may note that in the image above I’ve also changed the button from PUSH (momentary) to SWITCH (latching). For now please follow along. The other configuration options for Button widgets control to color. That wasn’t important to this demo and I left the defaults. Here is what the finished app should look like:

Bridge example device 1 setup

When the triangle in the upper-right corner is pressed, the app will run and the details of the wiring are hidden from the user.

Bridge example device 1 running

Firmware

The firmware for this demo is Arduino code. For detailed information on getting the Blynk libraries installed and your development environment configured, please see to Arduino development guide.

Configuration

One major way that the firmware for this demo differs from that in ‘standard’ Blynk firmware is that you need a second authentication code.

language:c
char auth[] = "7DF0F1DE119F48149EFF64BC7B2FBD11"; // Put your Auth Token here
char remoteAuth[] = "RemoteAuthToken"; // Auth token of bridged device

To get this second auth code you need a second project on your mobile device, or for the chat to also work, you will want to start the second project on a second mobile device logged into with the same account. Once you have the second project for a secondary Blynk Board that token can be entered as the remoteAuth for the primary Blynk Board. These two lines are the only differences between Bridge_Example_1.ino and Bridge_Example_2.ino. Two were created as a convenient way keep the confusion low and to make tweaks to one, but not both easier.

The next section to configure is the section of aliases used to tell the body of the code which virtual pin was chosen in the app. These don’t need to be changed if you followed along in the previous section on the mobile app configuration. In both the code and in the mobile app we have the local LED button mapped to virtual pin 1 (V1). We have configured the second button labeled REMT LED in the app to use virtual pin 2 (V2), so here in the code we defined an alias REMOTE_LED_BUTTON for V2. This section allows us to use the exact same code for many bridged devices.

language:c
// Virtual Pins:
#define TERMINAL                 0  // V0
#define LOCAL_LED_BUTTON         1  // V1
#define REMOTE_LED_BUTTON        2  // V2
#define TERMINAL_RECEIVE         3  // V3
#define BRIDGE                   4  // V4
#define LOCAL_LED_RECIEVE        5  // V5
#define REMOTE_LED_STATUS_UPDATE 6  // V6

The final configuration needed is to tell the Blynk Board how to connect to the Wi-Fi®. Replace SSID with the SSID (the name of your Wi-Fi® network) leaving the double quotes. Also replace PASSWORD with the actual password for your network; again leaving the double quotes.

language:c
Blynk.begin(auth, "SSID", "PASSWORD");  // Here your Arduino connects to the Blynk Cloud.

How it works

Physical button

Let’s start with the physical button on the Blynk Board. This button will be used to toggle the LED on the other Blynk Board.

This button connects GPIO0 to ground when pressed. This is called active low; the signal goes low, when the button is pressed/active. An internal pull-up resistor is used to keep this signal high when inactive. An interrupt service routine is used to immediately capture the button press event, but the resulting action isn’t taken until the main loop of the code gets around to doing it. This keeps more important things running fast. Here is the code snippet to configure what was just described.

language:c
// Setup the onboard button
pinMode(BUTTON_PIN, INPUT_PULLUP);
// Attach BUTTON_PIN interrupt to our handler
attachInterrupt(digitalPinToInterrupt(BUTTON_PIN), onButtonPress, FALLING);

The second parameter to the attachInterrupt function call is the name of the interrupt service handler, onButtonPress.

language:c
// Interrupt service routine to capture button press event
void onButtonPress()
{
  // Invert state, since button is "Active LOW"
  wasButtonPressed = !digitalRead(BUTTON_PIN);
}

This function is called when the physical button is pressed. Since the processor may be in the middle of doing something with more critical timing, this function does as little as possible, and the even is dealt with later. Here we have a variable wasButtonPressed that keeps track of whether or not the button was pressed. We store the opposite of the current state of the pin in this variable. The opposite is obtained with the ! operator. We read this pin a second time as a form of debouncing. A real button press should send the value of that pin low, and it should remain low at least the fraction of a second it takes to jump to this function and double check the state. This avoids changing state based on fast transient glitches.

Next let’s discuss the main loop:

language:c
void loop()
{
  Blynk.run(); // All the Blynk Magic happens here...

  if (wasButtonPressed) {
    // This can be seen in the Serial Monitor
    BLYNK_LOG("Physical button was pressed.");
    // Toggle state
    remoteLedState ^= HIGH;
    // Send new state to remote board LED
    bridge.virtualWrite(LOCAL_LED_RECIEVE, remoteLedState);
    // Update state of button on local mobile app
    Blynk.virtualWrite(REMOTE_LED_BUTTON, remoteLedState);
    // Clear state variable set in ISR
    wasButtonPressed = false;
  }
}

Two things happen here. First we let the Blynk library do its thing. Next we check to see if the physical button was pressed. If the button had been pressed since the last time this check was run, we have a few things to do.

First, if the Blynk Board is connected via a micro USB cable to a computer running a terminal emulator or the Arduino Serial Monitor, we write a debug message to that at 9600 baud. This is done with BLYNK_LOG("Physical button was pressed.");. This code can be compiled out if the first line of actual code in the sketch is removed or commented out (#define BLYNK_PRINT Serial).

Next a state variable keeping track of the state of the remote LED is toggled. This is done with remoteLedState ^= HIGH; but could also be done with something like remoteLedState = 1 - remoteLedState;, or remoteLedState = !remoteLedState;.

Next we send the new state across the bridge doing a virtual write to the remote LOCAL_LED_RECIEVE virtual pin. On the other end is a function that handles the value sent.

After we have told the remote devices to update we need to update the state on the mobile app attached to this Blynk Board. We do this with a virtual write to the REMOTE_LED_BUTTON with the new state value.

The final thing to do is clear the variable that indicates we have an unhandled button press, wasButtonPressed. This causes the code block we are in to be skipped until the button is pressed again.

To follow along to logical flow of a physical button press, let’s cover the function that handles when another device signals that its button has been pressed:

language:c
// Remote device triggered an LED change. Update the LED and app status.
BLYNK_WRITE(LOCAL_LED_RECIEVE)
{
  // This can be seen in the Serial Monitor
  BLYNK_LOG("Remote device triggered LED change");

  ledState = param.asInt();
  // Turn on LED
  digitalWrite(LED_PIN, ledState);
  // Set state of virtual button to match remote LED
  Blynk.virtualWrite(LOCAL_LED_BUTTON, ledState);
}

The new or important items found in this function are the digitalWrite and the virtualWrite. After updating the state of the LED, this value is sent to the GPIO connected to the LED. We then update the UI on the mobile app associated with this board.

The previous code block handled updating the GUI associated with the board that had the button pressed, and this block update the physical LED, and the GUI associated with the board with the LED that changed. One virtual button press updated a physical pin, and two GUI elements.

LED button in the mobile app GUI

When the button labeled LED is pressed the following function is called. The first bit is nothing new, we update the state variable, log this info via a serial connection if it exists.

language:c
// Virtual button on connected app was used to change remote LED.
// Tell remote devices about the change.
BLYNK_WRITE(REMOTE_LED_BUTTON)
{
  remoteLedState = param.asInt(); // Update state with info from remote
  BLYNK_LOG("New remote LED state: %s", param.asInt() ? "HIGH" : "LOW");
  // Send updated status to remote board.
  bridge.virtualWrite(LOCAL_LED_RECIEVE, remoteLedState);
}

The last statement in this function sends the remoteLedStat to the other Bkynk Board’s LOCAL_LED_RECEIVE virtual pin over the bridge. The bridge was configured in this line:

language:c
WidgetBridge bridge(BRIDGE);

BRIDGE was defined earlier in the code to be virtual pin 4.

The other end of the bridge reacts to this signal with the following function. Nothing new to see here, we log via the serial port if it exists, update the state variable, update the physical pin, and finally update the state of the GUI.

language:c
// Remote device triggered an LED change. Update the LED and app status.
BLYNK_WRITE(LOCAL_LED_RECIEVE)
{
  // This can be seen in the Serial Monitor
  BLYNK_LOG("Remote device triggered LED change");

  ledState = param.asInt();
  // Turn on LED
  digitalWrite(LED_PIN, ledState);
  // Set state of virtual button to match remote LED
  Blynk.virtualWrite(LOCAL_LED_BUTTON, ledState);
}

Remote LED button in the mobile app GUI

The remote LED button in the mobile app GUI behaves roughly the same as the LED button. In this case the button is labeled REMT LED. It uses the following functions. This first is called when the button in the app is pressed.

language:c
// Virtual button on connected app was used to change remote LED.
// Tell remote devices about the change.
BLYNK_WRITE(REMOTE_LED_BUTTON)
{
  remoteLedState = param.asInt(); // Update state with info from remote
  BLYNK_LOG("New remote LED state: %s", param.asInt() ? "HIGH" : "LOW");
  // Send updated status to remote board.
  bridge.virtualWrite(LOCAL_LED_RECIEVE, remoteLedState);
}

That function sends a signal handled on the other end of the bridge handled with the following function.

language:c
// Remote device triggered an LED change. Update the LED and app status.
BLYNK_WRITE(LOCAL_LED_RECIEVE)
{
  // This can be seen in the Serial Monitor
  BLYNK_LOG("Remote device triggered LED change");

  ledState = param.asInt();
  // Turn on LED
  digitalWrite(LED_PIN, ledState);
  // Set state of virtual button to match remote LED
  Blynk.virtualWrite(LOCAL_LED_BUTTON, ledState);
}

Inter-device chat window

Another part of this demo is sending text over the bridge. Alone this isn’t the most amazing use of the technology, but in the case of an Internet outage a local Blynk Server and a Wi-Fi® router could be setup for a phone to phone chat service.

The first requirement is to setup a Terminal widget to go with the one added in the mobile app.

language:c
// Attach virtual serial terminal to TERMINAL Virtual Pin
WidgetTerminal terminal(TERMINAL);

Next a function takes the output of this widget and sends it to another Blynk Board.

language:c
// You can send commands from Terminal to your hardware. Just use
// the same Virtual Pin as your Terminal Widget
BLYNK_WRITE(TERMINAL)
{
  // Send from this terminal to remote terminal
  bridge.virtualWrite(TERMINAL_RECEIVE, param.asStr());
}

On the other side of the bridge is the following function that takes the received string and writes it to the local terminal.

language:c
// Receive a string on LOCAL_RECEIVE and write that value to the connected
// phone's terminal
BLYNK_WRITE(TERMINAL_RECEIVE)
{
  terminal.println(param.asStr());  // Write received string to local terminal
  terminal.flush();
}

Example of chat functionality

Resources and Going Further

In this demo we used 7 virtual pins. Three of them were used to send various types of data. If your project became more complex and you ran out of virtual pins, you could send all of the data over one by encoding information on one end and decoding it on the other.

This demo was aimed a little more at the software inclined user since it required no extra hardware. It used the built in buttons and LEDs. This could easily be modified to use other pins with whatever you want to connect to them. The button on one end could be replaced with a SparkFun Sound Detector, and the LED on the other Blynk Board could be replaced with SparkFun Beefcake Relay Control Kit. This would allow you to make your own Wi-Fi® version of The Clapper. Clap in one room to turn on/off a lamp on another house!

Related tutorials:

• Blynk Board Arduino Development Guide
• Blynk Board Project Guide
• Getting Started with the SparkFun Blynk Board

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

Getting Started with the SparkFun Blynk Board a learn.sparkfun.com tutorial

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

Introduction

The SparkFun Blynk Board – ESP8266 is your hardware gateway to the app-controlled wonderland that is Blynk. Combining the Blynk Board with the Blynk app (on your iOS or Android device), will allow you to control LEDs from your phone, send a tweet when it’s time to water your plants, monitor local weather conditions, and much more!

This tutorial will explain how to get your Blynk Board connected to a local Wi-Fi network – in a process called provisioning– and connected to a project within the Blynk app. Once you’ve completed the tutorial, you’ll have already created your first project: a zebra-controlled multicolored LED (it’ll make sense when you see it).

Gather the Gear

To follow along with this tutorial, you’ll need the following physical and digital goods:

SparkFun Blynk Board – ESP8266– The Blynk Board comes fully programmed – ready to start Blynking. All you need to do is connect it to Wi-Fi and your Blynk account.

Added to your cart!

SparkFun Blynk Board - ESP8266

In stock WRL-13794

Blynk is an easy to use app builder that allows users to add a variety of buttons, sliders, graphical displays and even RGB c…

$29.95

FavoritedFavorite1

Wish List

The Blynk Board also includes a Blynk Subscription code card, which you’ll need to connect the Blynk Board to your Blynk account (and to charge it up!).

Micro-B USB Cable– The Blynk Board can be powered via a USB cable connected on the other end to either a computer, laptop, or USB wall adapter.

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

6

FavoritedFavorite2

Wish List

Added to your cart!

Wall Adapter Power Supply - 5V DC 2A (USB Micro-B)

In stock TOL-12890

This is a high quality switching 'wall wart' AC to DC 5V 2000mA USB Micro-B wall power supply manufactured specifically for S…

$5.95

9

FavoritedFavorite6

Wish List

Added to your cart!

Wall Charger - 5V USB (1A)

In stock TOL-11456

USB is being implemented as a power connection standard more and more these days, but you don't always have a computer on han…

$3.95

2

FavoritedFavorite2

Wish List

Added to your cart!

USB Micro-B Cable - 6"

In stock CAB-13244

This is a USB 2.0 type B to Micro-B 5-pin black cable. You know, the mini-B connector that usually comes with cell phones, Ca…

$1.95

3

FavoritedFavorite1

Wish List

Blynk App– The Blynk smartphone app comes in two flavors: iOS and Android. Before going any further, download the app to your smart device:

The Blynk app is compatible with iDevices running iOS 7.0+, and Android’s running any version above or equal to 4.0.

Local Internet-Connected Wireless (Wi-Fi) Network– The Blynk Board is equipped with Wi-Fi support, and should be able to connect to most home wireless networks: 2.4GHz Wi-Fi networks, that are either open (no password) or protected with WPA, WPA-2, or WEP authentication.

Note that the Blynk Board cannot connect the 5GHz band of a dual-band Wi-Fi router. If your Wi-Fi router has two visible options, like HOME-AB12-2.4 and HOME-AB12-5, connect the Blynk Board to the “2.4” option.

Powering Up the Blynk Board

Once you’ve gathered all of the materials from above, it’s time to power up the Blynk Board! Grab your USB Cable, plug one end into a computer or USB wall adapter, and plug the other into the Blynk Board.

Blynk Board plugged in, PWR LED (in the upper-left of this image) is illuminated

You should immediately see the small, red “PWR” LED illuminate, followed shortly thereafter by a random-looking blinking of the large, RGB LED.

Identifying Your Blynk Board

While the Blynk Board’s RGB blinking may look random at first, it will follow a repeating pattern – a unique sequence of four colors including either red, green, blue, purple, or yellow, with a long stop in between. This color-code will help identify your board, just in case you’re not the only one in town setting up a Blynk Board.

Four characters matching that color code will be added to the name of your Blynk Board. For example, if the RGB LED is blinking a pattern of blue, green, red, green..

…the Blynk Board name will be BlynkMe-BGRG.

The table below documents which color matches which character.

That’s not all the RGB LED does though!

RGB Status Codes

During setup, the RGB LED on the Blynk Board will be your window into its soul. The board uses this multi-colored LED to indicate all sorts of status modes. If you’re ever unclear of what the RGB color-code means, consult the table below:

Provisioning the Blynk Board

In order to connect the Blynk Board to your local Wi-Fi network – and the Blynk app – you’ll need to send it a few pieces of information, including the name and password of your Wi-Fi network. This is a process called provisioning.

The Blynk Board has plenty of backup provisioning options, but the easiest method is through the Blynk app. Both iOS and Android versions of the Blynk app support Blynk Board provisioning. All you’ll need is the Blynk QR-Code Card, included with your Blynk Board.

Provisioning on a Smartphone (or Tablet)

The setup process in each OS looks and feels a little different. Select one of the sections below to get directions for your phone (or tablet) OS.

iOS Provisioning Android Provisioning

Do the zeRGBa

Once you’ve connected the Blynk Board to a local Wi-Fi network – and connected it to your Blynk account – the Blynk app should present you with a nearly blank canvas of a Blynk project.

You should be greeted by a festively colored zebra – the zeRGBa– and an LCD widget with a rather helpful link.

Your first Blynk project should be all set up to communicate with the Blynk Board. It should also already be running, meaning it’s play time! Poke and prod the zeRGBa to select a new color – you should quickly see a physical manifestation of that color on the Blynk Board.

If your zeRGBa isn’t making LEDs blink, first make sure the project is running. The icon in the upper-right corner of the app should be a square “stop” button. If it’s a triangular “play” button, tap that to run the project.

Congratulations! You’re well on-your-way to being a professional Blynker. From here we recommend you visit the Blynk Board Project Guide to explore over a dozen Blynk projects built into the Blynk Board.

Or, you may want to check out some of these other Blynk-related tutorials:

Troubleshooting

If, for any reason, you can’t successfully provision the Blynk Board through the Blynk app, you have a few alternatives. But first, you’ll need to create a new Blynk project.

Creating a Blynk Project

Each of the alternative provisioning methods below will require a Blynk project to be previously created. The new Blynk project will be assigned a Blynk auth token– a 32-character, unique string, which connects the Blynk Board to your Blynk project. That’s what we’re after in this process.

Follow these steps to create a new Blynk project and get a new auth token:

Step 1: Create a Blynk Project

Open the Blynk app, and log in if you haven’t. Make sure your phone is connected to an Internet-connected Wi-Fi network. On the Blynk main page, select Create new project.

Create a new Blynk Project by tapping “Create New Project” on the Blynk main page.

Step 2: Configure the Blynk Project

On the next page, select SparkFun Blynk Board under the “Hardware Model” list. You can give the project any name you please – the provisioning process sets it to “BlynkMe”.

Configure a new project: name it, and set the board type to “SparkFun Blynk Board.”

Do not hit Create Project yet!

Step 3: Email and Copy the Auth Token

Depending on which alternative provisioning option you choose, you’ll either need the auth token copied to your phone’s clipboard, or sitting in your email inbox. Might as well do both while we’re here!

Tap the E-Mail button to send the auth token to your Blynk-connected email account. Then tap the Auth token itself to copy the string to your phone’s clipboard. The phone should pop up a notification confirming that the token was copied.

Step 4: Create Project

Finally, with the token emailed and copied, click Create or Create Project. You should be brought to a new, blank project – perfect for now!

Alternative Provisioning

There are a few options available for alternatively provisioning the Blynk board. In order of our recommendation, you can:

1. Connect the Blynk Board to Wi-Fi/Blynk using a laptop or Wi-Fi-enabled computer.
2. Configure the Blynk Board through a serial terminal on a computer connected over USB to the Blynk Board.
3. Creatively use copy/paste, and app-switching on your smartphone to provision the Blynk Board.

Click one of the links below to see how.

Manually Adding a zeRGBa Widget

Hopefully one of the three alternative provisioning processes has worked for you. If not, please don’t hesitate to get in touch with our technical support team.

If your Blynk Board is breathing Blynk-green, open the Blynk app on your phone, and select the bare project you’ve created. Look at that blank canvas – room for so many widgets!

A new Blank Blynk project. (Android left, iOS right)

To add a widget to the Blynk app, first make sure the project isn’t running– you should see a triangular-shaped “play” icon in the upper-right-hand corner. Now tap anywhere in the grey project space to bring up the Blynk widget box.

Add a zeRGBa widget from the Blynk widget box.

Select the zeRGBa widget to add it to your project. You can tap-and-hold the widget to drag it around the project space. We find the zeRGBa prefers to be the center-of-attention.

Now tap the zeRGBa to enter the widget settings – you’ll get very used to this. Slide the Split/Merge switch over to Merge. Then tap “PIN”, and set the box to V0. The widget settings should look like this:

To back out of the settings tab, hit OK on iOS or the upper-left back arrow on an Android.

Back at the project screen, tap the play button in the upper-right corner to start Blynking! Once you’ve got the project running, poke-and-prod that colorful zebra!

Congratulations! You’re well on-your-way to being a professional Blynker. From here we recommend you visit the Blynk Board Project Guide to explore over a dozen Blynk projects built into the Blynk Board.

Or, you may want to check out some of these other Blynk-related tutorials:

Reconfiguring a Blynk Board

If you’ve taken your Blynk Board somwhere new, and need to reconfigure its Wi-Fi network – or if you need to update the Blynk auth token – there’s a built-in method for re-entering configuration mode to reset both credentials.

While the Blynk Board is attempting to connect to a Wi-Fi network or Blynk – blinking blue or green – press and hold the 0 button.

You should see the RGB LED turn white and slowly increase in brightness. After about a second, the LED will begin to dim. Once you’ve held the button for about 4 seconds and the LED begins to brighten again, release the button.

If the reset was successful, you should see the Blynk Board revert back to its R/G/B/Y/P color-combo sequence. It should also show up as a Wi-Fi access point, and you’ll be able to configure it over either Wi-Fi or a serial terminal.

You can even re-scan your Blynk Board QR-Code Card. No, you won’t get another 15k energy, but you will be able to step through the provisioning process again!

Resources

If your Blynk Board is successfully provisioned, head over to the Blynk Board Project tutorial to explore the Blynk Board’s pre-loaded projects.

If you need any technical assistance with your Blynk Board, don’t hesitate to contact our technical support team via either e-mail, chat, or phone.

If you need general Blynk Board or Blynk App resources, these may help:

• SparkFun Blynk Board Resources
  • Blynk Board GitHub Repository
  • Blynk Board Schematic
  • Blynk Board Eagle PCB Design Files
  • Blynk Board Arduino Firmware
• Blynk Resources
  • Blynk Homepage
  • Blynk Getting Started Guide
  • Blynk Documentation
  • Blynk Arduino Library

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

Boss Alarm a learn.sparkfun.com tutorial

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

Introduction

It’s a common occurrence in any office – you’re on Facebook or browsing SparkFun when all of a sudden your boss walks in to see that you’re not working.

This project aims to avoid that embarrassment and frowns from management. The Boss Alarm alerts you of anyone walking into your office and automatically changes the active program on your computer. The sensors are inconspicuously hidden in cute woodland creatures that are guaranteed to brighten up your office and definitely not creep out any of your coworkers!

Definitely not creepy

The Boss Alarm uses an infrared breakbeam sensor made with a few common components. The design is based on schematics from this article with a few modifications.

There are three components to the Boss Alarm. There is a transmitter (hidden in the squirrel) that sends an invisible beam to the owl. The owl contains an infrared receiver (namely, the TSOP38238 IR Receiver Diode) and also another infrared transmitter. The last component is another IR receiver connected to a Teensy 3.2.

Harmless woodland creatures!

The Teensy is configured as a USB keyboard device. When the beam between the owl and the squirrel is broken, the owl sends a signal to the Teensy. When the Teensy receives this signal, it simply sends the Alt+Tab keyboard command to your computer to change the active program. If you are on a different operating system, you can change the key commands to whatever you want (for example, Windows Key + D to minimize all programs). You can trigger practically anything using this project.

Check out a video of the project in action below:

Materials

You’re going to need a few things to build this project yourself.

Along with those parts, you will need a few other parts and tools:

• Various common parts including resistors, capacitors, and transistors (this project uses an NPN 2N3904)
• A single LED, but just get a whole bunch‘cause they’re awesome!
• Hookup wire
• Wire strippers and pliers
• Soldering iron and solder
• It’s always a good idea to have desoldering wick in case you make mistakes (it’s easy to forget the pinout of those IR receivers…)
• You may need a common electric drill and bit set
• Heat-shrink tubing and a source of heat

If you plan on installing the electronics in the woodland creature enclosures, you will also need access to a 3D printer and a hot glue gun. You may also wish to paint them.

I highly recommend obtaining some sort of oscilloscope for troubleshooting, but it is not necessary to complete this project. You may also want to acquire a decent multimeter for diagnosing any issues you encounter.

Recommended Reading

You may need to read up on a few subjects to wrap your head around this project:

• Through Hole Soldering
• How to use an Oscilloscope
• Infrared Light for Electrical Engineers
• Infrared Communication
• Getting Started with the Teensy
• The 555 Timer
• How to Read a Schematic
• Transistors
• Pull-Up Resistors

Printing the Models

Sectioned owl model enclosure

The cute squirrel model

I am more of an engineer than an artist, so I sourced the basic owl and squirrel models from Autodesk’s 123Dapp website. The original artist’s page for the owl can be found here. And the squirrel’s artist can be found here.

The elusive nuclear-green owl

I modified the models a bit to fit the electronics inside. The owl was too tall for my printer to handle so I separated it into two parts and used printed pegs to align them. This also aids in assembly later on and isn’t too noticeable. I used Autodesk’s free, online program, Tinkercad, to create the models.

You should start the printer now, the models take a while to print!

Making the Squirrel Transmitter

The transmitter is a simple astable 555 timer circuit. The 555 timer is a popular and versatile (and some might say dated) IC found in many hobbyist projects.

The parts you need for this component of the project are:

• 220Ω, 2.2kΩ, and 10kΩ Resistors (1 each)
• 10kΩ potentiometer
• 1nF and 10nF ceramic capacitors
• Infrared LED
• 555 timer (x1)
• 9V Battery Connector and 9V Battery
• Snapable Protoboard
• Heatshrink Tubing

Here’s the circuit diagram:

The infrared receivers we are using have built-in filtering that makes them very reliable for digital communication. However, in order for the receivers to see our infrared beam we need to modulate it (turn it off and on) at 38kHz.

When operated in astable mode, the 555 timer will oscillate between high and low voltage at a frequency determined by external resistors and capacitors. If you want to learn more about how to work with a 555 timer, there are several websites dedicated to the chip.

Let me remind you of the pinout for the infrared receiver:

Ask me why I know this by heart…

Solder together the circuit in the diagram, try to keep it a bit compact so it fits in the model nicely! The squirrel can accommodate a 9V battery and a circuit board about 1.25 X 1 and 0.5 inches tall.

The Squirrel’s circuit board

Don’t solder the infrared LED directly on the board. Instead, solder some longer-than-you-think-you-need wires onto the LED’s terminals making sure to note which one is the anode (+) and which is the cathode (-).

To avoid short circuits, you should put some shrink wrap tubing on the soldered connections. You can use a heat gun or a blow dryer to shrink the tubing. I used a lighter but be careful not to melt the LED or yourself.

If you are using the printed models, I recommend painting them so they blend into your desk’s knick-knacks better.

You can install the infrared LED in the squirrel’s acorn. You may need to drill out the hole a bit to make the LED fit. Feed the wires through the model until they come out the bottom and then use a little hot glue to keep the LED in place. Tuck the wires away, and then no one will notice the squirrel is actually a nark!

The squirrel’s circuit board installed

The finished squirrel transmitter

Making the Owl Transceiver

Circuit Operation

Here’s the circuit schematic for the owl:

Click the image for a closer look.

The circuit for the owl may look really complicated but it’s not! The owl transceiver operates in a way similar to the squirrel transmitter. Only instead of having one 555 timer circuit, the owl has TWO! Let’s go through it step by step.

The owl has a 555 timer operating in monostable mode and another operating in astable mode. The IR Receiver Diode is an active low device. This means that, when it receives a signal, the output pin is pulled low. This works great with our 555 timer since the trigger pin needs to be pulled low to activate the monostable circuit.

The monostable circuit is designed to hold the output high for approximately 1 second (this timing isn’t crucial) when triggered by the IR Receiver.

The next part of the circuit is our reset transistor. There are two current-limiting resistors (1kΩ for the base, 220Ω for the Red eye LED) and a 10kΩ pull-down resistor on the transistor’s emitter.

Notice that the emitter is also connected to the reset pin of the second 555 timer. In most astable applications, you tie the reset pin to the supply voltage so the chip is always on. However, in this project we only want the owl to send a signal to the computer when someone walks by.

In this configuration, when the output of the first 555 is low, the transistor will be off. The pull-down resistor makes sure the voltage seen by the second 555 timer’s reset pin is around 0V, keeping it off. When the circuit is triggered, the red LED and the transistor turn on. Since the transistor is conducting, the voltage at the emitter becomes high enough to enable the second 555 timer for about 1 second.

The second 555 timer is designed to operate in astable mode at 38kHz just like the circuit in the squirrel. This sends another infrared signal to your computer telling it that someone walked by!

The additional circuits shown in the schematic are the 5V regulator circuit and the infrared receiver filtering circuit. The regulator simply takes the 9 volts from the battery and outputs a stable 5V source that plays nicely with our infrared receiver. The filtering circuit has a couple capacitors that help stabilize the output of the receiver and a pull-up resistor to keep the output high when the receiver is off.

Soldering Time!

The parts you need for this component of the project are:

• 100Ω, 220Ω (x2), 1kΩ, 2.2kΩ, 10kΩ (x3), and 100kΩ Resistors
• 10kΩ potentiometer
• 1nF, 10nF (x2), 0.1μF (x3), and 10μF (x2) capacitors
• Infrared LED
• Red LED
• Infrared Receiver
• 555 timer (x2)
• 2N3904 NPN Transistor
• L7805 Regulator
• 9V Battery Connector
• Snapable Protoboard
• Heatshrink Tubing

Build the circuit according to the included schematic. Make sure not to solder the red and infrared LEDs or the infrared receiver. Just like with the squirrel, solder on some long wires to these, and cover the connections with shrink tubing.

Completed owl circuit board. It looks complicated, but that’s just because it’s densely populated!

Paint the owl however you want; I went with a classic brown woodland owl. Again, you may need to drill out the mounting holes to get the parts to fit. It’s best to do this before painting the models to avoid scratching the paint off.

When your model is prepped, you can install the components. The infrared LED is mounted in the hole on the side of the log. The Red LED goes in either eye of the owl. The IR receiver goes in the other eye of the owl. Solder the components to the board, and it should be all set!

Hot glue the infrared LED in the side of the log. I accidentally melted the paint a bit, try to avoid that!

The Red LED and the IR receiver get installed in the head of the owl. The split in the model makes installation much easier!

The completed owl model. Such beautiful eyes!

Tuning the Transmitters

You may have noticed each astable 555 timer circuit includes a potentiometer. This allows us to fine-tune the frequency at which the circuit oscillates. We want it to be as close to 38kHz as possible so the receiver can see it in full strength.

This is where an oscilloscope comes in handy. This nice piece of kit lets you visualize voltage waveforms in (pretty much) real time. My current oscilloscope is a USB-based one called the Analog Discovery 2 by Digilent. This device not only acts as a 2-channel oscilloscope but also has a 2-channel function generator, a variable power supply, a pattern generator for digital circuits, and a logic analyzer! I prefer actual lab equipment but the Analog Discovery is nice for how compact and affordable it is.

Analog Discovery 2 – Photo courtesy of Digilent

Use a small screwdriver to adjust the potentiometer. When you have it tuned just right, you may want to hot glue the knob in place so it doesn’t get changed accidentally. Make sure to repeat this procedure for each transmitter circuit!

Tuning the transmitter frequency with a potentiometer

Tuning Without an Oscilloscope

To tune the circuit without an oscilloscope, you can just play with the potentiometer until the circuit operates reliably. The IR receiver will work with frequencies that are close enough to 38kHz.

Tuning With an Oscilloscope

If you are lucky enough to have access to an oscilloscope, this part becomes very easy. Simply hook your probe up to the output pin of the astable 555 timer, and the waveform should appear. You can adjust the potentiometer until the frequency is about 38kHz.

With the equipment mentioned above, measure the frequency of the wave using vertical cursors, and place them one period apart. The inverse of the difference between them will be your frequency (the oscilloscope usually does this calculation for you).

Checking the frequency using an oscilloscope. Notice the frequency is almost exactly 38kHz!

If you’re just getting started with the oscilloscope, you should read this guide.

Making the Computer Receiver

The computer receiver is just a copy of the IR filtering circuit used in the owl hooked up to a Teensy 3.2.

The IR filter and Teensy connected. I used an old servo connector to join the two boards. Notice the pins the filter board connects to. (Contrary to convention) Black is Vs, red is ground, and white is out.

Build the Circuit

The parts you need for this component of the project are:

• Teensy 3.2 and USB Cable
• Male headers
• 100Ω and 10kΩ Resistors
• 0.1μF, and 10μF capacitors
• Infrared Receiver
• Snapable Protoboard

Here’s the schematic again:

First, solder headers on your Teensy board, if you haven’t already.

Solder together the IR filtering circuit, and use a connector to tie the Teensy’s power and ground pins to the appropriate pins on the infrared receiver. Make sure to use the V_USB pin to get a 5V source rather than the 3.3V source on the Teensy. Connect the output of the receiver to pin 0 on the Teensy.

The IR filtering board. Notice I messed up with the IR receiver: it’s soldered twice!

Programming the Teensy

Plug the Teensy into your computer, and get ready to program it! If you haven’t used the Teensy before, read this guide to get started.

The Teensy is like an Arduino, but it has a unique feature – it can be configured as a USB device. This lets your computer “see” the Teensy as another device and automatically load the drivers for it. For example, you can configure the Teensy as a USB keyboard (as in this project), and, when you plug it in, your computer will see it as a keyboard – no special software required!

The code used in this project is almost identical to the Teensy’s USB keyboard example sketch. We simply treat the output of the IR receiver as a switch and send key presses/releases on the falling/rising edge of the receiver’s output.

language:c
/* Title: Boss Alarm
 * Date: 3/14/2016
 * Author: Don Beckstein

   Note: You must select Keyboard from the "Tools > USB Type" menu

*/

#include <Bounce.h>

// Helps us debounce the output from the IR receiver (helps suppress false-alarms)
Bounce button0 = Bounce(0, 100);

//Change these to set the key combination used
unsigned const int modifierKey = MODIFIERKEY_ALT;
unsigned const int combinationKey = KEY_TAB;

//If you're on Mac you can try this code (I haven't tested it)
//unsigned const int modifierKey = MODIFIERKEY_GUI;
//unsigned const int combinationKey = KEY_TAB;

//If you want it to show your desktop on Windows instead of switch windows, use this code:
//Sends Windows Key + D
//unsigned const int modifierKey = MODIFIERKEY_GUI;
//unsigned const int combinationKey = KEY_D;

void setup() {
  // Configure the pins for input mode with internal pullup resistors.
  pinMode(0, INPUT_PULLUP);

}

void loop() {

  //Update the buttons
  button0.update();

  //Press keyboard keys when the IR Receiver is triggered
  if (button0.fallingEdge()) {

    //Send the key commands
    Keyboard.set_modifier(modifierKey);
    Keyboard.send_now();
    Keyboard.set_key1(combinationKey);
    Keyboard.send_now();
  }

  //Release the keyboard keys when the trigger returns to normal
  if (button0.risingEdge()) {

    //Release keys
    Keyboard.set_modifier(0);
    Keyboard.set_key1(0);
    Keyboard.send_now();
  }
}

The default key combination is ALT+Tab to switch between programs on Windows. If you have multiple monitors you might want all programs to be minimized. I included a few different key combinations in the code, you can uncomment/comment lines of code to suit your needs. I also included a key combination that should work on Mac. If you want to make your own key command, this page provides a reference to the Teensy’s defined keys.

Make sure to click Tools->Board->Teensy 3.2 and Tools->USB Type->Keyboard+Mouse+Joystick to set up your Teensy correctly. Load the Boss Alarm code onto your Teensy, and it should be all set!

Setting Up the Boss Alarm

The squirrel and owl should be placed across from each other at the same height for best operation. Make sure the IR LED in the owl is pointing towards your computer! The Boss Alarm should work well for typical small office spaces.

Remember that light can reflect (including infrared, we just can’t see it)! You may find that the IR signal coming from the squirrel gets picked up by your Teensy receiver causing false-alarms. If this happens, reposition the squirrel so it is angled away from your Teensy receiver.

Plug in the Teensy board, and that’s it!

The Boss Alarm will change your active program using Alt-Tab. Make sure the last program you had selected was work-related. Excel has some nice templates that certainly look business-y.

The red LED lets you know it’s working.

The active program changes to something more business-y

The Boss Alarm has the unintended benefit that when your boss walks away, it will trigger again and return your active program to whatever you were doing before!

Now you can browse SparkFun at work without fear of your boss finding out. :)

Resources and Going Further

Though it may seem like something out of a spy movie, you likely use this kind of technology every day. The infrared receiver in the owl’s eye is the same you will find if you open up any modern TV or DVD player. That’s right – remote controls use this to send key presses!

Dramatization of your manager after the Boss Alarm is set up. (Clip from Tenacious D and the Pick of Destiny)

To Infinity… and Beyond!

Infrared communication has applications beyond breakbeam sensors and remote controls. NASA is using infrared lasers to speed up data transmission to and from Mars! It is also used in modern fiber-optic communication systems. For more on infrared communication, read this page on Wikipedia.

Infrared is one of my favorite communication methods to use in my projects. It is a pretty lightweight, cheap, and versatile platform. All it takes is a common IR LED and an IR receiver diode.

Another project I made for a hackathon was a multi-user chatroom that transferred messages across the room using infrared! My team even transmitted a picture over the channel. We called it IRC (pun intended, InfraRed Chat).

You can use this design as a basis for a number of other projects! See if you can modify the circuits to trigger other things using an infrared breakbeam sensor.

Aside from those mentioned in the tutorial, here are a few resources I used along the way:

• Astable 555 Timer Calculator
• Monostable 555 Timer Calculator

If you are having trouble with the Teensy, browse through the board’s website to find more information and tutorials.

If you have any interest in microelectronics, you might like this article on the internals of the 555 timer!

For more project ideas, check out these other great SparkFun tutorials.

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

Blynk Board Washer/Dryer Alarm a learn.sparkfun.com tutorial

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

Introduction

We created the SparkFun Blynk Board to solve problems. Big problems – like keeping plants healthy– and problems trending closer to the “first-world” end of the spectrum – like a phone-alerting laundry monitor.

This tutorial demonstrates how to pair the Blynk Board with an MMA8452Q Accelerometer Breakout to create a shake-sensing laundry monitor. Once the laundry is done, the electronics will communicate with the Blynk app– over Wi-Fi – to send your phone a push notification.

Together, the Blynk Board and app will allow you to power through laundry day as quickly and efficiently as possible!

Required Materials

The wishlist below includes all of the electronics and components you’ll need to follow along with this tutorial:

In addition to those breakout boards and cables, this project also requires a bit of soldering. A simple soldering iron, some solder, wire strippers, and a flush cutter should be all you really need.

Added to your cart!

Wire Strippers - 30AWG (Hakko)

In stock TOL-12630

These are extremely handy and comfortable to use wire strippers from Hakko. These are an essential part to any hacker's arsen…

$9.95

1

FavoritedFavorite6

Wish List

Added to your cart!

Flush Cutters - Hakko

In stock TOL-11952

These are our new and improved flush cutters, giving you a way to cut leads very cleanly and close to the solder joint. Diago…

$6.95

14

FavoritedFavorite11

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

3

FavoritedFavorite10

Wish List

Added to your cart!

Solder Lead Free - 15-gram Tube

In stock TOL-09163

This is your basic tube of unleaded (Pb-free) solder with a 60/40 no clean, water soluble resin core. 0.031" gauge and 15 gra…

$3.5

1

FavoritedFavorite3

Wish List

Suggested Reading

To follow along with this tutorial, you’ll need to program your Blynk Board with new firmware. Hopefully, by this point, you’ve already exhausted the Project Guide and set your computer up to program the Blynk Board using Arduino. If not, check out either – or both – of those tutorials first.

Blynk Board Project GuideBlynk Board Arduino Development Guide

This project builds on a handful of electronics concepts. If your unfamiliar with any of the subjects below, consider reading through that tutorial first.

Hardware Hookup

The MMA8452Q is controlled and monitored via an I²C interface interface – a two-wire, serial interface popular among embedded electronics like this. On the Blynk Board, that interface is broken out to the 4-pin, white JST connector adjacent to the USB port.

Our 4-Pin JST wire assembly mates perfectly with that connector, but tying the other end to an accelerometer will require some soldering.

Solder the JST Cable to the Accelerometer

Plugged into the Blynk Board, the colors of the 4-wire JST assembly match up closely with what you’d expect. Black is ground, red is power (3.3V), yellow is SCL, and blue is SDA. That’s exactly how you’ll need to solder the accelerometer on the other end.

Once the JST cable is soldered into the accelerometer, simply plug the connector into the mating end of the Blynk Board.

Optional: Add a Battery

This project can take advantage of the Blynk Board’s integrated LiPo battery charger. If you don’t have an empty wall outlet nearby, you can simply plug the battery in and set the assembly on top of your washer/dryer.

Any of our single-cell lithium-polymer batteries should work. If you’re looking for suggestions, we find the 400mAh and 850mAh LiPo’s to be a nice compromise between capacity and size.

To charge the battery, simply connect a USB cable (connected on the other end to either a computer or wall adapter) to the Blynk Board.

Blynk Setup

To enable phone notifications – and to configure the Blynk Board laundry monitor on-the-fly – we're using the Blynk app. Blynk is available for both iOS and Android devices. Click one of the links below, if you don't have the app yet.

On your phone, create a new Blynk project (or use a previously-created project if you prefer). Then drag in the following widgets:

Push Notifications

The most critical widget of the bunch! There’s not a whole lot to configure here. The “Send even if app is in background” option is useful, but may end up draining more of your phone’s battery.

Button | “Enable Push” | V0

This button will allow you to easily enable or disable push notifications – just in case you don’t always want the intrusive alerts.