cmapi.c

MATSNL is a package of MATLAB M-files for computing wireless sensor node lifetime/power budget and

/*
 * cmAPI.c - Module for the 1670 implementation of the Camera Module
 *           API interface
 *
 * Modification History:
 *
 *  1.3     - Added cmRegisterIoctl() to be able to set delays after 
 *              read/write and autobaud functions.  
 */

#include <stdio.h>
#include "cmApi.h"
#include "cmApiCom.h"
#include "cmRegisterIO.h"
#include "cmIniFile.h"
#include "cmJpgHdr.h"


/* Global variables */
int g_debug = 0;                /* debug level */
char g_revision_string[] = "1.3";
HANDLE g_comh;                  /* COM port handle */
int g_videomode = 1;            /* 1 = enabled, 0 = disabled */
int g_packetsize = 2048;               /* packet size on image transfers */
int g_getImageMode = CM_PACKETCODES;
int g_image_timeout = 3;        /* timeout counter for get image call */

Image_t g_defaultStill;         /* default settings */
Image_t g_defaultVideo;         /* default settings */


/* forward declarations */
static int IsVideoEnabled(void);


/*
 * Function: cmRevisionGet 
 * 
 * Description:     Retrieve the API revision
 *
 * Inputs:  None
 * Outputs: None
 * Returns:
 *      revision string
 */
char * cmRevisionGet(void)
{
    return g_revision_string;        
}

/*
 * Function cmIdGet 
 *
 * Description: Retrieve the Camera ID
 *
 * Inputs:
 *      id_p        Pointer to location to store ID
 *
 * Outputs:
 *      id_p        The camera ID
 * Returns:
 *      < 0         Error
 */
int cmIdGet (unsigned int *id_p)
{
    int status = 0;

    status = cmRegisterRead (CM_REG_ID, id_p);

    return status;
}

/*
 * Function:  cmInit 
 *
 * Description: Initialize the 1670 upon startup.
 *
 * Inputs:
 *      comName     For the 1670, this is the com port name "com1" or
 *                  "com2".
 *      filename    Name of an initialization file.  Register settings
 *                  can be set here. If the filename field is NULL, do 
 *                  not override any register values.
 * Outpus: None
 * Returns: 
 *      < 0         Error
 */
int cmInit (char *comName, char *filename)
{
    int status = 0;
    unsigned int data;

    /* Open up COM port */
    if (comName != NULL) {
        g_comh = cmComOpen (comName);
        if (g_comh == INVALID_HANDLE_VALUE) {
            printf ("Could not open COM port, %s, Error = %d\n", comName, GetLastError());
            status = -1;
            return status;
        }

    /* perform autobaud detection for RS232 */
        cmAutoBaud ();
    }

    /* read initialization file */
    if (filename != NULL) {
        status = cmIniFileRead (filename);
        if (status < 0) {
            printf ("\nError processing initialization file\n");
        }
    }

    /* Initialize the image_t structures */

    /* video */
    cmRegisterRead (CM_REG_SZR_IN_W_VID, &data);
    g_defaultVideo.szr_in_w = data;
    cmRegisterRead (CM_REG_SZR_IN_H_VID, &data);
    g_defaultVideo.szr_in_h = data;
    cmRegisterRead (CM_REG_SZR_OUT_W_VID, &data);
    g_defaultVideo.szr_out_w = data;
    cmRegisterRead (CM_REG_SZR_OUT_H_VID, &data);
    g_defaultVideo.szr_out_h = data;

    /* still */
    cmRegisterRead (CM_REG_SZR_IN_W_STL, &data);
    g_defaultStill.szr_in_w = data;
    cmRegisterRead (CM_REG_SZR_IN_H_STL, &data);
    g_defaultStill.szr_in_h = data;
    cmRegisterRead (CM_REG_SZR_OUT_W_STL, &data);
    g_defaultStill.szr_out_w = data;
    cmRegisterRead (CM_REG_SZR_OUT_H_STL, &data);
    g_defaultStill.szr_out_h = data;

    cmRegisterRead (CM_REG_UART_PCKT_SIZE, &data);
    g_packetsize = data;

    return status;
}
int cmImageSizeGet (int *width_p, int *height_p) 
{
    unsigned int data;
    int status = 0;

    cmRegisterRead (CM_REG_SZR_OUT_W_STL, &data);
    *width_p = data;
    cmRegisterRead (CM_REG_SZR_OUT_H_STL, &data);
    *height_p = data;

    return status;
}
/*
 * Function:    cmImageGet 
 *
 * Description: Retrieve an image from the imager
 *
 *      The data is retrieved form the imager (jpeg format), and the
 *      correct jpeg header is built.
 *
 *      The initialization file would either have either started the
 *      camera in video mode or still mode. If it is in still mode, the
 *      application must call the cmImageSmap function to take a picture
 *
 *      The data streamed from the 1670 is jpeg data, but it does not 
 *      include the header. Therefore, the header must be built.
 *
 * Inputs:
 *      buffer      A pointer to a buffer that is sized large enough for
 *                  the image. The size can be determined by the camera
 *                  ID type and the settings.  For the 1670, the maximum
 *                  possible size can be 640*480*3.
 *      nbytes      A pointer to a location to put the length of the 
 *                  data written to the buffer in bytes.
 * Outputs:
 *      buffer      jpeg data written to the buffer
 *      nbytes      length of data written to the buffer.
 *
 * Returns:
 *      < 0         Error, no image
 *        0         No problems
 *      > 0         Image status 
 */
int cmImageGet (unsigned char *buffer_p, int *length_p)
{
    int status = 0;
// fix this
    unsigned char inbuf[4096];  /* add 3 bytes for SOP EOP BRK */
// end fix this
    int bytesread = 0;
    int i;
    int data_len = 0;           /* # bytes in buffer */
    int timeout_count = 0;
    unsigned char sop;              /* start  of packet protocol code */
    unsigned char eop;              /* end of packet protocol code */
    int offset = 0;
    int eop_offset = 0;
    int image_done = 0;
    int bytecount = 0;
    int timeout = 0;

    cmFlowCtlSet (1);   
    if (g_debug > 0) {
        fflush(NULL);
    }
    /* Read in the jpeg data. */
    /* The only exit from this loop is if we have an EOP condition */
    while (!image_done) {             /* image not done */
        bytecount = 0;
        timeout_count = 0;
        bytesread = 0;
        timeout = 0;
        /* note that the last packet nay be less than the packet size */
        while (bytecount < (g_packetsize+3)) {
            status = cmComRecv (g_comh, &inbuf[bytecount], 4096, &bytesread);
            if (status < 0) {
                printf ("Read error retrieving image %d\n", GetLastError());
                break;
            }

            if (bytesread == 0) {
                ++timeout_count;
                if (timeout_count > g_image_timeout) {
                    /* this is primarily for the last packet whichis always less than
                       the packet size */
                    timeout = 1;  // not an error case. This happens every image.
                    break;
                }
                //Sleep (20);
                continue;     // otherwise continue 
            }
            bytecount = bytecount + bytesread;
            if (g_debug > 0) {
                printf ("bytes = %d\n", bytecount);
                fflush(NULL);
            }
        } // end while
        //if (timeout == 1) break;        /* done with this one */ 
        /*
         * At this point, we have a full packet 
         */
        /* check if SOP is present */
        sop = inbuf[0]; 
        offset = 0;
        eop_offset = 0;
        switch (sop) {
            case 0x11:
                offset = 1;     /* skip this byte */
                eop_offset = eop_offset + 1;
                break;  
            default:
                offset = 0;
                break;
        }
        eop = inbuf[bytecount - 2];
        switch (eop) {
            case 0x04:
                /* end of the packet, use CREDIT flow control */
                cmFlowCtlSet (1);   
                eop_offset = eop_offset + 2;     /* skip 3 end bytes*/
                break;  
            case 0x02:
                /* End of the image */
                eop_offset = eop_offset + 2;
                image_done = 1;
                break;
            default:
                printf ("Warning: not EOP code \n");
                eop_offset = eop_offset + 0;     /* continue reading */
                break;
        }
        /* check the EOP conditons */
        for (i = 0; i < (bytecount - eop_offset); ++i) {
            buffer_p[(data_len+i)] = inbuf[i+offset];
        }
        data_len = data_len + i;

    }  
    if (g_debug > 0) {
        printf ("total bytes = %d\n",data_len);
        fflush(NULL);
    }

    *length_p = data_len;

    return status;
}

/*
 * Function:    cmFlowCtlSet
 *
 * Description:  Set the number of credits for flow control
 *
 * Inputs:
 *      credits     The number of credits. 0 = disable.
 *
 * Outputs:
 *      None
 *
 * Return:
 *      < 0         Error
 */
int cmFlowCtlSet (int credits)
{
    int status = 0;

    status = cmRegisterWrite (CM_REG_UART_CREDITS, credits);

    return status;
}
/*
 * Function:    cmDestroy
 *
 * Description: Perform the opposite of cmInit
 *
 *  Applications need to call this before they exit. It cleans up the 
 *  communication port.
 *
 * Inputs: None
 *
 * Outputs: None
 *
 * Returns: void
 */
void cmDestroy (void)
{
    cmComClose (g_comh);
}
/*
 * Function: cmDebugLevelSet
 *
 * Description: Set the debug level to control debug output
 *
 * Inputs:
 *          debug_level     0 = no debug output
 *
 * Outputs: 
 *          None
 * Returns: void
 */
void cmDebugLevelSet (int debug_level)
{
    g_debug = debug_level;
    if (debug_level >= 5) {
        cmComIoctl (CMCOMIOCTL_TAG_DBG, &g_debug);
    }
}
/*
 * Function: IsVideoEnabled
 *
 * Description: Returns true if video mode is enabled
 *
 *      The value is stored in a global variable g_videomode, so 
 *      that the register does not have to be read each time to get
 *      the state.
 *
 * Input: None
 * Output: None
 *
 * Returns: 
 *      1       Video Mode enabled
 *      0       Video Mode disabled
 */
static int IsVideoEnabled(void)
{
    int status = 1;