SparkFun Inventor's Kit for MicroView

Pages
Contributors: Joel_E_B
Favorited Favorite 5

Introduction

Welcome to the Experiment Guide for the SparkFun Inventor’s Kit for MicroView, or the SIK for MicroView for short. This tutorial will guide you through eleven experiments to help you better understand your MicroView, and, once finished, you should have the knowledge necessary to make your MicroView project dreams a reality.

SparkFun Inventor's Kit for MicroView

KIT-13205
12 Retired

Included Materials

Before you do anything, you should make sure that you have all the necessary parts included with the SIK for MicroView. It’s a good idea to familiarize yourself with the parts now, so you know what to look for when it comes time to build the circuits.

Suggested Reading

To make your MicroView experience as enjoyable as possible, we recommend you be familiar with the following concepts before beginning.

MicroView Overview

Let’s first familiarize ourselves with the MicroView and its pins. Below you’ll find a list of specifications as well as a graphical datasheet detailing the function(s) of each pin.

microview

Hardware Specifications

  • Input Voltage : 3.3VDC - 16VDC
  • Display : 64x48 OLED Display
  • Microcontroller : ATmega328P
  • Operating Voltage : 5V
  • Digital I/O Pins : 12 (of which 3 provide PWM output)
  • Analog Input Pins : 6
  • Flash Memory : 32 KB
  • SRAM : 2 KB
  • EEPROM : 1 Kilobyte
  • Clock Speed : 16 Mhz

Pin Configuration

The MicroView has 16 “physical pins” that map to corresponding “Arduino pins” that can be referenced from within your Arduino sketch. For example, Physical Pin2 maps to the Arduino’s pin A5 (analog pin 5).

pinout

Pinout of MicroView on it’s side. The top of the MicroView is on the right. (Click image for closer look.)

The pin numbering for the MicroView increments as you move counter-clockwise.

The MicroView’s physical Pin1 is denoted by a dot on the underside of the MicroView.

alt text

For more details on each pin’s function, please refer to the ATmega328P Datasheet.

Quick Start Experiment

The MicroView comes with preinstalled code to get you learning right out of the box without having to do any programming. Using just a few components, you can learn the in’s and out’s of the MicroView.

Setting Up Your MicroView

Identify PIN 1 of MicroView based on the following diagram, or refer back to the MicroView Overview section.

alt text

In this guide, when there is a reference for PIN x of MicroView, it is referring to the above diagram’s PIN number. For example, connect PIN 5 and PIN 8 of the MicroView.

MicroView with USB Programmer

The quickest way to get started is to use the USB programmer.

Insert the MicroView to the USB Programmer, then connect the female end of the USB extension cable to the factory USB Programmer.

alt text

Note that it is much easier to connect a USB extension cable if the MicroView is inserted into the end of the breadboard.

Connect the male end of the USB extension cable to the computer. The MicroView will power on, and the demo will start.

MicroView without USB Programmer

If you would like to use the MicroView without the USB Programmer, you will need the following (please note that the 9V battery and snap connector will need to be purchased separately):

Connect the required parts based on the diagram below. Plug in the battery connectors last. Once plugged in, the 9V battery will power the MicroView through the VIN pin (PIN 1).

alt text

As soon as the MicroView is powered, the demo will start.

Learn How to Use MicroView

The MicroView comes pre-programmed with a few simple built-in tutorials to help you get use to inserting jumper wires, resistors and an LED. Skip these tutorials if you are already familiar with them. They will begin after the visual demo.

Note: The following examples are based on MicroView without the USB Programmer, if you have the USB Programmer, please ignore the battery, red jumper and black jumper. The MicroView gets its power supply from the USB Programmer via the USB cable connected to the computer.

Simple Tutorial 1

Follow the instruction displayed on the MicroView, and connect PIN 5 and PIN 8 of the MicroView with a jumper using the following diagram as reference:

alt text

Once you have successfully connected PIN 5 and PIN 8 of the MicroView, a “Well done!” message will be displayed. To proceed to the next simple tutorial, remove the jumper.

Simple Tutorial 2

Follow the instruction displayed on the MicroView, and connect PIN 3 and PIN 8 of the MicroView with a jumper using the following diagram as reference:

alt text

Once you have successfully connected PIN 3 and PIN 8 of the MicroView, a “Well done!” message will be displayed. To proceed to the next simple tutorial, remove the jumper.

Simple Tutorial 3

Follow the instruction displayed on the MicroView, and connect PIN 2 and PIN 8 of the MicroView with a jumper using the following diagram as reference:

alt text

Once you have successfully connected PIN 2 and PIN 8 of the MicroView, a “Well done!” message will be displayed. To proceed to the next simple tutorial, remove the jumper.

Simple Tutorial 4

Follow the instruction displayed on the MicroView, and connect PIN 4 and PIN 8 of the MicroView with a 330Ω resistor using the following diagram as reference:

alt text

Once you have successfully connected PIN 4 and PIN 8 of the MicroView with the resistor, a “Well done!” message will be displayed. To proceed to the next simple tutorial, remove the resistor.

Simple Tutorial 5

Follow the instruction displayed on the MicroView, and connect PIN 4 and PIN 8 of the MicroView with a 10KΩ resistor using the following diagram as reference:

alt text

Once you have successfully connected PIN 4 and PIN 8 of the MicroView with the resistor, a “Well done!” message will be displayed. To proceed to the next simple tutorial, remove the resistor.

Simple Tutorial 6

Follow the instruction displayed on the MicroView, connect PIN 5 and PIN 8 of the MicroView with a 330Ω resistor using the following diagram as reference:

alt text

With the resistor still at the same place, insert an LED with both of the pins at PIN 4 and PIN 5 of MicroView respectively using the following diagram as reference.

alt text

Note: LEDs are polarized components. Make sure you insert the LED in the correct orientation.

The MicroView is able to detect if the LED is inserted with the correct polarity, and it will begin blinking the LED.

If the LED does not blink, remove the LED and turn the pins the other way round and connect them to PIN 4 and PIN 5 of the MicroView.

With that, you are now ready to upload code and begin building the experiments in this guide.


If you would like to load the Demo Sketch back on to the MicroView after you have uploaded any other code, you can find the MicroViewDemo.ino sketch in the MicroView Library Examples.

demo

Programming the MicroView

The following section will cover all the of the instructions to install the MicroView library and get started using the MicroView with the Arduino IDE.

In order to get your MicroView up and running, there a few easy steps you will need to follow:

  1. Download the FTDI Drivers
  2. Install Arduino software and MicroView Library
  3. Select the right board
  4. Run your first sketch

Driver Installation

If have never used an Arduino or Arduino compatible device on your computer before, you’ll likely need to install the drivers for the FTDI chip located on the MicroView USB Programmer board. If you have never installed an FTDI Driver before, please visit our FTDI Driver Installation tutorial. Once successfully installed, your MicroView should show up as a valid COM Port in the Arduino IDE under Tools -> Ports.

On a Mac or Linux machine, it will appear as /dev/cu.usbmodemXXXXXX or as /dev/cu.usbserialXXXXXX, where the X’s are some specific characters and numbers.


On Windows, it will appear as COMXX, where the X’s are a specific number.

Once you have finished the FTDI driver installation, you will need to prepare your MicroView to be inserted into the computer’s USB port.

If you’re using the USB Programmer, insert the MicroView into the USB Programmer now. Be sure to align Pin 1 of the MicroView with Pin 1 of the USB Programmer. Once you have inserted the MicroView into the USB Programmer, you can now insert the USB Programmer into the USB port of the computer as pictured below. If your computer does not have a right-sided USB port, please use a USB Cable Extension to extend the USB port to the front so that you can easily work with the MicroView.

alt text


As an alternative to the USB Programmer, you can use a 5V FTDI Basic Breakout or 5V FTDI Cable instead. Connect the FTDI Basic Breakout board as below, and you are ready to go.

alt text

Install Arduino IDE and the MicroView Library

If you have not installed the Arduino IDE already, now is the time to do so. Visit our Installing the Arduino IDE tutorial for detailed instructions.

Download the library using the Arduino Library Manager (found in all version of the Arduino IDE from v1.6.4 and on).

Click Sketch -> Include Library -> Manger Libraries to open the Library Manger. Once open, type ‘microview’ in the search field. Install the SparkFun MicroView library by clicking on the library then clicking the install button. Once installed, there should be a blue ‘installed’ indicator next to the library.

Library Manger

You should now be able to find all the MicroView examples in your Arduino IDE skecthbook.

examples

Board Selection

Once the Arduino IDE is up and running, you’ll need to select the correct Board. Luckily, the MicroView is supported as an Arduino Uno variant, meaning no extra .brd files need to be installed to use the MicroView. Select Arduino Uno under Tools -> Boards.

board selection

In the Arduino IDE under Tools -> Ports, select the correct COM port. This is the port that was found in the Driver Installation section.

alt text


For advance user that like to see MicroView as a board by itself in the IDE, add the following board definition to the boards.txt file. Depending on your setup, the boards.txt file usually located at arduino-version\hardware\arduino folder. Replace arduino-version with the right folder name for your Arduino version installed in your computer.

uview.upload.tool=avrdude
uview.bootloader.tool=avrdude
uview.name=MicroView
uview.upload.protocol=arduino
uview.upload.maximum_size=32256
uview.upload.speed=115200
uview.bootloader.low_fuses=0xff
uview.bootloader.high_fuses=0xde
uview.bootloader.extended_fuses=0x05
uview.bootloader.path=optiboot
uview.bootloader.file=optiboot_atmega328.hex
uview.bootloader.unlock_bits=0x3F
uview.bootloader.lock_bits=0x0F
uview.build.mcu=atmega328p
uview.build.f_cpu=16000000L
uview.build.core=arduino
uview.build.variant=standard

With the drivers and library installed and the correct settings in selected in the Arduino IDE, it’s time to run our first program on the MicroView. The Hello World sketch in the next section will be the first code we upload to the MicroView.

Experiment 1: Blinking an LED

LEDs (light-emitting diodes) are small, powerful lights that are used in many different applications. To start off the MicroView course, we will work on blinking an LED. That’s right – it’s as simple as turning a light on and off. It might not seem like much, but establishing this important baseline will give you a solid foundation as we work toward more complex experiments. Blink is the “Hello World” of hardware.

Parts Needed

You will need the following parts:

  • 1x LED
  • 1x 330Ω Resistor (Orange, Orange, Brown, Gold)

Breadboard Setup

Pay close attention to the polarity of the LED.

alt text

Hook up your circuit as pictured below:

Circuit 1

MicroView Arduino Code

Upload the following code to your MicroView:

language:c
int LED = A3;               // declare LED as pin A3 of MicroView

void setup()
{
    pinMode(LED, OUTPUT);   // set LED pin as OUTPUT
}

void loop()
{
    digitalWrite(LED, HIGH);    // set LED pin HIGH voltage, LED will be on
    delay(1000);                // delay 1000 ms 
    digitalWrite(LED, LOW);     // set LED pin LOW voltage, LED will be off
    delay(1000);                // delay 1000 ms
}

What You Should See

You should see your LED blink on and off. If it isn’t, make sure you have assembled the circuit correctly and verified and uploaded the code to your MicroView or see the troubleshooting tips below.

Code to Note

Before you can use one of the MicroView’s pins, you need to tell the MicroView whether it is an INPUT or OUTPUT. We use a built-in “function” called pinMode() to do this.

pinMode(A3, OUTPUT);

When you’re using a pin as an OUTPUT, you can command it to be HIGH (output 5 volts), or LOW (output 0 volts).

digitalWrite(A3, HIGH);

Arduino programs run in a loop. When the MicroView sees the delay() command, it will pause the loop for the amount of time (in milliseconds). For example delay(1000) will stop the loop for one second as there are 1000 ms in one second.

delay(1000);

Troubleshooting

LED Not Lighting Up?

LEDs will only work in one direction. Try taking it out and turning it around 180 degrees (no need to worry, installing it backward does no permanent harm).

Still No Success?

A broken circuit is no fun, send us an e-mail and we will get back to you as soon as we can: TechSupport@sparkfun.com

Experiment 2: Reading a Potentiometer

In this circuit, you’ll work with a potentiometer. A potentiometer is also known as a variable resistor. When it’s connected with 5 volts across its two outer pins, the middle pin outputs a voltage between 0 and 5, depending on the position of the knob on the potentiometer. A potentiometer is a perfect demonstration of a variable voltage divider circuit. The voltage is divided proportionate to the resistance between the middle pin and the ground pin. In this circuit, you’ll learn how to use a potentiometer and display its value on the MicroView.

Parts Needed

You will need the following parts:

  • 1x Potentiometer
  • 3x Jumper Wire

Breadboard Setup

Hook up your circuit as pictured below:

MicroView Circuit 2

MicroView Arduino Code

Upload the following code to your MicroView:

language:c
#include <MicroView.h>          // include MicroView library

MicroViewWidget *widget;        // create widget pointer
MicroViewWidget *widget2;       // create widget pointer

int sensorPin = A1;    // select the input pin for the potentiometer
int sensorValue = 0;  // variable to store the value coming from the sensor

void setup()
{
    digitalWrite(sensorPin, HIGH);      // Internal Pull-up
    pinMode(sensorPin, INPUT);          // make pin as INPUT
    uView.begin();                      // start MicroView
    uView.clear(PAGE);                  // clear page
    widget = new MicroViewSlider(0, 0, 0, 1024);    // make widget as Slider
    widget2 = new MicroViewSlider(0, 20, 0, 1024, WIDGETSTYLE1);    // make widget as Silder STYLE1
    uView.display();                    // display the content in the screen buffer
}

void loop()
{
    sensorValue = analogRead(sensorPin);    // read sensorPin
    widget->setValue(sensorValue);          // set value of sensorPin to widget
    widget2->setValue(sensorValue);         // set value of sensorPin to widget 
    uView.display();                        // display the content in the screen buffer
}

What You Should See

By turning the potentiometer’s knob you should see on your MicroView’s display two different styles of widget reflect the reading of the potentiometer.

Code to Note

A “variable” is a stored value you’ve given a name to. You must introduce, or “declare” variables before you use them; here we’re declaring a variable called sensorValue, of type “int” (integer). Don’t forget that variable names are case-sensitive!

int sensorValue;

We use the analogRead() function to read the value on an analog pin. analogRead() takes one parameter, the analog pin you want to use (“sensorPin”), and returns a number (“sensorValue”) between 0 (0 volts) and 1023 (5 volts).

sensorValue = analogRead(sensorPin);

Troubleshooting

LED Not Lighting Up?

LEDs will only work in one direction. Try taking it out and turning it around 180 degrees (no need to worry, installing it backward does no permanent harm).

Still No Success?

A broken circuit is no fun, send us an e-mail and we will get back to you as soon as we can: TechSupport@sparkfun.com

Experiment 3: RGB LED

You know what’s even more fun than a blinking LED? Changing colors with one LED. RGB, or red-green-blue, LEDs have three different color-emitting diodes that can be combined to create all sorts of colors. In this circuit, you’ll learn how to use an RGB LED to create unique color combinations. Depending on how bright each diode is, nearly any color is possible!

Parts Needed

You will need the following parts:

  • 1x RGB LED
  • 3x 330Ω Resistor (Orange, Orange, Brown, Gold)
  • 4x Jumper Wire

Breadboard Setup

Be sure to pay close attention to the polarity of the RGB LED.

LED polarity

Hook up your circuit as pictured below:

circuit 3

MicroView Arduino Code

language:c
#include <MicroView.h>      // include MicroView library

MicroViewWidget *redWidget, *greenWidget, *blueWidget;  // declare 3 widget pointers

int RED = 6;            // declare RED LED pin 6
int GREEN = 5;          // declare GREEN LED pin 5
int BLUE = 3;           // declare BLUE LED pin 3
int fadeStep = 10;      // declare fading steps
int dly=20;             // declare delay

void setup()
{
    uView.begin();                                  // start MicroView
    uView.clear(PAGE);                              // clear page
    redWidget = new MicroViewSlider(0,0,0,255);     // declare RED widget as slider
    greenWidget = new MicroViewSlider(0,10,0,255);  // declare GREEN widget as slider
    blueWidget = new MicroViewSlider(0,20,0,255);   // declare BLUE widget as slider

    pinMode(RED, OUTPUT);                           // set RED LED pin as OUTPUT
    pinMode(GREEN, OUTPUT);                         // set GREEN LED pin as OUTPUT
    pinMode(BLUE, OUTPUT);                          // set BLUE LED pin as OUTPUT
}

void loop()
{
    int i;                                  // init i variable for general use

    // brightening
    for (i=0;i<=255;i+=fadeStep) {          // step i from 0 to 255 by fadeSteps
        redWidget->setValue(i);             // set brightness value for RED LED to widget
        uView.display();                    // display the content of the screen buffer
        analogWrite(RED,i);                 // set brightness value for RED LED to the pin
        delay(dly);
    }

    // dimming
    for (i=255;i>=0;i-=fadeStep) {          // step i from 255 to 0 by fadeSteps
        redWidget->setValue(i);
        uView.display();
        analogWrite(RED,i);
        delay(dly);
    }

    // brightening
    for (i=0;i<=255;i+=fadeStep) {
        greenWidget->setValue(i);
        uView.display();
        analogWrite(GREEN,i);
        delay(dly);
    }

    // dimming
    for (i=255;i>=0;i-=fadeStep) {
        greenWidget->setValue(i);
        uView.display();
        analogWrite(GREEN,i);
        delay(dly);
    }

    // brightening
    for (i=0;i<256;i+=fadeStep) {
        blueWidget->setValue(i);
        uView.display();
        analogWrite(BLUE,i);
        delay(dly);
    }

    // dimming
    for (i=255;i>=0;i-=fadeStep) {
        blueWidget->setValue(i);
        uView.display();
        analogWrite(BLUE,i);
        delay(dly);
    }
}

What You Should See

You should see your RGB LED go through a colorful sequence of various colors with the slider widget showing the value of each color channel’s brightness.

Code to Note

A for() loop is used to step a number across a range, and repeatedly runs code within the brackets {} until a condition is met. We use for loops to change over time the intensity of our RGB pin’s brightness. The variable “i” starts a 0, ends at 255, and increases by the amount of the variable fadeStep.

for (i=0;i<=255;i+=fadeStep) 
{}

The MicroView is very very fast, capable of running thousands of lines of code each second. To slow it down so that we can see what it’s doing, we’ll often insert delays into the code. delay() counts in milliseconds; there are 1000 ms in one second.

delay(dly);

Troubleshooting

LED Remains Dark or Shows Incorrect Color

With the four pins of the LED so close together, it’s sometimes easy to misplace one. Double check each pin is where it should be.

Seeing Red

The red diode within the RGB LED may be a bit brighter than the other two. To make your colors more balanced, use a higher Ohm resistor. Or adjust in code. Change

analogWrite(RED,i);

to

analogWrite(RED,i/3);
Still No Success?

A broken circuit is no fun, send us an e-mail and we will get back to you as soon as we can: TechSupport@sparkfun.com

Pulse-Width Modulation

We’ve seen that the Arduino can read analog voltages (voltages between 0 and 5 volts) using the analogRead() function. Is there a way for the MicroView to output analog voltages as well?

The answer is no… and yes. The MicroView does not have a true analog voltage output. But, because the MicroView is so fast, it can fake it using something called PWM (“Pulse-Width Modulation”).

Pins named 3, 5, and 6 within the Arduino code, map to the MicoView physical pins of 12, 13, and 14. Each of these pins are PWM/analogWrite out compatible.

PWM varies the amount of time that a blinking pin spends HIGH vs. the time it spends LOW. If the pin spends most of its time HIGH, a LED connected to that pin will appear bright. If it spends most of its time LOW, the LED will look dim. Because the pin is blinking much faster than your eye can detect, the MicroView creates the illusion of a “true” analog output.

alt text

Experiment 4: Push Buttons

In this circuit, we’ll be looking at one of the most common and simple inputs – a push button. The way a push button works with this MicroView tutorial is that when the button is pushed, the contacts in the button connects to the ground, MicroView reads this and reacts accordingly.

Parts Needed

You will need the following parts:

  • 1x Push Button
  • 2x Jumper Wire

Breadboard Setup

Hook up your circuit as pictured below:

Circuit04

MicroView Arduino Code

language:c
#include <MicroView.h>      // include MicroView library

int buttonPin = A0;         // push button pin
int buttonState = 0;        // variable to store the pushbutton status

void setup() {
    uView.begin();          // start MicroView
    uView.clear(PAGE);      // clear page

    pinMode(buttonPin, INPUT);      // initialize the pushbutton pin as an input
    digitalWrite(buttonPin,HIGH);   // set Internal pull-up
}

void loop() {
    buttonState = digitalRead(buttonPin);   // read the state of the pushbutton value

    // check if the pushbutton is pressed.
    // if it is not pressed, the buttonState is HIGH:
    if (buttonState == HIGH) {     
        uView.setCursor(0,0);       // set cursor at 0,0
        uView.print("OFF");         // print OFF
        uView.display();
    } 
    else {
        uView.setCursor(0,0);
        uView.print("ON ");
        uView.display();
  }
}

What You Should See

You should see your MicroView print “ON” if you push the button, and “OFF” if you let go. (See the code to find out why!) If it isn’t working, make sure you have assembled the circuit correctly and verified and uploaded the code to your MicroView or see the troubleshooting tips below.

Code to Note

The digital pins can be used as inputs as well as outputs. Before you do either, you need to tell the MicroView which direction you’re going.

pinMode(buttonPin, INPUT);

To read a digital input, you use the digitalRead() function. It will return HIGH if there’s 5V present at the pin, or LOW if there’s 0V present at the pin.

buttonState = digitalRead(buttonPin);

Because we’ve connected the button to GND, it will read LOW when it’s being pressed. Here we’re using the “equivalence” operator (“==”) to see if the button is being pressed.

if (buttonState == LOW)

Troubleshooting

Light Not Turning On

The pushbutton is square, and because of this it is easy to put it in the wrong way. Rotate the button by 90 degrees and see if it starts working.

Underwhelmed

No worries, these circuits are all super stripped down to make playing with the components easy, but once you throw them together the sky is the limit.

Still No Success?

A broken circuit is no fun, send us an e-mail and we will get back to you as soon as we can: TechSupport@sparkfun.com

Getting Logical

One of the things that makes the MicroView so useful is that it can make complex decisions based on the input it’s getting. For example, you could make a thermostat that turns on a heater if it gets too cold, a fan if it gets too hot, waters your plants if they get too dry, etc.

alt text

You can combine these functions to build complex if() statements.

if ((mode == heat) && ((temperature < threshold) || (override == true))) {
    digitalWrite(HEATER, HIGH);
}

…will turn on a heater if you’re in heating mode AND the temperature is low, OR if you turn on a manual override. Using these logic operators, you can program your MicroView to make intelligent decisions and take control of the world around it! To learn more about logic, check out our tutorial on digital logic.

To learn more about the different types of buttons and switches you can use in your projects, visit the Switch Basics tutorial.

Experiment 5: Photoresistors

You’ve already played with a potentiometer, which varies resistance based on the twisting of a knob. In this circuit, you’ll be using a photoresistor (also known as a photocell), which changes resistance based on how much light the sensor receives.

Parts Needed

You will need the following parts:

  • 1x Photoresistor

Breadboard Setup

Hook up your circuit as pictured below:

Circuit05

MicroView Arduino Code

language:c
#include <MicroView.h>      // include MicroView library

MicroViewWidget *widget;    // declare widget pointer

int sensorPin = A2;     // select the input pin for the photoresistor
int sensorValue = 0;    // variable to store the value coming from the sensor

void setup() {
    pinMode(sensorPin,INPUT);       // set sensor pin as INPUT
    digitalWrite(sensorPin,HIGH);   // set Internal pull-up
    uView.begin();                  // start MicrView
    uView.clear(PAGE);              // clear page
    widget = new MicroViewGauge(32,24,0,1023,WIDGETSTYLE1); // set widget as gauge STYLE1
}

void loop() {
    sensorValue= analogRead(sensorPin);     // read value from sensorPin
    widget->setValue(sensorValue);          // set the sensorValue to the gauge widget
    uView.display();                        // display the widget
}

What You Should See

You should see the potentiometer value being displayed on the MicroView’s display.

Code to Note

A “variable” is a stored value you’ve given a name to. You must introduce, or “declare” variables before you use them; here we’re declaring a variable called sensorValue, of type “int” (integer). Don’t forget that variable names are case-sensitive!

int sensorValue;

We use the analogRead() function to read the value on an analog pin. analogRead() takes one parameter, the analog pin you want to use (“sensorPin”), and returns a number (“sensorValue”) between 0 (0 volts) and 1023 (5 volts).

sensorValue = analogRead(sensorPin);

Troubleshooting

Sporadically Working

This is most likely due to a slightly dodgy connection with the photoresistor’s pins. This can usually be conquered by pushing the photoresistor down into the breadboard.

Still No Success?

A broken circuit is no fun, send us an e-mail and we will get back to you as soon as we can: TechSupport@sparkfun.com

Pull-up Resistors

Many of the sensors you’ll use (potentiometers, photoresistors, etc.) are resistors in disguise. Their resistance changes in proportion to whatever they’re sensing (light level, temperature, sound, etc.).

The MicroView’s analog input pins measure voltage, not resistance. But we can easily read voltage by using the MicroView’s internal pull-up resistors. Visit our pull-up resistors tutorial for more info. To get the most out of your photoresistor, we recommend replacing one of the resistors in a voltage divider circuit with a photoresistor.

Experiment 6: Temperature Sensor

A temperature sensor is exactly what it sounds like – a sensor used to measure ambient temperature. This particular sensor has three pins – a positive, a ground, and a signal. This is a linear temperature sensor. A change in temperature of one degree centigrade is equal to a change of 10 millivolts at the sensor output. The TMP36 sensor has a nominal 750 mV at 25°C (about room temperature). In this circuit, you’ll learn how to integrate the temperature sensor with your MicroView, and use the serial monitor to display the temperature.

Heads up! When you’re building the circuit be careful not to mix up the transistor and the temperature sensor, they’re almost identical. Look for “TMP” on the body of the temperature sensor.

alt text

Parts Needed

You will need the following parts:

  • 1x TMP36 Temperature Sensor
  • 2x Jumper Wire

Breadboard Setup

Hook up your circuit as pictured below:

Be sure to insert the TMP36 in the correct orientation. It is polarized and will not work if inserted incorrectly.

Circuit06_a

Once you are sure orientation is correct, you can place the remaining jumper wires.

Circuit06_b

MicroView Arduino Code

language:c
#include <MicroView.h>      // include MicroView library

MicroViewWidget *widget;    // declare widget pointer

int sensorPin = A0;     // select the input pin for the temperature sensor
int sensorValue = 0;    // variable to store the value coming from the sensor

void setup() {
    pinMode(sensorPin,INPUT);   // set sensor pin as INPUT
    uView.begin();              // start MicroView
    uView.clear(PAGE);          // clear page
    widget = new MicroViewGauge(32,24,0,255,WIDGETSTYLE1);      // declare as gauge widget
    uView.drawChar(47,33,67);   // Character C is ASCII code 67
}

void loop() {
    sensorValue= analogRead(sensorPin);             // read sensor pin value
    float voltage = sensorValue * 5.0;              // voltage at pin in volt
    voltage /= 1024.0;                              // voltage = sensorValue x (5/1024)
    float temperatureC = (voltage - 0.5) * 100 ;    // C = (voltage - 0.5) x 100
    widget->setValue(temperatureC);                 // set temperature value to the gauge
    uView.display();                                // display gauge tick
}

What You Should See

As you warm and cool your temperature sensor, you should be able to see the gauge on your MicroView’s display go up or down.

Troubleshooting

Temperature Value is Unchanging

Try pinching the sensor with your fingers to heat it up or pressing a bag of ice against it to cool it down.

Still No Success?

A broken circuit is no fun, send us an e-mail and we will get back to you as soon as we can: TechSupport@sparkfun.com

Experiment 7: Servo Motors

Servos are ideal for embedded electronics applications because they do one thing very well that motors cannot – they can move to a position accurately. By varying the pulse width of the output voltage to a servo, you can move a servo to a specific position. For example, a pulse of 1.5 milliseconds will move the servo 90 degrees. In this circuit, you’ll learn how to use PWM (pulse width modulation) to control and rotate a servo. To learn more about PWM, visit our tutorial.

Parts Needed

You will need the following parts:

  • 1x Servo Motor
  • 3x Jumper Wire

Breadboard Setup

Connect 3x jumper wires to the female 3 pin header on the servo. This will make it easier to breadboard the servo.

Servo Jumpers

Hook up your circuit as pictured below:

Circuit07

MicroView Arduino Code

language:c
#include <MicroView.h>      // include MicroView library
#include <Servo.h>          // include Servo library

Servo servo;                // declare servo object

void setup()
{
    uView.begin();          // start MicroView 
    uView.clear(PAGE);      // clear page
    servo.attach(6);        // servo control pin at D6  
}

void loop()
{
    uView.setCursor(0,0);   // set cursor to 0,0
    uView.print("Mid  ");   // display Mid
    uView.display();
    servo.write(90);    // about 90 degree
    delay(2000);        // delay 2 seconds

    uView.setCursor(0,0);
    uView.print("Left ");
    uView.display();
    servo.write(20);    //  about 20 degree
    delay(2000);

    uView.setCursor(0,0);
    uView.print("Mid  ");
    uView.display();
    servo.write(90);    // about 90 degree
    delay(2000);

    uView.setCursor(0,0);
    uView.print("Right");
    uView.display();
    servo.write(160);   // about 160 degree
    delay(2000);
}

What You Should See

You should see your servo motor move to various locations at several speeds. If the motor doesn’t move, check your connections and make sure you have verified and uploaded the code, or see the troubleshooting tips below.

Code to Note

#include is a special “preprocessor” command that inserts a library (or any other file) into your sketch. You can type this command yourself, or choose an installed library from the “sketch / import library” menu.

#include <Servo.h>

The servo library adds new commands that let you control a servo. To prepare the Arduino to control a servo, you must first create a Servo “object” for each servo (here we’ve named it “servo”), and then “attach” it to a digital pin (here we’re using digital pin 6).

Servo servo;
servo.attach(6);

The servo in this kit doesn’t spin all the way around, but they can be commanded to move to a specific position. We use the servo library’s write() command to move a servo to a specified number of degrees(0 to 160). Remember that the servo requires time to move, so give it a short delay() if necessary.

servo.write(160);

Troubleshooting

Servo Not Twisting

Even with colored wires it is still shockingly easy to plug a servo in backward. This might be the case.

Still Not Working

A mistake we made a time or two was simply forgetting to connect the power (red and brown wires) to +5 volts and ground.

Fits and Starts

If the servo begins moving then twitches, and there’s a flashing light on your MicroView, the power supply you are using is not quite up to the challenge. Try using a USB adapter that provides more current.

Still No Success?

A broken circuit is no fun, send us an e-mail and we will get back to you as soon as we can: TechSupport@sparkfun.com

Experiment 8: Piezo Buzzer

Introduction

In this circuit, we’ll again bridge the gap between the digital world and the analog world. We’ll be using a Piezo buzzer that makes a small “click” when you apply voltage to it (try it!). By itself that isn’t terribly exciting, but if you turn the voltage on and off hundreds of times a second, the buzzer will produce a tone. And if you string a bunch of tones together, you’ve got music! This circuit and sketch will play a classic tune. We’ll never let you down!

Parts Needed

You will need the following parts:

  • 1x Piezo Buzzer
  • 2x Jumper Wires

Breadboard Setup

Hook up your circuit as pictured below:

Circuit08

MicroView Arduino Code

language:c
#include <MicroView.h>
// adapted from SparkFun Inventor Kit https://www.sparkfun.com/products/12001
// Please download the original source code for detail comment of the source code
// http://cdn.sparkfun.com/datasheets/Kits/SIK%20Guide%20Code.zip

const int buzzerPin = A0;
const int songLength = 18;
char notes[] = "cdfda ag cdfdg gf "; // a space represents a rest
int beats[] = {1,1,1,1,1,1,4,4,2,1,1,1,1,1,1,4,4,2};

int tempo = 150;

void setup() 
{
    uView.begin();
    uView.clear(PAGE);
    pinMode(buzzerPin, OUTPUT);
}

void loop() 
{
    int i, duration;

    for (i = 0; i < songLength; i++) // step through the song arrays
    {
        duration = beats[i] * tempo;  // length of note/rest in ms

        if (notes[i] == ' ')          // is this a rest? 
        {
            uView.print(" ");
            uView.display();
            delay(duration);            // then pause for a moment
        }
        else                          // otherwise, play the note
        {
            uView.print(notes[i]);
            uView.display();
            tone(buzzerPin, frequency(notes[i]), duration);
            delay(duration);            // wait for tone to finish
        }
        delay(tempo/10);              // brief pause between notes
    }

    // We only want to play the song once, so we'll pause forever:
    while(true){}
    // If you'd like your song to play over and over,
    // remove the above statement
}


int frequency(char note) 
{
    // This function takes a note character (a-g), and returns the
    // corresponding frequency in Hz for the tone() function.

    int i;
    const int numNotes = 8;  // number of notes we're storing

    // The following arrays hold the note characters and their
    // corresponding frequencies. The last "C" note is uppercase
    // to separate it from the first lowercase "c". If you want to
    // add more notes, you'll need to use unique characters.

    // For the "char" (character) type, we put single characters
    // in single quotes.

    char names[] = { 'c', 'd', 'e', 'f', 'g', 'a', 'b', 'C' };
    int frequencies[] = {262, 294, 330, 349, 392, 440, 494, 523};

    // Now we'll search through the letters in the array, and if
    // we find it, we'll return the frequency for that note.

    for (i = 0; i < numNotes; i++)  // Step through the notes
    {
        if (names[i] == note)         // Is this the one?
        {
            return(frequencies[i]);     // Yes! Return the frequency
        }
    }
    return(0);  // We looked through everything and didn't find it,
    // but we still need to return a value, so return 0.
}

What You Should See

You should see - well, nothing; but you should be able to hear a song. If it isn’t working, make sure you have assembled the circuit correctly and verified and uploaded the code to your MicroView or see the troubleshooting tips below.

Code to Note

Up until now we’ve been working solely with numerical data, but the Arduino can also work with text. Characters (single, printable, letters, numbers and other symbols) have their own type, called “char”. When you have an array of characters, it can be defined between double-quotes (also called a “string”), OR as a list of single-quoted characters.

char notes[] = "cdfda ag cdfdg gf ";
char names[] = {'c','d','e','f','g','a','b','C'};

One of Arduino’s many useful built-in commands is the tone() function. This function drives an output pin at a certain frequency, making it perfect for driving buzzers and speakers. If you give it a duration (in milliseconds), it will play the tone then stop. If you don’t give it a duration, it will keep playing the tone forever (but you can stop it with another function, noTone() ).

tone(pin, frequency, duration);

Troubleshooting

No Sound

Given the size and shape of the piezo element it is easy to miss the right holes on the breadboard. Try double checking its placement.

Can’t Think While the Melody is Playing

Just pull up the piezo element whilst you think, upload your program then plug it back in.

Still No Success?

A broken circuit is no fun, send us an e-mail and we will get back to you as soon as we can: TechSupport@sparkfun.com

Experiment 9: Spinning a Motor

Introduction

Remember before when you played around with a servo motor? Now we are going to tackle spinning a motor. This requires the use of a transistor, which can switch a larger amount of current than the MicroView can. When using a transistor, you just need to make sure its maximum specs are high enough for your use. The transistor we are using for this circuit is rated at 40V max and 200 milliamps max – perfect for our toy motor! When the motor is spinning and suddenly turned off, the magnetic field inside it collapses, generating a voltage spike. This can damage the transistor. To prevent this, we use a “flyback diode”, which diverts the voltage spike around the transistor.

Parts Needed

You will need the following parts:

  • 1x 330Ω resistor (Orange Orange Brown Gold)
  • 1x Transistor
  • 1x Diode
  • 1x Motor
  • 4x Jumper Wires

Breadboard Setup

Pay close attention when building this circuit as there are two polarized parts that must be inserted into the breadboard correctly in order for this circuit to work.

The first polarized part is the transistor.

transistor

The second is the diode.

diode

Hook up the rest of your circuit as pictured below:

Circuit09

MicroView Arduino Code

language:c
#include <MicroView.h>      // include MicroView library

int motorPIN = 3;           // set motor control pin
MicroViewWidget *widget;    // declare widget pointer

void setup() {                
    uView.begin();          // start MicroView
    uView.clear(PAGE);      // clear page
    pinMode(motorPIN, OUTPUT);      // initialize the digital pin as an output.
    widget = new MicroViewGauge(32,24,90,255,WIDGETSTYLE1);     // set widget as gauge STYLE1
    setPwmFrequency(motorPIN,1);    // set PWM frequency to about 31K
}

void loop() {
    for (int i=90;i<255;i+=10) {    // step i from 90 to 255 by step of 10
        widget->setValue(i);        // set i value to gauge
        uView.display();            // display gauge
        analogWrite(motorPIN, i);   // set the DUTY cycle of the motorPIN
        delay(500);                 // delay 500 ms
    }
}

// function to set the frequency of the PWM pin
// adapted from http://playground.arduino.cc/Code/PwmFrequency
void setPwmFrequency(int pin, int divisor) {
    byte mode;
    if(pin == 5 || pin == 6 || pin == 9 || pin == 10) {
        switch(divisor) {
        case 1: mode = 0x01; break;
        case 8: mode = 0x02; break;
        case 64: mode = 0x03; break;
        case 256: mode = 0x04; break;
        case 1024: mode = 0x05; break;
        default: return;
        }
        if(pin == 5 || pin == 6) {
            TCCR0B = TCCR0B & 0b11111000 | mode;
        } else {
            TCCR1B = TCCR1B & 0b11111000 | mode;
        }
    } else if(pin == 3 || pin == 11) {
        switch(divisor) {
        case 1: mode = 0x01; break;
        case 8: mode = 0x02; break;
        case 32: mode = 0x03; break;
        case 64: mode = 0x04; break;
        case 128: mode = 0x05; break;
        case 256: mode = 0x06; break;
        case 1024: mode = 0x7; break;
        default: return;
        }
        TCCR2B = TCCR2B & 0b11111000 | mode;
    }
}

What You Should See

The DC Motor should spin if you have assembled the circuit’s components correctly, and also verified/uploaded the correct code. If your circuit is not working check the troubleshooting section below.

Code to Note

In this code, we use the command setPwmFrequency(motorPIN,1); to call a function (an encapsulated section of resuable code) for setting the PWM Frequency. Pulse Width Modulation, or PWM, is a technique for getting analog results with digital means. Digital control is used to create a square wave, a signal switched between on and off.

The setPwmFrequency function is defined on line 25.

void setPwmFrequency(int pin, int divisor){
  ...
}

Troubleshooting

USB Port not providing enough power or tripping?

Some USB ports don’t provide enough current to spin the motor. If that’s the case with a USB port on your computer we recommend powering your MicroView and motor with a powered USB hub or by using batteries. Checkout this circuit for powering your motor with batteries.

Motor Not Spinning

If you sourced your own transistor, double check with the data sheet that the pinout is compatible with a P2N2222AG (many are reversed).

Still No Luck

If you sourced your own motor, double check that it will work with 5 volts and that it does not draw too much power.

Still No Success?

A broken circuit is no fun, send us an e-mail and we will get back to you as soon as we can: TechSupport@sparkfun.com

Experiment 10: Relays

A relay is basically an electrically controlled mechanical switch. Inside that harmless looking plastic box is an electromagnet that, when it gets a jolt of energy, causes a switch to trip. In this circuit, you’ll learn how to control a relay like a pro – giving your MicroView even more powerful abilities!

Parts Needed

You will need the following parts:

  • 2x 330Ω resistor (Orange Orange Brown Gold)
  • 1x Transistor
  • 1x Diode
  • 1x Yellow LED
  • 1x Red LED
  • 1x Relay
  • 11x Jumper Wires

Breadboard Setup

Hook up your circuit as pictured below. Be cautious of polarized parts. Refer back to previous experiments to see how each component is oriented. For the relay, pay attention to which side has two pins and which has three pins.

Circuit10

MicroView Arduino Code

language:c
#include <MicroView.h>          // include MicroView library

int relayPin = 2;               // set relayPin as pin 2 of Arduino

void setup() {                
    uView.begin();              // start MicroView
    uView.clear(PAGE);          // clear page
    pinMode(relayPin, OUTPUT);  // initialize the digital pin as an output.
}

void loop() {
    uView.setCursor(0,0);           // set cursor at 0,0
    uView.print("YELLOW");          // print YELLOW text
    uView.display();                // display 
    digitalWrite(relayPin, HIGH);   // turn the RELAY ON (HIGH is the voltage level)
    delay(1000);                    // wait for a second

    uView.setCursor(0,0);       
    uView.print("RED   ");
    uView.display();
    digitalWrite(relayPin, LOW);    // turn the RELAY off by making the voltage LOW
    delay(1000);                    // wait for a second
}

What You Should See

You should be able to hear the relay contacts click, and see the two LEDs alternate illuminating at 1-second intervals. If you don’t, double-check that you have assembled the circuit correctly, and uploaded the correct sketch to the MicroView. Also, see the troubleshooting tips below.

Code to Note

When we turn on the transistor, which in turn energizes the relay’s coil, the relay’s switch contacts are closed. This connects the relay’s COM pin to the NO (Normally Open) pin. Whatever you’ve connected using these pins will turn on. (Here we’re using LEDs, but this could be almost anything.)

digitalWrite(relayPin, HIGH);

The relay has an additional contact called NC (Normally Closed). The NC pin is connected to the COM pin when the relay is OFF. You can use either pin depending on whether something should be normally on or normally off. You can also use both pins to alternate power to two devices, much like railroad crossing warning lights.

digitalWrite(relayPin, LOW);

Troubleshooting

LEDs Not Lighting

Double-check that you’ve plugged them in correctly. The longer lead (and non-flat edge of the plastic flange) is the positive lead.

No Clicking Sound

The transistor or coil portion of the circuit isn’t quite working. Check the transistor is plugged in the right way.

Not Quite Working

The included relays are designed to be soldered rather than used in a breadboard. As such you may need to press it in to ensure it works (and it may pop out occasionally). When you’re building the circuit be careful not to mix up the temperature sensor and the transistor, they’re almost identical.

Still No Success?

A broken circuit is no fun, send us an e-mail and we will get back to you as soon as we can: TechSupport@sparkfun.com

Experiment 11: Soft Potentiometer

Introduction

In this circuit you’ll work with a soft potentiometer. Back in Experiment 2, you used a regular potentiometer to vary the resistance of a circuit. With the soft pot, you can do all the same things you would with a regular potentiometer. However, this time the interface changes, showing you how you can accomplish the same tasks with different forms of the same technology or with different technologies altogether.

Parts Needed

You will need the following parts:

  • 1x Soft Potentiometer
  • 2x 330Ω resistor (Orange Orange Brown Gold)
  • 2x Jumper Wires

Breadboard Setup

Hook up your circuit as pictured below. The soft pot is polarized, so pay attention to its orientation. The side with the adhesive back is the bottom, and the side with the touch strips is the top (as pictured below).

Circuit11

MicroView Arduino Code

language:c
#include <MicroView.h>              // include MicroView library

MicroViewWidget  *widget;           // declare widget pointer

int sensorValue;                    // declare variable to store sensor value
int sensorPin=A0;                   // declare sensor pin as A0 of Arduino  

void setup() {
  uView.begin();                    // start MicroView  
  uView.clear(PAGE);                // clear page
  widget = new MicroViewSlider(0,0,0,1024, WIDGETSTYLE1);   // declare widget as slider
  pinMode(sensorPin, INPUT);                // set sensor pin as INPUT
}

void loop () {
  sensorValue=analogRead(sensorPin);        // read and store sensor value
  widget->setValue(sensorValue);            // set sensor value to widget
  uView.display();                          // display widget
  delay(20);                                // delay 20 ms
}

What You Should See

As you move a blunt long object (like your finger) up and down the soft potentiometer, the MicroView Slider Widget should change it’s value accordingly. If it isn’t working, make sure you have assembled the circuit correctly and verified and uploaded the code to your MicroView, or see the troubleshooting tips below.

Troubleshooting

Bizarre Results

The most likely cause of this is if you’re pressing the potentiometer in more than one position. This is normal and can actually be used to create some neat results.

Still No Success?

A broken circuit is no fun, send us an e-mail and we will get back to you as soon as we can: TechSupport@sparkfun.com

Resources and Going Further

Congratulations, you have completed the SparkFun Inventor’s Kit for MicroView! From here, the world is your oyster. Here are some more resources to aid in your understanding of the MicroView.

Check out these other experiment guides for more learning fun!