LSY201 is an Arduino library to interface with the LinkSprite JPEG TTL Camera. You can purchase the camera from SparkFun here:
https://www.sparkfun.com/products/11610
Download the library here: LSY201.zip.
The following example assumes that the TX and RX pins of the camera are attached to pins 2 and 3 respectively of the Arduino. This example continuously takes pictures and outputs the raw bytes of the JPEG-encoded images to Serial:
#include <SoftwareSerial.h>
#include <LSY201.h>
SoftwareSerial camera_serial(2, 3);
LSY201 camera;
uint8_t buf[32];
void setup()
{
camera.setSerial(camera_serial);
camera_serial.begin(38400);
}
void loop()
{
camera.reset();
camera.takePicture();
uint16_t offset = 0;
while (camera.readJpegFileContent(offset, buf, sizeof(buf)))
{
for (int i = 0; i < sizeof(buf); i ++)
Serial.write(buf[i]);
offset += sizeof(buf);
}
}
Create a LSY201 instance and call setSerial to give a it stream object
configured for the camera. This example assumes that the TX and RX pins of the
camera are attached to pins 2 and 3 respectively of the Arduino:
SoftwareSerial camera_serial(2, 3);
camera_serial.begin(38400); /* LSY201's default baud */
LSY201 camera;
camera.setSerial(camera_serial);
Call setDebugSerial to have debug information written to a serial object:
camera.setDebugSerial(Serial);
Most of the methods of LSY201 send some bytes to the camera and read some bytes back. These requests and responses are logged to the debug serial object when present.
For example, the following debug output shows the bytes transmitted and received while changing the image size to 640x480, resetting the camera, waiting for "Init end," and finally taking a picture:
sending bytes: 56 0 31 5 4 1 0 19
sending bytes: 0
expecting bytes: 76 0 31 0 0
76 ok
0 ok
31 ok
0 ok
0 ok
sending bytes: 56 0 26 0
expecting bytes: 76 0 26 0
76 ok
0 ok
26 ok
0 ok
Ctrl infr exist
User-defined sensor
625
Init end
sending bytes: 56 0 36 1 0
expecting bytes: 76 0 36 0 0
76 ok
0 ok
36 ok
0 ok
0 ok
takePicture takes a picture and stores it in the camera's internal buffer to
be read back later.
camera.takePicture();
Call readJpegFileContent repeatedly to read the JPEG image data stored on the
camera. This method expects three parameters:
- the 0-based byte offset at which to start reading,
- a buffer to store the data, and
- the number of bytes to read.
The method returns true if it wrote new data to the buffer, or false if it
did not because the end-of-file had previously been reached.
For example, the following reads the entire contents of the JPEG in 32-byte chunks and writes the raw bytes to Serial:
uint16_t offset = 0;
uint8_t buf[32];
while (camera.readJpegFileContent(buf, offset, sizeof(buf)))
{
for (int i = 0; i < sizeof(buf); i ++)
Serial.write(buf[i]);
offset += sizeof(buf);
}
The camera has an internal buffer that must be cleared prior to taking another
picture; otherwise the next call to takePicture will effectively be ignored
and the buffer will not change.
Call stopTakingPictures to clear the camera's buffer. You'll need to wait a
short while afterwords for this to work. I've found that a 25ms delay is
consistently sufficient:
camera.takePicture();
camera.stopTakingPictures();
delay(25);
camera.takePicture();
You can alternatively use reset to clear the buffer, but that has some
additional side effects described below.
Call setBaudRate with one of the supported baud rates: 9600, 19200, 38400,
57600, or 115200. The camera will be using that baud when the method returns
so you'll need to reconfigure your serial object accordingly:
camera.setBaudRate(9600);
camera_serial.begin(9600);
Using a baud rate other than the default 38400 can make development on the
Arduino a bit tricky. Suppose that your sketch's setup looks like this:
LSY201 camera;
SoftwareSerial camera_serial(2, 3);
void setup()
{
camera.setSerial(camera_serial);
camera_serial.begin(38400);
camera.setBaudRate(9600);
camera_serial.begin(9600);
}
This will work the first time. However, after you reset the Arduino or
redeploy your sketch, the call to setBaudRate will never return. This is
because the camera is still operating at 9600 baud. To get around this you can
power cycle the camera so that it returns to it's default 38400 baud assumed by
setup.
Resetting the camera clears the internal buffer and returns the compression ratio and baud rate to their default values.
If you are using the default 38400 baud rate, simply call reset:
camera.reset();
Things are a little more complicated if you're not using 38400 baud. This is because a reset actually consists of two steps: sending the reset command, and waiting for the camera to output "Init end\r\n" thus signaling that it is okay to resume operations.
The issue is that the camera returns to the default 38400 baud prior to outputting "Init end", so you must reconfigure your serial object accordingly:
camera.resetWithoutWaitingForInitEnd();
camera_serial.begin(38400);
camera.waitForInitEnd();
Call setImageSize with one of the following values to change the image size
used to encode pictures:
LS101::Small(160x120)LS101::Medium(320x240)LS101::Large(640x480)
You must reset the camera for the image size change to take effect:
camera.setImageSize(LS101::Small);
camera.reset();
Call setCompressionRatio with a value between between 0 (low compression,
high quality) and 0xFF (high compression, low quality.)
Note that resetting the camera returns the compression ratio to its default value, so if you need to change both the image size and compression ratio, you must change the compression ratio after performing the reset:
camera.setImageSize(LS101::Large);
camera.reset();
camera.setCompressionRatio(0x20);
readJpegFileSize returns size, in bytes, of the most recently taken picture:
camera.takePicture();
uint16_t size = camera.readJpegFileSize();