/* * 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 20int 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;}