main.cpp

00001 /**
00002  * Thresholding on Red using the C328 camera 
00003  * based on Shinichiro Nakamura's c328 driver.
00004  * Copyright (C) 2010 Devesh Rai
00005  *
00006  *
00007  * Original copyright notice
00008  * Copyright (C) 2010 Shinichiro Nakamura (CuBeatSystems)
00009  * http://shinta.main.jp/
00010  */
00011 
00012 #include "mbed.h"
00013 #include "CameraC328.h"
00014 #include "MobileLCD.h"
00015 
00016 Serial serial(USBTX, USBRX);
00017 
00018 MobileLCD lcd(p5, p6, p7, p8, p9);
00019 int x,y;
00020 
00021 LocalFileSystem fs ("fs");
00022 
00023 CameraC328 camera(p9, p10, CameraC328::Baud19200);
00024 const int IMG_X = 80;
00025 const int IMG_Y = 60;
00026 char buf[IMG_X * IMG_Y * 2];
00027 FILE *fp_jpeg;
00028 
00029 void uncompressed_callback(size_t done, size_t total, char c) {
00030     buf[done - 1] = c;
00031 }
00032 
00033 void jpeg_callback(char *buf, size_t siz) {
00034     for (int i = 0; i < (int)siz; i++) {
00035         fprintf(fp_jpeg, "%c", buf[i]);
00036     }
00037 }
00038 
00039 void sync(void) {
00040     CameraC328::ErrorNumber err = CameraC328::NoError;
00041 
00042     err = camera.sync();
00043     if (CameraC328::NoError == err) {
00044         printf("[ OK ] : CameraC328::sync\n");
00045     } else {
00046         printf("[FAIL] : CameraC328::sync (Error=%02X)\n", (int)err);
00047     }
00048 }
00049 
00050 void test_uncompressed_snapshot_picture(void) {
00051     CameraC328::ErrorNumber err = CameraC328::NoError;
00052 
00053     err = camera.init(CameraC328::Color16bit, CameraC328::RawResolution80x60, CameraC328::JpegResolution80x64);
00054     if (CameraC328::NoError == err) {
00055         printf("[ OK ] : CameraC328::init\n");
00056     } else {
00057         printf("[FAIL] : CameraC328::init (Error=%02X)\n", (int)err);
00058     }
00059 
00060     for (int i = 0; i < 10; i++) {
00061         err = camera.getUncompressedSnapshotPicture(uncompressed_callback);
00062         if (CameraC328::NoError == err) {
00063             printf("[ OK ] : CameraC328::getUncompressedSnapshotPicture\n");
00064         } else {
00065             printf("[FAIL] : CameraC328::getUncompressedSnapshotPicture (Error=%02X)\n", (int)err);
00066         }
00067 
00068         char fname[64];
00069         snprintf(fname, sizeof(fname), "/fs/ucss%04d.ppm", i);
00070         FILE *fp = fopen(fname, "w");
00071         fprintf(fp, "P3\n");
00072         fprintf(fp, "%d %d\n", IMG_X, IMG_Y);
00073         fprintf(fp, "%d\n", 255);
00074         for (int y = 0; y < IMG_Y; y++) {
00075             for (int x = 0; x < IMG_X; x++) {
00076                 int adrofs = y * (IMG_X * 2) + (x * 2);
00077                 uint16_t dat = (buf[adrofs + 0] << 8) | (buf[adrofs + 1] << 0);
00078                 uint8_t r = ((dat >> 11) & 0x1f) << 3;
00079                 uint8_t g = ((dat >> 5) & 0x3f) << 2;
00080                 uint8_t b = ((dat >> 0) & 0x1f) << 3;
00081                 fprintf(fp,"%d %d %d\n", r, g, b);
00082             }
00083         }
00084         fclose(fp);
00085     }
00086 }
00087 
00088 void test_uncompressed_preview_picture(void) {
00089     CameraC328::ErrorNumber err = CameraC328::NoError;
00090 
00091     err = camera.init(CameraC328::Color16bit, CameraC328::RawResolution80x60, CameraC328::JpegResolution80x64);
00092     if (CameraC328::NoError == err) {
00093         printf("[ OK ] : CameraC328::init\n");
00094     } else {
00095         printf("[FAIL] : CameraC328::init (Error=%02X)\n", (int)err);
00096     }
00097 
00098     for (int i = 0; i < 10; i++) {
00099         err = camera.getUncompressedPreviewPicture(uncompressed_callback);
00100         if (CameraC328::NoError == err) {
00101             printf("[ OK ] : CameraC328::getUncompressedPreviewPicture\n");
00102         } else {
00103             printf("[FAIL] : CameraC328::getUncompressedPreviewPicture (Error=%02X)\n", (int)err);
00104         }
00105 
00106         //char fname[64];
00107         //snprintf(fname, sizeof(fname), "/fs/ucpv%04d.ppm", i);
00108         //FILE *fp = fopen(fname, "w");
00109         //fprintf(fp, "P3\n");
00110         //fprintf(fp, "%d %d\n", IMG_X, IMG_Y);
00111         //fprintf(fp, "%d\n", 255);
00112         for (int y = 0; y < IMG_Y; y++) {
00113             for (int x = 0; x < IMG_X; x++) {
00114                 int adrofs = y * (IMG_X * 2) + (x * 2);
00115                 uint16_t dat = (buf[adrofs + 0] << 8) | (buf[adrofs + 1] << 0);
00116                 uint8_t r = ((dat >> 11) & 0x1f) << 3;
00117                 uint8_t g = ((dat >> 5) & 0x3f) << 2;
00118                 uint8_t b = ((dat >> 0) & 0x1f) << 3;
00119                 lcd.pixel(x,y,r);
00120                 //fprintf(fp,"%d %d %d\n", r, g, b);
00121             }
00122         }
00123         //fclose(fp);
00124     }
00125 }
00126 
00127 void test_jpeg_snapshot_picture(void) {
00128     CameraC328::ErrorNumber err = CameraC328::NoError;
00129 
00130     err = camera.init(CameraC328::Jpeg, CameraC328::RawResolution80x60, CameraC328::JpegResolution640x480);
00131     if (CameraC328::NoError == err) {
00132         printf("[ OK ] : CameraC328::init\n");
00133     } else {
00134         printf("[FAIL] : CameraC328::init (Error=%02X)\n", (int)err);
00135     }
00136 
00137     for (int i = 0; i < 10; i++) {
00138         char fname[64];
00139         snprintf(fname, sizeof(fname), "/fs/jpss%04d.jpg", i);
00140         fp_jpeg = fopen(fname, "w");
00141 
00142         err = camera.getJpegSnapshotPicture(jpeg_callback);
00143         if (CameraC328::NoError == err) {
00144             printf("[ OK ] : CameraC328::getJpegSnapshotPicture\n");
00145         } else {
00146             printf("[FAIL] : CameraC328::getJpegSnapshotPicture (Error=%02X)\n", (int)err);
00147         }
00148 
00149         fclose(fp_jpeg);
00150     }
00151 }
00152 
00153 void test_jpeg_preview_picture(void) {
00154     CameraC328::ErrorNumber err = CameraC328::NoError;
00155 
00156     err = camera.init(CameraC328::Jpeg, CameraC328::RawResolution80x60, CameraC328::JpegResolution640x480);
00157     if (CameraC328::NoError == err) {
00158         printf("[ OK ] : CameraC328::init\n");
00159     } else {
00160         printf("[FAIL] : CameraC328::init (Error=%02X)\n", (int)err);
00161     }
00162 
00163     for (int i = 0; i < 10; i++) {
00164         char fname[64];
00165         snprintf(fname, sizeof(fname), "/fs/jppv%04d.jpg", i);
00166         fp_jpeg = fopen(fname, "w");
00167 
00168         err = camera.getJpegPreviewPicture(jpeg_callback);
00169         if (CameraC328::NoError == err) {
00170             printf("[ OK ] : CameraC328::getJpegPreviewPicture\n");
00171         } else {
00172             printf("[FAIL] : CameraC328::getJpegPreviewPicture (Error=%02X)\n", (int)err);
00173         }
00174 
00175         fclose(fp_jpeg);
00176     }
00177 }
00178 
00179 int main() {
00180     serial.baud(19200);
00181     serial.printf("\n");
00182     serial.printf("==========\n");
00183     serial.printf("CameraC328\n");
00184     serial.printf("==========\n");
00185     //lcd.
00186     lcd.background(0x000000);
00187     lcd.cls();
00188     for(x=0;x<80;x++)
00189         for(y=0;y<60;y++)
00190             lcd.pixel(x,y,0x0000ff);
00191     lcd.locate(2,3);
00192     lcd.printf("Camera");        
00193     lcd.locate(0,9);
00194     lcd.printf("Tracking: Circle");
00195     lcd.locate(10,2);
00196     lcd.printf("X: 0.0");
00197     lcd.locate(10,3);
00198     lcd.printf("Y: 0.0");
00199     lcd.locate(0,13);
00200     sync();
00201    // test_uncompressed_snapshot_picture();
00202     test_uncompressed_preview_picture();
00203     //test_jpeg_preview_picture();
00204     //test_jpeg_snapshot_picture();
00205 
00206     return 0;
00207 }