The Visual programing paradigm easily allows you to create prototypes by manipulating graphical API elements on the system rather than by specifying them textually as in traditional programming languages. These system API elements are referred to as patches and are connected to create a composition. As you work with a composition, you can visually see the results in a viewer window, no compilation required.

The following is a really simple Quartz example utilizing an Arduino Micro-Controller as an input. We will be connecting a pot (potentiometer ) to the Arduino and measuring the amount of voltage resistance as an analog value. The Arduino will convert the value to a number between 0 and 1023 and it will print the number to the serial port . We will set up Quartz to monitor the serial port and to display the incoming value in its viewer.

REQUIRED HARDWARE :

REQUIRED SOFTWARE :

I’m going to assume you are familiar with the Arduino board and you have already installed the Arduino Ide on your computer. If not, here’s a basic tutorial to get you up and running. I will walk you through the necessary steps to connect Quartz Composer to the Arduino.

Let’s start off by identifying your operating system version, and determine if your Mac’s graphics card supports Quartz Extreme or Core Image.

*NOTE : If you use Mac OS X v10.6, your Mac already meets the requirements for Quartz Extreme and Core Image graphics.

The following steps will help you identify your graphics card support for Quartz Extreme or Core Image.

(1) Open System Profiler (in /Applications/Utilities).
(2) Click “Graphics/Displays” under Contents.
(3) In the right pane under “Display,” look for the Quartz Extreme and Core Image lines; next to each, you will see either
“Supported” or “Not Supported.”

Computers that have a Core Image capable graphics card will sometime display “Hardware Accelerated” and those that do not will have software written in system profiler like so: “Software (Titanium PowerBook G4) ”

As you can see my Macbook Pro has the muscles needed to continue on to the next step of installing Apple’s Xcode suite of tools. If you haven’t already registered as an Apple Developer, (all the cool kids are doing it) this is the perfect opportunity to do so. The main reason to register is to be able to access the downloads section of the Developer Tools and of course to get support from Apple if ever needed. You don’t have to join the paid program, choose the FREE option.

Here’s the direct link to the Apple Developer tools section (you must be logged in to Apple Support to access the page). Peruse the list, download and install a compatible version of Xcode for your current operating system.

Once you have installed Xcode, you now have access to the Quartz Composer application. Quartz Composer is located under:

/Developer/Applications
(not in the standard/Applications directory)

Select the Quartz Composer.app icon and drag it to your dock for easier access. The next thing you need to do is register with Kineme to have access to their media patches. The patch we are most interested in is the Kineme Serial IO plugin (you need to be registered to access the Quartz patch). Once you have downloaded the patch, put it in the following folder:

/Users/[you]/Library/Graphics/Quartz Composer Patches/

If the folder doesn’t already exist, CREATE IT!.

That pretty much covers the software needs for the Quartz Composer end of the equation. Now, lets focus on setting up your Arduino. Grab the Arduino, jumper wire and potentiometer. Connect a wire from one of the outer pins of the potentiometer to the ground pin on the Arduino. Connect another wire to the other outer pin of the potentiometer to the 5 volts pin on the Arduino . Lastly, connect a wire from the middle pin of the potentiometer to the analog input pin 0 on the Arduino.

Connect your Arduino board via USB to your computer and open up the Arduino IDE.
Go to Tools->Serial Port and choose the entry that reads /dev/tty.usbserial-XXXXXXXX. Take note of the Serial port location, we will need to add it as a variable to the Serial IO patch in the Quartz Composer composition.

Next Go to Tools->Board and select your board.

You can either copy, type or download the source for the following Arduino sketch.

/*
This example shows the output of an analogRead() of a Potentiometer.
By M.Gonzalez
www.codingcolor.com
The example code is in the public domain
*/
int potentiometerPin = A0;    // select the input pin for the potentiometer
int potentiometerValue = 0;  // variable to store the value coming from the potentiometer

void setup() {

  Serial.begin(9600);
  pinMode(potentiometerPin, INPUT);
 
}

void loop() {
  // read the value from the potentiometer:
  potentiometerValue = analogRead(potentiometerPin);    
  // send the value to Quartz Composer with line break
  Serial.println( potentiometerValue);  
  delay(1000);
}

The sketch is relatively simple. All it’s doing is reading the input from the pot and printing the data. Upload the Sketch to your Arduino and open your Serial Monitor (click on the button directly to the right of the “Upload” button). You should see a steady stream of numbers ranging from 0-1023, correlating to the position of the pot. As you turn your potentiometer, these numbers will respond almost instantly. If all went well, you can close the Arduino Ide and open up Quartz Composer.

The first thing you will do is create a Blank Composition.

Next, select the Patch Creator button, which will spawn the Patch Creator utility window. The window enables you to browse the available Quartz Composer patches and clips. When you select a patch name, you can read its description and pertinent information about the patch .

In the search bar enter the text “clear”. The results should display the Clear patch. The Clear patch paints the entire rendering destination (Viewer Window) with a constant color and clears the depth buffer. Either double click on the patch or drag it to the composition editor window. If the Viewer Window is open, you will notice that it’s now rendering a black screen. To change the color, you select the Clear patch in the Editor window and click on the Patch Parameters button on the toolbar at the top of the editor window.

The patch parameters pane will be shown to the right of the workspace. The pane provides convenient access for editing input parameters. You will notice that the Clear Color input is set to black, this is where you would change the color if need be.

Next navigate back to the Patch Creator utility window and search for “Serial input”. If you followed the Quartz Composer set up, you will have successfully found the Serial input by Kineme. Double click on the Serial Input patch or drag it to the composition editor window. With the Kineme Serial Input patch selected in the editor window, select the Patch Inspector button on the toolbar to spawn the Patch Inspector utility window. Remember when I told you to take note of the Serial port location of your Arduino, well this is the time when you need it. Enter the location of your USB port, enter the Baud rate (by default 9600) and enter ‘\n’ into the Break String input field.

This Serial patch is all you need to receive data from your Arduino. Whatever the Arduino is printing out, will be available to the Quartz application. It is up to you to handle the data and transform it into a visual representation.

Navigate back to the Patch Creator utility window and run a search for “Image With String”. Double click on the patch or drag it to the composition editor window. Now here’s your first connection. Select the Data output on the Kineme Serial Input patch and connect it to the String input of the Image With String patch.

Navigate back to the Patch Creator utility window and run a search for “Billboard”. Double click on the patch or drag it to the composition editor window. Connect the Image output of the Image With String patch to the Image input on the Billboard patch.

There you have it, you should now be viewing the value of the Arduino pot in the Viewer Window. Turn the pot and the numbers will update in the viewer. This posting introduces you to the possibilities of interaction you can have between Quartz and the Arduino. If you are wondering if you can use Quartz to send data to Arduino, well the answer is yes, but I’ll save that for another post. For now get familiar with Quartz it’s a powerful application, take this example and plug it into a Particle system or make a blur filter. Swap out the pot for a Photocell, get creative!
Enjoy!

The Arduino Pro Mini comes in two flavors, 3.3 volt or 5 volt. I prefer the 5 volt option. I alter the voltage when need be, especially when working with sensors that operate at 3.3V . A few other things you will find a bit different migrating from the Duemilanove are the RAW, VCC and RESET pins. The RAW pin enables you to supply the board with a raw unregulated voltage (5-12 volts, depending on the model). The VCC pins requires a regulated 3.3 or 5 volt supply (once again, depending on the model) to power the board. I usually power the board via the RAW pin and use the VCC pin to output a regulated 5v power source. The RESET pin is typically used to add a reset button to shields which block the one on the board.

You will notice that the board has analog pins 4(sda) and 5(scl) on the interior of the board. Pins 4 and 5 have a specialized functionality. The pins are used to support I2C (TWI) communications using the Wire library. That pretty much sums up the differences between the Duemilanove beginners board and the Arduino Pro Mini. I love the size of the Pro Mini. It compliments most of my prototyping applications and gives me the inputs and outputs I have grown to love from the Duemilanove.

I recommend you take an Arduino Pro Mini and set it up to be Breadboard friendly. To do this you will need a medium size Breadboard, a set of straight headers and (optional) a set of Right Angle breakaway headers. The next steps provide you with info on how to set up your Arduino Pro Mini to be Breadboard friendly.

Take the break away headers and cut them to fit the Arduino Pro Mini. You will need (2) 12 pin headers, (1) 6 pin header and (1) 2 pin header.

Now get your soldering iron out and lets solder the headers onto the board. The first thing I do is solder the 6 pin header to the top of the Arduino board. This is where the Arduino board will connect with the Basic FTDI board. I prefer to use Right Angle headers for the 6 pin. Place the 6 pin header on the Arduino board and flip the board over keeping the header pins in place and solder. Take a pair of wire snipers and snip the excess wire from the bottom of the board to allow the Arduino Mini to set flush up against a Breadboard. You should now have an Arduino board that looks like this (if you used the Right angle header):

Next, grab the medium size Breadboard and insert the 2 pin header into the Breadboard (shorter side of the pins up). Then flip the Arduino board over (backside up) and set the analog A4 and A5 holes of the Arduino onto the header pins. Align the Arduino board parallel to the Breadboard and solder. When you are done grab your snipers and cut the excess wire on the bottom of the Arduino board. You should now have 2 pins sticking out of the top of the Arduino board, enabling access to analog pins 4 and 5.

Placing the headers on a Breadboard prior to soldering helps, keep the Arduino Mini in place. In the next step we use this technique to add the 12 pin headers.

Simply place one of the 12 pin headers (short side of the pins up) onto the Breadboard. Place the Arduino Mini (top side up) onto the header. Take a mental note of the placement of the holes in relation to the Breadboard and place the other 12 pin header in its place. You should now have a stable Arduino Mini sitting on top of the 12 pin headers. All you have left to do is solder the headers in place. The end result should look like this:

That concludes my instructional.

I have one more cool tip for you. Look into Modern Devices wired Breadboard. They make a foolproof beginners PCB board that enables you to transfer your project directly from your solderless breadboard to the PCB, now that’s cool! This is just the tip of the iceberg, I will release other topics primarily featuring the Arduino Pro Mini, so subscribe to my RSS feed to get the latest and greatest on my Arduino adventures.
Till next time, Enjoy!

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 (40)

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. (44)

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) );
}
//////////////////////////////////////////////////////////////////////

Take a look at the setup method in particular
////////////////////////////////
  seconds = 00;
  minutes = 26;
  hours = 17;
  day = 7;
  date = 31;
  month = 5;
  year = 10;
  //initChrono();//just set the time once on your RTC
  ///////////////////////////////

When you upload your sketch for the first time you will want to update the variables to the correct time then, un-comment out the initChrono() to set the clock, upload your sketch and now should 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.