main.cpp

00001 /**
00002  * Test program.
00003  *
00004  * Copyright (C) 2010 Shinichiro Nakamura (CuBeatSystems)
00005  * http://shinta.main.jp/
00006  */
00007 
00008 /*
00009  * Include files.
00010  */
00011 
00012 #include "mbed.h"
00013 #include "CameraC328.h"
00014 #include "SDFileSystem.h"
00015 
00016 /*
00017  * Definitions.
00018  */
00019 #define USE_JPEG_HIGH_RESOLUTION  1
00020 #define USE_SD_CARD 1
00021 
00022 /*
00023  * Variables.
00024  */
00025 static const int CAPTURE_FRAMES = 5;
00026 static const int RAWIMG_X = 10;
00027 static const int RAWIMG_Y = 10;
00028 static char buf[RAWIMG_X * RAWIMG_Y * 2];
00029 static FILE *fp_jpeg;
00030 
00031 /*
00032  * Modules.
00033  */
00034 #if USE_SD_CARD
00035 SDFileSystem sd(PB_3, PB_2, PB_1, PB_0, "fs"); // the pinout on the mbed Cool Components workshop board
00036 #else
00037 LocalFileSystem fs("fs");
00038 #endif
00039 CameraC328 camera(PA_14, PA_13, CameraC328::Baud14400);
00040 /**
00041  * A callback function for uncompressed images.
00042  * Please do NOT block this callback function.
00043  * Because the camera module transmit image datas continuously.
00044  *
00045  * @param done a done number of packets.
00046  * @param total a total number of packets.
00047  * @param c received data.
00048  */
00049 void uncompressed_callback(size_t done, size_t total, char c) {
00050     buf[done - 1] = c;
00051 }
00052 
00053 /**
00054  * A callback function for jpeg images.
00055  * You can block this function until saving the image datas.
00056  *
00057  * @param buf A pointer to the image buffer.
00058  * @param siz A size of the image buffer.
00059  */
00060 void jpeg_callback(char *buf, size_t siz) {
00061     for (int i = 0; i < (int)siz; i++) {
00062         fprintf(fp_jpeg, "%c", buf[i]);
00063     }
00064 }
00065 
00066 /**
00067  * Synchronizing.
00068  */
00069 void sync(void) {
00070     CameraC328::ErrorNumber err = CameraC328::NoError;
00071 
00072     err = camera.sync();
00073     if (CameraC328::NoError == err) {
00074         printf("[ OK ] : CameraC328::sync\n");
00075     } else {
00076         printf("[FAIL] : CameraC328::sync (Error=%02X)\n", (int)err);
00077     }
00078 }
00079 
00080 /**
00081  * A test function for uncompressed snapshot picture.
00082  */
00083 void test_uncompressed_snapshot_picture(void) {
00084     CameraC328::ErrorNumber err = CameraC328::NoError;
00085 
00086     err = camera.init(CameraC328::Color16bit, CameraC328::RawResolution80x60, CameraC328::JpegResolution160x128);
00087     if (CameraC328::NoError == err) {
00088         printf("[ OK ] : CameraC328::init\n");
00089     } else {
00090         printf("[FAIL] : CameraC328::init (Error=%02X)\n", (int)err);
00091     }
00092 
00093     for (int i = 0; i < CAPTURE_FRAMES; i++) {
00094         err = camera.getUncompressedSnapshotPicture(uncompressed_callback);
00095         if (CameraC328::NoError == err) {
00096             printf("[ OK ] : CameraC328::getUncompressedSnapshotPicture\n");
00097         } else {
00098             printf("[FAIL] : CameraC328::getUncompressedSnapshotPicture (Error=%02X)\n", (int)err);
00099         }
00100 
00101         char fname[64];
00102         snprintf(fname, sizeof(fname), "/fs/ucss%04d.ppm", i);
00103         FILE *fp = fopen(fname, "w");
00104         fprintf(fp, "P3\n");
00105         fprintf(fp, "%d %d\n", RAWIMG_X, RAWIMG_Y);
00106         fprintf(fp, "%d\n", 255);
00107         for (int y = 0; y < RAWIMG_Y; y++) {
00108             for (int x = 0; x < RAWIMG_X; x++) {
00109                 int adrofs = y * (RAWIMG_X * 2) + (x * 2);
00110                 uint16_t dat = (buf[adrofs + 0] << 8) | (buf[adrofs + 1] << 0);
00111                 uint8_t r = ((dat >> 11) & 0x1f) << 3;
00112                 uint8_t g = ((dat >> 5) & 0x3f) << 2;
00113                 uint8_t b = ((dat >> 0) & 0x1f) << 3;
00114                 fprintf(fp,"%d %d %d\n", r, g, b);
00115             }
00116         }
00117         fclose(fp);
00118     }
00119 }
00120 
00121 /**
00122  * A test function for uncompressed preview picture.
00123  */
00124 void test_uncompressed_preview_picture(void) {
00125     CameraC328::ErrorNumber err = CameraC328::NoError;
00126 
00127     err = camera.init(CameraC328::Color16bit, CameraC328::RawResolution80x60, CameraC328::JpegResolution160x128);
00128     if (CameraC328::NoError == err) {
00129         printf("[ OK ] : CameraC328::init\n");
00130     } else {
00131         printf("[FAIL] : CameraC328::init (Error=%02X)\n", (int)err);
00132     }
00133 
00134     for (int i = 0; i < CAPTURE_FRAMES; i++) {
00135         err = camera.getUncompressedPreviewPicture(uncompressed_callback);
00136         if (CameraC328::NoError == err) {
00137             printf("[ OK ] : CameraC328::getUncompressedPreviewPicture\n");
00138         } else {
00139             printf("[FAIL] : CameraC328::getUncompressedPreviewPicture (Error=%02X)\n", (int)err);
00140         }
00141 
00142         char fname[64];
00143         snprintf(fname, sizeof(fname), "/fs/ucpv%04d.ppm", i);
00144         FILE *fp = fopen(fname, "w");
00145         fprintf(fp, "P3\n");
00146         fprintf(fp, "%d %d\n", RAWIMG_X, RAWIMG_Y);
00147         fprintf(fp, "%d\n", 255);
00148         for (int y = 0; y < RAWIMG_Y; y++) {
00149             for (int x = 0; x < RAWIMG_X; x++) {
00150                 int adrofs = y * (RAWIMG_X * 2) + (x * 2);
00151                 uint16_t dat = (buf[adrofs + 0] << 8) | (buf[adrofs + 1] << 0);
00152                 uint8_t r = ((dat >> 11) & 0x1f) << 3;
00153                 uint8_t g = ((dat >> 5) & 0x3f) << 2;
00154                 uint8_t b = ((dat >> 0) & 0x1f) << 3;
00155                 fprintf(fp,"%d %d %d\n", r, g, b);
00156             }
00157         }
00158         fclose(fp);
00159     }
00160 }
00161 
00162 /**
00163  * A test function for jpeg snapshot picture.
00164  */
00165 void test_jpeg_snapshot_picture(void) {
00166     CameraC328::ErrorNumber err = CameraC328::NoError;
00167 
00168 #if USE_JPEG_HIGH_RESOLUTION
00169     err = camera.init(CameraC328::Jpeg, CameraC328::RawResolution80x60, CameraC328::JpegResolution640x480);
00170 #else
00171     err = camera.init(CameraC328::Jpeg, CameraC328::RawResolution80x60, CameraC328::JpegResolution320x240);
00172 #endif
00173     if (CameraC328::NoError == err) {
00174         printf("[ OK ] : CameraC328::init\n");
00175     } else {
00176         printf("[FAIL] : CameraC328::init (Error=%02X)\n", (int)err);
00177     }
00178 
00179     for (int i = 0; i < CAPTURE_FRAMES; i++) {
00180         char fname[64];
00181         snprintf(fname, sizeof(fname), "/fs/jpss%04d.jpg", i);
00182         fp_jpeg = fopen(fname, "w");
00183 
00184         err = camera.getJpegSnapshotPicture(jpeg_callback);
00185         if (CameraC328::NoError == err) {
00186             printf("[ OK ] : CameraC328::getJpegSnapshotPicture\n");
00187         } else {
00188             printf("[FAIL] : CameraC328::getJpegSnapshotPicture (Error=%02X)\n", (int)err);
00189         }
00190 
00191         fclose(fp_jpeg);
00192     }
00193 }
00194 
00195 /**
00196  * A test function for jpeg preview picture.
00197  */
00198 void test_jpeg_preview_picture(void) {
00199     CameraC328::ErrorNumber err = CameraC328::NoError;
00200 
00201 #if USE_JPEG_HIGH_RESOLUTION
00202     err = camera.init(CameraC328::Jpeg, CameraC328::RawResolution80x60, CameraC328::JpegResolution640x480);
00203 #else
00204     err = camera.init(CameraC328::Jpeg, CameraC328::RawResolution80x60, CameraC328::JpegResolution320x240);
00205 #endif
00206     if (CameraC328::NoError == err) {
00207         printf("[ OK ] : CameraC328::init\n");
00208     } else {
00209         printf("[FAIL] : CameraC328::init (Error=%02X)\n", (int)err);
00210     }
00211 
00212     for (int i = 0; i < CAPTURE_FRAMES; i++) {
00213         char fname[64];
00214         snprintf(fname, sizeof(fname), "/fs/jppv%04d.jpg", i);
00215         fp_jpeg = fopen(fname, "w");
00216 
00217         err = camera.getJpegPreviewPicture(jpeg_callback);
00218         if (CameraC328::NoError == err) {
00219             printf("[ OK ] : CameraC328::getJpegPreviewPicture\n");
00220         } else {
00221             printf("[FAIL] : CameraC328::getJpegPreviewPicture (Error=%02X)\n", (int)err);
00222         }
00223 
00224         fclose(fp_jpeg);
00225     }
00226 }
00227 
00228 /**
00229  * A entry point.
00230  */
00231 int main() {
00232     printf("\n");
00233     printf("==========\n");
00234     printf("CameraC328\n");
00235     printf("==========\n");
00236 
00237     sync();
00238 //    test_uncompressed_snapshot_picture();
00239 //    test_uncompressed_preview_picture();
00240 //    test_jpeg_preview_picture();
00241     test_jpeg_snapshot_picture();
00242 
00243     /*printf("Hello World!\n");   
00244  
00245     mkdir("/fs/mydir", 0777);
00246     
00247     FILE *fp = fopen("/fs/mydir/sdtest.txt", "w");
00248     if(fp == NULL) {
00249         error("Could not open file for write\n");
00250     }
00251     fprintf(fp, "Hello fun SD Card World!");
00252     fclose(fp); 
00253  
00254     printf("Goodbye World!\n");
00255     return 0;*/
00256 }