Revision 1:d16a4c3a272a, committed 2017-07-19

Comitter:

hepta2ume

Date:

Wed Jul 19 09:07:30 2017 +0000

Parent:

0:5a6468b4164d

Child:

2:686c7043f5f4

Commit message:

hepta_cam

Changed in this revision

--- a/CameraC1098.cpp	Mon Jul 09 10:23:32 2012 +0000
+++ b/CameraC1098.cpp	Wed Jul 19 09:07:30 2017 +0000
@@ -1,22 +1,10 @@
-/**
- * C1098-SS device driver class (Version 1.0)
- * Reference documents: C1098-SS User Manual v1.0 2012.4.1
- *
- * CameraC328Library
- * Copyright (C) 2010 Shinichiro Nakamura (CuBeatSystems)
- * http://shinta.main.jp/
- *
- * CameraC1098-SS Library
- * Copyright (C) 2012 Tadao Iida
- */
-
 #include "CameraC1098.h"
-
+static FILE *fp_jpeg;
 #define WAITIDLE    waitIdle
 #define SENDFUNC    sendBytes
 #define RECVFUNC    recvBytes
 #define WAITFUNC    waitRecv
-
+int num=0;
 /**
  * Constructor.
  *
@@ -24,20 +12,23 @@
  * @param rx A pin for receive.
  * @param baud Baud rate. (Default is Baud14400.)
  */
-CameraC1098::CameraC1098(PinName tx, PinName rx, int baud) : serial(tx, rx) {
+CameraC1098::CameraC1098(PinName tx, PinName rx, int baud) : serial(tx, rx)
+{
     serial.baud(baud);
 }
 
 /**
  * Destructor.
  */
-CameraC1098::~CameraC1098() {
+CameraC1098::~CameraC1098()
+{
 }
 
 /**
  * Make a sync. for baud rate.
  */
-CameraC1098::ErrorNumber CameraC1098::sync() {
+CameraC1098::ErrorNumber CameraC1098::sync()
+{
     for (int i = 0; i < SYNCMAX; i++) {
         if (NoError == sendSync()) {
             if (NoError == recvAckOrNck()) {
@@ -64,28 +55,29 @@
  * @param baud Camera Interface Speed.
  * @param jr JPEG resolution.
  */
-CameraC1098::ErrorNumber CameraC1098::init(Baud baud,JpegResolution jr) {
+CameraC1098::ErrorNumber CameraC1098::init(Baud baud,JpegResolution jr)
+{
     int i ;
     ErrorNumber en;
     WAITIDLE();
     setmbedBaud((Baud)(0x07)) ;
-  
+
     for ( i = 1 ; i < 7 ; i++ ) {
         if ( NoError == sendSync() ) {
-            if ( NoError == recvAckOrNck() ){
+            if ( NoError == recvAckOrNck() ) {
                 if ( NoError == recvSync() ) {
                     if ( NoError == sendAck(0x0D, 0x00) ) {
                         en = sendInitial(baud,jr);
                         if (NoError != en) {
                             return en;
-                        }    
+                        }
                         en = recvAckOrNck();
                         if (NoError != en) {
                             return en;
-                        }      
+                        }
                         wait_ms(50) ;
-                        setmbedBaud(baud);   
-                        //wait_ms(50) ; 
+                        setmbedBaud(baud);
+                        //wait_ms(50) ;
                         static bool alreadySetupPackageSize = false;
                         if (!alreadySetupPackageSize) {
                             en = sendSetPackageSize(packageSize);
@@ -99,21 +91,21 @@
                             }
                             alreadySetupPackageSize = true;
                         }
-                        
+
                         wait(2.0);
-                        return (ErrorNumber)NoError;                                                                 
-                       /*
-                        * After synchronization, the camera needs a little time for AEC and AGC to be stable.
-                        * Users should wait for 1-2 seconds before capturing the first picture.
-                        */
+                        return (ErrorNumber)NoError;
+                        /*
+                         * After synchronization, the camera needs a little time for AEC and AGC to be stable.
+                         * Users should wait for 1-2 seconds before capturing the first picture.
+                         */
                     }
-                }                 
-            }else{
-                setmbedBaud((Baud)(i+1)) ;   
+                }
+            } else {
+                setmbedBaud((Baud)(i+1)) ;
             }
         }
-        wait_ms(50);   
-    }                 
+        wait_ms(50);
+    }
     return UnexpectedReply;
 }
 
@@ -125,7 +117,116 @@
  *             You can block this function until saving the image datas.
  * @return Status of the error.
  */
-CameraC1098::ErrorNumber CameraC1098::getJpegSnapshotPicture(void(*func)(char *buf, size_t siz)) {
+CameraC1098::ErrorNumber CameraC1098::getJpegSnapshotPicture()
+{
+    WAITIDLE();
+    ErrorNumber en;
+
+
+    en = sendSnapshot();
+    if (NoError != en) {
+        return en;
+    }
+    WAITFUNC();
+    en = recvAckOrNck();
+    if (NoError != en) {
+        return en;
+    }
+
+    en = sendGetPicture();
+    if (NoError != en) {
+        return en;
+    }
+    WAITFUNC();
+    en = recvAckOrNck();
+    if (NoError != en) {
+        return en;
+    }
+
+    /*
+     * Data : snapshot picture
+     */
+    uint32_t length = 0;
+    WAITFUNC();
+    en = recvData(&length);
+    if (NoError != en) {
+        return en;
+    }
+    en = sendAck(0x00, 0);
+    if (NoError != en) {
+        return en;
+    }
+
+    char databuf[packageSize - 6];
+    uint16_t pkg_total = length / (packageSize - 6);
+    for (int i = 0; i <= (int)pkg_total; i++) {
+        uint16_t checksum = 0;
+        // ID.
+        char idbuf[2];
+        WAITFUNC();
+        if (!RECVFUNC(idbuf, sizeof(idbuf))) {
+            return (ErrorNumber)UnexpectedReply;
+        }
+        checksum += idbuf[0];
+        checksum += idbuf[1];
+        uint16_t id = (idbuf[1] << 8) | (idbuf[0] << 0);
+        if (id != i) {
+            return (ErrorNumber)UnexpectedReply;
+        }
+
+        // Size of the data.
+        char dsbuf[2];
+        WAITFUNC();
+        if (!RECVFUNC(dsbuf, sizeof(dsbuf))) {
+            return (ErrorNumber)UnexpectedReply;
+        }
+
+        // Received the data.
+        checksum += dsbuf[0];
+        checksum += dsbuf[1];
+        uint16_t ds = (dsbuf[1] << 8) | (dsbuf[0] << 0);
+        WAITFUNC();
+        if (!RECVFUNC(&databuf[0], ds)) {
+            return (ErrorNumber)UnexpectedReply;
+        }
+        for (int j = 0; j < ds; j++) {
+            checksum += databuf[j];
+        }
+
+        // Verify code.
+        char vcbuf[2];
+        WAITFUNC();
+        if (!RECVFUNC(vcbuf, sizeof(vcbuf))) {
+            return (ErrorNumber)UnexpectedReply;
+        }
+        uint16_t vc = (vcbuf[1] << 8) | (vcbuf[0] << 0);
+        if (vc != (checksum & 0xff)) {
+            return (ErrorNumber)UnexpectedReply;
+        }
+
+        /*
+         * Call a call back function.
+         * You can block this function while working.
+         */
+        size_t siz = ds;
+        for (int ii = 0; ii < (int)siz; ii++) {
+            fprintf(fp_jpeg, "%c", databuf[ii]);
+        }
+        /*
+         * We should wait for camera working before reply a ACK.
+         */
+        wait_ms(100);
+        en = sendAck(0x00, 1 + i);
+        if (NoError != en) {
+            return en;
+        }
+    }
+
+    return (ErrorNumber)NoError;
+}
+
+CameraC1098::ErrorNumber CameraC1098::getJpegSnapshotPicture_data()
+{
     WAITIDLE();
     ErrorNumber en;
 
@@ -215,8 +316,11 @@
          * Call a call back function.
          * You can block this function while working.
          */
-        func(databuf, ds);
-
+        size_t siz = ds;
+        for (int ii = 0; ii < (int)siz; ii++) {
+            fprintf(fp_jpeg, "%02X ", databuf[ii]);
+            if(++num%16==0) fprintf(fp_jpeg,"\r\n");
+        }
         /*
          * We should wait for camera working before reply a ACK.
          */
@@ -230,11 +334,10 @@
     return (ErrorNumber)NoError;
 }
 
-
+CameraC1098::ErrorNumber CameraC1098::sendInitial(Baud baud, JpegResolution jr)
+{
+    char send[COMMAND_LENGTH];
 
-CameraC1098::ErrorNumber CameraC1098::sendInitial(Baud baud, JpegResolution jr) {
-    char send[COMMAND_LENGTH];
-    
     send[0] = 0xAA;
     send[1] = 0x01;
     send[2] = (char)baud;
@@ -249,7 +352,8 @@
     return (ErrorNumber)NoError;
 }
 
-CameraC1098::ErrorNumber CameraC1098::sendGetPicture(void) {
+CameraC1098::ErrorNumber CameraC1098::sendGetPicture(void)
+{
     char send[COMMAND_LENGTH];
 
     send[0] = 0xAA;
@@ -265,7 +369,8 @@
     return (ErrorNumber)NoError;
 }
 
-CameraC1098::ErrorNumber CameraC1098::sendSnapshot(void) {
+CameraC1098::ErrorNumber CameraC1098::sendSnapshot(void)
+{
     char send[COMMAND_LENGTH];
     send[0] = 0xAA;
     send[1] = 0x05;
@@ -280,7 +385,8 @@
     return (ErrorNumber)NoError;
 }
 
-CameraC1098::ErrorNumber CameraC1098::sendSetPackageSize(uint16_t packageSize) {
+CameraC1098::ErrorNumber CameraC1098::sendSetPackageSize(uint16_t packageSize)
+{
     char send[COMMAND_LENGTH];
     send[0] = 0xAA;
     send[1] = 0x06;
@@ -295,33 +401,35 @@
     return (ErrorNumber)NoError;
 }
 
-void CameraC1098::setmbedBaud(Baud baud){
-    switch((int)baud){
-    case 0x02:
-        serial._baud(460800);
-        break;
-    case 0x03:
-        serial._baud(230400);
-        break;
-    case 0x04:
-        serial._baud(115200);
-        break;
-    case 0x05:
-        serial._baud(57600);
-        break;
-    case 0x06:
-        serial._baud((int)28800);
-        break;
-    case 0x07:
-        serial._baud(14400);
-        break;    
-    default:
-        serial._baud(14400);  
+void CameraC1098::setmbedBaud(Baud baud)
+{
+    switch((int)baud) {
+        case 0x02:
+            serial._baud(460800);
+            break;
+        case 0x03:
+            serial._baud(230400);
+            break;
+        case 0x04:
+            serial._baud(115200);
+            break;
+        case 0x05:
+            serial._baud(57600);
+            break;
+        case 0x06:
+            serial._baud((int)28800);
+            break;
+        case 0x07:
+            serial._baud(14400);
+            break;
+        default:
+            serial._baud(14400);
     }
 }
 
 
-CameraC1098::ErrorNumber CameraC1098::sendReset(ResetType specialReset) {
+CameraC1098::ErrorNumber CameraC1098::sendReset(ResetType specialReset)
+{
     char send[COMMAND_LENGTH];
     send[0] = 0xAA;
     send[1] = 0x08;
@@ -341,7 +449,8 @@
 }
 
 
-CameraC1098::ErrorNumber CameraC1098::recvData(uint32_t *length) {
+CameraC1098::ErrorNumber CameraC1098::recvData(uint32_t *length)
+{
     char recv[COMMAND_LENGTH];
     if (!RECVFUNC(recv, sizeof(recv))) {
         return (ErrorNumber)UnexpectedReply;
@@ -354,7 +463,8 @@
     return (ErrorNumber)NoError;
 }
 
-CameraC1098::ErrorNumber CameraC1098::sendSync() {
+CameraC1098::ErrorNumber CameraC1098::sendSync()
+{
     char send[COMMAND_LENGTH];
     send[0] = 0xAA;
     send[1] = 0x0D;
@@ -362,17 +472,18 @@
     send[3] = 0x00;
     send[4] = 0x00;
     send[5] = 0x00;
-    
-    
+
+
     if (!SENDFUNC(send, sizeof(send))) {
         return (ErrorNumber)SendRegisterTimeout;
     }
     return (ErrorNumber)NoError;
 }
 
-CameraC1098::ErrorNumber CameraC1098::recvSync() {
+CameraC1098::ErrorNumber CameraC1098::recvSync()
+{
     char recv[COMMAND_LENGTH];
-    
+
     if (!RECVFUNC(recv, sizeof(recv))) {
         return (ErrorNumber)UnexpectedReply;
     }
@@ -388,7 +499,8 @@
  * @param commandId The command with that ID is acknowledged by this command.
  * @param packageId For acknowledging Data command, these two bytes represent the requested package ID. While for acknowledging other commands, these two bytes are set to 00h.
  */
-CameraC1098::ErrorNumber CameraC1098::sendAck(uint8_t commandId, uint16_t packageId) {
+CameraC1098::ErrorNumber CameraC1098::sendAck(uint8_t commandId, uint16_t packageId)
+{
     char send[COMMAND_LENGTH];
 
     send[0] = 0xAA;
@@ -408,9 +520,10 @@
  *
  * @return Error number.
  */
-CameraC1098::ErrorNumber CameraC1098::recvAckOrNck() {
+CameraC1098::ErrorNumber CameraC1098::recvAckOrNck()
+{
     char recv[COMMAND_LENGTH];
-        
+
     if (!RECVFUNC(recv, sizeof(recv))) {
         return (ErrorNumber)UnexpectedReply;
     }
@@ -419,7 +532,7 @@
     }
     if ((0xAA == recv[0]) && (0x0F == recv[1]) && (0x00 == recv[2])) {
         return (ErrorNumber)NoError;
-    }    
+    }
     if ((0xAA == recv[0]) && (0x0F == recv[1])) {
         return (ErrorNumber)recv[4];
     }
@@ -434,7 +547,8 @@
  *
  * @return True if the data sended.
  */
-bool CameraC1098::sendBytes(char *buf, size_t len, int timeout_us) {
+bool CameraC1098::sendBytes(char *buf, size_t len, int timeout_us)
+{
     for (uint32_t i = 0; i < (uint32_t)len; i++) {
         int cnt = 0;
         while (!serial.writeable()) {
@@ -457,7 +571,8 @@
  *
  * @return True if the data received.
  */
-bool CameraC1098::recvBytes(char *buf, size_t len, int timeout_us) {
+bool CameraC1098::recvBytes(char *buf, size_t len, int timeout_us)
+{
     for (uint32_t i = 0; i < (uint32_t)len; i++) {
         int cnt = 0;
         while (!serial.readable()) {
@@ -477,7 +592,8 @@
  *
  * @return True if the data received.
  */
-bool CameraC1098::waitRecv() {
+bool CameraC1098::waitRecv()
+{
     while (!serial.readable()) {
     }
     return true;
@@ -486,9 +602,74 @@
 /**
  * Wait idle state.
  */
-bool CameraC1098::waitIdle() {
+bool CameraC1098::waitIdle()
+{
     while (serial.readable()) {
         serial.getc();
     }
     return true;
 }
+
+void CameraC1098::Sync(void)
+{
+    CameraC1098::ErrorNumber err = CameraC1098::NoError;
+    setmbedBaud(CameraC1098::Baud14400);
+    err = sync();
+    setmbedBaud(CameraC1098::Baud115200);
+    if (CameraC1098::NoError == err) {
+        printf("[ OK ] : CameraC1098::sync\r\n");
+    } else {
+        printf("[FAIL] : CameraC1098::sync (Error=%02X)\r\n", (int)err);
+    }
+}
+
+void CameraC1098::test_jpeg_snapshot_picture(void)
+{
+    CameraC1098::ErrorNumber err = CameraC1098::NoError;
+    for (int i = 0; i < CAPTURE_FRAMES; i++) {
+        char fname[64];
+        snprintf(fname, sizeof(fname), "/fs/test%d.jpg", i);
+        fp_jpeg = fopen(fname, "w");
+
+        err = getJpegSnapshotPicture();
+
+        if (CameraC1098::NoError == err) {
+            printf("[ OK ] : CameraC1098::getJpegSnapshotPicture\r\n");
+        } else {
+            printf("[FAIL] : CameraC1098::getJpegSnapshotPicture (Error=%02X)\r\n", (int)err);
+        }
+        fclose(fp_jpeg);
+    }
+}
+
+void CameraC1098::test_jpeg_snapshot_data(void)
+{
+    CameraC1098::ErrorNumber err = CameraC1098::NoError;
+    for (int i = 0; i < CAPTURE_FRAMES; i++) {
+        char fname[64];
+        snprintf(fname, sizeof(fname), "/fs/test%d.txt", i);
+        fp_jpeg = fopen(fname, "w");
+
+        err = getJpegSnapshotPicture_data();
+
+        if (CameraC1098::NoError == err) {
+            printf("[ OK ] : CameraC1098::getJpegSnapshotPicture\r\n");
+        } else {
+            printf("[FAIL] : CameraC1098::getJpegSnapshotPicture (Error=%02X)\r\n", (int)err);
+        }
+        fclose(fp_jpeg);
+    }
+}
+
+void CameraC1098::initialize(Baud baud,JpegResolution jr)
+{
+    CameraC1098::ErrorNumber err = CameraC1098::NoError;//ErrorNumber define
+    err = init(baud, jr);//
+
+    if (CameraC1098::NoError == err) {
+        printf("[ OK ] : CameraC1098::init\r\n");
+    } else {
+        printf("[FAIL] : CameraC1098::init (Error=%02X)\r\n", (int)err);
+    }
+
+}
\ No newline at end of file

--- a/CameraC1098.h	Mon Jul 09 10:23:32 2012 +0000
+++ b/CameraC1098.h	Wed Jul 19 09:07:30 2017 +0000
@@ -99,7 +99,8 @@
      *             You can block this function until saving the image datas.
      * @return Status of the error.
      */
-    ErrorNumber getJpegSnapshotPicture(void(*func)(char *buf, size_t siz));
+    ErrorNumber getJpegSnapshotPicture();
+    ErrorNumber getJpegSnapshotPicture_data();
 
     /** setmbedBaud
      *  mbed Interface Speed.
@@ -107,13 +108,18 @@
      *  @param baud mbed Interface Speed.
      */
     void setmbedBaud(Baud baud);
-    
+    void Sync(void);
+    void initialize(Baud baud,JpegResolution jr);
+    void test_jpeg_snapshot_picture(void);
+    void test_jpeg_snapshot_data(void);
+    void jpeg_callback(char *buf, size_t siz);
 private:
     SerialBuffered serial;
     static const int COMMAND_LENGTH = 6;
     static const int SYNCMAX = 60;
     static const int packageSize = 256;
-
+    static const int CAPTURE_FRAMES = 3;
+    
     ErrorNumber sendInitial(Baud band, JpegResolution jr);
     ErrorNumber sendGetPicture(void);
     ErrorNumber sendSnapshot(void);