Taking Pictures with Arduino

April 3, 2009 in Tutorials | 64 comments

Have you ever wanted to build your own wearable spy camera, UAV or other small, camera-enabled gizmo, gadget or device? While Arduino provides a wonderful prototyping platform for creating all sorts of DIY electronic gadgets, experimentations in physical computing, robotic artworks, and the like, it’s slim pickins’ when it comes to finding a tiny, easy-to-use digital camera to pair it up with. Fortunately, a company out of Hong Kong, COMedia Ltd., makes the C328R, a relatively small cell-phone style camera module that includes built-in JPEG image compression and UART serial communication. Couple the camera module with an Arduino and external storage (EEPROM, microSD, etc.) and you can have an instant Arduino-powered digital still image or video capture solution. That is to say, “instant,” once you have a working software driver … Fortunately for you, I’ve already done that work.

While working on a pigeon-based aerial photography solution as part of PigeonBlog for Beatriz da Costa, I wrote a library in C++ that allows the Arduino to communicate with the C328R camera over UART using the camera’s built-in communications protocol. Here’s a sample picture to prove that it works:

Sample C328R picture

The camera can take pictures in a variety of color depths (2- to 8-bit grayscale, 12- to 16-bit color, JPEG) and resolutions (80×64 to 640×480) with serial communication up to 115,200 baud. It’s fairly versatile and not terribly expensive (~$50) given the fact that it does a lot of work for you (i.e. on-board JPEG compression).

The rest of this post assumes that you have the camera and an Arduino Duemilanove (or similar) in hand. If you don’t, I suggest that you get them. You’re also going to need some type of external storage for the pictures, because the Arduino doesn’t provide any sufficient storage on-board. The sample code that follows assumes a 256KB Atmel SPI serial EEPROM or similar SPI EEPROM.

How to Use the Camera

Using the C328R camera involves a fairly straightforward issuance of commands. After power on, you essentially just have to synchronize with the camera, tell it what size and color-depth you want your pictures to be, and optionally set the byte size of the data packets it will send back to you (default 64 bytes), light frequency to use, etc. It looks something like this, assuming you want a JPEG photo:

Power on camera.
Issue “sync” command.
Issue “initial” command (tell the camera the desired color-depth, resolution, etc.).
Wait about 2 seconds for the camera to settle.
Issue “snapshot” command. This will tell the camera to take a snapshot and store it in its internal memory.
Issue “getPicture” command. The camera will then begin sending the JPEG image over serial in a series of data packets (default 64 bytes).
Take each data packet and store its image data sequentially in the EEPROM, until all image data has been retrieved. (A 640×480 JPEG can be upwards of 20KB. At 64 bytes a packet, this would be 320 individual data packets per photo.)

All of these commands are issued over a proprietary serial communications protocol. The C328R Arduino library takes care of all of this behind the scenes, and reduces the complexity to nothing more than a series of function calls.

Download the Library

You can download the camera library here. Standard Arduino library installation instructions apply.

Making the Connections

The camera should be powered at 3.3V, with the TX (yellow wire) connected to the RX pin on the Arduino, and the RX (green wire) connected to the TX pin on the Arduino. The wiring that comes with the camera is thin and stranded, so you may want to solder on some headers for a more robust electrical connection, especially if you plan on using a breadboard.

The SPI EEPROM, assuming you’re using an Atmel SPI EEPROM or another SPI EEPROM with the same pin layout, should be connected per the instructions found here.

An LED, with appropriate resistor, should be connected to pin 8. This will be used as an indicator LED to let you know when the Arduino is done writing the picture to the EEPROM.

Sample Code and Application

The following sample code operates in two parts: The first part captures a picture with the camera, stores it on an external EEPROM at address 0, then powers off the camera. The second part sends the JPEG image data from the EEPROM to the computer over USB, allowing a simple program written in Processing to read the data and save it to disk for viewing.

IMPORTANT NOTE: This sample code is designed primarily for testing and debugging purposes. Because the Arduino has only one hardware serial port, and the camera and computer (via USB) are both connected to that port, we use the indicator LED to notify us when the Arduino is done saving the data to the EEPROM and has powered off the camera. This way we know that any subsequent data being sent over serial is picture data that should be captured on the computer and saved to disk. By default, the code gives us 5 seconds to MANUALLY tell the Processing sketch to begin listening for and saving the serial data. You do this simply by pressing any key on the keyboard when the Processing sketch is running. After it is done reading the data, press any key again to write it to disk.

First up, the Arduino code. You will need to have the SPI library already installed. Save this as a sketch and upload it to your Arduino:

#include "CameraC328R.h"
#include "Spi.h"
 
#define LED_PIN 8
#define PAGE_SIZE 64
#define BAUD 38400
 
// EEPROM Opcodes
#define WREN 6
#define WRDI 4
#define RDSR 5
#define WRSR 1
#define READ 3
#define WRITE 2
 
// Buffer for EEPROM data
byte pageBuffer[PAGE_SIZE];
 
CameraC328R camera;
 
static uint16_t pictureSizeCount = 0;
static uint16_t pageBufferIndex = 0;
static uint16_t currentAddress = 0;
bool dirtyBuffer = false;
 
/**
 * Reads one byte from the EEPROM at the given address.
 */
byte readByte( uint16_t address )
{
  byte data;
 
  digitalWrite( SS_PIN, LOW );
  Spi.transfer( READ );
  Spi.transfer( (byte)(address >> 8) );
  Spi.transfer( (byte)(address) );
  data = Spi.transfer( 0xFF );
  digitalWrite( SS_PIN, HIGH );
  return data;
}
 
/**
 * Writes the data in the buffer to the EEPROM at the page
 * starting at the given address.
 */
void writeBuffer( uint16_t address, uint16_t bufferSize )
{
  // Write enable
  digitalWrite( SS_PIN, LOW );
  Spi.transfer( WREN );
  digitalWrite( SS_PIN, HIGH );
 
  delay( 10 );
 
  // Begin write
  digitalWrite( SS_PIN, LOW );
  Spi.transfer( WRITE );
 
  // Send the address
  Spi.transfer( (byte)(address>>8) ); // MSB
  Spi.transfer( (byte)(address) ); // LSB
 
  // Send the data
  for( uint16_t i = 0; i < bufferSize; i++ )
  {
    Spi.transfer( pageBuffer[i] );
  }
 
  digitalWrite( SS_PIN, HIGH );
}
 
/**
 * Fills the page buffer for the EEPROM with data.
 */
void fillPageBuffer( byte* data, uint16_t dataSize )
{
  for( uint16_t i = 0; i < dataSize; i++ )
  {
    pageBuffer[pageBufferIndex] = data[i];
    dirtyBuffer = true;
    pageBufferIndex++;
 
    if( pageBufferIndex == PAGE_SIZE && dirtyBuffer )
    {
      pageBufferIndex = 0;
      writeBuffer( currentAddress, PAGE_SIZE );
      currentAddress += PAGE_SIZE;
      dirtyBuffer = false;
      delay( 50 );
    }
  }
}
 
/**
 * Sends a picture to the computer.
 */
void transferPicture( uint16_t startAddress, uint16_t size )
{
  uint16_t endAddress = startAddress + size;
 
  for( uint16_t i = startAddress; i < endAddress; i++ )
  {
    Serial.print( readByte( i ), BYTE );
  }
}
 
/**
 * This callback is called EVERY time a JPEG data packet is received.
 */
void getJPEGPicture_callback( uint16_t pictureSize, uint16_t packageSize, uint16_t packageCount, byte* package )
{
  // packageSize is the size of the picture part of the package
  pictureSizeCount += packageSize;
 
  // package contains everything in the package
  fillPageBuffer( package, packageSize );
 
  if( pictureSizeCount == pictureSize )
  {
    // Is there still stuff in the buffer?
    if( dirtyBuffer )
    {
      writeBuffer( currentAddress, pageBufferIndex );
    }
 
    camera.powerOff();
    digitalWrite( LED_PIN, HIGH ); // DONE!
    Serial.flush();
    delay( 5000 ); // Give us 5 seconds to hit a key ...
    transferPicture( 0, pictureSize );
  }
}
 
void setup()
{
  Serial.begin( BAUD );
  digitalWrite( SS_PIN, HIGH ); // disable device
  pinMode( LED_PIN, OUTPUT );
 
  if( !camera.sync() )
  {
    Serial.println( "Sync failed." );
    return;
  }
 
  if( !camera.initial( CameraC328R::CT_JPEG, CameraC328R::PR_160x120, CameraC328R::JR_640x480 ) )
  {
    Serial.println( "Initial failed." );
    return;
  }
 
  if( !camera.setPackageSize( 64 ) )
  {
    Serial.println( "Package size failed." );
    return;
  }
 
  if( !camera.setLightFrequency( CameraC328R::FT_50Hz ) )
  {
    Serial.println( "Light frequency failed." );
    return;
  }
 
  // Let camera settle, per manual
  delay(2000);
 
  if( !camera.snapshot( CameraC328R::ST_COMPRESSED, 0 ) )
  {
    Serial.println( "Snapshot failed." );
    return;
  }
 
  if( !camera.getJPEGPicture( CameraC328R::PT_JPEG, PROCESS_DELAY, &getJPEGPicture_callback ) )
  {
    Serial.println( "Get JPEG failed." );
    return;
  }
}
 
void loop()
{
}

Next up, the Processing code. This code doubles as a serial monitor, so you can run it as soon as you plug in the Arduino to USB, and ignore the built-in Arduino serial monitor. Again, note that you must hit a key within 5 seconds of the LED lighting up, and again once data is done reading to save it to disk. By default, it will be saved as a file called “photo.jpg” in the same folder as your Processing sketch.

import processing.serial.*;
 
Serial myPort;
String filename = "photo.jpg";
byte[] photo = {};
Boolean readData = false;
 
void setup()
{
  println( Serial.list() );
  myPort = new Serial( this, Serial.list()[0], 38400 );
}
 
void draw()
{
  byte[] buffer = new byte[64];
  if( readData )
  {
    while( myPort.available() > 0 )
    {
      int readBytes = myPort.readBytes( buffer );
      print( "Read " );
      print( readBytes );
      println( " bytes ..." );
      for( int i = 0; i < readBytes; i++ )
      {
        photo = append( photo, buffer[i] );
      }
    }
  }
  else
  {
    while( myPort.available() > 0 )
    {
      print( "COM Data: " );
      println( myPort.readString() );
    }
  }
}
 
void keyPressed()
{
  if( photo.length > 0 ) {
    readData = false;
    print( "Writing to disk " );
    print( photo.length );
    println( " bytes ..." );
    saveBytes( filename, photo );
    println( "DONE!" );
  }
  else {
    readData = true;
    myPort.clear();
    println( "Waiting for data ..." );
  }
}

That should be enough to get started. The sample code above does not cover using the camera for RAW image capture, which is considerably faster and more useful as a solution for video (5 frames per second), but the library includes this functionality.

Feel free to post questions, comments or ideas below.

Tags: arduino, c++, camera, photography, processing

64 comments

Comments feed for this article

Trackback link: http://gizmologi.st/2009/04/taking-pictures-with-arduino/trackback/

follower on April 3, 2009 at 7:35 pm

A great addition to the Arduino world, I guess we can stop saying that it’s not possible to take photos with an Arduino now.

BTW did you mean to say “bytes” in the sentence “over serial in a series of data packets (default 64KB)” as it seems to contradict the next point.

Thanks for your work.

–Phil.
Sean on April 4, 2009 at 11:05 am

Thanks, and good catch; it should definitely be 64 bytes, not KB.
Anthony P on April 14, 2009 at 2:32 pm

Hey,

my camera does not even sync. I have put the response time to be 500 and 60 mx sync attempts, but I get a fail in sync, in less than 5 seconds, instead of 30! Why is that happening?

Thanks,
Anthony
TonyD on April 20, 2009 at 1:42 am

Thanks for the great work.

I’ve just got myself a Arduino Mega so it looks like I’ll be having some fun over the weekend.

- Tony
Eric on April 26, 2009 at 6:09 pm

Very wonderful tutor! Would it be possible to quote it in our C328 module product page?

http://www.seeedstudio.com/depot/uart-camera-module-with-jpeg-compression-c328-p-209.html
Sean on April 26, 2009 at 7:27 pm

Absolutely!
Jesse on June 8, 2009 at 4:11 pm

Sean, The link above goes to a camera without an R appended, do you think your library will work with it? Also, the C328R is out of stock from your link so do you think the C328-2225BW will work?

Thanks in advance for your advice.
Sean on June 10, 2009 at 2:04 pm

Hi Jesse – I’m pretty sure the library will work with any of those cameras. The hardware doesn’t really matter as long as they use the same serial communications protocol as the C328R. It looks like, from the data sheet, that the C328-2225BW should work.
Michelle on June 18, 2009 at 11:30 pm

Thanks for the camera library! I’m going to use it for a little project.
I’m only slightly confused about Processing’s Serial library. On their website it’s stated the library is used for RS-232 standard. Did you use a USB Serial Adaptor to connect your Arduino to PC?
Sean on June 19, 2009 at 7:40 am

Hi Michelle – I’m confused about your question. The Arduino I use, Duemilanove, has the USB FTDI chip on board. Just plug it straight into the USB port as normal and it’s good to go. What are you using?
Michelle on June 20, 2009 at 7:43 am

Hi, Sean:

Thanks for clearing it up for me. I haven’t purchased Duemilanove yet, I have an older version of Arduino that I bought 3 years ago. Right now I’m doing research on what parts I should get. And on Processing’s website, this is what is written about the Serial library:

“The Processing serial library allows for easily reading and writing data to and from external machines. It allows two computers to send and receive data and gives you the flexibility to communicate with custom microcontroller devices, using them as the input or output to Processing programs.

The serial port is a nine pin I/O port that exists on many PCs and can be emulated through USB with the Keyspan USB Serial Adaptor and other compliant devices.”

I originally thought that this library is only for serial connection which uses the R232 standard, and I would need a USB Serial adaptor for Duemilanove. But I guess there’s some confusion somewhere, Processing’s Serial library handles USB connections as well.

Thanks again!
Michelle on June 20, 2009 at 7:46 am

Correction: It should be RS-232 standard, not R232 as I mentioned.
Sorry about that!
Demetri on June 24, 2009 at 6:53 pm

Thanks for the informative post Sean, you’ve given me a leg up on my project

I had a somewhat odd question about the raw image capture; you load in the bytes in a while() loop polling Serial.available(), and I’m wondering what the consequence would be if you stuck some in-line computations between each byte read, say around line 510 in CameraC328R::waitForResponse.

Obviously, on a camera with unbuffered output you’d lose data, but since this has an onboard buffer I thought that perhaps there might be a way to do this? Or does the delivery as a single package preclude “waiting” for computations to finish before loading more of the raw data?

Sorry if this is a silly question, but I couldn’t sort it out from the data sheet and I haven’t yet received my camera (otherwise I would just test it myself .

Thanks again!
Sean on June 25, 2009 at 7:36 am

Hi Demetri,

I’m fairly certain you can do that, as long as it’s not too intensive. The Arduino incoming serial buffer is 128 bytes, so you don’t have a ton of room to play with I think. My understanding is that Serial.read() just pulls from the Arduino’s incoming buffer. The buffer on the camera wouldn’t seem to matter much in this instance, since it’s just spewing out bytes with complete disregard as to whether you received them until the very end.

One caveat: I haven’t really tested or used the raw image capture very extensively. I put it in there to make the library complete, but it’s not very well tested. I’d appreciate learning about your experience/feedback.

Sean
Demetri on June 26, 2009 at 6:04 pm

Thanks Sean I’ll let you know if I accomplish anything useful
Steve on August 15, 2009 at 12:29 pm

Sean thank you thank you thank you…

I am trying to get geared and brained up for a robotics project I have had on the shelf for years. I have recently learned about the complexity of sending digital video wirelessly, that 99% of cameras out there are analog and need some kind of board to decode them before sending them digitally. This camera gave me some hope, but the frame rate listed in the documentation for “preview” mode was pretty abysmal (.75 fps).

Your claim of 5fps and a mention of an altogether new lower res to operate at (fine by me) is just what I am looking for. I will be taking apart your code for the next month or so once I acquire this little device!

You are the man, hooray for smart people!
Sean on August 15, 2009 at 3:22 pm

Hi Steve – No guarantees on that 5 fps framerate. That’s just a rumor. I haven’t tried the video myself, only JPEG capture. But thanks!
Daniel on August 16, 2009 at 8:10 pm

Why does the data need to go via the SPI eeprom? can’t you just send the packets from the camera directly up to the computer? or is there timing issues?
Sean on August 17, 2009 at 12:34 pm

Hi Daniel: The EEPROM is necessary because the Arduino has only one serial port, and the camera is using it. It’s possible to modify the library to use software serial (which I plan to do in the near future), but for now some external storage is necessary. Also, unless you are doing some wireless communication (say over XBee) I doubt keeping the camera connected to the computer has much practical application value.
Daniel on August 17, 2009 at 2:58 pm

Yes exactly, I wasn’t planning on keeping attached to a computer but rather stream it to the net with the ethernet shield board, an eeprom could be used as a little storage buffer, but then the camera has its own storage eeprom doesn’t it? There is a nice web server library that has been developed called Webuino that would act as the frame work for displaying the captured image. Have you had a look down this path of displaying the image over a network connection at all?
Sean on August 20, 2009 at 12:55 pm

The camera has its own EEPROM, but that is only used to store the snapshot on the camera before you tell the camera to transfer it over. As far as I know, you can’t do anything with the EEPROM on the camera; it’s only used internally.

The Webduino sounds like an interesting webcam solution idea. Unfortunately, I’ve never tried it, but I’d be interested to learn about how well it works if you try it out.
Pat on August 31, 2009 at 10:29 am

Very Cool Stuff Almost Exactly What im Looking for… but what if instead of using a Atmel SPI EEPROM i used an sd/mmc card would the data thats written on the card be readable by pc via sd card reader? instead of turning off the camera to enable a serial connection to the pc one could just remove the sd card and view the photos via pc thats the idea at least but I’m sorta new at all this so if I’m talking crazy just let me know. o and one more thing whats the possibility of storing multiple images on said sd card?

thanks.
Sean on August 31, 2009 at 11:04 am

Hi Pat: I’ve done almost exactly what you mention in the latest version of my project that uses this camera. The biggest challenge I ran into was saving the images on the microSD using the FAT filesystem. There are some FAT16 implementations for Arduino out there, however they tend to use up a large amount of program space and working memory, and are only designed for saving text data to the microSD. They also do not support creating files in FAT, only reading/writing existing files.

At first, I hacked the uFAT library for Arduino to save arbitrary binary data to file. Unfortunately, this was still a hassle and never worked very well … the image file (picture.jpg or whatever) must already be on the disk, meaning you have to create an empty file of the size you anticipate the picture to be.

I have since abandoned saving images to regular FAT16 microSD and instead just created my own very basic filesystem, then wrote some code to pull the images off the microSD by navigating my custom filesystem. Works much better, but has the downside that you can’t just insert the microSD into any computer and extract the files without the custom software.

Hope that helps!
Pat on August 31, 2009 at 3:30 pm

Thanks for the insight. Thats a great idea. ill look into it all and if i figure anything out ill post it here.

Thanks, Pat.
evan on September 3, 2009 at 7:49 am

Is there anyway to analyze the Pixel data of the image with the arduino. In other words doing some kind of a read of the image on the EEPROM or before it is saved and getting the RGB value of a specific pixel? I hope that makes sense.
tror on September 11, 2009 at 5:05 pm

Hi,
Do you think that the Philips DC-3840 (OV528) works with your driver? or with a adaptation? The protocol looks similar ?! Because the old Handy cam kost only 9 euros in germany, not 50.

Thanks great work.
tror on September 11, 2009 at 6:21 pm

This ist the command list from http://www.ulrichradig.de/

http://docs.google.com/View?id=dhcbrfsc_18cjkmndcr
Don M on September 22, 2009 at 1:55 pm

Hey Sean:

Great article and excellent links. You’ve given me enough inspiration to attempt to build something similar to your project. Camera and boards are on the way. Want to try an XBee interface once I get your example working.

Just got some sample SPI EEPROMs from ST Micro – next day service – very impressive.

Do you anticipate any problems with ST EEPROM – or will it be a straight swap for the Atmel?

I have
1. M95256-WMN6TP (256K Serial SPI SO-8)
2. M95256-RMN6TP (256K Serial SPI SO-8)
3. M95512-RMN6TP (512K Serial SPI SO-8)
4. M95M01-RMN6TP (1MBIT Serial SPI SO-8)

Not sure what the difference is between WMN and RMN – possibly clock speed.

Will keep you posted – let me know if you have any suggestions to make this a success.

Thanks again
Don
ram on October 11, 2009 at 4:15 am

Hi Sean,

I understand that the serial EEProm comes into picture due the limitations of the Duemilanove having 1 UART interface.

Have u had a success getting the software serial port to work ?

–ram
Sean on October 11, 2009 at 7:39 am

Hi Don, I would think that as long as it’s an SPI interface it shouldn’t really matter.
Sean on October 11, 2009 at 7:41 am

Hi Ram: Correct. I have not yet tried with software serial, but it’s on the to-do list. Unfortunately, my only camera was just shipped off to France and then South Africa for science research, so I won’t be continuing work on the library until I get a new one.
ram on October 11, 2009 at 9:13 am

Thanks for your reply.

–Ram
Don M on October 15, 2009 at 8:04 am

Hey Sean:

Just an update for your other readers – anyone else that is a newbie like me and is going to order a sample or product directly from ST or Microchip to use with a breadboard, you need to order the “Plastic Dual In-Line” packaging type (PDIP). The ones I ordered are too narrow and have shorter legs than what’s needed to fit across the center breadboard channel.

Microchip product is 25AA256-I/P

I couldn’t seem to find any SPI EEPROMs on ST’s site that had a PDIP body

Hope that helps others…

My new ones should be here in a week. Testing will resume then.

Don
Don M on October 16, 2009 at 7:47 am

Pat:

While looking thru Arduino forums came across a couple of interesting topics on SD cards and the Arduino.

This one specifically looks to be what you want – note that he uses Sean’s library extensively.

Appropriately entitled “arduino + camera + sd memory card”
http://www.arduino.cc/cgi-bin/yabb2/YaBB.pl?num=1253595882/
Rodjownsu on October 17, 2009 at 5:10 pm

Hi Sean,

I am working with the same camera which I purchased from Sparkfun although I am having a few problems with it see here
http://forum.sparkfun.com/viewtopic.php?t=17119&sid=0061e0c804b7ddde9a11d5f0285d2f79

I was just wondering if you had tried to receive an uncompressed RGB image from the camera as they specify on page 10 of C328_UM.pdf (user manual).

It would be nice to know if this is an issue with the camera or just my code
it seems that everyone is basking in JPEG compression at the moment so maybe this quirk is going unnoticed!

Thanks mate!

Regards,

Murray
x on October 22, 2009 at 9:29 pm

If raw mode is so much faster, why not skip the OV328 entirely & just interface the microcontroller to the image sensor?
Doc on December 2, 2009 at 5:08 am

Hi,

Great tutorial!

However, i am a little bit confuse. Could be the C328 camera works with arduino 2009? It seems that the camera require 60mA, meanwhile the pins in arduino 2009 only have 40mA on exit…

So, is it neccesary any special component between the arduino 2009 and the C328R camera?

Tak, tak!
JR on December 9, 2009 at 12:49 pm

Hi Sean,

Great to see that you’ve update the library Smiley.

I just got mu C328 from Sparkfun and I am about to hook it up but:

Is it also possible to use the library without the EEPROM (why do you use the EEPROM?)?

The plan is to take a snapshot and directly send it to my PC instead of first save it to an EEPROM. The C328 will be connected onto my Arduino Mega board.
arms22 on January 4, 2010 at 5:40 am

Hi,

I had this library can used with the software serial port.
The code that I changed is here.

http://arms22.blog91.fc2.com/blog-entry-261.html
elli on January 19, 2010 at 2:00 pm

hi. thx for sharing that great idea.

i tried arms22 way of connecting the camera through serial port.

i have the same components but a lot of problems to get my camera synced. everytime i try ill get sync failed.

since the the c328r operates on 3.3V and the arduino duemilanove has TX/RX (in this case pin 2 & 3) output of 5V I added a 3.3V regulator for the RX connection (pin 3).

here is a link to my setup: http://bit.ly/7ppElz

ok, maybe one of you guys has any idea why my camera is not getting synced…

thx!
blue on January 31, 2010 at 12:24 pm

hey i tried what arms22 did but i a getting the error “photo.jpg containes bad image data.

can any one help?
Cyril on February 9, 2010 at 4:15 pm

Hello, im interested in doing an arduino project using a camera. Can you tell me if your library is compatible with a similar camera from Comedia, the C328-7640 or similar models.
Miguel Chaidez on February 19, 2010 at 6:06 pm

I have the same question as cyril. Is it compatible?
Miguel Chaidez on March 25, 2010 at 1:17 am

@elli: You need to get a logic level converter. I found one at Sparkfun that works from converting a 5v to 3.3. Here is the link http://www.sparkfun.com/commerce/product_info.php?products_id=8745

@Sean: Thanks for fixing the site. I was getting worried I couldn’t go back to this bookmark hehe. I have a question, I’m going to use matlab to process the image and send two bytes(x,y coordinates) back to the Arduino. Is there a way in processing or Arduino to communicate with a program like matlab? I know its strange but I have an algorithm to detect the hands and I want to send the data to the Arduino to display on a 16×16 dot matrix. I have everything working separately but I just need to make them communicate. Any help is welcome! Thanks again for the awesome site!!
JR on March 26, 2010 at 11:40 am

Is it really necessary to use 3.3V TX/RX pins? Or does the C328 only need 3.3 V as power?
Miguel Chaidez on March 28, 2010 at 8:48 am

What version of processing were you using?
Archana on April 2, 2010 at 1:19 pm

Hi,

I am trying to implement the exact same thing except I need the img packets to be transferred wirelessly immediately as there is no SD card involved. The project is very weight sensitive and I cannot add an SD card for now. If you can pls take a look at my code and help me figure out how to code the transfer, I would appreciate it very much!

I cant find you email anywhere on the site and so this public plea. Please get back to me asap.

P.S.: Happy Easter!
void256 on April 5, 2010 at 5:37 am

@JR
I’ve used the camera with 5V for TX/RX and it seemed to work fine. I don’t know if this can somewhat damage it tho. I’m a electronic noob

But I’m currently using a simple voltage divider to provide 3.3 V for TX/RX and think this is somewhat safer!?

It uses three 1.1k resistors for this and I connect them this way:

TX (arduino) -> R -> RX (C328) -> R -> R -> GND
TX (C328) -> RX (arduino)

with R being 1.1k resistors.

This works fine and I now get on RX and TX at the camera about 3.3 V and the camera still works ;D
Sean on April 5, 2010 at 7:24 am

You should definitely use 3.3V and a voltage divider on the TXO from the Arduino if you’re using a 5V Arduino. Otherwise you may damage the camera.
JR on April 5, 2010 at 1:09 pm

Thanks Sean and Void256 for the advice. I will devide the arduino TxD to 3.3 V using your suggestion (http://en.wikipedia.org/wiki/Voltage_divider).

Just a noob question: would this voltage devider be the best solution (If I move to PCB)? Or is there a better more common solution?

@Sean
Perhaps you can add this voltage devider to you tutorial, because I think many people (like me) hook up the power to 3.3V but forget to devide the voltage of the arduino’s TxD to 3.3V.

Cheers.

1 · 2 · Next ›

gizmologi.st

Taking Pictures with Arduino

How to Use the Camera

Download the Library

Making the Connections

Sample Code and Application

64 comments

Reply

Navigation

Archives