File content as of revision 3:ff47827160f8:

  #include "mbed.h"
#include "Camera_LS_Y201.h"
#include "SDFileSystem.h"
#include "Servo.h"

Servo myservo(p23);
//#include "FATFileSystem.h"
Serial xbee(p28,p27);
Serial pc(USBTX,USBRX);
//FILE *p1;
 
  #define DEBMSG      pc.printf
#define NEWLINE()   pc.printf("\r\n")

#define USE_SDCARD 0

#if USE_SDCARD
#define FILENAME    "/sd/IMG_%04d.jpg"
SDFileSystem fs(p5, p6, p7, p8, "sd");
#else
#define FILENAME    "/local/IMG_%04d.jpg"
LocalFileSystem fs("local");
#endif
Camera_LS_Y201 cam1(p17, p18);

typedef struct work {
    FILE *fp;
} work_t;

work_t work;

  
  
    uint8_t send[16] = {
        0x56,
        0x00,
        0x32,
        0x0C,
        0x00,
        0x0A,
        0x00,
        0x00,
        0x00, // MH
        0x00, // ML
        0x00,
        0x00,
        0x00, // KH
        0x00, // KL
        0x00, // XX
        0x00  // XX
    };
   
    uint16_t x = 10;    // Interval time. XX XX * 0.01m[sec]
    bool end = true;
    uint16_t m = 0; // Staring address.
     /*
     * Get the data size.
     */
uint8_t body[16000];
uint16_t k = sizeof(body);   
    int siz_done = 0;
    int siz_total = 0;
    int cnt = 0;
    int z;
//////////////////////////////////////////
void callback_func(int done, int total, uint8_t *buf, size_t siz) {
    
   // fwrite(buf, siz, 1, work.fp);

for(int i=0;i<siz;i++)
{
//xbee.printf("%x",buf[i]);
fprintf(work.fp,"%c",buf[i]);
 }
 
    static int n = 0;
    int tmp = done * 100 / total;
    if (n != tmp) {
        n = tmp;
        DEBMSG("Writ%3d%%", n);
        NEWLINE();
   }
}



////////////////////////////////////////////    




   void readdJpegFileContent(void (*func)(int done, int total, uint8_t *buf, size_t siz)) {



if(m==0)
{
z=sizeof(body); 
 }  
    
    //if (r != NoError) {
      //  return r;
    //}

    
        send[8] = (m >> 8) & 0xff;
        send[9] = (m >> 0) & 0xff;
        send[12] = (k >> 8) & 0xff;
        send[13] = (k >> 0) & 0xff;
        send[14] = (x >> 8) & 0xff;
        send[15] = (x >> 0) & 0xff;
        /*
         * Send a command.
         */
        cam1.sendBytes(send, sizeof(send), 200 * 1000) ;
       // printf("sended header");
        //    return SendError;
        
        /*
         * Read the header of the response.
         */
        uint8_t header[5];
        cam1.recvBytes(header, sizeof(header), 2 * 1000 * 1000);
        //    return RecvError;
        //printf("recved header");
        /*
         * Check the response and fetch an image data.
         */
         
        if ((header[0] == 0x76)
                && (header[1] == 0x00)
                && (header[2] == 0x32)
                && (header[3] == 0x00)
                && (header[4] == 0x00)) {
          
            cam1.recvBytes(body, z, 2 * 1000 * 1000); //{
                //return RecvError;
           // }
         //   printf("saved");
            
            siz_done += z;
            
            if (func != NULL) {
                if (siz_done > siz_total) {
                    z=sizeof(body)-siz_done+siz_total+3;
                    siz_done = siz_total;
                    
                    
                }
                func(siz_done, siz_total, body, z);
            }
            for (int i = 1; i < z; i++) {
                if ((body[i - 1] == 0xFF) && (body[i - 0] == 0xD9)) {
                    end = true;
                    //printf("saved%d",i);
                }
            }
        } //else {
           // return UnexpectedReply;
        //}
        /*
         * Read the footer of the response.
         */
        uint8_t footer[5];
        cam1.recvBytes(footer, sizeof(footer), 2 * 1000 * 1000);// {
        //    return RecvError;
        //}

        m += z;
    
   // return NoError;
}

//////////////////
/**
 * Capture.
 *
 * @param cam A pointer to a camera object.
 * @param filename The file name.
 *
 * @return Return 0 if it succeed.
 */
 float p=0.1;//////////////servo
 int flag=1;///////////////servo
int capture(Camera_LS_Y201 *cam, char *filename) {
    /*
     * Take a picture.
     */
if(end==true)
{
    ///////////////////////////////////////////servo
     myservo = p;
     //pc.printf("hhhhhhh%fhhhh",p);
    if (flag==1)        
    {
        p+=0.1;
    }
    else
    {
        p-=0.1;
        }
    if(p>0.9)
    
    {
    flag=0;
    }
    
    if(p<0.1)
    {
    flag=1;
     }
    
    //////////////////////////////////////////servo
    if (cam->takePicture() != 0) {
        return -1;
    }
    cam1.readJpegFileSize(&siz_total);
//    printf("%d",siz_total);
    siz_done = 0;

      
    DEBMSG("Captured.");
    NEWLINE();
    work.fp = fopen(filename, "wb");
    //p1= fopen("/sd/IMG_11111.txt", "wb");
    if (work.fp == NULL) {
        return -2;
    }

    /*
     * Read the content.
     */
    DEBMSG("%s", filename);
    NEWLINE();
end=false;
}
    /*
     * Open file.
     */
    
    readdJpegFileContent(callback_func);
       // fclose(work.fp);
        //return -3;
    
    

    /*
     * Stop taking pictures.
     */
 if(end== true)
 {
    fclose(work.fp);
    cam->stopTakingPictures();

DEBMSG("[%04d]:OK.", cnt);
            NEWLINE();
m=0;
cnt++;
//wait(1);
//xbee.printf("saved");
}
    return 0;
}
////////////////////////////
/////////////////////////

/////////////////////////////////////////////////////
int main(void) {
    
    xbee.baud(115200);
    pc.baud(115200);
    
DEBMSG("Camera module");
    NEWLINE();
    DEBMSG("Resetting...");
    NEWLINE();
    wait(1);

    if (cam1.reset() == 0) {
        DEBMSG("Reset OK.");
        NEWLINE();
    } else {
        DEBMSG("Reset fail.");
        NEWLINE();
        error("Reset fail.");
    }


    wait(1);
    cam1.baud();
    int j=1;
    int g=1;
    while (1) {
        
    char fname[64];
     //  xbee.printf("hello%d\n\r",g);
       
       if((end==true)||(j==1))
       {
        
        snprintf(fname, sizeof(fname) - 1, FILENAME, cnt);
        j=0;
        }
        capture(&cam1, fname);
        //if (r == 0) {
            
        
        //    }
        //} else {
            //DEBMSG("[%04d]:NG. (code=%d)", cnt, r);
           // NEWLINE();
           // error("Failure.");
        //}
        g++;
    }
}