So, in the spirit of teaching I decided to write a post on the Arduino Pro Mini and the Parallax Ultrasonic sensor. I went the extra mile and added audio feedback via a 8-ohm mini speaker, visual feedback via a BlinkM Led and included an external power source.

You will need the following components to build an ultra-sonic beeping thingamajiggy:

Lets start by addressing the Arduino Pro Mini.
The Arduino Pro Mini is intended for advanced users who require flexibility, low-cost, and small size. Please note that there are two versions of the board, one that operates at 5V (like most Arduino boards), and one that operates at 3.3V. Both boards come with the minimum of components (no on-board USB or pin headers) to keep the cost down. The Arduino Site has an overview on the Arduino Pro Mini, I suggest you at least review the page to get familiar with the Inputs and Outputs of the board. The Arduino Pro Mini is programmed using a FTDI Cable or in my case a FTDI Basic Breakout board.

Since we are using a breadboard to prototype the ultra-sonic beeping thingamajiggy, I suggest you solder the break away headers to the Arduino, in fact, I always suggest creating connectors for sensors rather than just soldering them to the Arduino. A quick soldering tip is to stick the headers into a breadboard and place the Arduino board on top. Then solder all headers. Make sure you also solder headers to Analog 4 and 5, which you will find on the board near the ATmega328 chip. You should now have something that resembles this:

Now, lets hook up some power. This part is very important, you don’t want to fry your board so pay close attention. Locate The power pins on your Arduino Pro Mini:

* RAW. For supplying a raw (unregulated) voltage to the board.
* VCC. The regulated 3.3 or 5 volt supply.
* GND. Ground pins.

The VCC pin on the Arduino Pro Mini is bypassing the regulator and you should NOT CONNECT ANY POWER SUPPLY ABOVE 5 VOLTS to this pin. In most cases you will use the RAW pin to connect a power supply (up to 12V) in need of regulation.

The enclosed 4 “AA” battery holder from Radio Shack, has a voltage of 6 volts, therefore I have no other choice but to connect it to the unregulated RAW pin.

ONLY USE THE VCC PIN IF YOU ARE SURE YOU HAVE A REGULATED 5 VOLT POWER SOURCE.

I took the battery enclosure and added a 2 pin screw terminal to the end of the wires to make the connection to the breadboard easier.

Make sure the battery enclosure switch is on the OFF state and then connect the power supply to the breadboard.
Add the ground (black) wire from the battery enclosure to the blue rail of the breadboard.
Add the power (red) wire from the battery enclosure to the red rail of the breadboard.

Grab some jumper wires and connect a wire from the blue rail of the breadboard to the GND pin on the Arduino (green wire in image below). Connect a wire from the red rail of the breadboard to the RAW pin on the Arduino (blue wire in image below).

Next lets connect the ultrasonic sensor.

You will notice the sensor only has 3 pins, the 5V pin, the GND pin and the SIG (signal) pin. You can easily place the senor onto your breadboard and wire it up. I had some extra Male/Female jumper wires, so I utilized them to free up some space on the breadboard.
Connect the GND pin of the sensor to the blue rail on the breadboard (black wire in image below).
Connect the 5V pin of the sensor to the red rail on the breadboard (red wire in image below).
Connect the SIG pin of the sensor to pin 7 of the Arduino (blue wire in image below).

If connecting the sensor is all you cared about, you could stop here. All you have left to do is connect the FTDI Cable or FTDI Basic breakout board to the Arduino Pro Mini. Open up the Arduino IDE:
Select Tools -> Serial Port
and select the correct usb port (mac) /dev/tty.usbserial-XXXXXXXX.
Select Tools->Board
and select Lilypad Arduino w/Atmega328 (I’m running Arduino IDE 018 and for some unknown reason this selection is the only one which enables an upload without errors).
Select File-> Examples->Sensors->Ping
and upload the sketch.
Your done! If you open up the Serial Monitor, it will display the distance being detected from the sensor in inches and cm’s.

Moving forward, lets add the BlinkM RGB Led. If you read my previous post on the BlinkM you will be familiar with the process. If not, grab your BlinkM and lets get familar with it.

The BlinkM is a networkable and programmable full-color RGB LED. It has a small AVR micro-controller on board to allow a user to digitally control the LED over a simple I2C interface. The Arduino will communicate with the BlinkM, using the Wire library so we don’t have to worry about the details of I2C. If you haven’t already checked out the BlinkM support page please do so, it has a bunch of perks you should be aware of. Take a look at the print on the board itself. You will notice PWR and I2C printed directly on the board, take mental note because that’s what we will be interfacing with shortly. BlinkM needs two wires for power and two for data. We will be connecting to the Arduino analog pins 4 & 5 which double as the I2C data signal (“SDA”) and clock signal (“SCL”), respectively.

Place the BlinkM onto your breadboard and connect a wire (red wire in image below) from the red rail on the breadboard to the positive (+) symbol printed on the BlinkM. Connect a wire (brown wire in image below) from the blue rail on the breadboard to the ground (-) symbol printed on the BlinkM.

Proceed by connecting a wire (blue wire in image below) to analog 4 of the Arduino Pro Mini. Connect the other end of the wire to the ‘d’ (I2C SDA) symbol printed on the BlinkM.
Connect another wire (green wire in image below) to analog 5 of the Arduino Pro Mini. Connect the other end of the wire to the ‘c’ (I2C SCL) symbol printed on the BlinkM.

Next, lets hook up the 8 ohm mini speaker for audio feedback.
Simply connect the black wire from the speaker to the blue rail of the breadboard. Connect the red wire from the speaker to digital pin 7 on the Arduino Pro Mini.

And there you have it. We have completed our simple circuit for an ultra-sonic beeping thingamajiggy.
Lets move onto the code.

The first thing you are going to want to do is connect the FTDI Cable or FTDI Basic breakout board to the Arduino Pro Mini. There are pros and cons to the FTDI Cable vs the FTDI Basic breakout board . The breakout board has TX and RX LEDs that allow you to actually see serial traffic on the LEDs to verify if the board is working, but the board requires a miniB cable. The FTDI Cable is well protected against the elements, but is large and cannot be embedded into a project as easily. The FTDI Basic breakout board uses DTR to cause a hardware reset where the FTDI Cable uses the RTS signal.

I prefer to use the FTDI Basic breakout board to connect to the Arduino pro Mini. Anyhow, connect either the FTDI Cable or Basic breakout board to the Arduino and open up the Arduino IDE.
Select Tools -> Serial Port
and select the correct usb port (mac) /dev/tty.usbserial-XXXXXXXX.
Select Tools->Board
and select Lilypad Arduino w/Atmega328.
Select File->New
and copy the following code to the sketch:
*NOTE you can download my source below*

/*
Code under (cc) by Manuel Gonzalez, www.codingcolor.com
http://creativecommons.org/license/cc-gpl
Digital pin 7 Parallax Ultrasonic Range Finder
Digital Pin 4 8-ohm mini speaker
Analog pins 4 (SDA),5(SCL) I2C communication with BlinkM
*/
#include <Wire.h>
#include "BlinkM_funcs.h"



const int pingPin = 7;
const int speakerPin = 4;
const int blinkm_addr = 9;//address to blinkM
byte r,g,b;

void setup() {
 // Serial.begin(9600);
  pinMode(speakerPin,OUTPUT);
 
  BlinkM_beginWithPower();
  BlinkM_stopScript(blinkm_addr);//stop the BlinkM
  BlinkM_setFadeSpeed(blinkm_addr, 255);//set up fade param
  BlinkM_fadeToRGB(0,0x00,0x00,0x00);//fade all to black
}

void loop()
{

  long duration, inches;
  pinMode(pingPin, OUTPUT);
  digitalWrite(pingPin, LOW);
  delayMicroseconds(2);
  digitalWrite(pingPin, HIGH);
  delayMicroseconds(5);
  digitalWrite(pingPin, LOW);

  pinMode(pingPin, INPUT);
  duration = pulseIn(pingPin, HIGH);

  // convert the time into a distance
  inches = microsecondsToInches(duration);
  /*
  Serial.print(inches);
  Serial.print("in, ");
  Serial.println();
  */
  displayColor(inches);
  delay(100);
}

void displayColor(long inches)
{
  if(inches < 12)
  {
     r = 255;
     g = 0;
     b = 0;
    beep(speakerPin, 2500, 500);
  }else {
     r = 9;
     g = 249;
     b = 17;
  }
 
   BlinkM_fadeToRGB(0, r,  g,  b);
}
void beep(int targetPin, long frequency, long length) {
 
  long delayValue = 1000000/frequency/2; // calculate the delay value between transitions
  long numCycles = frequency * length/ 1000; // calculate the number of cycles for proper timing
 for (long i=0; i < numCycles; i++){
    digitalWrite(targetPin,HIGH);
    delayMicroseconds(delayValue);
    digitalWrite(targetPin,LOW);
    delayMicroseconds(delayValue);
  }
}

long microsecondsToInches(long microseconds)
{
  // According to Parallax's datasheet for the PING))), there are
  // 73.746 microseconds per inch (i.e. sound travels at 1130 feet per
  // second).  This gives the distance travelled by the ping, outbound
  // and return, so we divide by 2 to get the distance of the obstacle.
  // See: http://www.parallax.com/dl/docs/prod/acc/28015-PING-v1.3.pdf
  return microseconds / 74 / 2;
}

Take note of the include.
#include "BlinkM_funcs.h"
It’s a BlinkM Arduino library written by Tod E. Kurt. You will need the BlinkM_funcs.h library which is also availbe in my download.

Upload the code to your Arduino Pro Mini disconnect the FTDI Cable or Basic breakout board and turn the power on.

If all went well, you should have an ultra-sonic beeping thingamajiggy.

Click here to view the embedded video.

Enjoy!
Download Source:
Ultra-Sonic beeping thingamajiggy (7)

Make sure you have all the components needed to recreate this prototype:

Lets start building the prototype.

The first thing I always do when prototyping, is connect the Arduino to a power source either via the USB or an external power supply and then I proceed to wire up the bread board to the Arduino power.

**Warning**
I advise you to read datasheets for the components that you will be working with, be aware that you may need to disconnect all power before connecting or disconnecting components to a circuit.

I simply take a Red wire from the Arduino 5v(+) and connect it to the red rail on the breadboard. Then take a Black wire and connect it to the GND of the Arduino and connect it to the blue rail on the Breadboard. We now have power!

The next step is to connect the Photocell to the breadboard and wire it up to the Arduino.
Add the Photocell to the board. Connect a Red wire from the red rail on the board to one of the leads of the Photocell.

Now, lets add the 10k resistor. Connect one end of the resistor to the other lead of the Photocell.

Connect a wire from the same Photocell lead that the resistor resides on to Analog 0 on the Arduino. Then ground the resistor by adding a black wire from the blue rail on the breadboard to the other end of the resistor, like so.

You have successfully created a basic Photocell circuit. Now, for a sanity check copy the code below, open up the Arduino Ide and create a new photocellTest.pde file, compile, upload to your Arduino and view the output of the Photocell in the serial monitor.
/*
This example shows the output of an analogRead() of a Photocell.
By M.Gonzalez
www.codingcolor.com
The example code is in the public domain
*/
int photocellPin = 0;// Photocell connected to analog pin 0
int photocellVal = 0; // define photocell variable


void setup() {
  Serial.begin(9600);
  pinMode(photocellPin, INPUT);
}
void loop() {
  photocellVal = analogRead(photocellPin);// read the analog from photocell
  Serial.println( photocellVal);    // print to screen
  delay(30);

 }

If the Photocell circuit is correct you should be viewing numbers printed in your serial monitor. Place your hand over the resistor to simulate darkness and witness the numbers change. We will be using the Photocell output as a switch to change the color of the BlinkM for red to blue. Grab your BlinkM and lets get familiar with it.

The BlinkM is a networkable and programmable full-color RGB LED. It has a small AVR micro-controller on board to allow a user to digitally control the LED over a simple I2C interface. The Arduino will communicate with the BlinkM, using the Wire library so we don’t have to worry about the details of I2C. If you haven’t already checked out the BlinkM support page please do so, it has a bunch of perks you should be aware of. Take a look at the print on the board itself. You will notice PWR and I2C printed directly on the board, take mental note because that’s what we will be interfacing with shortly. BlinkM needs two wires for power and two for data. We will be connecting to the Arduino analog pins 4 & 5 which double as the I2C data signal (“SDA”) and clock signal (“SCL”), respectively. Place the BlinkM onto your breadboard.

Power up the BlinkM by connecting a Red wire from the red rail on the breadboard to the positive (+) symbol printed on the BlinkM. Connect a Black wire from the blue rail on the breadboard to the ground (-) symbol printed on the BlinkM. If the power connections are correct, you will notice a pre-programmed color sequence which comes shipped as a default with the BlinkM.

Proceed by hooking up the BlinkM to the Arduino. Grab a breadboard wire and connect it to analog 4 of the Arduino. Connect the other end of the wire to the ‘d’ (I2C SDA) symbol printed on the BlinkM. Grab another breadboard wire and connect it to analog 5 of the Arduino. Connect the other end of the wire to the ‘c’ (I2C SCL) symbol printed on the BlinkM.

The prototype circuit is complete. Now, lets focus on the code. I wrote a simple sketch which utilizes Tod E. Kurt’s BlinkM Arduino library to fade the colors of the LED from red to blue. You will need the BlinkM_funcs.h library which you can obtain from the BlinkM example files. Better yet, I have made it available with my source code down below. Either way, you will have to place the BlinkM_funcs.h in the same directory as the Arduino sketch and “#include” it at the top to import all the functions. The BlinkM has many features, and I would advise you to download the datasheet if your interested, anyhow, here’s my simple sketch.

/*
Code under (cc) by Manuel Gonzalez, www.codingcolor.com
http://creativecommons.org/license/cc-gpl
Analog pin 0 photocell
Analog pins 4 (SDA),5(SCL) I2C communication with BlinkM
*/
#include <Wire.h>
#include "BlinkM_funcs.h"


int blinkm_addr = 9;//default address to blinkM
byte r,g,b;

int photocellPin = 0;// Photocell connected to analog pin 0
int photocellVal = 0; // define photocell variable
int minLight = 100;//min light threshold
int maxLight = 100;//max light threshold
int ledState = 0; //state of the led 0 = dark, 1 = light


void setup() {
 
  pinMode(photocellPin, INPUT);

  BlinkM_beginWithPower();
  BlinkM_stopScript(blinkm_addr);//stop the BlinkM
  BlinkM_setFadeSpeed(blinkm_addr, 1);//set up fade param for a smooth fade

}
void loop() {
 
  photocellVal = analogRead(photocellPin);//get photocells value

//conditional which determines if its dark or not
  if (photocellVal < minLight and ledState == 1){
    displayColor(0);
  }                      
    else if (photocellVal > maxLight and ledState == 0){
    displayColor(1);

  }
  delay(1000);  
}

void displayColor(int val)
{

  switch(val)
  {
    case 0:
      //0;34;102 Royal Blue 5
      r = 0;
      g = 34;
      b = 102;
      ledState = 0;
      break;
    case 1:
      //255;0;0 RED
      r = 255;
      g = 0;
      b = 0;
      ledState = 1;
    break;
   }
   
    BlinkM_fadeToRGB(blinkm_addr, r,  g,  b);//call which fades to desired color
}

You will notice in the displayColor() method I’m setting R,G,B values to change the color of the blinkM. BlinkM supports two different color models: RGB and HSB. RGB is the color model most people are familiar with so that’s why I used it. Here’s an online resource I use for RGB mapping. And there you have it, a simple prototype using Arduino a photocell and a BlinkM to create an interesting nightlight or ambient light.
Enjoy!.

Download Source:
The Arduino, Photocell and BlinkM example. (4)

Unfortunately both DS1337 and DS1307 chips seem to drift minutes per month, especially in extreme temperature ranges. So, I continued scouring the internet, until I found a thread that mentioned the ChronoDot RTC by MaceTech. The ChronoDot RTC is an extremely accurate real time clock module, based on the DS3231 temperature compensated RTC (TCXO). The ChronoDot claims to drift less than a minute per year, which makes the ChronoDot acceptable for my project. MaceTech provides a basic Arduino example using the Arduino Wire library which reads and prints the hours, minutes, and seconds from the ChronoDot. I basically borrowed the code and expanded upon it. I utilize a basic 16×2 LCD to output the time and date from the ChronoDot and I added the ability to change the hour and minutes via 2 push buttons.

The Arduino communicates with the ChronoDot, using the I2C standard interface. I2C is a serial data bus protocol that allows multiple devices to connect to each other with fairly slow data transfer rates. Thanks to the Arduino Wire library we don’t have to worry about the details. Moving forward you will need the following items to recreate my example:

Arduino Duemilanove,

a character LCD display with 0.1 header 16 pins long and a 10K potentiometer to adjust the contrast on the display,

a 6″ breadboard,

breadboarding wire,

a ChronoDot module,

2 10Kohm 1/2W 5% Carbon Film Resistors

and 2 push buttons.

The first thing you are going to do is connect your LCD to the Arduino. If you are not familiar with the steps, please read my post on connecting a character LCD to an Arduino. I placed my LCD as far left as I could on my 6″ breadboard to allow space for the other components.

The next step is to add the push buttons. The push buttons will enable the ability to set the hour and minutes, if needed.

Grab a push button, and place it on the breadboard. Grab a 10K resistor and connect one end of the resistor to the ground on the breadboard and then connect the other end of the resistor to one leg of the button, remember to leave space between the leg of the button and the resistor. Now, grab breadboarding wire and connect one end of the wire to the power supply on the breadboard, then connect the other end of the wire to the other leg of the button. You have completed a simple button circuit, grab the other push button and repeat the steps, your breadboard should resemble this:

Lets connect a button to the Arduino. Grab a breadboarding wire and connect one end of the wire to digital pin 6 of the Arduino. Connect the other end of the wire to the breadboard between the resistor and the one (grounded) leg of the push button. You have now created a button connection for the hour. Do the same for the minutes button but instead connect one end of a breadboarding wire to digital pin 7 of the Arduino. Connect the other end of the wire to the breadboard between the resistor and the one (grounded) leg of the push button. Your breadboard should look like this:

Now for the final piece, the good ole RTC Module. If you purchased the ChronoDot from Macetech, you should have received the lithium CR2032 battery. The battery allows timekeeping in the absence of external power, you will need to attach the battery to the module. The two solder pads on the PCB are marked + and -. The battery provided with the ChronoDot has a metal tab that runs from the top (positive, +) of the battery and down to the same level as the bottom (negative, -) side of the battery. You will need to solder the tab leading from the top of the battery to the + pad on the ChronoDot. The result should look like this:

Now, place the RTC module on the breadboard. Run breadboarding wire from the ground of the breadboard to the ground of the RTC. Run another strand of wire from the power supply of the breadboard to the VCC line of the RTC:

Grab two more wires to make the final connections to the RTC. Connect one end of a wire to the Arduino Analog pin 5. Now, connect the other end of the wire to the SCL pin of the ChronoDot RTC module on the breadboard. Grab the other wire and connect one end of the wire to the Arduino’s Analog pin 4. Connect the other end of the wire to the SDA pin of the RTC module on the breadboard. You have now connected the wires which communicate between the Arduino and the ChronoDot. Your completed breadboard should resemble this:

All there is left to do, is upload the example sketch below.
/*
 Code under (cc) by Manuel Gonzalez, www.codingcolor.com
 http://creativecommons.org/license/cc-gpl
 Pins 12, 11, 5, 4, 3, 2 to LCD
 Analog pins 4 (SDA),5(SCL) to Chronodot
 Pins 6 (hour), 7(min) buttons
*/

#include <Wire.h>
#include <LiquidCrystal.h>


const int hourButtonPin = 6;
const int minButtonPin = 7;

LiquidCrystal lcd(12, 11, 5, 4, 3, 2);

int hourButtonState;
int minButtonState;

int seconds; //00-59;
int minutes; //00-59;
int hours;//1-12 - 00-23;
int day;//1-7
int date;//01-31
int month;//01-12
int year;//0-99;




void setup()
{

  pinMode(hourButtonPin,INPUT);
  pinMode(minButtonPin,INPUT);

  Wire.begin();
  lcd.begin(16, 2);
 
  hourButtonState = 0;
  minButtonState = 0;
  ////////////////////////////////
  seconds = 00;
  minutes = 26;
  hours = 17;
  day = 7;
  date = 31;
  month = 5;
  year = 10;
  //initChrono();//just set the time once on your RTC
  ///////////////////////////////
}

void loop()
{
  check_buttons();
  get_time();
  get_date();
  display_time();
  display_date();
  delay(1000);
 
}
void display_time()
{
  char buf[12];
 
  lcd.setCursor(0, 0);
 
  if(hours == 0)
  {
    lcd.clear();
  }
 
  lcd.print("Time ");  
  lcd.print(itoa(hours, buf, 10));
  lcd.print(":");
 
  if(minutes < 10)
  {
    lcd.print("0");
  }
  lcd.print(itoa(minutes, buf, 10));
 
  lcd.print(":");
 
  if(seconds < 10){
    lcd.print("0");
  }
  lcd.print(itoa(seconds, buf, 10));

}
void display_date()
{
  char buf[12];
 
  lcd.setCursor(0, 1);
  lcd.print("Date ");
 
 if(month < 10){
    lcd.print("0");
  }  
 
  lcd.print(itoa(month, buf, 10));
  lcd.print("/");
  lcd.print(itoa(date, buf, 10));
  lcd.print("/");
 
  if(year < 10){
    lcd.print("0");
  }
 
  lcd.print(itoa(year, buf, 10));
}
void initChrono()
{
  set_time();
  set_date();
}


void set_date()
{
  Wire.beginTransmission(104);
  Wire.send(3);
  Wire.send(decToBcd(day));
  Wire.send(decToBcd(date));
  Wire.send(decToBcd(month));
  Wire.send(decToBcd(year));
  Wire.endTransmission();
}
void get_date()
{
  Wire.beginTransmission(104);
  Wire.send(3);//set register to 3 (day)
  Wire.endTransmission();
  Wire.requestFrom(104, 4); //get 5 bytes(day,date,month,year,control);
  day   = bcdToDec(Wire.receive());
  date  = bcdToDec(Wire.receive());
  month = bcdToDec(Wire.receive());
  year  = bcdToDec(Wire.receive());
}

void set_time()
{
   Wire.beginTransmission(104);
   Wire.send(0);
   Wire.send(decToBcd(seconds));
   Wire.send(decToBcd(minutes));
   Wire.send(decToBcd(hours));
   Wire.endTransmission();
}
void get_time()
{
  Wire.beginTransmission(104);
  Wire.send(0);//set register to 0
  Wire.endTransmission();
  Wire.requestFrom(104, 3);//get 3 bytes (seconds,minutes,hours);
  seconds = bcdToDec(Wire.receive() & 0x7f);
  minutes = bcdToDec(Wire.receive());
  hours = bcdToDec(Wire.receive() & 0x3f);
 
 


 
}
void setHour()
{
  hours++;
  if(hours > 23)
  {
   hours = 0;
   seconds = 0;
   minutes = 0;
  }
  set_time();
 
}
void setMinutes()
{
  minutes++;  
  if(minutes > 59)
  {
   minutes = 0;
   
  }
  seconds=0;
 
  set_time();
 
}
void check_buttons()
{
  hourButtonState = digitalRead(hourButtonPin);
  minButtonState = digitalRead(minButtonPin);
 
  if(hourButtonState == HIGH){
    setHour();
  }
 
  if(minButtonState == HIGH){
    setMinutes();
  }
}
///////////////////////////////////////////////////////////////////////

byte decToBcd(byte val)
{
  return ( (val/10*16) + (val%10) );
}

byte bcdToDec(byte val)
{
  return ( (val/16*10) + (val%16) );
}
//////////////////////////////////////////////////////////////////////

You should now have a running clock.
Enjoy!

Anyhow, at Radio Shack I bought a pack of Photocells, which contained 5 cells of different sizes. I have used Photocells in the past when I built some DIY analog synths, so, I was familiar with them, but I have never integrated them with my Arduino. So, I set out on an adventure to make a simple electronic gadget. The first thing that came to mind was to control a basic LED. I figured it out rather quickly, and realized that I could make an interesting night light with it, if I swapped the basic LED with a ShiftBrite LED, but that’s a recipe for another blog post.

So what the hell is a Photocell?

A Photocell acts as a light sensor and is usually used when you just want to detect light. Photocells are used in toys, appliances and in street lamps that turn themselves on at night. Sometimes known as photo resistors, they look like a small 0.5 to 2 inch disk with two leads out the back. They are inexpensive, low-power, and very easy to use. Photocells are available from a number of online sources and as mentioned at your local Radio Shack (catalog number 276-1657 ).
Technically Photocells are basically a resistor that changes its resistive value (in ohms Ω) depending on how much light the face is exposed to. Photocell properties vary widely from model to model, they tend to be very inaccurate and they shouldn’t be used to try to determine precise light levels you should only use them to determine basic light changes. Photocells are non-polarized and are pretty hardy as long as you avoid bending the leads right at the epoxied sensor.

Enough technical talk lets get crackin’.
Make sure you have all the components needed to make this simple circuit:

The first thing I always do when prototyping, is connect the Arduino to a power source either via the USB or external. I then proceed to power up the breadboard.

I simply take a Red wire from the Arduino 5v(+) and connect it to the red rail on the breadboard. Then I connect a Red wire from the red rail on the breadboard to the other red rail on the opposite side of the breadboard. I then take a Black wire and connect it to the GND of the Arduino and connect it to the blue rail on the Breadboard. I then follow suit by connecting a Black wire from the blue rail on the breadboard to the other blue rail on the opposite side of the breadboard. We now have power!

The next step is to connect the Photocell to the breadboard and wire it up to the Arduino.
Add the Photocell to the board. Connect a Red wire from the red rail on the board to one of the leads of the Photocell, remember Photocells are non-polarized, which means you can connect them up ‘either way’ and they’ll work just fine.

Now, lets add the 10k resistor. Connect one end of the resistor to the other lead of the Photocell.

Connect a wire from the same Photocell lead that the resistor resides on to Analog 0 on the Arduino. Then ground the resistor by adding a black wire from the blue rail on the breadboard to the other end of the resistor, like so.

You have now created a basic Photocell circuit.
The code below is all you would need to get values from the Photocell. You could easily copy the code below, create a new photocellTest.pde file, compile, upload to your Arduino and view the output of the Photocell in the Serial monitor.
/*
This example shows the output of an analogRead() of a Photocell.
By M.Gonzalez
www.codingcolor.com
The example code is in the public domain
*/
int photocellPin = 0;// Photocell connected to analog pin 0
int photocellVal = 0; // define photocell variable


void setup() {
  Serial.begin(9600);
  pinMode(photocellPin, INPUT);
}
void loop() {
  photocellVal = analogRead(photocellPin);// read the analog from photocell
  Serial.println( photocellVal);    // print to screen
  delay(30);

 }

Due to the inaccuracies of the readings, I would recommend adding a conditional statement as a threshold like so.

/*
This example shows the output of an analogRead() of a Photocell.
By M.Gonzalez
www.codingcolor.com
The example code is in the public domain
*/
int photocellPin = 0;// Photocell connected to analog pin 0
int photocellVal = 0; // define photocell variable


void setup() {
  Serial.begin(9600);
  pinMode(photocellPin, INPUT);
}
void loop() {
  photocellVal = analogRead(photocellPin);// read the analog from photocell
  Serial.println( photocellVal); // output to screen

  if (photocellVal < 100){
    Serial.println("lights on");// output to screen
   }                      
    else if (photocellVal > 100){
    Serial.println("light out");// output to screen
   }
  delay(30);

 }

Moving forward we will add the LED which will be the Night Light.
Grab your LED. You will notice that one lead is longer than the other. The longer lead is the Anode (+) and shorter lead is the Cathode(-), its important to now this, since you need to make sure you are connecting the circuit correctly. Plug the LED into your breadboard taking note of which lead is the Anode (positive) and which is the Cathode (ground). Now run a black wire from the blue rail on the breadboard to the Cathode lead(-) of the LED. Connect one end of the 220 Ohm resistor to the Anode(+) lead of the LED. Connect a wire from the PMW 9 pin on the Arduino to the other end of the 220 Ohm resistor. Your board should now resemble the following:

We have finally completed the simple circuit. Lets now update or existing code. We will add variables for the LED, create a new function which fades the LED in and out, and revise the conditional threshold statement.

/*
This example shows the output of an analogRead() of a Photocell.
By M.Gonzalez
www.codingcolor.com
The example code is in the public domain
*/

int photocellPin = 0;// Photocell connected to analog pin 0
int photocellVal = 0; // define photocell variable
int ledPin = 9;// LED connected to digital pin 9
int ledState = 0;//state of the led
int fadeDown = 30;//delay per fade
int fadeUp = 20;//delay per fade
int minLight = 100;//min light threshold
int maxLight = 100;//max light threshold


void setup() {
 //Serial.begin(9600);
  pinMode(photocellPin, INPUT);
  pinMode(ledPin, OUTPUT);
}
void loop() {
  photocellVal = analogRead(photocellPin);

  if (photocellVal < minLight and ledState == 0){
    fadeLed(1);
    //Serial.println("fade up");
  }                      
    else if (photocellVal > maxLight and ledState == 1){
    fadeLed(0);
   // Serial.println("fade down");
  }
   

 
}

void fadeLed(int num){
  if (num == 1){
     for(int fadeValue = 0 ; fadeValue <= 255; fadeValue +=5) {
     analogWrite(ledPin, fadeValue);            
     delay(fadeUp);                            
    }
     ledState = 1;
   
 }
  else{  
     for(int fadeValue = 255 ; fadeValue >= 0; fadeValue -=5) {
     analogWrite(ledPin, fadeValue);            
     delay(fadeDown);                            
  }
   ledState = 0;
 }

 
}

That pretty much concludes my Night Light prototype. Like I mentioned at the beginning of this post, I plan to tinker around with this base code and circuit and add a brighter LED. I’m awaiting on both a ShiftBrite LED and a BlinkM to arrive in my mail box. Till then happy tinkering.