TermApp/app/src/main/cpp/SensorsProtocol.cpp

#include <jni.h>
#include <string>

#include <fcntl.h>
#include <unistd.h>
#include <sys/ioctl.h>
#include <linux/spi/spidev.h>
#include <android/log.h>
#include <stdio.h>
#include <dirent.h>
#include <stdlib.h>
#include <unistd.h>
#include <fcntl.h>
#include <string.h>
#include <termios.h>
#include <time.h>
#include "GPIOControl.h"
#include "serialComm.h"
#include "SensorsProtocol.h"
#include <sys/time.h>
#include "SensorsProtocol.h"
//#include "Eint.h"

SIO_PARAM_SERIAL_DEF serialport[MAX_SERIAL_PORT_NUM];
SERIAL_PARAM devparam[MAX_SERIAL_DEV_NUM];
#if 0
float weatherpntmsg[10];

static void setInt(int cmd, int value)
{
    int fd = open("/dev/mtkgpioctrl", O_RDONLY);
    IOT_PARAM param;
    param.cmd = cmd;
    param.value = value;
    // LOGE("set_int fd=%d,cmd=%d,value=%d\r\n",fd, cmd, value);
    if( fd > 0 )
    {
        int res = ioctl(fd, IOT_PARAM_WRITE, &param);
        // LOGE("set_int22 cmd=%d,value=%d,result=%d\r\n",param.cmd, param.value, param.result);
        close(fd);
    }
    return;
}
static void setRS485Enable(bool z) {
    setInt(CMD_SET_485_EN_STATE, z ? 1 : 0);
}

static void set485WriteMode() {
    setInt(CMD_SET_485_STATE, 1);
}

static void set485ReadMode() {
    setInt(CMD_SET_485_STATE, 0);
}
static void set12VEnable(bool z) {
    setInt(CMD_SET_12V_EN_STATE, z ? 1 : 0);
}

static void setCam3V3Enable(bool enabled)
{
    setInt(CMD_SET_CAM_3V3_EN_STATE, enabled ? 1 : 0);
}
/*********************************************************************************
*						            气象数据处理							         *
**********************************************************************************/
static void PortDataProcess( void )
{
    float			fvalue, fcorvalue, *fvalua, frnb/*, fwind*/;
    //WORD		uDevAddr;
    unsigned char		cmdidx;
    int			i, j, aipnt, datanum;
    SIO_PARAM_SERIAL_DEF	*pPortParam;
    char			szbuf[64];

    pPortParam = &serialport;
    //取出装置地址,开始处理地址+++
    if(0x02 == pPortParam->m_au8RecvBuf[5])
    {
        //pPortParam->devaddr = pPortParam->m_au8RecvBuf[4];
        return;
    }
    cmdidx = pPortParam->m_au8RecvBuf[5];
#if 0
    aipnt = pPortParam->SameTypeDevIdx;
    uDevAddr = serialport->m_au8RecvBuf[4];
    if(0 == srdt.IsReadWireTem)
    {
        if(uDevAddr != pPortParam->devaddr)
            return;
    }
#endif
    fvalua = &fvalue;
    datanum = pPortParam->m_au8RecvBuf[6];
    if((0x08 != cmdidx) && (0x09 != cmdidx))
        return;

    for(i = 0, j=7; (i<datanum) && (j<6+pPortParam->m_au8RecvBuf[1]); i++, j+=5 )
    {
        if(0x08 == cmdidx)
            fvalue = (pPortParam->m_au8RecvBuf[j+1]<<24)+(pPortParam->m_au8RecvBuf[j+2]<<16)
                     +(pPortParam->m_au8RecvBuf[j+3]<<8)+pPortParam->m_au8RecvBuf[j+4];
        else
        {
            *(u_char *)fvalua = pPortParam->m_au8RecvBuf[j+4];
            *((u_char *)fvalua+1) = pPortParam->m_au8RecvBuf[j+3];
            *((u_char *)fvalua+2) = pPortParam->m_au8RecvBuf[j+2];
            *((u_char *)fvalua+3) = pPortParam->m_au8RecvBuf[j+1];
        }
        switch(pPortParam->m_au8RecvBuf[j])
        {
            case	1:	/*温度*/
                weatherpntmsg[0] = fvalue;
                LOGE("温度:%0.3f  ", fvalue);
                break;
            case	2:	/*气压*/
                weatherpntmsg[5] = fvalue;
                LOGE("气压:%0.3f  ", fvalue);
                break;
            case	3:	/*湿度*/
                weatherpntmsg[1] = fvalue;
                LOGE("湿度:%0.3f  ", fvalue);
                break;
            case	4:	/*雨量*/
                break;
            case	5:	/*日照*/
                break;
            case	6:	/*风速*/
                weatherpntmsg[2] = fvalue;
                LOGE("风速:%0.3f  ", fvalue);
                break;
            case	7:	/*风向*/
                weatherpntmsg[3] = fvalue;
                LOGE("风向:%0.3f  ", fvalue);
                break;
            case	8:	/*拉力*/
            case	9:	/*倾角传感器X轴倾角*/
            case	10:	/*倾角传感器Y轴倾角*/
            case	11:	/*测温球导线温度*/
            case	12:	/*测温球内部温度*/
                break;
            case	13:	/*测温球导线X轴倾角*/
                break;
            case	14:	/*测温球导线Y轴倾角*/
                break;
            case	15:	/*测温球导线电流*/
                break;
            case	16:	/*测温球电池电压*/
                break;
            case	17: /*A相泄漏电流平均值；*/
                break;
            case	18: /*A相泄漏电流最大值；*/
                break;
            case	19: /*A相超过3mA的脉冲频次*/
                break;
            case	20: /*A相超过10mA的脉冲频次*/
                break;
            case	21: /*B相泄漏电流平均值；*/
                break;
            case	22: /*B相泄漏电流最大值；*/
                break;
            case	23: /*B相超过3mA的脉冲频次*/
                break;
            case	24: /*B相超过10mA的脉冲频次*/
            case	25: /*C相泄漏电流平均值；*/
            case	26: /*C相泄漏电流最大值；*/
            case	27: /*C相超过3mA的脉冲频次*/
            case	28: /*C相超过10mA的脉冲频次*/
                break;
        }
    }
}

/***************************************************************
*    		     		按照协议格式化接收数据				       *
***************************************************************/
static void RecvData(u_char *buf, int len)// 规约读数据处理
{
    int  				i, ictime;
    //WORD				crc, check;
    SIO_PARAM_SERIAL_DEF	*pPortParam;

    pPortParam = &serialport;
    ictime = (int)time(NULL);

    if(pPortParam->m_iRecvLen == 0)
    {
        pPortParam->iRecvTime = ictime;
    }
    else
    {
        if((ictime-pPortParam->iRecvTime > 6) || (ictime - pPortParam->iRecvTime < 0))
            pPortParam->iRecvTime = ictime;
        else if(ictime - pPortParam->iRecvTime > 2)
        {
            pPortParam->m_iRecvLen = 0;
            pPortParam->m_iRevStatus = 0;
        }
    }

    for(i=0; i<len; i++)
    {
        switch(pPortParam->m_iRevStatus)
        {
            case 0:			// 0x68
                pPortParam->m_iRecvLen = 0;
                pPortParam->m_au8RecvBuf[pPortParam->m_iRecvLen++] = buf[i];
                if(0x68 == buf[i])
                    pPortParam->m_iRevStatus++;
                else
                    pPortParam->m_iRevStatus = 18;
                break;
            case 1:			// len1
                pPortParam->m_au8RecvBuf[pPortParam->m_iRecvLen++] = buf[i];
                pPortParam->m_iRevStatus++;
                break;
            case 2:			// len2
                pPortParam->m_au8RecvBuf[pPortParam->m_iRecvLen++] = buf[i];
                if(buf[i] == pPortParam->m_au8RecvBuf[pPortParam->m_iRecvLen-2])
                {
                    pPortParam->m_iRevStatus++;
                    pPortParam->m_iNeedRevLength = buf[i]+5;
                }
                else
                    pPortParam->m_iRevStatus = 18;
                break;
            case 3:			// 0x68
                pPortParam->m_au8RecvBuf[pPortParam->m_iRecvLen++] = buf[i];
                pPortParam->m_iNeedRevLength--;
                if(0x68 == buf[i])
                    pPortParam->m_iRevStatus++;
                else
                    pPortParam->m_iRevStatus = 18;
                break;
            case 4:	// 正确接收数据
                pPortParam->m_iNeedRevLength--;
                pPortParam->m_au8RecvBuf[pPortParam->m_iRecvLen++] = buf[i];
                if(pPortParam->m_iNeedRevLength > 0)
                    break;
                if(buf[i] != 0x16)
                {
                    pPortParam->m_iRevStatus=18;
                    break;
                }

                //if(CheckLpcError(serialport->m_au8RecvBuf, pPortParam->m_iRecvLen) == TRUE)
                {
                    PortDataProcess();
                    pPortParam->m_iRevStatus = 0;
                    pPortParam->RevCmdFlag = 1;
                }
                 pPortParam->m_iRecvLen = 0;
                break;
            case 255:// 错误接收数据
            default:
                if(buf[i] == 0x68)
                {
                    pPortParam->m_iRevStatus = 1;
                    pPortParam->m_iRecvLen = 1;
                    pPortParam->m_au8RecvBuf[0] = buf[i];
                }
                else if(buf[i] == 0x16)
                {
                    pPortParam->m_au8RecvBuf[pPortParam->m_iRecvLen++] = buf[i];
                    pPortParam->m_iRevStatus = 0;
                    pPortParam->m_iRecvLen = 0;
                }
                else
                {
                    pPortParam->m_au8RecvBuf[pPortParam->m_iRecvLen++] = buf[i];
                    if(pPortParam->m_iRecvLen > 200)
                    {
                        pPortParam->m_iRecvLen = 0;
                    }
                }
                break;
        }
    }
}

static long get_msec(void )
{
    struct timeval tv;

    gettimeofday(&tv, NULL);
    long time_in_msec = tv.tv_sec * 1000 + tv.tv_usec/1000;

    return time_in_msec;
}
//int inum =0;
//int itimecnt=0;
static int weather_comm(SERIAL_PARAM weatherport)
{
    int fd = -1;
    int len, i,ret, icnt=0;
    long ictime, iruntime, isendtime, irecvtime;
    unsigned char sendbuf[] = {0x68,0x00,0x00,0x68,0x01,0x09,0x0a,0x16};
    char recvbuf[256], szbuf[512];
    //char serial_description[] = "/dev/ttyS0";

#if 0
    DIR *dir = opendir("/dev");
    if (dir == NULL) {
        LOGE("_test_ opendir");
        return -1;
    }

    // 读取目录项
    struct dirent *entry;
    while ((entry = readdir(dir)) != NULL) {
        // 过滤出串口设备，通常以"ttyS"或"ttyUSB"开头
        if ((strncmp(entry->d_name, "ttyS2", 5) == 0) ||
            (strncmp(entry->d_name, "ttyS0", 5) == 0)) {
            LOGE("_test_ Found serial port: %s\n", entry->d_name);
        }
    }

    // 关闭目录
    closedir(dir);
#endif
    serialport.RevCmdFlag = 1;
    serialport.m_iRecvLen = 0;
    serialport.m_iRevStatus = 0;

    set12VEnable(true);
    setCam3V3Enable(true);
    setRS485Enable(true);
    sleep(2);
    //ictime = (int)time(NULL);
    ictime = get_msec();
    for(;;)
    {
        if(fd < 0)
        {
            fd = open(weatherport.pathname, O_RDWR | O_NDELAY);
            //fd = open(weatherport.pathname, O_RDWR | O_NOCTTY);
            if(fd < 0)
            {
                LOGE("_test_ open serial error \n");
                perror(weatherport.pathname);
                return -1;
            }

            ret= set_port_attr (fd, weatherport.baudrate,weatherport.databit,weatherport.stopbit,weatherport.parity,0,0 );/*9600 8n1 */
            if(ret < 0)
            {
                LOGE("_test_ set uart arrt faile \n");
                return -1;
            }
        }

        usleep(10000);
        //iruntime = (int)time(NULL);
        iruntime = get_msec();
        if((iruntime - ictime > 120000) || (iruntime - ictime < 0))
            ictime = iruntime;
        if(iruntime - ictime > 20000)
        {
            memset(szbuf, 0, sizeof(szbuf));
            sprintf(szbuf, "气象采样时间=%0.3f秒,停止采样!", (iruntime-ictime)/1000.0);
            LOGE("%s", szbuf);
            break;
        }

        if(1 == serialport.RevCmdFlag)
        {
            set485WriteMode();

            len = write(fd, sendbuf, sizeof(sendbuf));/* 向串囗发送字符串 */
            serialport.RevCmdFlag = 0;
            LOGE("发送命令时间差%ld毫秒", get_msec()-isendtime);
            //isendtime = time(NULL);
            isendtime = get_msec();
            if (len < 0) {
                LOGE("write data error \n");
                return -1;
            } else {
                memset(szbuf, 0, sizeof(szbuf));
                sprintf(szbuf, "Send：");
                for (i = 0; i < len; i++) {
                    sprintf(szbuf, "%s %02X", szbuf, sendbuf[i]);
                }
                LOGE("%s", szbuf);
                //icnt = 0;
                //inum++;
            }
            tcdrain(fd);
            //usleep(50000);
        }
        else
        {
            //irecvtime = time(NULL);
            irecvtime = get_msec();
            if((irecvtime-isendtime > 6000) ||(irecvtime - isendtime < 0))
                isendtime = irecvtime;
            if (irecvtime-isendtime > 300)
            {
                LOGE("传感器超过%ld毫秒未应答", irecvtime-isendtime);
                serialport.RevCmdFlag = 1;
                serialport.m_iRecvLen = 0;
                serialport.m_iRevStatus = 0;
                close(fd);
                fd = -1;
                continue;
            }
        }
        set485ReadMode();
        memset(recvbuf, 0, sizeof(recvbuf));
        len = read(fd, recvbuf, sizeof(recvbuf));/* 在串口读取字符串 */
        if (len < 0) {
            LOGE("serial read error \n");
            continue;
        }
        if(0 == len)
        {
            //icnt++;
            continue;
        }
        memset(szbuf, 0, sizeof(szbuf));
        sprintf(szbuf, "Recv：");
        for (i = 0; i < len; i++) {
            sprintf(szbuf, "%s %02X", szbuf, recvbuf[i]);
        }
        __android_log_print(ANDROID_LOG_INFO, "serial", "%s", szbuf);
        RecvData((u_char*)recvbuf, len);
        //LOGE("一周期空循环次数%d, 读取次数%d, 时间：%d %d", icnt, inum, (int)time(NULL), itimecnt);
        icnt = 0;
        //serialport.RevCmdFlag =1;
    }

    close(fd);
    set12VEnable(false);
    setCam3V3Enable(false);
    setRS485Enable(false);

    //exit(-1);
    return(0);
}

int serial_port_comm()
{
    SERIAL_PARAM  portparm;

    //struct timeval tv;

    //gettimeofday(&tv, NULL);
    //long time_in_microseconds = tv.tv_sec * 1000000 + tv.tv_usec;

    //LOGE("Current time in microseconds: %ld\n", time_in_microseconds);

#if 1
    memset(portparm.pathname, 0, sizeof(portparm.pathname));
    sprintf(portparm.pathname, "/dev/ttyS0");
    portparm.parity = 'N';
    portparm.databit = 8;
    portparm.baudrate = B9600;
    memset(portparm.stopbit, 0, sizeof(portparm.stopbit));
    sprintf(portparm.stopbit, "1");
#endif
    //itimecnt = (int)time(NULL);

    //for(;;)
        weather_comm(portparm);
    return 0;
}


static speed_t getBaudrate(int baudrate)
{
    switch(baudrate) {
        case 0: return B0;
        case 50: return B50;
        case 75: return B75;
        case 110: return B110;
        case 134: return B134;
        case 150: return B150;
        case 200: return B200;
        case 300: return B300;
        case 600: return B600;
        case 1200: return B1200;
        case 1800: return B1800;
        case 2400: return B2400;
        case 4800: return B4800;
        case 9600: return B9600;
        case 19200: return B19200;
        case 38400: return B38400;
        case 57600: return B57600;
        case 115200: return B115200;
        case 230400: return B230400;
        case 460800: return B460800;
        case 500000: return B500000;
        case 576000: return B576000;
        case 921600: return B921600;
        case 1000000: return B1000000;
        case 1152000: return B1152000;
        case 1500000: return B1500000;
        case 2000000: return B2000000;
        case 2500000: return B2500000;
        case 3000000: return B3000000;
        case 3500000: return B3500000;
        case 4000000: return B4000000;
        default: return -1;
    }
}
#endif

//u_char	serialstatus[MAX_SERIAL_PORT_NUM];
SRDT_DEF	srdt;
AI_DEF		weatherpntmsg[WEATHER_DATA_NUM];
AI_DEF		rallypntmsg[6][RALLY_DATA_NUM];
AI_DEF		slantpntmsg[6][SLANTANGLE_DATA_NUM];

//extern void *	memset(void *m, int c, unsigned int n);
extern int atoi(const char *s);
//extern int Gm_GetSamplingTimeSec(void);
//extern void Delayms(kal_uint32 time);
extern void srand( unsigned int seed );
extern int rand( void );

static long get_msec(void )
{
    struct timeval tv;

    gettimeofday(&tv, NULL);
    long time_in_msec = tv.tv_sec * 1000 + tv.tv_usec/1000;

    return time_in_msec;
}

/*
打开串口电源
*/
void Gm_OpenSerialPower(void)
{
    /*由传送的主站的地方来控制串口电源，这里不实现*/;
}

// 关闭串口电源
void Gm_CloseSerialPower(void)
{
}

// 关闭传感器电源
void Gm_CloseSensorsPower(int port)
{
    char		iIoNo;
    char		szbuf[128];

    sprintf(szbuf, "Close Sensors port %d Power!", port);

    /* 关闭电源*/
    //switch(port)


}

// 打开传感器电源
void Gm_OpenSensorsPower(int port)
{
    char		iIoNo;
    char		szbuf[128];

    if(0 == port)
        return;
    sprintf(szbuf, "Open Sensors port %d Power!", port);
     /* 打开电源*/
    //switch(port)

}

// 查询传感器电源状态
char Gm_GetSensorsPowerState(int port)
{
    char		iIoNo, cstate=0;
    //char		szbuf[128];

    /* 查询电源状态*/
    //switch(port)


    return	cstate;
}

void BytestreamLOG(char* describe, u_char* buf, int len, char flag)
{
    int     i;
    char    szbuf[4096];

    memset(szbuf, 0, sizeof(szbuf));
    if(NULL != describe)
        strncpy(szbuf, describe, strlen(describe));
    for (i = 0; i < len; i++)
    {
        sprintf(szbuf, "%s %02X", szbuf, buf[i]);
    }
    switch (flag)
    {
        case 'E':
            LOGE("%s", szbuf);
            break;
        case 'I':
            LOGI("%s", szbuf);
            break;
        case 'D':
            LOGD("%s", szbuf);
            break;
        case 'V':
            LOGV("%s", szbuf);
            break;
        case 'W':
            LOGW("%s", szbuf);
            break;
        default:
            LOGI("%s", szbuf);
            break;
    }
}

// 打开串口通讯
void Gm_OpenSerialPort(int devidx)
{
    int	fd = -1;

    if((devidx < 0) || (devidx >= MAX_SERIAL_DEV_NUM))
        return;
    if(serialport[devparam[devidx].commid].fd < 0)
    {
        fd = open(devparam[devidx].pathname, O_RDWR | O_NDELAY);
        if(fd < 0)
        {
            LOGE("装置%d 打开串口%d失败！fd=%d\n", devidx+1, devparam[devidx].commid+1, fd);
            return;
        }
        LOGI("装置%d 打开串口%d成功！fd=%d\n", devidx+1, devparam[devidx].commid+1, fd);
        serialport[devparam[devidx].commid].fd = fd;
        return;
    }
    LOGI("装置%d 串口%d已经打开！fd=%d\n", devidx+1, devparam[devidx].commid+1, serialport[devparam[devidx].commid].fd);
}

// 关闭串口通讯
void Gm_CloseSerialPort(void)
{
    int     i;

    for(i=0; i<MAX_SERIAL_PORT_NUM; i++)
    {
        if(serialport[i].fd > 0)
        {
            close(serialport[i].fd);
            serialport[i].fd = -1;
        }
    }

}

/*******************************************************************************
函数名称: int GM_SerialComSend(const BYTE * cSendBuf, DWORD nSendLen, int commid)
功能说明:串口发送数据 返回实际发送的字节数
输入参数:
输出参数:
其它说明:
*********************************************************************************/
int GM_SerialComSend(unsigned char * cSendBuf, unsigned long nSendLen, int commid)
{
    int     i, len;
    char    szbuf[512];

    len = write(serialport[commid].fd, cSendBuf, nSendLen);/* 向串囗发送字符串 */
    //serialport[commid].RevCmdFlag = 0;
    //LOGE("发送命令时间差%ld毫秒", get_msec() - isendtime);
    //isendtime = time(NULL);
    //isendtime = get_msec();
    if (len < 0)
    {
        LOGE("write data error \n");
        return -1;
    }
    else if(len > 0)
    {
        //memset(szbuf, 0, sizeof(szbuf));
        //sprintf(szbuf, "串口%d发送%d字节：", commid+1, len);
        //BytestreamLOG(szbuf, cSendBuf, len, 'D');
#if 0
        for (i = 0; i < len; i++)
        {
            sprintf(szbuf, "%s %02X", szbuf, cSendBuf[i]);
        }
        LOGE("%s", szbuf);
#endif
    }
    return len;
}

int Gm_SetSerialPortParam(int commid)
{
    int ret;
    SERIAL_PARAM *pPortParam=NULL;

    pPortParam = &devparam[srdt.curdevidx[commid]];
    ret= set_port_attr (serialport[commid].fd, pPortParam->baudrate,pPortParam->databit,pPortParam->stopbit,pPortParam->parity,0,0 );/*9600 8n1 */
    if(ret < 0)
    {
        LOGE("串口%d 波特率等参数设置错误！", commid+1);
        return -1;
    }
    return ret;
}

void Gm_InitSerialComm_Test(void)
{
    int	i, j;

    srdt.sampling = 0;
    srdt.PtzCmdType = Cmd_Cancel;			// 云台指令类型
    for(i=0; i<MAX_SERIAL_PORT_NUM; i++)
    {
        //***************** 串行端口信息 ************************
        //g_serialparam[i].Baud = 1200;
        //g_serialparam[i].dataBits = 8;
        //g_serialparam[i].stopBits = 1;
        //g_serialparam[i].parity = 0;
        //******************** Poll Cmd ****************************
        serialport[i].Retry = 0;
        //serialport[i].RetryTime = 500/TIMER_CNT;
        j = TIMER_CNT;
        serialport[i].RetryTime = 300/TIMER_CNT;
        j = 1500/TIMER_CNT;
        serialport[i].WaitTime = 0;
        memset(serialport[i].m_au8RecvBuf, 0, RECVDATA_MAXLENTH);	// 接收数据缓存区
        ClearCmdFormPollCmdBuf(i);
    }
    //g_serialparam[1].Baud = 1200;
    for(i=0; i<MAX_SERIAL_DEV_NUM; i++)
        devparam[i].IsNoInsta = 0;
    devparam[0].ProtocolIdx = WEATHER_PROTOCOL;
    devparam[0].baudrate = B9600;
    devparam[0].databit = 8;
    memset(devparam[0].stopbit, 0, sizeof(devparam[0].stopbit));
    sprintf(devparam[0].stopbit, "1");
    devparam[0].parity = 0;
    devparam[0].IsNoInsta = 1;
    //devparam[0].PowerPort = 2;
    devparam[0].devaddr = 4;

    devparam[1].ProtocolIdx = WEATHER_PROTOCOL;
    devparam[1].baudrate = B9600;
    devparam[1].databit = 8;
    memset(devparam[1].stopbit, 0, sizeof(devparam[1].stopbit));
    sprintf(devparam[1].stopbit, "1");
    devparam[1].parity = 0;
    devparam[1].IsNoInsta = 1;
    //devparam[1].PowerPort = 14;
    devparam[1].devaddr = 1;
#if 0
    devparam[2].ProtocolIdx = SLANT_PROTOCOL;
    devparam[2].baudrate = 1200;
    devparam[2].databit = 8;
    devparam[2].stopbit = 1;
    devparam[2].parity = 0;
    devparam[2].IsNoInsta = 0;
    //devparam[2].PowerPort = 3;
    devparam[2].devaddr = 2;

    devparam[3].ProtocolIdx = PELCO_P_PROTOCOL;
    devparam[3].baudrate = 9600;
    devparam[3].databit = 8;
    devparam[3].stopbit = 1;
    devparam[3].parity = 0;
    devparam[3].IsNoInsta = 0;
    //devparam[3].PowerPort = 15;
    devparam[3].CameraChannel = 1;
    devparam[3].devaddr = 0;

    devparam[4].ProtocolIdx = WDIITEMP_PROTOCOL_NEW;
    devparam[4].baudrate = 1200;
    devparam[4].databit = 8;
    devparam[4].stopbit = 1;
    devparam[4].parity = 0;
    devparam[4].IsNoInsta = 0;
    //devparam[4].PowerPort = 17;
    devparam[4].devaddr = 4;

    devparam[5].ProtocolIdx = RALLY_PROTOCOL_NEW;
    devparam[5].baudrate = 9600;
    devparam[5].databit = 8;
    devparam[5].stopbit = 1;
    devparam[5].parity = 0;
    devparam[5].IsNoInsta = 1;
    //devparam[5].PowerPort = 6;
    devparam[5].devaddr = 11;

    devparam[6].ProtocolIdx = RALLY_PROTOCOL_NEW;
    devparam[6].baudrate = 9600;
    devparam[6].databit = 8;
    devparam[6].stopbit = 1;
    devparam[6].parity = 0;
    devparam[6].IsNoInsta = 1;
    //devparam[6].PowerPort = 6;
    devparam[6].devaddr = 12;

    devparam[7].ProtocolIdx = RALLY_PROTOCOL_NEW;
    devparam[7].baudrate = 9600;
    devparam[7].databit = 8;
    devparam[7].stopbit = 1;
    devparam[7].parity = 0;
    devparam[7].IsNoInsta = 1;
    //devparam[7].PowerPort = 6;
    devparam[7].devaddr = 10;

    devparam[8].ProtocolIdx = PELCO_P_PROTOCOL;
    devparam[8].baudrate = 9600;
    devparam[8].databit = 8;
    devparam[8].stopbit = 1;
    devparam[8].parity = 0;
    devparam[8].IsNoInsta = 0;
    //devparam[8].PowerPort = 10;
    devparam[8].CameraChannel = 2;
    devparam[8].devaddr = 0;

    devparam[9].ProtocolIdx = WDIITEMP_PROTOCOL_NEW;
    devparam[9].baudrate = 9600;
    devparam[9].databit = 8;
    devparam[9].stopbit = 1;
    devparam[9].parity = 0;
    devparam[9].IsNoInsta = 1;
    //devparam[9].PowerPort = 17;
    devparam[9].devaddr = 47;

    devparam[10].ProtocolIdx = LCURRENT_PROTOCOL;
    devparam[10].baudrate = 9600;
    devparam[10].databit = 8;
    devparam[10].stopbit = 1;
    devparam[10].parity = 0;
    devparam[10].IsNoInsta = 1;
    //devparam[10].PowerPort = 5;
    devparam[10].devaddr = 7;

    devparam[11].ProtocolIdx = LCURRENT_PROTOCOL;
    devparam[11].baudrate = 9600;
    devparam[11].databit = 8;
    devparam[11].stopbit = 1;
    devparam[11].parity = 0;
    devparam[11].IsNoInsta = 1;
    //devparam[11].PowerPort = 6;
    devparam[11].devaddr = 6;

    devparam[12].ProtocolIdx = LCURRENT_PROTOCOL;
    devparam[12].baudrate = 9600;
    devparam[12].databit = 8;
    devparam[12].stopbit = 1;
    devparam[12].parity = 0;
    devparam[12].IsNoInsta = 1;
    //devparam[12].PowerPort = 8;
    devparam[12].devaddr = 5;

    devparam[13].ProtocolIdx = SLANT_PROTOCOL;
    devparam[13].baudrate = 1200;
    devparam[13].databit = 8;
    devparam[13].stopbit = 1;
    devparam[13].parity = 0;
    //devparam[13].PowerPort = 4;
    devparam[13].IsNoInsta = 1;
    devparam[13].devaddr = 2;

    devparam[14].ProtocolIdx = SLANT_PROTOCOL;
    devparam[14].baudrate = 1200;
    devparam[14].databit = 8;
    devparam[14].stopbit = 1;
    devparam[14].parity = 0;
    devparam[14].IsNoInsta = 1;
    //devparam[14].PowerPort = 2;
    devparam[14].devaddr = 3;
#endif
#if 0
    devparam[15].ProtocolIdx = LEIRALLY_PROTOCOL;
//#endif
    devparam[15].ProtocolIdx = WIND_PROTOCOL;
    devparam[15].baudrate = 9600;
    devparam[15].databit = 8;
    devparam[15].stopbit = 1;
    devparam[15].parity = 0;
    devparam[15].IsNoInsta = 1;
    devparam[15].PowerPort = 14;
    devparam[15].devaddr = 1;

    //	6	气象
    // 空气温度
    weatherpntmsg[0].AiParam.fFactor = 1.0;
    weatherpntmsg[0].AiParam.EuValueDelta = 50;
    // 相对湿度
    weatherpntmsg[1].AiParam.fFactor = 1.0;
    weatherpntmsg[1].AiParam.EuValueDelta = 0;
    // 风速
    weatherpntmsg[2].AiParam.fFactor = 0.01;
    weatherpntmsg[2].AiParam.EuValueDelta = 0;
    // 风向
    weatherpntmsg[3].AiParam.fFactor = 0.001;
    weatherpntmsg[3].AiParam.EuValueDelta = 0;
    // 降水强度
    weatherpntmsg[4].AiParam.fFactor = 60;
    weatherpntmsg[4].AiParam.EuValueDelta = 0;
    // 相对空气压力
    weatherpntmsg[5].AiParam.fFactor = 1.0;
    weatherpntmsg[5].AiParam.EuValueDelta = 0;
    // 备用
    weatherpntmsg[6].AiParam.fFactor = 1.0;
    weatherpntmsg[6].AiParam.EuValueDelta = 0;
    // 备用
    weatherpntmsg[7].AiParam.fFactor = 1.0;
    weatherpntmsg[7].AiParam.EuValueDelta = 0;

    smokepntmsg[0].AiParam.EuValueDelta = 0;
    smokepntmsg[0].AiParam.fFactor = 0.1;
    rizhaopntmsg[0].AiParam.fFactor = 1.0;
    rizhaopntmsg[0].AiParam.EuValueDelta = 0;
    rizhaopntmsg[1].AiParam.fFactor = 2.5;
    rizhaopntmsg[1].AiParam.EuValueDelta = 0;

    slantpntmsg[0][0].AiParam.fFactor = 100.0;
    slantpntmsg[0][0].AiParam.EuValueDelta = 0;
    slantpntmsg[0][1].AiParam.fFactor = 100.0;
    slantpntmsg[0][1].AiParam.EuValueDelta = 0;
    slantpntmsg[1][0].AiParam.fFactor = 100.0;
    slantpntmsg[1][0].AiParam.EuValueDelta = 0;
    slantpntmsg[1][1].AiParam.fFactor = 100.0;
    slantpntmsg[1][1].AiParam.EuValueDelta = 0;

    for(i=0; i<6; i++)
        for(j=0; j<RALLY_DATA_NUM; j++)
        {
            rallypntmsg[i][j].AiParam.fFactor = 1.0;
            rallypntmsg[i][j].AiParam.EuValueDelta = 0;
        }
#endif
}

// 初始化所有串口及所接传感器的配置
void Gm_InitSerialComm(void)
{
    int	i;
    char	szbuf[128];

    Gm_InitSerialComm_Test();
    // srdt 配置
    //srdt.sampling = 0;
    //srdt.PtzCmdType = Cmd_Cancel;			// 云台指令类型
    //srdt.SendStopPtzCmdTimeCnt=-1;			// 发送云台停止指令计数
    //srdt.uRunMode = 0;
    //srdt.CommMod = 0;

    // 查找装置使用的串口序号
    //FindDevUseSerialCommNo();

#if 0
    for(i=0; i<MAX_SERIAL_DEV_NUM; i++)
        srdt.ms_dev[i].uOpenPowerFlag = CLOSEPOWER;
#endif

#if 1
    //******************** 端口基本信息 ************************
    for(i=0; i<MAX_SERIAL_DEV_NUM; i++)
    {
        memset(szbuf, 0, sizeof(szbuf));
        switch(devparam[i].ProtocolIdx)
        {
            case	0:
                sprintf(szbuf, "传感器%d没有接!", i+1);
                break;
            case	WEATHER_PROTOCOL:
                sprintf(szbuf, "传感器%d接的是气象传感器!", i+1);
                break;
            case	SERIALCAMERA_PROTOCOL:
                sprintf(szbuf, "传感器%d接的是串口摄像机!", i+1);
                break;
            case	PELCO_P_PROTOCOL:
                sprintf(szbuf, "传感器%d接的是PELCO_P摄像机!", i+1);
                break;
            case	SLANT_PROTOCOL:
                sprintf(szbuf, "传感器%d接的是直川倾角!", i+1);
                break;
            case	WIND_PROTOCOL:
                sprintf(szbuf, "传感器%d接的是风速风向传感器", i+1);
                break;
            case	RALLY_PROTOCOL:
                sprintf(szbuf, "传感器%d接的是拉力!", i+1);
                break;
            case	PELCO_D_PROTOCOL:
                sprintf(szbuf, "传感器%d接的是PELCO_D摄像机!", i+1);
                break;
            case	RESERVE5_PROTOCOL:
                sprintf(szbuf, "传感器%d接的是加密芯片", i+1);
                break;
            default:
                sprintf(szbuf, "传感器%d没有接!", i+1);
                break;
        }
        LOGI("%s", szbuf);

        sprintf(szbuf, "地址%d!；", devparam[i].devaddr);
        LOGI("%s", szbuf);
        if(0 == devparam[i].IsNoInsta)
            sprintf(szbuf, "没有启用!；");
        else
        sprintf(szbuf, "已启用!；");
        LOGI("%s", szbuf);

    }
#endif
#if 0
    //u_char		UseSerialidx;		// 使用的串口序号

	// 数据参数配置
	sprintf(szbuf, "气象数据参数:");
	DebugStringPrintf(szbuf, strlen(szbuf), 1);
	//weatherpntmsg[0].AiParam.EuValueDelta = 500;
	sprintf(szbuf, "温度系数%4.2f, 偏移%4.2f", weatherpntmsg[0].AiParam.fFactor, weatherpntmsg[0].AiParam.EuValueDelta);
	DebugStringPrintf(szbuf, strlen(szbuf), 1);
	sprintf(szbuf, "湿度系数%4.2f, 偏移%4.2f", weatherpntmsg[1].AiParam.fFactor, weatherpntmsg[1].AiParam.EuValueDelta);
	DebugStringPrintf(szbuf, strlen(szbuf), 1);
	sprintf(szbuf, "风速系数%4.2f, 偏移%4.2f", weatherpntmsg[2].AiParam.fFactor, weatherpntmsg[2].AiParam.EuValueDelta);
	DebugStringPrintf(szbuf, strlen(szbuf), 1);
	sprintf(szbuf, "风向系数%4.2f, 偏移%4.2f", weatherpntmsg[3].AiParam.fFactor, weatherpntmsg[3].AiParam.EuValueDelta);
	DebugStringPrintf(szbuf, strlen(szbuf), 1);
	sprintf(szbuf, "雨量系数%4.2f, 偏移%4.2f", weatherpntmsg[4].AiParam.fFactor, weatherpntmsg[4].AiParam.EuValueDelta);
	DebugStringPrintf(szbuf, strlen(szbuf), 1);
	sprintf(szbuf, "空气压力系数%4.2f, 偏移%4.2f", weatherpntmsg[5].AiParam.fFactor, weatherpntmsg[5].AiParam.EuValueDelta);
	DebugStringPrintf(szbuf, strlen(szbuf), 1);

	sprintf(szbuf, "烟雾数据参数:");
	DebugStringPrintf(szbuf, strlen(szbuf), 1);
	sprintf(szbuf, "CO2浓度系数%4.2f, 偏移%4.2f", smokepntmsg[0].AiParam.fFactor, smokepntmsg[0].AiParam.EuValueDelta);
	DebugStringPrintf(szbuf, strlen(szbuf), 1);

#if 0
	sprintf(szbuf, "日照数据参数:");
	DebugStringPrintf(szbuf, strlen(szbuf), 1);
	sprintf(szbuf, "日照系数%4.2f, 偏移%4.2f", rizhaopntmsg[0].AiParam.fFactor, rizhaopntmsg[0].AiParam.EuValueDelta);
	DebugStringPrintf(szbuf, strlen(szbuf), 1);
#endif
#endif
}

// 通过传感器名称来确定使用的串口号
void FindDevUseSerialCommNo(void)
{
    int	i;

    for(i=0; i<MAX_SERIAL_DEV_NUM; i++)
    {
        if(0 == devparam[i].IsNoInsta)
            continue;
        switch(devparam[i].ProtocolIdx)
		{
			case	WEATHER_PROTOCOL:
			case	WIND_PROTOCOL:
			case	SLANT_PROTOCOL:
			case	RALLY_PROTOCOL:
			case	SERIALCAMERA_PROTOCOL:
                memset(devparam[i].pathname, 0, sizeof(devparam[i].pathname));
                /* 目前还不确定具体串口分配，暂时默认使用串口1</dev/ttyS0>*/
                sprintf(devparam[i].pathname, "/dev/ttyS0");
                devparam[i].commid = 0;
				break;
            default:
                devparam[i].IsNoInsta = 0;
                break;
		}
    }
}

void GM_StartSerialComm(void)
{
    int 	i, j;
    char	szbuf[64];
    long    polltime=0;

    // 测试使用初始化配置
    Gm_InitSerialComm();
    //DebugStringPrintf(szbuf, strlen(szbuf), 1);
    memset((void*)srdt.curdevidx, 0, sizeof(srdt.curdevidx));
    //Gm_OpenSerialPower(); /* 不在这使用*/
    FindDevUseSerialCommNo();
    //Gm_InitSensorsIsUse();
    // 初始化串口使用状态
    for(i=0; i<MAX_SERIAL_PORT_NUM; i++)
    {
        serialport[i].m_iRevStatus = 0;
        serialport[i].m_iRecvLen = 0;
        serialport[i].m_iNeedRevLength = 0;
        serialport[i].fd = -1;
        ClearCmdAllFlag(i);
    }
    for(i=0; i<MAX_SERIAL_DEV_NUM; i++)
    {
        srdt.ms_dev[i].FirstCmdTimeCnt = get_msec();
        memset(szbuf, 0, sizeof(szbuf));
        switch(devparam[i].ProtocolIdx)
        {
            case	WEATHER_PROTOCOL:	// 气象
                sprintf(szbuf, "气象");
                srdt.ms_dev[i].IsNeedSerial = 1;
                break;
            case	RALLY_PROTOCOL:		/* 拉力*/
                sprintf(szbuf, "拉力");
                srdt.ms_dev[i].IsNeedSerial = 1;
                break;
            case	WIND_PROTOCOL:				/* 风速风向*/
                sprintf(szbuf, "风速风向");
                srdt.ms_dev[i].IsNeedSerial = 1;
                break;
            case	SLANT_PROTOCOL:			/* 倾角*/
                sprintf(szbuf, "倾角");
                srdt.ms_dev[i].IsNeedSerial = 1;
                break;
            case	PELCO_D_PROTOCOL:		/* 摄像机协议*/
            case	PELCO_P_PROTOCOL:		/* 摄像机协议*/
            case	SERIALCAMERA_PROTOCOL:	/* 串口摄像机协议*/
                sprintf(szbuf, "摄像机");
                break;
            default:
                srdt.ms_dev[i].IsNeedSerial = 0;
                sprintf(szbuf, "无效传感器");
                break;
        }
        LOGI("装置%d, IsNoInsta=%d, 类型：%s", i+1, devparam[i].IsNoInsta, szbuf);
        if(0 == devparam[i].IsNoInsta)
        {
            srdt.ms_dev[i].IsNeedSerial = 0;
            continue;
        }
        // 打开传感器电源
        // 打开对应的485电源
        // 打开串口通讯
        Gm_OpenSerialPort(i);
    }

    LOGI("启动数据采样!");
    /* 直接使用循环进行采样处理*/
    polltime = get_msec();
    for(;;)
    {
        usleep(TIMER_CNT*100);
        //LOGW("polltime=%ldms", get_msec()-polltime);
        polltime = get_msec();
        if(GM_SerialTimer() < 0)
        {
            LOGV("退出采样流程！");
            break;
        }
    }
    return;
}

#if 1
// 启动使用串口拍照
void GM_StartSerialCameraPhoto(BYTE channel, int cmdidx)
{
    BYTE	bCameratype=SPEED_DOME_CAMERA;
    int 		i, flag=0;
    char	szbuf[64];

    srdt.RephotographCnt = 0;
    FindDevUseSerialCommNo();
    //sprintf(szbuf, "sampling=%02X !", srdt.sampling);
    //DebugStringPrintf(szbuf, strlen(szbuf), 1);
    if(0 == srdt.selfflag)
        srdt.selfflag = 1;
    Gm_OpenSerialPower();
    //if(0x00 == srdt.sampling)
    //{
    //    Gm_OpenSerialPort();
    //}
    if(0 == (srdt.sampling & 0x04))
    {
        srdt.sampling |= 4;
        flag = 1;
    }
    if(0x01 == (srdt.sampling & 0x01))
        flag = 0;
    // 初始化串口使用状态
    for(i=0; i<MAX_SERIAL_DEV_NUM; i++)
    {
        srdt.ms_dev[i].recvdatacnt = 0;
        srdt.ms_dev[i].m_iRevStatus = 0;
        srdt.ms_dev[i].m_iRecvLen = 0;
        srdt.ms_dev[i].m_iNeedRevLength = 0;
        //sprintf(szbuf, "装置%d, IsNoInsta=%d, 规约序号=%d", i+1, srdt.ms_dev[i].IsNoInsta, srdt.ms_dev[i].ProtocolIdx);
        //DebugStringPrintf(szbuf, strlen(szbuf), 1);
        if(0 == devparam[i].IsNoInsta)
        {
            srdt.ms_dev[i].IsNeedSerial = 0;
            continue;
        }
        switch(devparam[i].ProtocolIdx)
        {
            case	SERIALCAMERA_PROTOCOL:		/* 串口摄像机协议*/
            case	PELCO_P_PROTOCOL:		    /* 摄像机协议*/
            case	PELCO_D_PROTOCOL:		    /* 摄像机协议*/
                if((1>devparam[i].CameraChannel) || (devparam[i].CameraChannel >MAX_CHANNEL_NUM))
                {
                    srdt.ms_dev[i].IsNeedSerial = 0;
                    break;
                }
                if(channel == devparam[i].CameraChannel)
                {
                        ;
                }
                else
                    break;
                if(SERIAL_CAMERA == bCameratype)
                {
                    if(0 == srdt.ms_dev[i].IsNeedSerial)
                        srdt.iLastGetPhotoNo = -1;
                    else
                        srdt.iLastGetPhotoNo = srdt.ms_dev[i].SerialCmdidx;
                    srdt.ms_dev[i].IsNeedSerial = 1;
                    srdt.ms_dev[i].SerialCmdidx = cmdidx;
                    srdt.ms_dev[i].FirstCmdTimeCnt = -1;
                    srdt.sendphotocmdcnt = 0;
                    break;
                }
                srdt.ms_dev[i].IsNeedSerial = 0;
                break;
            default:
                if(1 == srdt.ms_dev[i].IsNeedSerial)
                    break;
                srdt.ms_dev[i].IsNeedSerial = 0;
                break;
        }
    }
    if(0x01 == flag)
    {
        sprintf(szbuf, "非数据采样期间，摄像机拍照启动串口定时器!");
        LOGI("%s", szbuf);
        //StartTimer(GM_SERIAL_START, TIMER_CNT, GM_SerialTimer);
    }
    return;
}
#endif

int GM_SerialTimer(void)
{
    int flag = -1;

    Gm_FindAllSensorsCommand();
    GM_IsCloseSensors();
    GM_AllSerialComRecv();
    flag = GM_CloseTimer();
    return  flag;
}

/********************************************************************************
函数名称: void Gm_FindAllSensorsCommand()
功能说明:轮询所有串口和传感器是否需要生成下发命令
输入参数:
输出参数:
其它说明:
*********************************************************************************/
void Gm_FindAllSensorsCommand(void)
{
    int i, j,curidx,flag;

    //Gm_CheckSensorsPower();  /* 暂时不考虑电源控制*/
    for(j=0; j<MAX_SERIAL_PORT_NUM; j++)
    {
        // 发送缓冲区中命令
        SendCmdFormPollCmdBuf(j);
        // 串口已经被占用则直接跳过
        curidx = srdt.curdevidx[j];
        for(i=0; i<MAX_SERIAL_DEV_NUM; i++)
        {
            curidx = (curidx+1)%MAX_SERIAL_DEV_NUM;
            if(j != devparam[curidx].commid)
                continue;
            if(srdt.ms_dev[curidx].IsNeedSerial == 0)
                continue;
            if(serialport[devparam[curidx].commid].fd < 0)
                Gm_OpenSerialPort(curidx);
            if(serialport[devparam[curidx].commid].cmdlen > 0)
                break;

            flag = -1;
            switch(devparam[curidx].ProtocolIdx)
            {
                case 	WEATHER_PROTOCOL:		/* 温湿度气压*/
                case	RALLY_PROTOCOL:		    /* 拉力*/
                case	WIND_PROTOCOL:				/* 风速风向*/
                case	SLANT_PROTOCOL:	/* 倾角*/
                    flag = FindNextShxyProtocolCommand(curidx);
                    break;
                case	RESERVE2_PROTOCOL:
                    break;
                case	RESERVE5_PROTOCOL:
                    break;
                case	PELCO_D_PROTOCOL:		/* 摄像机协议*/
                case	PELCO_P_PROTOCOL:		/* 摄像机协议*/
                    flag = FindNextCameraPhotoCommand(curidx);
                    break;
                case	SERIALCAMERA_PROTOCOL:	/* 串口摄像机协议*/
                    break;
            }
            if(flag == -1)
                continue;
            srdt.curdevidx[j] = curidx;
            break;
        }
    }
}

/********************************************************************************
函数名称: void GM_IsCloseSensors()
功能说明:检查所有传感器是否采集完毕，采集完毕的关闭传感器电源
输入参数:
输出参数:
其它说明:
*********************************************************************************/
void GM_IsCloseSensors(void)
{
    int		i;
    char		buf[256];

    for(i=0; i<MAX_SERIAL_DEV_NUM; i++)
    {
        if(srdt.ms_dev[i].IsNeedSerial == 0)
            continue;
        switch(devparam[i].ProtocolIdx)
        {
            case 	WEATHER_PROTOCOL:		/* 气象*/
            case	RALLY_PROTOCOL:		    /* 拉力*/
            case	WIND_PROTOCOL:			/* 风速风向*/
            case	SLANT_PROTOCOL:			/* 倾角*/
                if((get_msec()-srdt.ms_dev[i].FirstCmdTimeCnt > 50*1000) ||(get_msec()-srdt.ms_dev[i].FirstCmdTimeCnt < 0))
                {
                    srdt.ms_dev[i].FirstCmdTimeCnt = get_msec();
                    break;
                }
                if(get_msec()- srdt.ms_dev[i].FirstCmdTimeCnt > 15*1000)
                {
                    srdt.ms_dev[i].IsNeedSerial = 0;
                    // 关闭传感器电源
                    LOGI("读取装置%d数据%0.3f秒，关闭装置%d电源!", i+1, (get_msec()-srdt.ms_dev[i].FirstCmdTimeCnt)/1000.0,i+1);
                    //Gm_CtrlCloseSensorsPower(i);
                }
                break;
            case	PELCO_D_PROTOCOL:	/* 摄像机类型*/
            case	PELCO_P_PROTOCOL:	/* 摄像机类型*/
            case	SERIALCAMERA_PROTOCOL:	/* 串口摄像机协议*/
                if(-1 == srdt.ms_dev[i].SerialCmdidx)
                {
                    if(srdt.ms_dev[i].FirstCmdTimeCnt > 6*1000/TIMER_CNT)
                    {
                        srdt.ms_dev[i].IsNeedSerial = 0;
                        srdt.sampling &= 0xFB;
                        memset(buf, 0, sizeof(buf));
                        LOGI("通道%d摄像机使用完毕!可以关闭摄像机电源!", devparam[i].CameraChannel);
                        //netportparam.SerialCameraPowerCtrl[srdt.ms_dev[i].CameraChannel-1] = 0;
                        //if(0 == netportparam.InitTimeFlag)
                        //    Gm_CtrlCloseSensorsPower(i);
                    }
                }
                srdt.ms_dev[i].FirstCmdTimeCnt++;
                break;
        }
    }
}

/********************************************************************************
函数名称: void GM_AllSerialComRecv()
功能说明:检查所有串口是否有数据接收，有则启动接收
输入参数:
输出参数:
其它说明:
*********************************************************************************/
void GM_AllSerialComRecv(void)
{
    int	i, j, recvlen;
    u_char	recvbuf[RECVDATA_MAXLENTH];
    char		buf[256];

    for(j=0; j<MAX_SERIAL_PORT_NUM; j++)
    {
        memset(recvbuf, 0, sizeof(recvbuf));
        if(serialport[j].fd < 0)
            continue;
        recvlen = read(serialport[j].fd, recvbuf, sizeof(recvbuf));/* 在串口读取字符串 */
        if(recvlen < 1)
            continue;
        sprintf(buf, "收到串口%d, %d字节数据:", j+1, recvlen);
        BytestreamLOG(buf, recvbuf, recvlen, 'I');

        SerialDataProcess(srdt.curdevidx[j], recvbuf, recvlen);
    }
}

/********************************************************************************
函数名称: int GM_CloseTimer()
功能说明:
输入参数:
输出参数:
其它说明:
*********************************************************************************/
int GM_CloseTimer(void)
{
    int		i, j, iretime;
    char		buf[256];

    for(i=0; i<MAX_SERIAL_DEV_NUM; i++)
    {
        if((srdt.ms_dev[i].IsNeedSerial == 1)
           && ((0<devparam[i].ProtocolIdx)&&(INVALID_PROTOCOL >devparam[i].ProtocolIdx)))
            break;
    }
    if(i < MAX_SERIAL_DEV_NUM)
    {
        return 1; // 寻找
    }
    else		// 关闭所有串口及电源
    {
#if 0
        for(i=0; i<MAX_SERIAL_DEV_NUM; i++)
        {
            if((srdt.ms_dev[i].IsNeedSerial == 1) && (7 == devparam[i].ProtocolIdx))
                break;
        }
        if(i<MAX_SERIAL_DEV_NUM)
        {
            if(-1 == srdt.tempsamplingstartime)
            {
                ;
            }
            for(j=0; j<MAX_SERIAL_DEV_NUM; j++)
            {
                if(srdt.ms_dev[j].IsNeedSerial == 0)
                    continue;
                switch(devparam[j].ProtocolIdx)
                {
                    case	7:		// 测温
                        Gm_SetSerialPortParam(srdt.ms_dev[j].UseSerialidx);
                        iretime = (int)get_msec()/1000-srdt.ms_dev[j].FirstCmdTimeCnt;
                        //if(iretime > 35)
                        //{
                       // if((devparam[j].PowerPort) == 0)
                        {
                            sprintf(buf, "打开无线模块电源!当前时间%d秒，起始时间%d秒",
                                    (int)time(NULL), srdt.ms_dev[j].FirstCmdTimeCnt);
                            LOGI("%s", buf);
                        }
                        //}

#if 1
                        //samtime =  (int)(Gm_GetSamplingTimeSec()-10);
                        //if(iretime > samtime)
                        if(iretime > 155)
                        {
                            srdt.ms_dev[j].IsNeedSerial = 0;
                            //srdt.tempsamplingstartime = -1;
                            srdt.tempsamplingsucctime = -1;
                            // 关闭传感器电源
                            memset(buf, 0, sizeof(buf));
                            sprintf(buf, "关闭无线模块电源!当前时间%d秒，起始时间%d秒，采样间隔时间10",
                                    (int)time(NULL), srdt.ms_dev[j].FirstCmdTimeCnt/*, samtime*/);
                            LOGI("%s", buf);
                            //Gm_CtrlCloseSensorsPower(j);
                        }
#endif
                        break;
                }
            }
            //StartTimer(GM_SERIAL_START, TIMER_CNT, GM_SerialTimer);
        }
        else

        {
#endif
#if 0
            for(i=0; i<MAX_SERIAL_DEV_NUM; i++)
            {
                if((srdt.ms_dev[i].IsNeedSerial == 1) && (RESERVE5_PROTOCOL == devparam[i].ProtocolIdx))
                    break;
            }
            if(i<MAX_SERIAL_DEV_NUM)
                return;
            else
            {
#endif
                Gm_CloseSerialPort();
                for(j=0; j<MAX_SERIAL_PORT_NUM; j++)
                    ClearCmdFormPollCmdBuf(j);
                sprintf(buf, "关闭串口定时器!");
                LOGI("%s", buf);
                return -1;
#if 0
                //g_usleep &= 0xFE;
                //if(0 == g_usleep)
                {
                    sprintf(buf, "采集数据结束模块休眠!");
                    LOGI("%s", buf);
                    //if(0 == srdt.uRunMode)
                    //	L1SM_SleepEnable(l1handle);
                }
                //sprintf(buf, "usleep=%d", g_usleep);
                //DebugStringPrintf(buf, strlen(buf), 1);
                srdt.sampling &= 0xFA;

                if(1 == srdt.uRunMode)
                {
                    GM_StartSerialComm();
                    for(i=0; i<MAX_SERIAL_DEV_NUM; i++)
                    {
                        srdt.ms_dev[i].FirstCmdTimeCnt = 4*1000/TIMER_CNT;
                    }
                }
                srdt.tempsamplingstartime = -1;
    }
#endif
#if 0
            if(0 == srdt.selfflag)
                ;
            else
                ;//Gm_CloseSerialPower();
            //srdt.clcyesampling = 0;
            //Gm_CloseAllSensorsPower();

            //srdt.selfflag = 0;
        //}
#endif
    }
}

void SerialDataProcess(int devidx, u_char *buf, int len)
{
    switch(devparam[devidx].ProtocolIdx)
    {
#if 1
        case 	WEATHER_PROTOCOL:		/* 气象*/
        case	RALLY_PROTOCOL:		/* 拉力*/
        case	WIND_PROTOCOL:				/* 风速风向*/
#endif
        case	SLANT_PROTOCOL:			/* 倾角*/
            ShxyProtocolRecvData(devidx, buf,  len);
            break;
        case	RESERVE2_PROTOCOL:			/* 意科电池电量读取协议*/
            break;
        case	RESERVE5_PROTOCOL:			/* 网络安全加密协议*/
            //EncryptRecvData(devidx, buf,  len);
            break;
        case	SERIALCAMERA_PROTOCOL:		/* 青青子木串口摄像机协议*/
            break;
    }
}

/*********************************************************************************
				CameraPhoto 端口数据处理
**********************************************************************************/
void CameraPhotoPortDataProcess( int port)
{
    RTUMSG		rtumsg;
    SERIAL_DEV_DEF	*pPortParam;
    SIO_PARAM_SERIAL_DEF *serialport;
    int img_file_size,  packetnum, iNo, packsize, i=0, presetno, iphototime;
    char			szbuf[128];
    WORD			uDevAddr;
    BYTE			cmdidx, recvend;

    pPortParam = &srdt.ms_dev[port];
    serialport = &serialport[pPortParam->UseSerialidx];

    memset((void*)rtumsg.MsgData, 0, sizeof(rtumsg.MsgData));
    memcpy((void*)rtumsg.MsgData, (void*)serialport->m_au8RecvBuf, pPortParam->m_iRecvLen);
    rtumsg.MsgLen = pPortParam->m_iRecvLen;
    rtumsg.PortIdx = port;
    cmdidx = serialport->m_au8RecvBuf[5];
    uDevAddr = serialport->m_au8RecvBuf[4];

    //sprintf(szbuf, "摄像机地址%d,命令%02X!", uDevAddr, cmdidx);
    //DebugStringPrintf(szbuf, strlen(szbuf), 1);
    if(uDevAddr != devparam[port].devaddr)
        return;

    switch(cmdidx)
    {
        case	0x10:		/* 拍照应答*/
            if(0xFF == rtumsg.MsgData[6])
            {
                srdt.RephotographCnt++;
                if(srdt.RephotographCnt > 2)
                {
                    pPortParam->SerialCmdidx = -1;
                    sprintf(szbuf, "因摄像机重拍%d次均未成功!结束拍照!",srdt.RephotographCnt);
                    //DebugStringPrintf(szbuf, strlen(szbuf), 1);
                }
                break;
            }
            i = 6;
            iphototime = rtumsg.MsgData[i+3]+ (rtumsg.MsgData[i+2]<<8)+(rtumsg.MsgData[i+1]<<16)+(rtumsg.MsgData[i]<<24);
            srdt.photographtime = iphototime;
            i=10;
            img_file_size = rtumsg.MsgData[i+3]+ (rtumsg.MsgData[i+2]<<8)+(rtumsg.MsgData[i+1]<<16)+(rtumsg.MsgData[i]<<24);
            packetnum = rtumsg.MsgData[i+5]+(rtumsg.MsgData[i+4]<<8);
            srdt.imagepacketnum = packetnum;
            srdt.historyimagenum[devparam[port].CameraChannel-1] = rtumsg.MsgData[i+7]+(rtumsg.MsgData[i+6]<<8);
            sprintf(szbuf, "有%d张历史图片!",srdt.historyimagenum[devparam[port].CameraChannel-1]);
            //DebugStringPrintf(szbuf, strlen(szbuf), 1);
            //presetno = (int)GetPhotoPresetNo(pPortParam->CameraChannel);
            presetno = (int)rtumsg.MsgData[i+8];
            //if(0 == netportparam.InitTimeFlag)
            {
                serialport->RevCmdFlag = 1;
                srdt.sendphotocmdcnt = 0;
                pPortParam->SerialCmdidx = 10001;
/* 保存图片*/
                //break
            }
            serialport->RevCmdFlag = 1;
            pPortParam->SerialCmdidx = 1;
            srdt.sendphotocmdcnt = 0;
            break;
        case	0x11:		/* 图片数据包*/
           // if(0 == netportparam.InitTimeFlag)
            {
                serialport->RevCmdFlag = 1;
                srdt.sendphotocmdcnt = 0;
                pPortParam->SerialCmdidx = 10001;
/* 保存图片*/
                //break;
            }
            i = 6;
            iNo = rtumsg.MsgData[i+1]+rtumsg.MsgData[i]*256;
            packsize = rtumsg.MsgData[i+3]+rtumsg.MsgData[i+2]*256;
            sprintf(szbuf, "收到第%d(总%d包)", iNo, srdt.imagepacketnum);
            //DebugStringPrintf(szbuf, strlen(szbuf), 1);
            serialport->RevCmdFlag = 1;
            pPortParam->FirstCmdTimeCnt = 0;
            if((iNo == pPortParam->SerialCmdidx) && (0xFF > rtumsg.MsgData[i+2]))
            {
                if(1 == recvend)
                    pPortParam->SerialCmdidx = 10002;/* 图片读取完成*/
                else if(0xFF == recvend)
                {
                    pPortParam->SerialCmdidx = -1;
                }
                else
                {
                    if((iNo > srdt.imagepacketnum) || (0 >= srdt.imagepacketnum))
                    {
                        pPortParam->SerialCmdidx = -1;
                    }
                    else
                        pPortParam->SerialCmdidx = iNo+1;
                }
                srdt.errorPhotoNoCnt = 0;
                break;
            }
            srdt.errorPhotoNoCnt++;
            sprintf(szbuf, "问询第%d包图片摄像机应答第%d包,连续错误%d次!",
                    pPortParam->SerialCmdidx, iNo, srdt.errorPhotoNoCnt);
            if(srdt.errorPhotoNoCnt > 5)
            {
                pPortParam->SerialCmdidx = 0;
                srdt.RephotographCnt++;
                if(srdt.RephotographCnt > 2)
                {
                    pPortParam->SerialCmdidx = -1;
                    sprintf(szbuf, "因摄像机重拍%d次均未成功!结束拍照!",srdt.RephotographCnt);
                    //DebugStringPrintf(szbuf, strlen(szbuf), 1);
                }
            }
            break;
        case	0x03:
            sprintf(szbuf, "设置波特率%d成功", devparam[port].baudrate);
            //DebugStringPrintf(szbuf, strlen(szbuf), 1);
            //pPortParam->Baud = serialport->Baud;
            pPortParam->SerialCmdidx = srdt.iLastGetPhotoNo;
            serialport->RevCmdFlag = 1;
            pPortParam->FirstCmdTimeCnt = 0;
            break;
        case	0x15:
            if(0xFF == rtumsg.MsgData[6])
            {
                pPortParam->SerialCmdidx = -1;
                sprintf(szbuf, "没有历史图片!结束读取图片!");
                //DebugStringPrintf(szbuf, strlen(szbuf), 1);
                break;
            }
            i = 6;
            iphototime = rtumsg.MsgData[i+3]+ (rtumsg.MsgData[i+2]<<8)+(rtumsg.MsgData[i+1]<<16)+(rtumsg.MsgData[i]<<24);
            srdt.photographtime = iphototime;
            i=10;
            img_file_size = rtumsg.MsgData[i+3]+ (rtumsg.MsgData[i+2]<<8)+(rtumsg.MsgData[i+1]<<16)+(rtumsg.MsgData[i]<<24);
            packetnum = rtumsg.MsgData[i+5]+(rtumsg.MsgData[i+4]<<8);
            srdt.imagepacketnum = packetnum;
            srdt.historyimagenum[devparam[port].CameraChannel-1] = rtumsg.MsgData[i+7]+(rtumsg.MsgData[i+6]<<8);
            //presetno = netportparam.CurPresetno[pPortParam->CameraChannel-1];
            presetno = rtumsg.MsgData[i+8];
            sprintf(szbuf, "读取历史图片,还有%d张历史图片!",srdt.historyimagenum[devparam[port].CameraChannel-1]);
            //DebugStringPrintf(szbuf, strlen(szbuf), 1);
            //if(0 == netportparam.InitTimeFlag)
            {
                serialport->RevCmdFlag = 1;
                srdt.sendphotocmdcnt = 0;
                pPortParam->SerialCmdidx = -1;
                //netportparam.PhotosFlag = FALSE;
                break;
            }
            serialport->RevCmdFlag = 1;
            pPortParam->SerialCmdidx = 1;
            srdt.sendphotocmdcnt = 0;
            break;
        case	0x16:
            if(0xFF == rtumsg.MsgData[10])
            {
                pPortParam->SerialCmdidx = -1;
                sprintf(szbuf, "图片保存失败!");
                //DebugStringPrintf(szbuf, strlen(szbuf), 1);
            }
            if(0 == rtumsg.MsgData[10])
            {
                if(0 == srdt.historyimagenum[devparam[port].CameraChannel-1])
                {
                    //netportparam.SerialCameraPowerCtrl[devparam[port].CameraChannel-1] = 0;
                    srdt.sampling &= 0xFB;

                }
                else
                    pPortParam->FirstCmdTimeCnt = -3*60*1000/TIMER_CNT;
            }
            else
            {
                srdt.sampling &= 0xFB;
                //netportparam.SerialCameraPowerCtrl[pPortParam->CameraChannel-1] = 0;
            }
            pPortParam->SerialCmdidx = -1;
            serialport->RevCmdFlag = 1;
            //if(0 == netportparam.InitTimeFlag)
            break;
        default:
            serialport->RevCmdFlag = 1;
            break;
    }
}

long lsendtime=0;
/*********************************************************************************
							发送命令
**********************************************************************************/
void SendCmdFormPollCmdBuf( int port )
{
    char			buf[64];
    int				len, idelay=0, i, ret;
    SIO_PARAM_SERIAL_DEF 	*pPortParam;
    //int recvlen;
    //u_char  recvbuf[300];

    pPortParam = &serialport[port];
    if(pPortParam->ForceWaitFlag && pPortParam->ForceWaitCnt)
    {
        pPortParam->ForceWaitCnt--;
        return;
    }

    if(pPortParam->SendCmdFlag 	&& (pPortParam->RevCmdFlag == 0))
    {
        pPortParam->RetryTimeCnt++;
        //if(srdt.sendphotocmdcnt > 0)
          //  idelay = 10*1000/TIMER_CNT;
          //LOGV("polltime:%ldms", get_msec()-srdt.ms_dev[0].FirstCmdTimeCnt);
        if(pPortParam->RetryTimeCnt < (pPortParam->RetryTime+idelay))
        {
            return;
        }
        pPortParam->RetryTimeCnt = 0;
        pPortParam->RetryCnt++;
        if(pPortParam->RetryCnt > pPortParam->Retry)
        {
            ClearCmdFormPollCmdBuf(port);
        }
        else
        {
            pPortParam->SendCmdFlag = 0;
            pPortParam->RevCmdFlag = 0;
            pPortParam->ReSendCmdFlag = 1;
        }
    }

    if ( pPortParam->SendCmdFlag && pPortParam->RevCmdFlag )
    {
        // 清除当前命令
        ClearCmdFormPollCmdBuf(port);
    }

    if(pPortParam->WaitTime)
    {
        pPortParam->WaitTimeCnt++;
        if(pPortParam->WaitTimeCnt < pPortParam->WaitTime)
        {
            return;
        }
    }
    pPortParam->WaitTimeCnt = 0;

    if ( pPortParam->ReSendCmdFlag )
        len = pPortParam->cmdlen;
    else
    {
        len = pPortParam->cmdlen;
        pPortParam->RetryCnt = 0;
    }
    if ( len == 0 )
        return;

    serialport[devparam[srdt.curdevidx[port]].commid].m_iRecvLen = 0;	// 当发送一条新指令时，清除接收状态
    serialport[devparam[srdt.curdevidx[port]].commid].m_iRevStatus = 0;
    ret = Gm_SetSerialPortParam(port);
    if(ret < 0)
        return;
    len = GM_SerialComSend(&pPortParam->PollCmd[2], pPortParam->cmdlen-2, port);
    if(len < 1)
    {
        LOGE("串口%d, 发送命令失败!", port+1);
    }
    else
    {

        sprintf(buf, "发送串口%d 装置%d命令:", port+1, srdt.curdevidx[port]+1);
        BytestreamLOG(buf, &pPortParam->PollCmd[i+2], len, 'D');
        LOGW("sendtimeconst= %ld", get_msec()-lsendtime);
        lsendtime = get_msec();
    }
    pPortParam->SendCmdFlag = 1;
    pPortParam->ReSendCmdFlag = 0;
    pPortParam->RevCmdFlag = 0;
    pPortParam->RetryTimeCnt = 0;

    pPortParam->ForceWaitCnt = pPortParam->PollCmd[0]*256+pPortParam->PollCmd[1]+TIMER_CNT-1;
    pPortParam->ForceWaitCnt /= TIMER_CNT;
    if(pPortParam->ForceWaitCnt)
    {
        pPortParam->ForceWaitFlag = 1;
    }
}

void ClearCmdAllFlag(int commid)
{
    if((commid < 0) || (commid >= MAX_SERIAL_PORT_NUM))
        return;

    serialport[commid].RetryCnt = 0;
    serialport[commid].RetryTimeCnt = 0;
    serialport[commid].WaitTimeCnt = 0;
    serialport[commid].ForceWaitFlag = 0;
    serialport[commid].ForceWaitCnt = 0;
    serialport[commid].SendCmdFlag = 0;
    serialport[commid].RevCmdFlag = 0;
    serialport[commid].ReSendCmdFlag = 0;
}

void ClearCmdFormPollCmdBuf(int port)
{
    //int		len, idx;
    SIO_PARAM_SERIAL_DEF 	*pPortParam;

    if((port < 0) || (port >= MAX_SERIAL_PORT_NUM))
        return;
    pPortParam = &serialport[port];

    pPortParam->cmdlen = 0;
    memset(pPortParam->PollCmd, 0, sizeof(pPortParam->PollCmd));
    srdt.serialstatus[port] = 0;
    // 清除指令下发标识
    ClearCmdAllFlag(port);
}

// 下发串口拍照指令控制
int FindNextCameraPhotoCommand(int devidx)
{
    int	imagesize=3, cmdno;
    BYTE	channel, imagequality=50;
    WORD	packetsize;
    BYTE	cmdidx=0x10;
    char		szbuf[128];

    //如果命令缓冲区仍有命令，则退出本函数
    if((srdt.ms_dev[devidx].UseSerialidx < 1) || (srdt.ms_dev[devidx].UseSerialidx >= MAX_SERIAL_PORT_NUM))
        return -1;
    if(-1 == srdt.ms_dev[devidx].SerialCmdidx)/* 下发拍照指令*/
        return -1;
    cmdno = srdt.ms_dev[devidx].SerialCmdidx;
    if(0 == cmdno)/* 下发拍照指令*/
    {
        if(srdt.ms_dev[devidx].FirstCmdTimeCnt < 4*1000/TIMER_CNT)
        {
            return -1;
        }
        if(srdt.ms_dev[devidx].FirstCmdTimeCnt > 35*1000/TIMER_CNT)
        {
            srdt.ms_dev[devidx].SerialCmdidx = -1;
            sprintf(szbuf, "串口摄像机未接或故障!结束拍照!");
            LOGI("%s", szbuf);
            return -1;
        }
        channel = devparam[devidx].CameraChannel;
        if((1>channel) || (channel >MAX_CHANNEL_NUM))
        {
            /* 通道号错误退出拍照流程*/;
            srdt.ms_dev[devidx].SerialCmdidx = -1;
            sprintf(szbuf, "装置配置中，通道号配置错误!结束拍照!");
            LOGI("%s", szbuf);
        }
        packetsize = (WORD)MAX_PHOTO_FRAME_LEN;
        srdt.sendphotocmdcnt++;
        srdt.imagepacketnum = 0;
        srdt.errorPhotoNoCnt = 0;
        cmdidx = 0x10;
        srdt.sendphototime=(int)time(NULL);
    }
    else if(10000 == cmdno)/* 下发设置串口波特率命令*/
    {
        switch(devparam[devidx].baudrate)
        {
            case	9600:
                imagesize = 0x07;
                break;
            case	14400:
                imagesize = 0x08;
                break;
            case	19200:
                imagesize = 0x08;
                break;
            case	38400:
                imagesize = 0x09;
                break;
            case	57600:
                imagesize = 0x09;
                break;
            case	115200:
                imagesize = 0x09;
                break;
            default:
                sprintf(szbuf, "设置串口摄像机参数时，配置参数错误!退出设置!");
                LOGI("%s", szbuf);
                srdt.ms_dev[devidx].SerialCmdidx = srdt.iLastGetPhotoNo;
                return -1;
        }
        if(srdt.ms_dev[devidx].FirstCmdTimeCnt > 15*1000/TIMER_CNT)
        {
            srdt.ms_dev[devidx].SerialCmdidx = -1;
            sprintf(szbuf, "设置串口摄像机参数时，15秒未收到摄像机应答!退出设置!");
            LOGI("%s", szbuf);
            return -1;
        }
        cmdidx = 0x03;
        packetsize = 0xFFFF;
    }
    else if((10001 == cmdno)||(10002 == cmdno))/* 通知摄像机图片读取完成或存储（16H）*/
    {
        cmdidx = 0x16;
        if(10001 == cmdno)
            packetsize = 1;
        else
            packetsize = 0;
        imagesize = srdt.photographtime;	/* 需要保存或删除的图片拍摄时间*/
    }
    else if(10003 == cmdno)		/* 读取历史图片（15H）*/
    {
        cmdidx = 0x15;
        packetsize = (WORD)MAX_PHOTO_FRAME_LEN;
        srdt.sendphototime=(int)time(NULL);
    }
    else
    {
        imagesize = 0xFF;
        packetsize = (WORD)srdt.ms_dev[devidx].SerialCmdidx;
        cmdidx = 0x11;
        if(srdt.ms_dev[devidx].FirstCmdTimeCnt > 35*1000/TIMER_CNT)
        {
            srdt.ms_dev[devidx].SerialCmdidx = -1;
            sprintf(szbuf, "读取第%d包图片数据35秒未收到!结束拍照!",packetsize);
            LOGI("%s", szbuf);
            return -1;
        }
    }
    MakeCameraPhotoCommand(devidx, cmdidx, imagesize, packetsize, imagequality);
    srdt.curdevidx[srdt.ms_dev[devidx].UseSerialidx] = devidx;
    return 1;
}

/*********************************************************************************
					生成 CameraPhoto命令
**********************************************************************************/
void MakeCameraPhotoCommand( int portno, BYTE cmdidx, int OneParam, WORD TwoParam, BYTE Threep )
{
    int			i, icurtime;
    u_char		*sendbuf;
    //char			szbuf[128];

    sendbuf = serialport[srdt.ms_dev[portno].UseSerialidx].PollCmd;

    icurtime = (int)time(NULL);
    i = 0;
    sendbuf[i++] = 0x00;		/* 强制等待时间*/
    sendbuf[i++] = 0x00;		/* 强制等待时间*/
    sendbuf[i++] = 0x68;			/* 起始字符*/
    sendbuf[i++] = (BYTE)0x00;		/* length	*/
    sendbuf[i++] = (BYTE)0x00;		/* length	*/
    sendbuf[i++] = 0x68;			/* 起始字符*/
    sendbuf[i++] = (BYTE)devparam[portno].devaddr;/* 传感器地址*/
    sendbuf[i++] = cmdidx;		/* 命令字*/
    switch(cmdidx)
    {
        case	0x03:	/*设置传感器通讯参数（03H）*/
            sendbuf[i++] = 0x00;	/* 波特率*/
            sendbuf[i++] = 0x00;
            sendbuf[i++] = 0x00;
            sendbuf[i++] = (BYTE)OneParam;
            sendbuf[i++] = 0x08;	/* 数据位*/
            sendbuf[i++] = 0x00;	/* 校验位*/
            sendbuf[i++] = 0x01;	/* 停止位*/
            break;
        case	0x010:	/* 拍摄图片并指定大小分包（10H）*/
            sendbuf[i++] = OneParam;	/* 图片大小（Resolution）*/
            sendbuf[i++] = HIBYTE(TwoParam);/*包大小（PackageSize）*/
            sendbuf[i++] = LOBYTE(TwoParam);
            sendbuf[i++] = HIBYTE(HIWORD(icurtime+8*60*60));/* 请求拍摄图片时间（PhotoTime）*/
            sendbuf[i++] = LOBYTE(HIWORD(icurtime+8*60*60));
            sendbuf[i++] = HIBYTE(LOWORD(icurtime+8*60*60));
            sendbuf[i++] = LOBYTE(LOWORD(icurtime+8*60*60));
            sendbuf[i++] = Threep;/*图像质量（ImageQuality）*/
            //sendbuf[i++] = netportparam.CurPresetno[srdt.ms_dev[portno].CameraChannel-1];/*拍照预置点（PresetNo）*/
            break;
        case	0x11:	/* 获取指定包数据（11H）*/
            sendbuf[i++] = HIBYTE(TwoParam);/*图片包号：（PackageNo）*/
            sendbuf[i++] = LOBYTE(TwoParam);
            break;
        case	0x15:	/* 读取历史图片（15H）*/
            sendbuf[i++] = HIBYTE(TwoParam);/*包大小（PackageSize）*/
            sendbuf[i++] = LOBYTE(TwoParam);
            break;
        case	0x16:	/* 通知摄像机图片读取完成或存储（16H）*/
            sendbuf[i++] = HIBYTE(HIWORD(OneParam));/*  需要保存或删除的图片拍摄时间*/
            sendbuf[i++] = LOBYTE(HIWORD(OneParam));
            sendbuf[i++] = HIBYTE(LOWORD(OneParam));
            sendbuf[i++] = LOBYTE(LOWORD(OneParam));
            sendbuf[i++] = (BYTE)TwoParam;	/* 是否需要保存*/
            break;
    }
    sendbuf[i] = CalLpc((u_char *)&sendbuf[6],i-6);
    i+= 1;
    sendbuf[i++] = 0x16;			/* 信息尾*/
    sendbuf[3] = (BYTE)((i-10)>>8);
    sendbuf[4] = (BYTE)(i-10);
    serialport[srdt.ms_dev[portno].UseSerialidx].cmdlen = i;
    return;
}

// 准备发送云台指令
int Gm_CtrlPtzCmd(u_char channel, DWORD ptzcmd)
{
    int	i;
    char	szbuf[64];

    srdt.PtzCmdType = ptzcmd;
    // 查找装置序号
    for(i=0; i<MAX_SERIAL_DEV_NUM; i++)
    {
        if((channel == devparam[i].CameraChannel) && ((devparam[i].ProtocolIdx ==PELCO_P_PROTOCOL)
                                                         || (devparam[i].ProtocolIdx ==PELCO_D_PROTOCOL)))
            break;
    }
    if(i == MAX_SERIAL_DEV_NUM)
    {
        sprintf(szbuf, "没有找到摄像机使用的通道和串口通讯协议");
        LOGI("%s", szbuf);
        return 1;
    }
    if((2 > srdt.ms_dev[i].UseSerialidx+1) ||(MAX_SERIAL_PORT_NUM < srdt.ms_dev[i].UseSerialidx+1))
    {
        sprintf(szbuf, "通道%d摄像机错误的使用了串口%d", channel, srdt.ms_dev[i].UseSerialidx+1);
        LOGI("%s", szbuf);
        return 1;
    }
    else
    {
        sprintf(szbuf, "摄像机通道%d 使用串口%d", channel, srdt.ms_dev[i].UseSerialidx+1);
        LOGI("%s", szbuf);
    }
    srdt.usecameradevidx = i;
    // 查找串口序号
    srdt.camerauseserial = srdt.ms_dev[i].UseSerialidx;
    //if(0 == srdt.sampling)
    //{
    // 1.打开串口电源
    Gm_OpenSerialPower();
    // 2.打开串口通讯
    Gm_OpenSerialPort(i);
    //}
    srdt.sampling |= 2;
    srdt.SendStopPtzCmdTimeCnt = -1;
    //return 1;
    return Gm_Camera_Timer();
    //return 1;
}

// 发送转动摄像机云台命令定时器
int Gm_Camera_Timer(void)
{
    char	szbuf[128];

    if((2 > srdt.camerauseserial+1) ||(MAX_SERIAL_PORT_NUM < srdt.camerauseserial+1))
    {
        sprintf(szbuf, "摄像机错误的使用了串口%d", srdt.camerauseserial+1);
        LOGI("%s", szbuf);
        return 1;
    }
    if(PELCO_D_PROTOCOL == devparam[srdt.usecameradevidx].ProtocolIdx)
    {
        switch(srdt.PtzCmdType)
        {
            case P_Auto_Scan:
                srdt.PtzCmdType = D_Auto_Scan;
                break;
            case P_IRIS_CLOSE:
                srdt.PtzCmdType = D_IRIS_CLOSE;
                break;
            case P_IRIS_OPEN:
                srdt.PtzCmdType = D_IRIS_OPEN;
                break;
            case P_FOCUS_NEAR:
                srdt.PtzCmdType = D_FOCUS_NEAR;
                break;
            case P_FOCUS_FAR:
                srdt.PtzCmdType = D_FOCUS_FAR;
                break;
            case P_ZOOM_WIDE:
                srdt.PtzCmdType = D_ZOOM_WIDE;
                break;
            case P_ZOOM_TELE:
                srdt.PtzCmdType = D_ZOOM_TELE;
                break;
            case P_MOVE_DOWN:
                srdt.PtzCmdType = D_MOVE_DOWN;
                break;
            case P_MOVE_UP:
                srdt.PtzCmdType = D_MOVE_UP;
                break;
            case P_MOVE_LEFT:
                srdt.PtzCmdType = D_MOVE_LEFT;
                break;
            case P_MOVE_RIGHT:
                srdt.PtzCmdType = D_MOVE_RIGHT;
                break;
        }
    }
    if(srdt.SendStopPtzCmdTimeCnt == -1)
    {
        if(serialport[srdt.camerauseserial].cmdlen > 0)
            return -1;
        if(PELCO_D_PROTOCOL == devparam[srdt.usecameradevidx].ProtocolIdx)
            Gm_SendPelco_DCommand(srdt.PtzCmdType);
        else
            Gm_SendPelco_pCommand(srdt.PtzCmdType);

        if((SET_PRESETNO == (srdt.PtzCmdType & 0xFFFF0000))
           || (MOVE_TO_PRESETNO ==  (srdt.PtzCmdType & 0xFFFF0000)))
        {
            srdt.sampling &= 0xFD;
            return 1;
        }
        srdt.PtzCmdType = Cmd_Cancel;
        srdt.SendStopPtzCmdTimeCnt = 0;
    }

    if(srdt.SendStopPtzCmdTimeCnt > PTZ_MOVETIME*1000)
    {
        if(serialport[srdt.camerauseserial].cmdlen > 0)
            return -1;
        if(PELCO_D_PROTOCOL == devparam[srdt.usecameradevidx].ProtocolIdx)
            Gm_SendPelco_DCommand(srdt.PtzCmdType);
        else
            Gm_SendPelco_pCommand(srdt.PtzCmdType);
        srdt.SendStopPtzCmdTimeCnt = -1;
        srdt.sampling &= 0xFD;
        return 1;
    }
    else
        srdt.SendStopPtzCmdTimeCnt ++;
    return -1;
}

/********************************************************************************
*						 生成 PELCO_P 命令					      			*
*********************************************************************************/
void Gm_SendPelco_pCommand( DWORD cmdtype)
{
    int		len;
    BYTE	commandbuf[32];
    char		buf[128];

    len = 0;
    commandbuf[len++] = (BYTE)0xA0;
    commandbuf[len++] = (BYTE)devparam[srdt.usecameradevidx].devaddr;
    commandbuf[len++] = (BYTE)(cmdtype>>24);
    commandbuf[len++] = (BYTE)(cmdtype>>16);
    commandbuf[len++] = (BYTE)(cmdtype>>8);
    commandbuf[len++] = (BYTE)(cmdtype);
    commandbuf[len++] = (BYTE)0xAF;
    commandbuf[len] = (BYTE)Gm_Pelco_pXORCheck(commandbuf, len);
    len++;
    serialport[srdt.camerauseserial].cmdlen = len;
    Gm_SetSerialPortParam(srdt.camerauseserial);
    len = GM_SerialComSend(commandbuf, len, srdt.camerauseserial);
    if(len < 1)
    {
        LOGE("发送Pelco_p命令失败");
    }
    else
    {
        sprintf(buf, "发送串口%d 像机通道%d Pelco_P命令:",
                srdt.camerauseserial+1, devparam[srdt.usecameradevidx].CameraChannel);
        BytestreamLOG(buf, commandbuf, len, 'D');
    }
    ClearCmdFormPollCmdBuf(srdt.camerauseserial);
    serialport[srdt.camerauseserial].ForceWaitCnt = 100;
    serialport[srdt.camerauseserial].ForceWaitFlag = 1;
}

BYTE Gm_Pelco_pXORCheck( BYTE *msg, int len )
{
    int		i;
    BYTE	checkvalue=0;

    if(len <= 0)
        return checkvalue;
    checkvalue = msg[0];
    for(i=1; i<len; i++)
        checkvalue ^= msg[i];
    return checkvalue;
}

/********************************************************************************
*						 生成 PELCO_D 命令					      			*
*********************************************************************************/
void Gm_SendPelco_DCommand( DWORD cmdtype)
{
    int		len;
    BYTE	commandbuf[32];
    char		buf[128];

    len = 0;
#if 1	/* Pelco_D*/
    commandbuf[len++] = (BYTE)0xFF;
    commandbuf[len++] = (BYTE)devparam[srdt.usecameradevidx].devaddr;
    commandbuf[len++] = (BYTE)(cmdtype>>24);
    commandbuf[len++] = (BYTE)(cmdtype>>16);
    commandbuf[len++] = (BYTE)(cmdtype>>8);
    commandbuf[len++] = (BYTE)(cmdtype);
    commandbuf[len] = (BYTE)Gm_Pelco_DCheck(commandbuf, len);
#endif
    len++;
    serialport[srdt.camerauseserial].cmdlen = len;
    Gm_SetSerialPortParam(srdt.camerauseserial);
    len = GM_SerialComSend(commandbuf, len, srdt.camerauseserial);
    if(len < 1)
    {
        LOGE("发送Pelco_D命令失败");
     }
    else
    {
        sprintf(buf, "发送串口%d 像机通道%d Pelco_D命令:",
                srdt.camerauseserial+1, devparam[srdt.usecameradevidx].CameraChannel);
        BytestreamLOG(buf, commandbuf, len, 'D');
    }
    ClearCmdFormPollCmdBuf(srdt.camerauseserial);
    serialport[srdt.camerauseserial].ForceWaitCnt = 10;
    serialport[srdt.camerauseserial].ForceWaitFlag = 1;
}

// 计算Pelco_D校验
BYTE Gm_Pelco_DCheck( BYTE *msg, int len )
{
    int		i;
    BYTE	checkvalue=0;

    if(len <= 0)
        return checkvalue;
    checkvalue = 0;
    for(i=1; i<len; i++)
        checkvalue += msg[i];
    return checkvalue;
}

/*********************************************************************************
					寻找并生成下一条倾角命令
**********************************************************************************/
int FindNextShxyProtocolCommand( int devidx )
{
    //如果命令缓冲区仍有命令，则退出本函数
    if((devparam[devidx].commid+1 < 1) || (devparam[devidx].commid+1 >= MAX_SERIAL_PORT_NUM))
        return -1;
    //if(srdt.ms_dev[devidx].SerialCmdidx == 0)
    {
        if(get_msec()-srdt.ms_dev[devidx].FirstCmdTimeCnt < 3*1000)
        {
            //srdt.ms_dev[devidx].FirstCmdTimeCnt++;
            return -1;
        }
        //if(SLANT_PROTOCOL == devparam[devidx].ProtocolIdx)
        //    MakeShxyProtocolPollCommand(devidx, 0x06);
        //else if(WEATHER_PROTOCOL== devparam[devidx].ProtocolIdx)
            MakeShxyProtocolPollCommand(devidx, 0x09);
        //else
            //MakeShxyProtocolPollCommand(devidx, 0x08);
        srdt.curdevidx[srdt.ms_dev[devidx].UseSerialidx] = devidx;
        return 1;
    }
    return -1;
}

/*********************************************************************************
							生成下发命令
**********************************************************************************/
void MakeShxyProtocolPollCommand(int portno, BYTE cmdidx)
{
    int			i/*, sendWaitTime = 100, y*/;
    //char			buf[128];
    u_char		*sendbuf;

    sendbuf = serialport[srdt.ms_dev[portno].UseSerialidx].PollCmd;

    i = 0;
    sendbuf[i++] = 0x00;		// 强制等待时间
    sendbuf[i++] = 0x00;		//
    sendbuf[i++] = 0x68;								// 起始字符
    sendbuf[i++] = (BYTE)0x00;							// length
    sendbuf[i++] = (BYTE)0x00;							// length
    sendbuf[i++] = 0x68;
    sendbuf[i++] = (BYTE)devparam[portno].devaddr;		// 传感器地址
    sendbuf[i++] = cmdidx;								// 命令信息0x06
    sendbuf[i] = CalLpc((u_char *)&sendbuf[6],i-6);
    i+= 1;
    sendbuf[i++] = 0x16;								// 信息尾
    serialport[srdt.ms_dev[portno].UseSerialidx].cmdlen = i;
    //sprintf((char*)buf, "生成串口%d 装置%d倾角命令:", srdt.ms_dev[portno].UseSerialidx+1, portno+1);
    //Gm_OMC_UART_DebugHex(buf, i-2, (char*)&sendbuf[2]);
}


unsigned char CalLpc(unsigned char *msg, int len)
{
    int		i;
    u_char	retval = 0;

    for (i = 0 ; i < len; i++)
        retval += msg[i];
    return retval;
}

/***************************************************************
*    		     		    读上海欣影传感器协议数据			    *
***************************************************************/
void ShxyProtocolRecvData(int commid, u_char *buf, int len)// 规约读数据处理
{
    int  				i, ictime;
    //WORD				crc, check;
    //SERIAL_DEV_DEF	*pPortParam;
    SIO_PARAM_SERIAL_DEF *pPortParam;

    if((commid<0) || (commid > MAX_SERIAL_DEV_NUM))
    {
        return;
    }
    pPortParam = &serialport[devparam[commid].commid];

    for(i=0; i<len; i++)
    {
        switch(pPortParam->m_iRevStatus)
        {
            case 0:			// 0x68
                pPortParam->m_iRecvLen = 0;
                pPortParam->m_au8RecvBuf[pPortParam->m_iRecvLen++] = buf[i];
                if(0x68 == buf[i])
                    pPortParam->m_iRevStatus++;
                else
                    pPortParam->m_iRevStatus = 18;
                break;
            case 1:			// len1
                pPortParam->m_au8RecvBuf[pPortParam->m_iRecvLen++] = buf[i];
                pPortParam->m_iRevStatus++;
                break;
            case 2:			// len2
                pPortParam->m_au8RecvBuf[pPortParam->m_iRecvLen++] = buf[i];
                if(buf[i] == pPortParam->m_au8RecvBuf[pPortParam->m_iRecvLen-2])
                {
                    pPortParam->m_iRevStatus++;
                    pPortParam->m_iNeedRevLength = buf[i]+5;
                }
                else
                    pPortParam->m_iRevStatus = 18;
                break;
            case 3:			// 0x68
                pPortParam->m_au8RecvBuf[pPortParam->m_iRecvLen++] = buf[i];
                pPortParam->m_iNeedRevLength--;
                if(0x68 == buf[i])
                    pPortParam->m_iRevStatus++;
                else
                    pPortParam->m_iRevStatus = 18;
                break;
            case 4:	// 正确接收数据
                pPortParam->m_iNeedRevLength--;
                pPortParam->m_au8RecvBuf[pPortParam->m_iRecvLen++] = buf[i];
                if(pPortParam->m_iNeedRevLength > 0)
                    break;
                if(buf[i] != 0x16)
                {
                    pPortParam->m_iRevStatus=18;
                    break;
                }

                if(CheckShxyProtocolLpcError(pPortParam->m_au8RecvBuf, pPortParam->m_iRecvLen) == TRUE)
                {
                    ShxyProtocolDataProcess(commid);
                    pPortParam->m_iRevStatus = 0;
                    pPortParam->RevCmdFlag = 1;
                }
                else
                {
                    pPortParam->m_iRevStatus = 0;
                }
                pPortParam->m_iRecvLen = 0;
                break;
            case 255:// 错误接收数据
            default:
                if(buf[i] == 0x68)
                {
                    pPortParam->m_iRevStatus = 1;
                    pPortParam->m_iRecvLen = 1;
                    pPortParam->m_au8RecvBuf[0] = buf[i];
                }
                else if(buf[i] == 0x16)
                {
                    pPortParam->m_au8RecvBuf[pPortParam->m_iRecvLen++] = buf[i];
                    pPortParam->m_iRevStatus = 0;
                    pPortParam->m_iRecvLen = 0;
                }
                else
                {
                    pPortParam->m_au8RecvBuf[pPortParam->m_iRecvLen++] = buf[i];
                    if(pPortParam->m_iRecvLen > 200)
                    {
                        pPortParam->m_iRecvLen = 0;
                    }
                }
                break;
        }
    }
}

//********************************************************************************
//								检查检验和是否正确
//********************************************************************************
int CheckShxyProtocolLpcError( u_char* msg, int len )
{
    int		bRetval = FALSE;
    int		iCheckLen;

    if(0x68 == msg[0])
    {
        if ( msg[0] != msg[3] )
            return bRetval;
        if ( msg[len-1] != 0x16 )
            return bRetval;
        if ( msg[1] != msg[2] )
            return bRetval;
        iCheckLen = msg[1];
        if ( CalLpc( &msg[4], iCheckLen+2 ) != msg[len-2] )
            return bRetval;
        bRetval = TRUE;
    }
    return bRetval;
}

/*********************************************************************************
						上海欣影传感器协议数据处理
**********************************************************************************/
void ShxyProtocolDataProcess( int commid)
{
    float			fvalue, fcorvalue, *fvalua, frnb/*, fwind*/;
    WORD		uDevAddr;
    BYTE		cmdidx;
    int			i, j, aipnt, datanum;
    SERIAL_DEV_DEF	*pPortParam;
    SIO_PARAM_SERIAL_DEF *serialport;
    char			szbuf[64];

    pPortParam = &srdt.ms_dev[commid];
    serialport = &serialport[pPortParam->UseSerialidx];

    //取出装置地址,开始处理地址+++
    if(0x02 == serialport->m_au8RecvBuf[5])
    {
        devparam[commid].devaddr = serialport->m_au8RecvBuf[4];
        //pPortParam->LinkOk = TRUE;
        return;
    }

    cmdidx = serialport->m_au8RecvBuf[5];
    aipnt = pPortParam->SameTypeDevIdx;
    uDevAddr = serialport->m_au8RecvBuf[4];

    fvalua = &fvalue;
    if(0x06 == cmdidx)
    {
        if(0x08 !=serialport->m_au8RecvBuf[1])
            return;
        pPortParam->recvdatacnt++;
        if(pPortParam->recvdatacnt < 2)
            return;
        // ++++++++++++++++++++++++++++
        //g_SelfTest.SensorsFault |= (0x800<<aipnt);

        *(BYTE*)fvalua = serialport->m_au8RecvBuf[9];
        *((BYTE*)fvalua+1) = serialport->m_au8RecvBuf[8];
        *((BYTE*)fvalua+2) = serialport->m_au8RecvBuf[7];
        *((BYTE*)fvalua+3) = serialport->m_au8RecvBuf[6];
        if((fvalue < -59) ||(fvalue > 59))
        {
            frnb = (GeneratingRandomNumber()%101-50)/1000.0;
            slantpntmsg[aipnt][0].EuValue *= (1+frnb);
        }
        else
            slantpntmsg[aipnt][0].EuValue = fvalue*slantpntmsg[aipnt][0].AiParam.fFactor\
				+slantpntmsg[aipnt][0].AiParam.EuValueDelta;
        slantpntmsg[aipnt][0].AiState = 1;
        //if ((gDisSunRain & 0x20) == 0x20)
        {
            sprintf(szbuf, "倾角ID:%d slantangle X=%0.3f  ", devparam[commid].devaddr, fvalue);
            LOGV("%s", szbuf);
        }
        //XslantSec[aipnt][srdt.SectimesamplingCnt[0]] = (short)slantpntmsg[aipnt][0].EuValue;
        //srdt.SectimesamplingCnt[0] += 1;

        *(BYTE*)fvalua = serialport->m_au8RecvBuf[13];
        *((BYTE*)fvalua+1) = serialport->m_au8RecvBuf[12];
        *((BYTE*)fvalua+2) = serialport->m_au8RecvBuf[11];
        *((BYTE*)fvalua+3) = serialport->m_au8RecvBuf[10];
        //if ((gDisSunRain & 0x20) == 0x20)
        {
            sprintf(szbuf, "Y =%0.3f  ", fvalue);
            LOGV("%s", szbuf);
        }
        if((fvalue < -59) ||(fvalue > 59))
        {
            frnb = (GeneratingRandomNumber()%101-50)/1000.0;
            slantpntmsg[aipnt][1].EuValue *= (1+frnb);
        }
        else
            slantpntmsg[aipnt][1].EuValue = fvalue*slantpntmsg[aipnt][1].AiParam.fFactor\
				+slantpntmsg[aipnt][1].AiParam.EuValueDelta;
        slantpntmsg[aipnt][1].AiState = 1;
        //YslantSec[aipnt][srdt.SectimesamplingCnt[1]] = (short)slantpntmsg[aipnt][1].EuValue;
        srdt.SectimesamplingCnt[1] += 1;
    }
    datanum = serialport->m_au8RecvBuf[6];
    if((0x08 != cmdidx) && (0x09 != cmdidx))
        return;

#if 0
    if(1 == srdt.IsReadWireTem)
    {
        for(i=0; i<MAX_SERIAL_DEV_NUM; i++)
        {
            if((WDIITEMP_PROTOCOL_NEW == srdt.ms_dev[i].ProtocolIdx) && (uDevAddr == (WORD)srdt.ms_dev[i].devaddr))
                break;
        }
        if(i == MAX_SERIAL_DEV_NUM)
            return;
        pPortParam = &srdt.ms_dev[i];
        aipnt = pPortParam->SameTypeDevIdx;
    }
#endif
    for(i = 0, j=7; (i<datanum) && (j<6+serialport->m_au8RecvBuf[1]); i++, j+=5 )
    {
        if(0x08 == cmdidx)
            fvalue = (serialport->m_au8RecvBuf[j+1]<<24)+(serialport->m_au8RecvBuf[j+2]<<16)
                     +(serialport->m_au8RecvBuf[j+3]<<8)+serialport->m_au8RecvBuf[j+4];
        else
        {
            *(BYTE*)fvalua = serialport->m_au8RecvBuf[j+4];
            *((BYTE*)fvalua+1) = serialport->m_au8RecvBuf[j+3];
            *((BYTE*)fvalua+2) = serialport->m_au8RecvBuf[j+2];
            *((BYTE*)fvalua+3) = serialport->m_au8RecvBuf[j+1];
        }
        switch(serialport->m_au8RecvBuf[j])
        {
            case	1:	/*温度*/
                if((fvalue < -40) ||(fvalue > 85))
                {
                    frnb = (GeneratingRandomNumber()%101-50)/1000.0;
                    weatherpntmsg[0].EuValue *= (1+frnb);
                }
                else
                    weatherpntmsg[0].EuValue = fvalue*weatherpntmsg[0].AiParam.fFactor + weatherpntmsg[0].AiParam.EuValueDelta;
                weatherpntmsg[0].AiState = 1;
                //g_SelfTest.SensorsFault |= (0x01);
                //if ((gDisSunRain & 0x80) == 0x80)
                {
                    sprintf(szbuf, "温度:%0.3f  ", fvalue);
                    LOGV("%s", szbuf);
                }
                break;
            case	2:	/*气压*/
                if((fvalue < 550) ||(fvalue > 1060))
                {
                    frnb = (GeneratingRandomNumber()%41-20)/10000.0;
                    weatherpntmsg[5].EuValue *= (1+frnb);
                }
                else
                    weatherpntmsg[5].EuValue = fvalue*weatherpntmsg[5].AiParam.fFactor + weatherpntmsg[5].AiParam.EuValueDelta;
                weatherpntmsg[5].AiState = 1;
                //g_SelfTest.SensorsFault |= (0x10);
                //if ((gDisSunRain & 0x80) == 0x80)
                {
                    sprintf(szbuf, "气压:%0.3f  ", fvalue);
                    LOGV("%s", szbuf);
                }
                break;
            case	3:	/*湿度*/
                if((fvalue < 0) ||(fvalue > 100))
                {
                    frnb = (GeneratingRandomNumber()%41-20)/1000.0;
                    weatherpntmsg[1].EuValue *= (1+frnb);
                }
                else
                    weatherpntmsg[1].EuValue = fvalue*weatherpntmsg[1].AiParam.fFactor + weatherpntmsg[1].AiParam.EuValueDelta;
                weatherpntmsg[1].AiState = 1;
                //g_SelfTest.SensorsFault |= (0x02);
                //if ((gDisSunRain & 0x80) == 0x80)
                {
                    sprintf(szbuf, "湿度:%0.3f  ", fvalue);
                    LOGV("%s", szbuf);
                }
                break;
            case	4:	/*雨量*/
                break;
            case	5:	/*日照*/
                break;
            case	6:	/*风速*/
                if((fvalue/1000 < 0) ||(fvalue/1000 > 80))
                {
                    frnb = (GeneratingRandomNumber()%41-20)/1000.0;
                    weatherpntmsg[2].EuValue *= (1+frnb);
                }
                else
                    weatherpntmsg[2].EuValue = fvalue*weatherpntmsg[2].AiParam.fFactor + weatherpntmsg[2].AiParam.EuValueDelta;
                weatherpntmsg[2].AiState = 1;
                //g_SelfTest.SensorsFault |= (0x04);
                //if ((gDisSunRain & 0x10) == 0x10)
                {
                    //fwind = fvalue/1000*0.95;
                    //if(fvalue/1000 > 25)
                    //	fwind -= 1.2;
                    //sprintf(szbuf, "风速:%0.3f  ", fwind);
                    sprintf(szbuf, "风速:%0.3f  ", fvalue/1000);
                    LOGV("%s", szbuf);
                }
                break;
            case	7:	/*风向*/
                if((fvalue/1000 < 0) ||(fvalue/1000 > 359.99))
                {
                    frnb = (GeneratingRandomNumber()%41-20)/1000.0;
                    weatherpntmsg[3].EuValue *= (1+frnb);
                }
                else
                    weatherpntmsg[3].EuValue = fvalue*weatherpntmsg[3].AiParam.fFactor + weatherpntmsg[3].AiParam.EuValueDelta;
                weatherpntmsg[3].AiState = 1;
                //g_SelfTest.SensorsFault |= (0x08);
                //if ((gDisSunRain & 0x10) == 0x10)
                {
                    sprintf(szbuf, "风向:%0.3f  ", fvalue/1000);
                    LOGV("%s", szbuf);
                }
                break;
            case	8:	/*拉力*/
#if 0
                if(RESERVE1_PROTOCOL == pPortParam->ProtocolIdx)
                {
                    leirallypntmsg[0].EuValue = fvalue*leirallypntmsg[0].AiParam.fFactor\
						+leirallypntmsg[0].AiParam.EuValueDelta;
                    leirallypntmsg[0].AiState = 1;
                    g_SelfTest.SensorsFault |= (0x800000);
                    if ((gDisSunRain & 0x10) == 0x10)
                    {
                        sprintf(szbuf, "地址%d模拟导线拉力:%0.3fKg  ", pPortParam->devaddr, fvalue/1000.0);
                        DebugStringPrintf(szbuf, strlen(szbuf), 1);
                    }
                }
                else
                {
#endif
                    pPortParam->recvdatacnt++;
                    if(pPortParam->recvdatacnt < 2)
                        break;
                    //g_SelfTest.SensorsFault |= (0x040<<aipnt);
                    //if(fvalue/1000.0 < rallypntmsg[aipnt][1].AiParam.EuValueDelta)
                    //	rallypntmsg[aipnt][0].EuValue = 0;
                    //else
                    rallypntmsg[aipnt][0].EuValue = fvalue*rallypntmsg[aipnt][0].AiParam.fFactor\
							+rallypntmsg[aipnt][0].AiParam.EuValueDelta;
                    rallypntmsg[aipnt][0].AiState = 1;
                    //if ((gDisSunRain & 0x10) == 0x10)
                    {
                        sprintf(szbuf, "地址%d拉力:%0.3fKg  ", devparam[commid].devaddr, fvalue/1000.0);
                        LOGV("%s", szbuf);
                    }
                    // yizhonghu 20110629
                    //rallyd[aipnt][srdt.SectimesamplingCnt[2]] = (short)slantpntmsg[aipnt][0].EuValue;
                    srdt.SectimesamplingCnt[2] += 1;
                //}
                break;
            case	9:	/*倾角传感器X轴倾角*/
                break;
            case	10:	/*倾角传感器Y轴倾角*/
                break;
#if 0
            case	11:	/*测温球导线温度*/

                fcorvalue = WireTemperatureCorrection(fvalue/100, (WORD)pPortParam->devaddr);

                wdiitemppntmsg[aipnt][0].EuValue = fvalue*wdiitemppntmsg[aipnt][0].AiParam.fFactor\
					+wdiitemppntmsg[aipnt][0].AiParam.EuValueDelta;
//#else
                wdiitemppntmsg[aipnt][0].EuValue = fcorvalue*100*wdiitemppntmsg[aipnt][0].AiParam.fFactor\
					+wdiitemppntmsg[aipnt][0].AiParam.EuValueDelta;

                wdiitemppntmsg[aipnt][0].AiState = 1;
                g_SelfTest.SensorsFault |= (0x100000);
                sprintf(szbuf, "地址%d导线温度:%0.3f  ", pPortParam->devaddr, fcorvalue);
                DebugStringPrintf(szbuf, strlen(szbuf), 0);
                break;
            case	12:	/*测温球内部温度*/
                wdiitemppntmsg[aipnt][1].EuValue = fvalue*wdiitemppntmsg[aipnt][1].AiParam.fFactor\
					+wdiitemppntmsg[aipnt][1].AiParam.EuValueDelta;
                wdiitemppntmsg[aipnt][1].AiState = 1;
                sprintf(szbuf, "地址%d内部温度:%0.3f  ", pPortParam->devaddr, fvalue/100);
                DebugStringPrintf(szbuf, strlen(szbuf), 1);
                break;
            case	13:	/*测温球导线X轴倾角*/
                wdiitemppntmsg[aipnt][3].EuValue = fvalue*wdiitemppntmsg[aipnt][3].AiParam.fFactor\
					+wdiitemppntmsg[aipnt][3].AiParam.EuValueDelta;
                wdiitemppntmsg[aipnt][3].AiState = 1;
                sprintf(szbuf, "地址%d导线X轴倾角:%0.3f  ", pPortParam->devaddr, fvalue/100);
                DebugStringPrintf(szbuf, strlen(szbuf), 0);
                break;
            case	14:	/*测温球导线Y轴倾角*/
                wdiitemppntmsg[aipnt][4].EuValue = fvalue*wdiitemppntmsg[aipnt][4].AiParam.fFactor\
					+wdiitemppntmsg[aipnt][4].AiParam.EuValueDelta;
                wdiitemppntmsg[aipnt][4].AiState = 1;
                sprintf(szbuf, "地址%d导线Y轴倾角:%0.3f  ", pPortParam->devaddr, fvalue/100);
                DebugStringPrintf(szbuf, strlen(szbuf), 1);
                break;
            case	15:	/*测温球导线电流*/
                wdiitemppntmsg[aipnt][5].EuValue = fvalue*wdiitemppntmsg[aipnt][5].AiParam.fFactor\
					+wdiitemppntmsg[aipnt][5].AiParam.EuValueDelta;
                wdiitemppntmsg[aipnt][5].AiState = 1;
                sprintf(szbuf, "地址%d导线电流:%0.3f  ", pPortParam->devaddr, fvalue/100);
                DebugStringPrintf(szbuf, strlen(szbuf), 0);
                break;
            case	16:	/*测温球电池电压*/
                wdiitemppntmsg[aipnt][2].EuValue = fvalue*wdiitemppntmsg[aipnt][2].AiParam.fFactor\
					+wdiitemppntmsg[aipnt][2].AiParam.EuValueDelta;
                wdiitemppntmsg[aipnt][2].AiState = 1;
                sprintf(szbuf, "地址%d测温球电池电压:%0.3fV  ", pPortParam->devaddr, fvalue/100);
                DebugStringPrintf(szbuf, strlen(szbuf), 1);
                break;
            case	17: /*A相泄漏电流平均值；*/
                LCpntmsg[0].EuValue = fvalue*LCpntmsg[0].AiParam.fFactor + LCpntmsg[0].AiParam.EuValueDelta;
                LCpntmsg[0].AiState = 1;
                sprintf(szbuf, "A相泄漏电流平均值:%0.3f  ", fvalue/100);
                DebugStringPrintf(szbuf, strlen(szbuf), 0);
                break;
            case	18: /*A相泄漏电流最大值；*/
                LCpntmsg[1].EuValue = fvalue*LCpntmsg[1].AiParam.fFactor + LCpntmsg[1].AiParam.EuValueDelta;
                LCpntmsg[1].AiState = 1;
                sprintf(szbuf, "A相泄漏电流最大值:%0.3f  ", fvalue/100);
                DebugStringPrintf(szbuf, strlen(szbuf), 0);
                break;
            case	19: /*A相超过3mA的脉冲频次*/
                LCpntmsg[2].EuValue = fvalue*LCpntmsg[2].AiParam.fFactor + LCpntmsg[2].AiParam.EuValueDelta;
                LCpntmsg[2].AiState = 1;
                sprintf(szbuf, "A相超过3mA的脉冲频次:%0.3f  ", fvalue);
                DebugStringPrintf(szbuf, strlen(szbuf), 0);
                break;
            case	20: /*A相超过10mA的脉冲频次*/
                LCpntmsg[3].EuValue = fvalue*LCpntmsg[3].AiParam.fFactor + LCpntmsg[3].AiParam.EuValueDelta;
                LCpntmsg[3].AiState = 1;
                sprintf(szbuf, "A相超过10mA的脉冲频次:%0.3f  ", fvalue);
                DebugStringPrintf(szbuf, strlen(szbuf), 1);
                break;
            case	21: /*B相泄漏电流平均值；*/
                LCpntmsg[4].EuValue = fvalue*LCpntmsg[4].AiParam.fFactor + LCpntmsg[4].AiParam.EuValueDelta;
                LCpntmsg[4].AiState = 1;
                sprintf(szbuf, "B相泄漏电流平均值:%0.3f ", fvalue/100);
                DebugStringPrintf(szbuf, strlen(szbuf), 0);
                break;
            case	22: /*B相泄漏电流最大值；*/
                LCpntmsg[5].EuValue = fvalue*LCpntmsg[5].AiParam.fFactor + LCpntmsg[5].AiParam.EuValueDelta;
                LCpntmsg[5].AiState = 1;
                sprintf(szbuf, "B相泄漏电流最大值:%0.3f  ", fvalue/100);
                DebugStringPrintf(szbuf, strlen(szbuf), 0);
                break;
            case	23: /*B相超过3mA的脉冲频次*/
                LCpntmsg[6].EuValue = fvalue*LCpntmsg[6].AiParam.fFactor + LCpntmsg[6].AiParam.EuValueDelta;
                LCpntmsg[6].AiState = 1;
                sprintf(szbuf, "B相超过3mA的脉冲频次:%0.3f  ", fvalue);
                DebugStringPrintf(szbuf, strlen(szbuf), 0);
                break;
            case	24: /*B相超过10mA的脉冲频次*/
                LCpntmsg[7].EuValue = fvalue*LCpntmsg[7].AiParam.fFactor + LCpntmsg[7].AiParam.EuValueDelta;
                LCpntmsg[7].AiState = 1;
                sprintf(szbuf, "B相超过10mA的脉冲频次:%0.3f  ", fvalue);
                DebugStringPrintf(szbuf, strlen(szbuf), 1);
                break;
            case	25: /*C相泄漏电流平均值；*/
                LCpntmsg[8].EuValue = fvalue*LCpntmsg[8].AiParam.fFactor + LCpntmsg[8].AiParam.EuValueDelta;
                LCpntmsg[8].AiState = 1;
                sprintf(szbuf, "C相泄漏电流平均值:%0.3f  ", fvalue/100);
                DebugStringPrintf(szbuf, strlen(szbuf), 0);
                break;
            case	26: /*C相泄漏电流最大值；*/
                LCpntmsg[9].EuValue = fvalue*LCpntmsg[9].AiParam.fFactor + LCpntmsg[9].AiParam.EuValueDelta;
                LCpntmsg[9].AiState = 1;
                sprintf(szbuf, "C相泄漏电流最大值:%0.3f  ", fvalue/100);
                DebugStringPrintf(szbuf, strlen(szbuf), 0);
                break;
            case	27: /*C相超过3mA的脉冲频次*/
                LCpntmsg[10].EuValue = fvalue*LCpntmsg[10].AiParam.fFactor + LCpntmsg[10].AiParam.EuValueDelta;
                LCpntmsg[10].AiState = 1;
                sprintf(szbuf, "C相超过3mA的脉冲频次:%0.3f  ", fvalue);
                DebugStringPrintf(szbuf, strlen(szbuf), 0);
                break;
            case	28: /*C相超过10mA的脉冲频次*/
                LCpntmsg[11].EuValue = fvalue*LCpntmsg[11].AiParam.fFactor + LCpntmsg[11].AiParam.EuValueDelta;
                LCpntmsg[11].AiState = 1;
                sprintf(szbuf, "C相超过10mA的脉冲频次:%0.3f  ", fvalue);
                DebugStringPrintf(szbuf, strlen(szbuf), 1);
                break;
#endif

        }
    }
}

/*********************************************************************************
			把16进制和10进制ASCII字符串转换成int整数
*********************************************************************************/
int ATOI(char *buf)
{
    int	i, ilen, iRetVal;

    if(NULL == buf)
        return 0;
    ilen = strlen(buf);
    if(ilen > 2)
    {
        if((buf[0]=='0') && ((buf[1]=='x') || (buf[1]=='X')))
        {
            iRetVal = 0;
            for(i=2; i<ilen; i++)
            {
                iRetVal = (iRetVal << 4) + HexCharToInt(buf[i]);
            }
        }
        else
        {
            iRetVal = atoi(buf);
        }
    }
    else
    {
        iRetVal = atoi(buf);
    }
    return iRetVal;
}

#if 0
// 控制关闭传感器电源
void Gm_CtrlCloseSensorsPower(int devidx)
{
    if((devidx<0) || (devidx > MAX_SERIAL_DEV_NUM-1))
        return;
    srdt.ms_dev[devidx].uOpenPowerFlag = CLOSEPOWER;
}


// 检查传感器电源是否应该关闭或打开
void Gm_CheckSensorsPower(void)
{
    int	i, j;

    for(i=0; i<MAX_SERIAL_DEV_NUM-2; i++)
    {
        if((1 > srdt.ms_dev[i].ProtocolIdx) ||(INVALID_PROTOCOL<=srdt.ms_dev[i].ProtocolIdx))
            continue;
        if((PELCO_P_PROTOCOL == srdt.ms_dev[i].ProtocolIdx) ||(PELCO_D_PROTOCOL == srdt.ms_dev[i].ProtocolIdx)
           ||( SERIALCAMERA_PROTOCOL == srdt.ms_dev[i].ProtocolIdx))
            continue;
        // 需要传感器处于上电状态
            for(j=0; j<MAX_SERIAL_DEV_NUM-2; j++)
            {
                if((srdt.ms_dev[i].PowerPort == srdt.ms_dev[j].PowerPort) && (srdt.ms_dev[j].uOpenPowerFlag == OPENPOWER))
                    break;
            }
            if(j <MAX_SERIAL_DEV_NUM-2)
                continue;

    }
}
#endif

int GeneratingRandomNumber(void)
{
    int	ictime, randomdate;
    /* 生成随机数n-m -> rand()%(m-n+1)+n*/
    ictime = (int)time(NULL);
    srand((DWORD)ictime);
    randomdate = rand();
    return randomdate;
}