File content as of revision 6:4749dd1acdd1:

/**
 * C328-7640 device driver class (Version 0.0.2)
 * Reference documents: C328-7640 User Manual v3.0 2004.8.19
 *
 * Copyright (C) 2010 Shinichiro Nakamura (CuBeatSystems)
 * http://shinta.main.jp/
 */

#include "mbed.h"

#ifndef _CAMERA_C328_H_
#define _CAMERA_C328_H_

/** C328-7640 Device Driver Class.
 *
 * @code
 * #include "mbed.h"
 * #include "CameraC328.h"
 *
 * CameraC328 camera(p9, p10, CameraC328::Baud57600);
 *
 * const int IMG_X = 80;
 * const int IMG_Y = 60;
 * char buf[IMG_X * IMG_Y * 2];
 *
 * void uncompressed_callback(size_t done, size_t total, char c) {
 *     buf[done - 1] = c;
 * }
 *
 * void jpeg_callback(char *buf, size_t siz) {
 *     for (int i = 0; i < (int)siz; i++) {
 *         fprintf(fp_jpeg, "%c", buf[i]);
 *     }
 * }
 *
 * void test_uncompressed_snapshot_picture(void) {
 *     CameraC328::ErrorNumber err = CameraC328::NoError;
 *
 *     err = camera.sync();
 *     err = camera.init(CameraC328::Color16bit, CameraC328::RawResolution80x60, CameraC328::JpegResolution80x64);
 *     err = camera.getUncompressedSnapshotPicture(uncompressed_callback);
 *
 *     snprintf(fname, sizeof(fname), "/fs/ucss.ppm");
 *     FILE *fp = fopen(fname, "w");
 *     fprintf(fp, "P3\n");
    fprintf(fp, "%d %d\n", IMG_X, IMG_Y);
    fprintf(fp, "%d\n", 255);
    for (int y = 0; y < IMG_Y; y++) {
        for (int x = 0; x < IMG_X; x++) {
            int adrofs = y * (IMG_X * 2) + (x * 2);
            uint16_t dat = (buf[adrofs + 0] << 8) | (buf[adrofs + 1] << 0);
            uint8_t r = ((dat >> 11) & 0x1f) << 3;
            uint8_t g = ((dat >> 5) & 0x3f) << 2;
            uint8_t b = ((dat >> 0) & 0x1f) << 3;
            fprintf(fp,"%d %d %d\n", r, g, b);
        }
    }
    fclose(fp);
}

void test_uncompressed_preview_picture(void) {
    CameraC328::ErrorNumber err = CameraC328::NoError;

    err = camera.init(CameraC328::Color16bit, CameraC328::RawResolution80x60, CameraC328::JpegResolution80x64);
    if (CameraC328::NoError == err) {
        serial.printf("[ OK ] : CameraC328::init\n");
    } else {
        serial.printf("[FAIL] : CameraC328::init (Error=%02X)\n", (int)err);
    }

    for (int i = 0; i < 10; i++) {
        err = camera.getUncompressedPreviewPicture(uncompressed_callback);
        if (CameraC328::NoError == err) {
            serial.printf("[ OK ] : CameraC328::getUncompressedPreviewPicture\n");
        } else {
            serial.printf("[FAIL] : CameraC328::getUncompressedPreviewPicture (Error=%02X)\n", (int)err);
        }

        char fname[64];
        snprintf(fname, sizeof(fname), "/fs/ucpv%04d.ppm", i);
        FILE *fp = fopen(fname, "w");
        fprintf(fp, "P3\n");
        fprintf(fp, "%d %d\n", IMG_X, IMG_Y);
        fprintf(fp, "%d\n", 255);
        for (int y = 0; y < IMG_Y; y++) {
            for (int x = 0; x < IMG_X; x++) {
                int adrofs = y * (IMG_X * 2) + (x * 2);
                uint16_t dat = (buf[adrofs + 0] << 8) | (buf[adrofs + 1] << 0);
                uint8_t r = ((dat >> 11) & 0x1f) << 3;
                uint8_t g = ((dat >> 5) & 0x3f) << 2;
                uint8_t b = ((dat >> 0) & 0x1f) << 3;
                fprintf(fp,"%d %d %d\n", r, g, b);
            }
        }
        fclose(fp);
    }
}

void test_jpeg_snapshot_picture(void) {
    CameraC328::ErrorNumber err = CameraC328::NoError;

    err = camera.init(CameraC328::Jpeg, CameraC328::RawResolution80x60, CameraC328::JpegResolution640x480);
    if (CameraC328::NoError == err) {
        serial.printf("[ OK ] : CameraC328::init\n");
    } else {
        serial.printf("[FAIL] : CameraC328::init (Error=%02X)\n", (int)err);
    }

    for (int i = 0; i < 10; i++) {
        char fname[64];
        snprintf(fname, sizeof(fname), "/fs/jpss%04d.jpg", i);
        fp_jpeg = fopen(fname, "w");

        err = camera.getJpegSnapshotPicture(jpeg_callback);
        if (CameraC328::NoError == err) {
            serial.printf("[ OK ] : CameraC328::getJpegSnapshotPicture\n");
        } else {
            serial.printf("[FAIL] : CameraC328::getJpegSnapshotPicture (Error=%02X)\n", (int)err);
        }

        fclose(fp_jpeg);
    }
}

void test_jpeg_preview_picture(void) {
    CameraC328::ErrorNumber err = CameraC328::NoError;

    err = camera.init(CameraC328::Jpeg, CameraC328::RawResolution80x60, CameraC328::JpegResolution640x480);
    if (CameraC328::NoError == err) {
        serial.printf("[ OK ] : CameraC328::init\n");
    } else {
        serial.printf("[FAIL] : CameraC328::init (Error=%02X)\n", (int)err);
    }

    for (int i = 0; i < 10; i++) {
        char fname[64];
        snprintf(fname, sizeof(fname), "/fs/jppv%04d.jpg", i);
        fp_jpeg = fopen(fname, "w");

        err = camera.getJpegPreviewPicture(jpeg_callback);
        if (CameraC328::NoError == err) {
            serial.printf("[ OK ] : CameraC328::getJpegPreviewPicture\n");
        } else {
            serial.printf("[FAIL] : CameraC328::getJpegPreviewPicture (Error=%02X)\n", (int)err);
        }

        fclose(fp_jpeg);
    }
}

int main() {
    serial.baud(19200);
    serial.printf("\n");
    serial.printf("==========\n");
    serial.printf("CameraC328\n");
    serial.printf("==========\n");

    sync();
    test_uncompressed_snapshot_picture();
    test_uncompressed_preview_picture();
    test_jpeg_preview_picture();
    test_jpeg_snapshot_picture();
}
 */
class CameraC328 {
public:

    /**
     * Color type
     */
    enum ColorType {
        GrayScale2bit = 0x01,   // 2bit for Y only
        GrayScale4bit = 0x02,   // 4bit for Y only
        GrayScale8bit = 0x03,   // 8bit for Y only
        Color12bit = 0x05,      // 444 (RGB)
        Color16bit = 0x06,      // 565 (RGB)
        Jpeg = 0x07
    };

    enum RawResolution {
        RawResolution80x60 = 0x01,
        RawResolution160x120 = 0x03
    };

    enum JpegResolution {
        JpegResolution80x64 = 0x01,
        JpegResolution160x128 = 0x03,
        JpegResolution320x240 = 0x05,
        JpegResolution640x480 = 0x07
    };

    enum ErrorNumber {
        NoError = 0x00,
        PictureTypeError = 0x01,
        PictureUpScale = 0x02,
        PictureScaleError = 0x03,
        UnexpectedReply = 0x04,
        SendPictureTimeout = 0x05,
        UnexpectedCommand = 0x06,
        SramJpegTypeError = 0x07,
        SramJpegSizeError = 0x08,
        PictureFormatError = 0x09,
        PictureSizeError = 0x0a,
        ParameterError = 0x0b,
        SendRegisterTimeout = 0x0c,
        CommandIdError = 0x0d,
        PictureNotReady = 0x0f,
        TransferPackageNumberError = 0x10,
        SetTransferPackageSizeWrong = 0x11,
        CommandHeaderError = 0xf0,
        CommandLengthError = 0xf1,
        SendPictureError = 0xf5,
        SendCommandError = 0xff
    };

    enum PictureType {
        SnapshotPicture = 0x01,
        PreviewPicture = 0x02,
        JpegPreviewPicture = 0x05
    };

    enum SnapshotType {
        CompressedPicture = 0x00,
        UncompressedPicture = 0x01
    };

    enum Baud {
        Baud7200 = 7200,
        Baud9600 = 9600,
        Baud14400 = 14400,
        Baud19200 = 19200,  // Default.
        Baud28800 = 28800,
        Baud38400 = 38400,
        Baud57600 = 57600,
        Baud115200 = 115200
    };

    enum ResetType {
        ResetWholeSystem = 0x00,
        ResetStateMachines = 0x01
    };

    enum DataType {
        DataTypeSnapshotPicture = 0x01,
        DataTypePreviewPicture = 0x02,
        DataTypeJpegPreviewPicture = 0x05
    };

    /**
     * @param tx TX of UART.
     * @param rx RX of UART.
     * @param baud Baudrate of UART. (Default is Baud19200)
     */
    CameraC328(PinName tx, PinName rx, Baud baud = Baud19200);

    ~CameraC328();

    ErrorNumber sync();
    ErrorNumber init(ColorType ct, RawResolution rr, JpegResolution jr);
    ErrorNumber getUncompressedSnapshotPicture(void(*func)(size_t done, size_t total, char c));
    ErrorNumber getUncompressedPreviewPicture(void(*func)(size_t done, size_t total, char c));
    ErrorNumber getJpegSnapshotPicture(void(*func)(char *buf, size_t siz));
    ErrorNumber getJpegPreviewPicture(void(*func)(char *buf, size_t siz));

private:
    Serial serial;
    static const int COMMAND_LENGTH = 6;
    static const int SYNCMAX = 60;
    static const int packageSize = 512;

    ErrorNumber sendInitial(ColorType ct, RawResolution rr, JpegResolution jr);
    ErrorNumber sendGetPicture(PictureType pt);
    ErrorNumber sendSnapshot(SnapshotType st, uint16_t skipFrames);
    ErrorNumber sendSetPackageSize(uint16_t packageSize);
    ErrorNumber sendSetBaudrate(Baud baud);
    ErrorNumber sendReset(ResetType rt, bool specialReset);
    ErrorNumber sendPowerOff();
    ErrorNumber recvData(DataType *dt, uint32_t *length);
    ErrorNumber sendSync();
    ErrorNumber recvSync();
    ErrorNumber sendAck(uint8_t commandId, uint16_t packageId);
    ErrorNumber recvAckOrNck();

    bool sendBytes(char *buf, size_t len, int timeout_us = 20000);
    bool recvBytes(char *buf, size_t len, int timeout_us = 20000);
    bool waitRecv();
};

#endif