cmregisterio.c

Abstract—Wireless networks in combination with image sensors open up a multitude of previously unth

/*
 * Module:  cmRegisterIO.c
 *
 * Description:  Contains the 1670 implementation of the register I/O
 *               commands.
 *
 *
 * There are several delay periods that can be configured using 
 * cmRegisterIoctl.
 *
 *          g_read_delay - delay this number of ms after sending out a read
 *                          command.
 *          g_write_delay - delay this number of ms after sending out a 
 *                          write command.
 *          g_autobaud_delay - delay this number of ms after an autobaud
 *
 * WARNING: there should really be a check done on the COM PORT to make
 * sure that cmInit had been called, but we assume good citizens will use
 * this.
 */
#include <stdio.h>
#include "cmRegisterIo.h"
#include "cmApiCom.h"

extern int g_debug;
extern HANDLE g_comh;       /* HANDLE of com port opened earlier in cmInit */

#define CM_CMDBUF_SIZE 20

int g_read_delay = 0;               /* ms delay after read command */
int g_write_delay = 0;              /* ms delay after write command */
int g_autobaud_delay = 10;          /* ms delay after autobaud */
/*
 * Function:    cmRegisterWrite
 *
 * Description: Write to a register on the 1670 camera module
 *
 *      This function understands the protocol required. It will use 
 *      the EOP and the SOP, and insert ESC characters where needed.
 *
 * Inputs:
 *      addr        Register address (16 bits)
 *      data        Register data (16 bits)
 *
 *  Returns:
 *      < 0         Error
 *
 */

int cmRegisterWrite (unsigned int addr, unsigned int data)
{
    int status = 0;
    unsigned char cmdbuf[CM_CMDBUF_SIZE];       /* don't really need this many bytes */
    unsigned char cval;
    int i;


    if (g_debug > 0) printf ("\nWriting %x to register %x\n", data, addr);

    /* build packet */
    i = 0;
    cmdbuf[i] = CM_CMD_SOP_WRITE;
    /* address word */
    cval = (addr & 0xff00) >> 8;
    if ((cval == CM_CMD_EOP) || (cval == CM_CMD_ESC_VAL)) {   /* check if ESC needed */
        cmdbuf[++i] = CM_CMD_ESC_VAL;
    }
    cmdbuf[++i] = cval;
    cval = (addr & 0x00ff);
    if ((cval == CM_CMD_EOP) || (cval == CM_CMD_ESC_VAL)) {   /* check if ESC needed */
        cmdbuf[++i] = CM_CMD_ESC_VAL;
    }
    cmdbuf[++i] = cval;
    /* data word */
    cval = (data & 0xff00) >> 8;
    if ((cval == CM_CMD_EOP) || (cval == CM_CMD_ESC_VAL)) {   /* check if ESC needed */
        cmdbuf[++i] = CM_CMD_ESC_VAL;
    }
    cmdbuf[++i] = cval;
    cval = (data & 0x00ff);
    if ((cval == CM_CMD_EOP) || (cval == CM_CMD_ESC_VAL)) {   /* check if ESC needed */
        cmdbuf[++i] = CM_CMD_ESC_VAL;
    }
    cmdbuf[++i] = cval;
    /* End of packet byte */
    cmdbuf[++i] = CM_CMD_EOP;
    /* terminate for COMM program */
    cmdbuf[++i] = 0x00;

    /* send it out. No response needed for this packet.  */
    cmComSend (g_comh, cmdbuf, i);      /* no response will come back */

    Sleep (g_write_delay);
    return status;
}
/*
 * Function:    cmRegisterRead
 *
 * Description: Read a register on the 1670 camera module
 *
 *      This function understands the protocol required. It will parse 
 *      the EOP and the SOP.
 *
 * Inputs:
 *      addr        Register address (16 bits)
 *      data        Register data (16 bits)
 *
 *  Returns:
 *      < 0         Error
 */
int cmRegisterRead (unsigned int addr, unsigned int *data_p)
{
    int status = 0;
    unsigned char cmdbuf[128];
    unsigned char cval;
    unsigned int mydata = 0;
    int bytesread = 0;
    int i;


    if (g_debug > 0) printf ("\nReading register %x\n", addr);

    /* build command */
    i = 0;
    cmdbuf[i] = CM_CMD_SOP_READ;
    /* load address */
    cval = (addr & 0xff00) >> 8;
    if ((cval == CM_CMD_EOP) || (cval == CM_CMD_ESC_VAL)) {   /* check if ESC needed */
        cmdbuf[++i] = CM_CMD_ESC_VAL;
    }
    cmdbuf[++i] = cval;
    cval = (addr & 0x00ff);
    if ((cval == CM_CMD_EOP) || (cval == CM_CMD_ESC_VAL)) {   /* check if ESC needed */
        cmdbuf[++i] = CM_CMD_ESC_VAL;
    }
    cmdbuf[++i] = cval;

    /* end of packet */
    cmdbuf[++i] = CM_CMD_EOP;
    /* terminate for COMM program */
    cmdbuf[++i] = 0x00;

    /* send command */
    cmComSend (g_comh, cmdbuf, i);      

    /* get response */
    cmComRecv (g_comh, cmdbuf, 128, &bytesread);
    i = 1;                  /* skip the SOP */
    *data_p = (cmdbuf[i] << 8) + cmdbuf[i + 1];

    Sleep (g_read_delay);
    return status;
}
/*
 * Function:    cmAutoBaud
 *
 * Description:    Send out the autobaud character
 *
 * Returns:     void
 */

void cmAutoBaud (void)
{
    unsigned char cmdbuf[CM_CMDBUF_SIZE];
    int i = 0;

    cmdbuf[i] = CM_CMD_AUTOBAUD_CHAR;   /* auto baud detection char for 1670 */
    cmdbuf[++i] = 0x00;         /* required for cmComSend */

    cmComSend (g_comh, cmdbuf, i);
    /* send again */
    cmComSend (g_comh, cmdbuf, i);

    Sleep (g_autobaud_delay);
}
/*
 * Function: cmRegisterIoctl
 *
 * Description: Set up IO control parameters
 *
 * Input Parameters:
 *          tag
 *          value
 *
 * Output Parameters:
 *          None
 *
 * Returns:  
 *          < 0         Error (unknown tag)
 */
int cmRegisterIoctl (cmRegisterIO_tag_t tag, int value)
{

    int status = 0;

    switch (tag) {

        case CMREGISTERIO_TAG_READ_DELAY:
            g_read_delay = value;
            break;
        case CMREGISTERIO_TAG_WRITE_DELAY:
            g_write_delay = value;
            break;
        case CMREGISTERIO_TAG_AUTOB_DELAY:
            g_autobaud_delay = value;
            break;
        default:
            status = -1;        /* unknown tag */
            break;

    }
    return status;
}